diff options
| author | Dan Winship <danw@gnome.org> | 2012-10-21 18:18:46 +0200 |
|---|---|---|
| committer | Dan Winship <danw@gnome.org> | 2015-04-06 10:46:41 -0400 |
| commit | 8f5d05c27fbf79e1a77d0d1ae294db7da4eeecd9 (patch) | |
| tree | e98efd2b0f54dbd5c94792995da144328ac49f21 | |
| parent | 60968576962f10212caf9e59a41ef0a9f77e6165 (diff) | |
| download | gvfs-wip/gtask-porting.tar.gz | |
Port to GTaskwip/gtask-porting
31 files changed, 1379 insertions, 1755 deletions
diff --git a/client/gdaemonfile.c b/client/gdaemonfile.c index 15c368c8..1cd37c44 100644 --- a/client/gdaemonfile.c +++ b/client/gdaemonfile.c @@ -552,16 +552,14 @@ do_sync_2_path_call (GFile *file1, typedef void (*AsyncPathCallCallback) (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data); typedef struct { - GSimpleAsyncResult *result; GFile *file; char *op; - GCancellable *cancellable; DBusMessage *args; AsyncPathCallCallback callback; gpointer callback_data; @@ -575,12 +573,8 @@ async_path_call_free (AsyncPathCall *data) if (data->notify) data->notify (data->callback_data); - if (data->result) - g_object_unref (data->result); g_object_unref (data->file); g_free (data->op); - if (data->cancellable) - g_object_unref (data->cancellable); if (data->args) dbus_message_unref (data->args); if (data->mount_info) @@ -594,30 +588,25 @@ async_path_call_done (DBusMessage *reply, GError *io_error, gpointer _data) { - AsyncPathCall *data = _data; - GSimpleAsyncResult *result; + GTask *task = _data; + AsyncPathCall *data = g_task_get_task_data (task); if (io_error != NULL) { - g_simple_async_result_set_from_error (data->result, io_error); - _g_simple_async_result_complete_with_cancellable (data->result, data->cancellable); + g_task_return_error (task, g_error_copy (io_error)); async_path_call_free (data); } else { - result = data->result; - g_object_weak_ref (G_OBJECT (result), (GWeakNotify)async_path_call_free, data); - data->result = NULL; - data->callback (reply, connection, data->mount_info, - result, - data->cancellable, + task, + g_task_get_cancellable (task), data->callback_data); /* Free data here, or later if callback ref:ed the result */ - g_object_unref (result); + g_object_unref (task); } } @@ -626,7 +615,8 @@ do_async_path_call_callback (GMountInfo *mount_info, gpointer _data, GError *error) { - AsyncPathCall *data = _data; + GTask *task = _data; + AsyncPathCall *data = g_task_get_task_data (task); GDaemonFile *daemon_file = G_DAEMON_FILE (data->file); const char *path; DBusMessage *message; @@ -634,9 +624,7 @@ do_async_path_call_callback (GMountInfo *mount_info, if (error != NULL) { - g_simple_async_result_set_from_error (data->result, error); - _g_simple_async_result_complete_with_cancellable (data->result, data->cancellable); - async_path_call_free (data); + g_task_return_error (data->result, g_error_copy (error)); return; } @@ -662,8 +650,8 @@ do_async_path_call_callback (GMountInfo *mount_info, } _g_vfs_daemon_call_async (message, - async_path_call_done, data, - data->cancellable); + async_path_call_done, task, + g_task_get_cancellable (task)); dbus_message_unref (message); } @@ -682,22 +670,20 @@ do_async_path_call (GFile *file, { GDaemonFile *daemon_file = G_DAEMON_FILE (file); va_list var_args; + GTask *task; AsyncPathCall *data; - data = g_new0 (AsyncPathCall, 1); - - data->result = g_simple_async_result_new (G_OBJECT (file), - op_callback, op_callback_data, - NULL); + task = g_task_new (file, cancellable, op_callback, op_callback_data); + data = g_new0 (AsyncPathCall, 1); data->file = g_object_ref (file); data->op = g_strdup (op); - if (cancellable) - data->cancellable = g_object_ref (cancellable); data->callback = callback; data->callback_data = callback_data; data->notify = notify; + g_task_set_task_data (task, data, (GDestroyNotify) async_path_call_free); + if (first_arg_type != 0) { data->args = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL); @@ -713,9 +699,9 @@ do_async_path_call (GFile *file, _g_daemon_vfs_get_mount_info_async (daemon_file->mount_spec, - daemon_file->path, - do_async_path_call_callback, - data); + daemon_file->path, + do_async_path_call_callback, + task); } @@ -891,7 +877,7 @@ static void query_info_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { @@ -906,10 +892,9 @@ query_info_async_cb (DBusMessage *reply, if (!dbus_message_iter_init (reply, &iter) || (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRUCT)) { - g_simple_async_result_set_error (result, - G_IO_ERROR, G_IO_ERROR_FAILED, - _("Invalid return value from %s"), "query_info"); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_new_error (task, + G_IO_ERROR, G_IO_ERROR_FAILED, + _("Invalid return value from %s"), "query_info"); return; } @@ -917,18 +902,15 @@ query_info_async_cb (DBusMessage *reply, info = _g_dbus_get_file_info (&iter, &error); if (info == NULL) { - g_simple_async_result_set_from_error (result, error); - g_error_free (error); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_error (result, error); return; } - file = G_FILE (g_async_result_get_source_object (G_ASYNC_RESULT (result))); + file = g_task_get_source_object (task); add_metadata (file, attributes, info); g_object_unref (file); - g_simple_async_result_set_op_res_gpointer (result, info, g_object_unref); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_pointer (result, info, g_object_unref); } static void @@ -964,77 +946,60 @@ g_daemon_file_query_info_finish (GFile *file, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - GFileInfo *info; + GTask *task = G_TASK (res); - info = g_simple_async_result_get_op_res_gpointer (simple); - if (info) - return g_object_ref (info); - - return NULL; + return g_task_propagate_pointer (task, error); } -typedef struct { - GSimpleAsyncResult *result; - GCancellable *cancellable; - gboolean can_seek; -} GetFDData; - static void read_async_get_fd_cb (int fd, gpointer callback_data) { - GetFDData *data = callback_data; + GTask *task = callback_data; + gboolean can_seek = GPOINTER_TO_INT (g_task_get_task_data (task)); GFileInputStream *stream; if (fd == -1) { - g_simple_async_result_set_error (data->result, - G_IO_ERROR, G_IO_ERROR_FAILED, - _("Couldn't get stream file descriptor")); + g_task_return_new_error (task, + G_IO_ERROR, G_IO_ERROR_FAILED, + _("Couldn't get stream file descriptor")); } else { - stream = g_daemon_file_input_stream_new (fd, data->can_seek); - g_simple_async_result_set_op_res_gpointer (data->result, stream, g_object_unref); + stream = g_daemon_file_input_stream_new (fd, can_seek); + g_task_return_pointer (task, stream, g_object_unref); } - _g_simple_async_result_complete_with_cancellable (data->result, data->cancellable); - - g_object_unref (data->result); - g_free (data); + g_object_unref (task); } static void read_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { guint32 fd_id; dbus_bool_t can_seek; - GetFDData *get_fd_data; if (!dbus_message_get_args (reply, NULL, DBUS_TYPE_UINT32, &fd_id, DBUS_TYPE_BOOLEAN, &can_seek, DBUS_TYPE_INVALID)) { - g_simple_async_result_set_error (result, - G_IO_ERROR, G_IO_ERROR_FAILED, - _("Invalid return value from %s"), "open"); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_new_error (task, + G_IO_ERROR, G_IO_ERROR_FAILED, + _("Invalid return value from %s"), "open"); return; } - - get_fd_data = g_new0 (GetFDData, 1); - get_fd_data->result = g_object_ref (result); - get_fd_data->can_seek = can_seek; + + g_task_set_task_data (task, GINT_TO_POINTER (can_seek), NULL); _g_dbus_connection_get_fd_async (connection, fd_id, - read_async_get_fd_cb, get_fd_data); + read_async_get_fd_cb, task); } static void @@ -1062,14 +1027,9 @@ g_daemon_file_read_finish (GFile *file, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - gpointer op; + GTask *task = G_TASK (res); - op = g_simple_async_result_get_op_res_gpointer (simple); - if (op) - return g_object_ref (op); - - return NULL; + return g_task_propagate_pointer (task, error); } @@ -1317,25 +1277,23 @@ mount_mountable_location_mounted_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *result = user_data; + GFile *file = G_FILE (source_object); + GTask *task = user_data; GError *error = NULL; - if (!g_file_mount_enclosing_volume_finish (G_FILE (source_object), res, &error)) - { - g_simple_async_result_set_from_error (result, error); - g_error_free (error); - } - - g_simple_async_result_complete (result); - g_object_unref (result); + if (!g_file_mount_enclosing_volume_finish (file, res, &error)) + g_task_return_error (task, error); + else + g_task_return_pointer (task, file, g_object_unref); + g_object_unref (task); } static void mount_mountable_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { @@ -1356,11 +1314,9 @@ mount_mountable_async_cb (DBusMessage *reply, DBUS_TYPE_BOOLEAN, &must_mount_location, 0)) { - g_simple_async_result_set_error (result, - G_IO_ERROR, G_IO_ERROR_FAILED, - _("Invalid return value from %s"), "call"); - _g_simple_async_result_complete_with_cancellable (result, cancellable); - + g_task_return_new_error (task, + G_IO_ERROR, G_IO_ERROR_FAILED, + _("Invalid return value from %s"), "call"); return; } @@ -1373,10 +1329,9 @@ mount_mountable_async_cb (DBusMessage *reply, mount_spec = g_mount_spec_from_dbus (&iter); if (mount_spec == NULL) { - g_simple_async_result_set_error (result, - G_IO_ERROR, G_IO_ERROR_FAILED, - _("Invalid return value from %s"), "call"); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_new_error (task, + G_IO_ERROR, G_IO_ERROR_FAILED, + _("Invalid return value from %s"), "call"); return; } @@ -1385,7 +1340,6 @@ mount_mountable_async_cb (DBusMessage *reply, } g_free (path); - g_simple_async_result_set_op_res_gpointer (result, file, g_object_unref); if (must_mount_location) { @@ -1394,11 +1348,10 @@ mount_mountable_async_cb (DBusMessage *reply, mount_operation, cancellable, mount_mountable_location_mounted_cb, - g_object_ref (result)); - + g_object_ref (task)); } else - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_pointer (task, file, g_object_unref); } static void @@ -1438,25 +1391,20 @@ g_daemon_file_mount_mountable_finish (GFile *file, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result); - GFile *result_file; - - result_file = g_simple_async_result_get_op_res_gpointer (simple); - if (result_file) - return g_object_ref (result_file); + GTask *task = G_TASK (result); - return NULL; + return g_task_propagate_pointer (task, error); } static void start_mountable_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_boolean (task, TRUE); } static void @@ -1503,11 +1451,11 @@ static void stop_mountable_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_boolean (task, TRUE); } static void @@ -1557,11 +1505,11 @@ static void eject_mountable_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_boolean (task, TRUE); } static void @@ -1628,11 +1576,11 @@ static void unmount_mountable_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_boolean (task, TRUE); } static void @@ -1681,11 +1629,11 @@ static void poll_mountable_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_boolean (task, TRUE); } static void @@ -1733,9 +1681,6 @@ g_daemon_file_unmount_mountable_finish (GFile *file, typedef struct { GFile *file; GMountOperation *mount_operation; - GAsyncReadyCallback callback; - GCancellable *cancellable; - gpointer user_data; } MountData; static void g_daemon_file_mount_enclosing_volume (GFile *location, @@ -1750,32 +1695,13 @@ mount_reply (DBusMessage *reply, GError *error, gpointer user_data) { - MountData *data = user_data; - GSimpleAsyncResult *res; + GTask *task = user_data; + GMountOperation *mount_operation = g_task_get_task_data (task); if (reply == NULL) - { - res = g_simple_async_result_new_from_error (G_OBJECT (data->file), - data->callback, - data->user_data, - error); - } + g_task_return_error (task, g_error_copy (error)); else - { - res = g_simple_async_result_new (G_OBJECT (data->file), - data->callback, - data->user_data, - g_daemon_file_mount_enclosing_volume); - } - - _g_simple_async_result_complete_with_cancellable (res, data->cancellable); - - g_object_unref (data->file); - if (data->cancellable) - g_object_unref (data->cancellable); - if (data->mount_operation) - g_object_unref (data->mount_operation); - g_free (data); + g_task_return_boolean (task, TRUE); } static void @@ -1791,7 +1717,7 @@ g_daemon_file_mount_enclosing_volume (GFile *location, GMountSpec *spec; GMountSource *mount_source; DBusMessageIter iter; - MountData *data; + GTask *task; daemon_file = G_DAEMON_FILE (location); @@ -1810,20 +1736,13 @@ g_daemon_file_mount_enclosing_volume (GFile *location, g_mount_source_to_dbus (mount_source, message); g_object_unref (mount_source); - data = g_new0 (MountData, 1); - data->callback = callback; - if (data->cancellable) - data->cancellable = g_object_ref (data->cancellable); - data->user_data = user_data; - data->file = g_object_ref (location); - if (mount_operation) - data->mount_operation = g_object_ref (mount_operation); + task = g_task_new (location, cancellable, callback, user_data); /* TODO: Ignoring cancellable here */ _g_dbus_connection_call_async (_g_daemon_vfs_get_async_bus (), message, G_VFS_DBUS_MOUNT_TIMEOUT_MSECS, - mount_reply, data); + mount_reply, task); dbus_message_unref (message); } @@ -1833,8 +1752,7 @@ g_daemon_file_mount_enclosing_volume_finish (GFile *location, GAsyncResult *result, GError **error) { - /* Errors handled in generic code */ - return TRUE; + return g_task_propagate_boolean (G_TASK (result)); } static GFileInfo * @@ -1879,7 +1797,7 @@ static void query_fs_info_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { @@ -1892,10 +1810,9 @@ query_fs_info_async_cb (DBusMessage *reply, if (!dbus_message_iter_init (reply, &iter) || (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRUCT)) { - g_simple_async_result_set_error (result, - G_IO_ERROR, G_IO_ERROR_FAILED, - _("Invalid return value from %s"), "query_info"); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_new_error (task, + G_IO_ERROR, G_IO_ERROR_FAILED, + _("Invalid return value from %s"), "query_info"); return; } @@ -1903,14 +1820,11 @@ query_fs_info_async_cb (DBusMessage *reply, info = _g_dbus_get_file_info (&iter, &error); if (info == NULL) { - g_simple_async_result_set_from_error (result, error); - g_error_free (error); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_error (task, error); return; } - g_simple_async_result_set_op_res_gpointer (result, info, g_object_unref); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_pointer (result, info, g_object_unref); } static void @@ -1935,14 +1849,9 @@ g_daemon_file_query_filesystem_info_finish (GFile *file, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - GFileInfo *info; + GTask *task = G_TASK (res); - info = g_simple_async_result_get_op_res_gpointer (simple); - if (info) - return g_object_ref (info); - - return NULL; + return g_task_propagate_pointer (task, error); } static GMount * @@ -2621,41 +2530,38 @@ g_daemon_file_monitor_file (GFile* file, typedef struct { - GSimpleAsyncResult *result; - GCancellable *cancellable; dbus_bool_t can_seek; guint64 initial_offset; +} StreamOpenParams; + +static void +free_stream_open_params (StreamOpenParams *params) +{ + g_slice_free (StreamOpenParams, params); } -StreamOpenParams; static void -stream_open_cb (gint fd, StreamOpenParams *params) +stream_open_cb (gint fd, GTask *task) { + StreamOpenParams *params = g_task_get_task_data (task); GFileOutputStream *output_stream; if (fd == -1) { - g_simple_async_result_set_error (params->result, G_IO_ERROR, G_IO_ERROR_FAILED, - "%s", _("Didn't get stream file descriptor")); - goto out; + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, + "%s", _("Didn't get stream file descriptor")); + return; } output_stream = g_daemon_file_output_stream_new (fd, params->can_seek, params->initial_offset); - g_simple_async_result_set_op_res_gpointer (params->result, output_stream, g_object_unref); - -out: - _g_simple_async_result_complete_with_cancellable (params->result, params->cancellable); - if (params->cancellable) - g_object_unref (params->cancellable); - g_object_unref (params->result); - g_slice_free (StreamOpenParams, params); + g_task_return_pointer (task, output_stream, g_object_unref); } static void append_to_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { @@ -2670,21 +2576,16 @@ append_to_async_cb (DBusMessage *reply, DBUS_TYPE_UINT64, &open_params->initial_offset, DBUS_TYPE_INVALID)) { - g_simple_async_result_set_error (result, G_IO_ERROR, G_IO_ERROR_FAILED, - _("Invalid return value from %s"), "open"); - goto failure; + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, + _("Invalid return value from %s"), "open"); + g_slice_free (StreamOpenParams, open_params); + return; } - open_params->result = g_object_ref (result); - if (cancellable) - open_params->cancellable = g_object_ref (cancellable); - _g_dbus_connection_get_fd_async (connection, fd_id, - (GetFdAsyncCallback) stream_open_cb, open_params); - return; + g_task_set_task_data (task, open_params, (GDestroyNotify) free_stream_open_params); -failure: - g_slice_free (StreamOpenParams, open_params); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + _g_dbus_connection_get_fd_async (connection, fd_id, + (GetFdAsyncCallback) stream_open_cb, task); } static void @@ -2726,21 +2627,16 @@ g_daemon_file_append_to_finish (GFile *file, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - GFileOutputStream *output_stream; + GTask *task = G_TASK (res); - output_stream = g_simple_async_result_get_op_res_gpointer (simple); - if (output_stream) - return g_object_ref (output_stream); - - return NULL; + return g_task_propagate_pointer (task, error); } static void create_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { @@ -2755,19 +2651,16 @@ create_async_cb (DBusMessage *reply, DBUS_TYPE_UINT64, &open_params->initial_offset, DBUS_TYPE_INVALID)) { - g_simple_async_result_set_error (result, G_IO_ERROR, G_IO_ERROR_FAILED, - _("Invalid return value from %s"), "open"); - goto failure; + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, + _("Invalid return value from %s"), "open"); + g_slice_free (StreamOpenParams, open_params); + return; } - open_params->result = g_object_ref (result); - _g_dbus_connection_get_fd_async (connection, fd_id, - (GetFdAsyncCallback) stream_open_cb, open_params); - return; + g_task_set_task_data (task, open_params, (GDestroyNotify) free_stream_open_params); -failure: - g_slice_free (StreamOpenParams, open_params); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + _g_dbus_connection_get_fd_async (connection, fd_id, + (GetFdAsyncCallback) stream_open_cb, task); } static void @@ -2809,39 +2702,30 @@ g_daemon_file_create_finish (GFile *file, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - GFileOutputStream *output_stream; - - output_stream = g_simple_async_result_get_op_res_gpointer (simple); - if (output_stream) - return g_object_ref (output_stream); + GTask *task = G_TASK (res); - return NULL; + return g_task_propagate_pointer (task, error); } static void enumerate_children_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { GDaemonFileEnumerator *enumerator = callback_data; if (reply == NULL || connection == NULL) - { - g_simple_async_result_set_error (result, G_IO_ERROR, G_IO_ERROR_FAILED, - _("Invalid return value from %s"), "enumerate_children"); - goto out; - } + { + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, + _("Invalid return value from %s"), "enumerate_children"); + return; + } g_object_ref (enumerator); - - g_simple_async_result_set_op_res_gpointer (result, enumerator, g_object_unref); - -out: - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_pointer (result, enumerator, g_object_unref); } static void @@ -2885,50 +2769,33 @@ g_daemon_file_enumerate_children_finish (GFile *file, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - GDaemonFileEnumerator *enumerator; + GTask *task = G_TASK (res); - enumerator = g_simple_async_result_get_op_res_gpointer (simple); - if (enumerator) - return g_object_ref (enumerator); - - return NULL; + return g_task_propagate_pointer (task, error); } -typedef struct -{ - GFile *file; - GSimpleAsyncResult *result; - GCancellable *cancellable; -} -FindEnclosingMountData; - static void find_enclosing_mount_cb (GMountInfo *mount_info, gpointer user_data, GError *error) { - FindEnclosingMountData *data = user_data; - GError *my_error = NULL; + GTask *task = user_data; - if (data->cancellable && g_cancellable_set_error_if_cancelled (data->cancellable, &my_error)) - { - g_simple_async_result_set_from_error (data->result, my_error); - goto out; - } + if (g_task_return_error_if_cancelled (task)) + return; if (error) { - g_simple_async_result_set_from_error (data->result, error); - goto out; + g_task_return_error (task, g_error_copy (error)); + return; } if (!mount_info) { - g_simple_async_result_set_error (data->result, G_IO_ERROR, G_IO_ERROR_FAILED, - "Internal error: \"%s\"", - "No error but no mount info from g_daemon_vfs_get_mount_info_async"); - goto out; + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, + "Internal error: \"%s\"", + "No error but no mount info from g_daemon_vfs_get_mount_info_async"); + return; } if (mount_info->user_visible) @@ -2941,23 +2808,14 @@ find_enclosing_mount_cb (GMountInfo *mount_info, mount = g_daemon_mount_new (mount_info, NULL); if (mount) - g_simple_async_result_set_op_res_gpointer (data->result, mount, g_object_unref); + g_task_return_pointer (task, mount, g_object_unref); else - g_simple_async_result_set_error (data->result, G_IO_ERROR, G_IO_ERROR_FAILED, - "Internal error: \"%s\"", - "Mount info did not yield a mount"); + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, + "Internal error: \"%s\"", + "Mount info did not yield a mount"); } - -out: - _g_simple_async_result_complete_with_cancellable (data->result, data->cancellable); - - if (my_error) - g_error_free (my_error); - if (data->cancellable) - g_object_unref (data->cancellable); - g_object_unref (data->file); - g_object_unref (data->result); - g_free (data); + else + g_task_return_pointer (task, NULL, NULL); } static void @@ -2967,23 +2825,15 @@ g_daemon_file_find_enclosing_mount_async (GFile *file, GAsyncReadyCallback callback, gpointer user_data) { - GDaemonFile *daemon_file = G_DAEMON_FILE (file); - FindEnclosingMountData *data; - - data = g_new0 (FindEnclosingMountData, 1); - - data->result = g_simple_async_result_new (G_OBJECT (file), - callback, user_data, - NULL); - data->file = g_object_ref (file); + GDaemonFile *daemon_file = G_DAEMON_FILE (file); + GTask *task; - if (cancellable) - data->cancellable = g_object_ref (cancellable); + task = g_task_new (file, cancellable, callback, user_data); _g_daemon_vfs_get_mount_info_async (daemon_file->mount_spec, daemon_file->path, find_enclosing_mount_cb, - data); + task); } static GMount * @@ -2991,21 +2841,16 @@ g_daemon_file_find_enclosing_mount_finish (GFile *file, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - GMount *mount; + GTask *task = G_TASK (res); - mount = g_simple_async_result_get_op_res_gpointer (simple); - if (mount) - return g_object_ref (mount); - - return NULL; + return g_task_propagate_pointer (task, error); } static void replace_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { @@ -3020,19 +2865,16 @@ replace_async_cb (DBusMessage *reply, DBUS_TYPE_UINT64, &open_params->initial_offset, DBUS_TYPE_INVALID)) { - g_simple_async_result_set_error (result, G_IO_ERROR, G_IO_ERROR_FAILED, - _("Invalid return value from %s"), "open"); - goto failure; + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, + _("Invalid return value from %s"), "open"); + g_slice_free (StreamOpenParams, open_params); + return; } - open_params->result = g_object_ref (result); - _g_dbus_connection_get_fd_async (connection, fd_id, - (GetFdAsyncCallback) stream_open_cb, open_params); - return; + g_task_set_task_data (task, open_params, (GDestroyNotify) free_stream_open_params); -failure: - g_slice_free (StreamOpenParams, open_params); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + _g_dbus_connection_get_fd_async (connection, fd_id, + (GetFdAsyncCallback) stream_open_cb, task); } static void @@ -3073,21 +2915,16 @@ g_daemon_file_replace_finish (GFile *file, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - GFileOutputStream *output_stream; - - output_stream = g_simple_async_result_get_op_res_gpointer (simple); - if (output_stream) - return g_object_ref (output_stream); + GTask *task = G_TASK (res); - return NULL; + return g_task_propagate_pointer (task, error); } static void set_display_name_async_cb (DBusMessage *reply, DBusConnection *connection, GMountInfo *mount_info, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, gpointer callback_data) { @@ -3101,9 +2938,9 @@ set_display_name_async_cb (DBusMessage *reply, G_DBUS_TYPE_CSTRING, &new_path, 0)) { - g_simple_async_result_set_error (result, G_IO_ERROR, G_IO_ERROR_FAILED, - _("Invalid return value from %s"), "set_display_name"); - goto out; + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, + _("Invalid return value from %s"), "set_display_name"); + return; } g_mount_info_apply_prefix (mount_info, &new_path); @@ -3111,10 +2948,7 @@ set_display_name_async_cb (DBusMessage *reply, g_free (new_path); - g_simple_async_result_set_op_res_gpointer (result, file, g_object_unref); - -out: - _g_simple_async_result_complete_with_cancellable (result, cancellable); + g_task_return_pointer (task, file, g_object_unref); } static void @@ -3141,11 +2975,9 @@ g_daemon_file_set_display_name_finish (GFile *file, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - GFile *new_file; + GTask *task = G_TASK (res); - new_file = g_simple_async_result_get_op_res_gpointer (simple); - return new_file; + return g_task_propagate_pointer (task, error); } #if 0 diff --git a/client/gdaemonfileenumerator.c b/client/gdaemonfileenumerator.c index d8ca8ab6..6302b916 100644 --- a/client/gdaemonfileenumerator.c +++ b/client/gdaemonfileenumerator.c @@ -55,7 +55,7 @@ struct _GDaemonFileEnumerator int async_requested_files; gulong cancelled_tag; guint timeout_tag; - GSimpleAsyncResult *async_res; + GTask *task; GFileAttributeMatcher *matcher; MetaTree *metadata_tree; @@ -219,25 +219,6 @@ add_metadata (GFileInfo *info, g_free (path); } -static GCancellable * -simple_async_result_get_cancellable (GSimpleAsyncResult *res) -{ - return g_object_get_data (G_OBJECT (res), "file-enumerator-cancellable"); -} - -static void -simple_async_result_set_cancellable (GSimpleAsyncResult *res, - GCancellable *cancellable) -{ - if (!cancellable) - return; - - g_object_set_data_full (G_OBJECT (res), - "file-enumerator-cancellable", - g_object_ref (cancellable), - g_object_unref); -} - /* Called with infos lock held */ static void trigger_async_done (GDaemonFileEnumerator *daemon, gboolean ok) @@ -246,7 +227,7 @@ trigger_async_done (GDaemonFileEnumerator *daemon, gboolean ok) if (daemon->cancelled_tag != 0) { - GCancellable *cancellable = simple_async_result_get_cancellable (daemon->async_res); + GCancellable *cancellable = g_task_get_cancellable (daemon->task); /* If ok, we're a normal callback on the main thread, ensure protection against a thread cancelling and @@ -290,12 +271,12 @@ trigger_async_done (GDaemonFileEnumerator *daemon, gboolean ok) g_list_foreach (l, (GFunc)add_metadata, daemon); - g_simple_async_result_set_op_res_gpointer (daemon->async_res, - l, - (GDestroyNotify)free_info_list); + g_task_return_pointer (daemon->task, + l, + (GDestroyNotify)free_info_list); } - - g_simple_async_result_complete_in_idle (daemon->async_res); + else + g_task_return_pointer (daemon->task, NULL, NULL); daemon->cancelled_tag = 0; @@ -305,8 +286,8 @@ trigger_async_done (GDaemonFileEnumerator *daemon, gboolean ok) daemon->async_requested_files = 0; - g_object_unref (daemon->async_res); - daemon->async_res = NULL; + g_object_unref (daemon->task); + daemon->task = NULL; } static DBusHandlerResult @@ -460,10 +441,10 @@ static void async_cancelled (GCancellable *cancellable, GDaemonFileEnumerator *daemon) { - g_simple_async_result_set_error (daemon->async_res, - G_IO_ERROR, - G_IO_ERROR_CANCELLED, - _("Operation was cancelled")); + g_task_return_new_error (daemon->task, + G_IO_ERROR, + G_IO_ERROR_CANCELLED, + _("Operation was cancelled")); G_LOCK (infos); trigger_async_done (daemon, FALSE); G_UNLOCK (infos); @@ -498,11 +479,9 @@ g_daemon_file_enumerator_next_files_async (GFileEnumerator *enumerator, * We could possibly pump it ourselves in this case, but i'm not sure * how much sense this makes, so we don't for now. */ - g_simple_async_report_error_in_idle (G_OBJECT (enumerator), - callback, - user_data, - G_IO_ERROR, G_IO_ERROR_FAILED, - "Can't do asynchronous next_files() on a file enumerator created synchronously"); + g_task_report_new_error (enumerator, callback, user_data, + G_IO_ERROR, G_IO_ERROR_FAILED, + "Can't do asynchronous next_files() on a file enumerator created synchronously"); return; } @@ -510,9 +489,7 @@ g_daemon_file_enumerator_next_files_async (GFileEnumerator *enumerator, daemon->cancelled_tag = 0; daemon->timeout_tag = 0; daemon->async_requested_files = num_files; - daemon->async_res = g_simple_async_result_new (G_OBJECT (enumerator), callback, user_data, - g_daemon_file_enumerator_next_files_async); - simple_async_result_set_cancellable (daemon->async_res, cancellable); + daemon->task = g_task_new (enumerator, cancellable, callback, user_data); /* Maybe we already have enough info to fulfill the requeust already */ if (daemon->done || @@ -536,23 +513,7 @@ g_daemon_file_enumerator_next_files_finish (GFileEnumerator *enumerator, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (res); - GCancellable *cancellable; - GList *l; - - cancellable = simple_async_result_get_cancellable (result); - if (g_cancellable_is_cancelled (cancellable)) - { - g_set_error (error, - G_IO_ERROR, - G_IO_ERROR_CANCELLED, - "%s", _("Operation was cancelled")); - return NULL; - } - - l = g_simple_async_result_get_op_res_gpointer (result); - g_list_foreach (l, (GFunc)g_object_ref, NULL); - return g_list_copy (l); + return g_task_propagate_pointer (G_TASK (res), error); } static gboolean @@ -575,13 +536,11 @@ g_daemon_file_enumerator_close_async (GFileEnumerator *enumerator, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *res; + GTask *task; - res = g_simple_async_result_new (G_OBJECT (enumerator), callback, user_data, - g_daemon_file_enumerator_close_async); - simple_async_result_set_cancellable (res, cancellable); - g_simple_async_result_complete_in_idle (res); - g_object_unref (res); + task = g_task_new (enumerator, cancellable, callback, user_data); + g_task_return_boolean (task, TRUE); + g_object_unref (task); } static gboolean @@ -589,17 +548,5 @@ g_daemon_file_enumerator_close_finish (GFileEnumerator *enumerator, GAsyncResult *result, GError **error) { - GCancellable *cancellable; - - cancellable = simple_async_result_get_cancellable (G_SIMPLE_ASYNC_RESULT (result)); - if (g_cancellable_is_cancelled (cancellable)) - { - g_set_error (error, - G_IO_ERROR, - G_IO_ERROR_CANCELLED, - "%s", _("Operation was cancelled")); - return FALSE; - } - - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } diff --git a/client/gdaemonfileinputstream.c b/client/gdaemonfileinputstream.c index 45918321..5ba28b94 100644 --- a/client/gdaemonfileinputstream.c +++ b/client/gdaemonfileinputstream.c @@ -1837,7 +1837,7 @@ async_read_done (GInputStream *stream, ReadOperation *op; gssize count_read; GError *error; - GSimpleAsyncResult *simple; + GTask *task; op = op_data; @@ -1852,18 +1852,18 @@ async_read_done (GInputStream *stream, error = op->ret_error; } - simple = g_simple_async_result_new (G_OBJECT (stream), + task = g_task_new (stream, callback, user_data, g_daemon_file_input_stream_read_async); - g_simple_async_result_set_op_res_gssize (simple, count_read); + g_task_return_int (task, count_read); if (count_read == -1) - g_simple_async_result_set_from_error (simple, error); + g_task_return_error (task, error); /* Complete immediately, not in idle, since we're already in a mainloop callout */ - _g_simple_async_result_complete_with_cancellable (simple, cancellable); - g_object_unref (simple); + _g_task_async_result_complete_with_cancellable (task, cancellable); + g_object_unref (task); if (op->ret_error) g_error_free (op->ret_error); @@ -1907,13 +1907,13 @@ g_daemon_file_input_stream_read_finish (GInputStream *stream, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; gssize nread; - simple = G_SIMPLE_ASYNC_RESULT (result); - g_assert (g_simple_async_result_get_source_tag (simple) == g_daemon_file_input_stream_read_async); + task = G_TASK (result); + g_assert (g_task_async_result_get_source_tag (task) == g_daemon_file_input_stream_read_async); - nread = g_simple_async_result_get_op_res_gssize (simple); + nread = g_task_propagate_ssize (task, error); return nread; } @@ -1948,7 +1948,7 @@ async_close_done (GInputStream *stream, GError *io_error) { GDaemonFileInputStream *file; - GSimpleAsyncResult *simple; + GTask *task; CloseOperation *op; gboolean result; GError *error; @@ -1979,16 +1979,16 @@ async_close_done (GInputStream *stream, g_input_stream_close (file->data_stream, cancellable, NULL); - simple = g_simple_async_result_new (G_OBJECT (stream), + task = g_task_new (stream, callback, user_data, g_daemon_file_input_stream_read_async); if (!result) - g_simple_async_result_set_from_error (simple, error); + g_task_return_error (task, error); /* Complete immediately, not in idle, since we're already in a mainloop callout */ - _g_simple_async_result_complete_with_cancellable (simple, cancellable); - g_object_unref (simple); + _g_task_async_result_complete_with_cancellable (task, cancellable); + g_object_unref (task); if (op->ret_error) g_error_free (op->ret_error); @@ -2035,7 +2035,7 @@ async_query_done (GInputStream *stream, GCancellable *cancellable, GError *io_error) { - GSimpleAsyncResult *simple; + GTask *task; QueryOperation *op; GFileInfo *info; GError *error; @@ -2053,19 +2053,19 @@ async_query_done (GInputStream *stream, error = op->ret_error; } - simple = g_simple_async_result_new (G_OBJECT (stream), + task = g_task_new (stream, callback, user_data, g_daemon_file_input_stream_query_info_async); if (info == NULL) - g_simple_async_result_set_from_error (simple, error); + g_task_return_error (task, error); else - g_simple_async_result_set_op_res_gpointer (simple, info, + g_task_return_pointer (task, info, g_object_unref); /* Complete immediately, not in idle, since we're already in a mainloop callout */ - _g_simple_async_result_complete_with_cancellable (simple, cancellable); - g_object_unref (simple); + _g_task_async_result_complete_with_cancellable (task, cancellable); + g_object_unref (task); if (op->ret_error) g_error_free (op->ret_error); @@ -2106,13 +2106,13 @@ g_daemon_file_input_stream_query_info_finish (GFileInputStream *stream, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; GFileInfo *info; - simple = G_SIMPLE_ASYNC_RESULT (result); - g_assert (g_simple_async_result_get_source_tag (simple) == g_daemon_file_input_stream_query_info_async); + task = G_TASK (result); + g_assert (g_task_async_result_get_source_tag (task) == g_daemon_file_input_stream_query_info_async); - info = g_simple_async_result_get_op_res_gpointer (simple); + info = g_task_propagate_pointer (task, error); return g_object_ref (info); diff --git a/client/gdaemonfileoutputstream.c b/client/gdaemonfileoutputstream.c index 74e4caff..58879142 100644 --- a/client/gdaemonfileoutputstream.c +++ b/client/gdaemonfileoutputstream.c @@ -1386,7 +1386,7 @@ async_write_done (GOutputStream *stream, GCancellable *cancellable, GError *io_error) { - GSimpleAsyncResult *simple; + GTask *task; WriteOperation *op; gssize count_written; GError *error; @@ -1404,18 +1404,18 @@ async_write_done (GOutputStream *stream, error = op->ret_error; } - simple = g_simple_async_result_new (G_OBJECT (stream), + task = g_task_new (stream, callback, user_data, g_daemon_file_output_stream_write_async); - g_simple_async_result_set_op_res_gssize (simple, count_written); + g_task_return_int (task, count_written); if (count_written == -1) - g_simple_async_result_set_from_error (simple, error); + g_task_return_error (task, error); /* Complete immediately, not in idle, since we're already in a mainloop callout */ - _g_simple_async_result_complete_with_cancellable (simple, cancellable); - g_object_unref (simple); + _g_task_async_result_complete_with_cancellable (task, cancellable); + g_object_unref (task); if (op->ret_error) g_error_free (op->ret_error); @@ -1459,13 +1459,13 @@ g_daemon_file_output_stream_write_finish (GOutputStream *stream, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; gssize nwritten; - simple = G_SIMPLE_ASYNC_RESULT (result); - g_assert (g_simple_async_result_get_source_tag (simple) == g_daemon_file_output_stream_write_async); + task = G_TASK (result); + g_assert (g_task_async_result_get_source_tag (task) == g_daemon_file_output_stream_write_async); - nwritten = g_simple_async_result_get_op_res_gssize (simple); + nwritten = g_task_propagate_ssize (task, error); return nwritten; } @@ -1478,7 +1478,7 @@ async_close_done (GOutputStream *stream, GError *io_error) { GDaemonFileOutputStream *file; - GSimpleAsyncResult *simple; + GTask *task; CloseOperation *op; gboolean result; GError *error; @@ -1508,16 +1508,16 @@ async_close_done (GOutputStream *stream, else g_input_stream_close (file->data_stream, cancellable, NULL); - simple = g_simple_async_result_new (G_OBJECT (stream), + task = g_task_new (stream, callback, user_data, g_daemon_file_output_stream_close_async); if (!result) - g_simple_async_result_set_from_error (simple, error); + g_task_return_error (task, error); /* Complete immediately, not in idle, since we're already in a mainloop callout */ - _g_simple_async_result_complete_with_cancellable (simple, cancellable); - g_object_unref (simple); + _g_task_async_result_complete_with_cancellable (task, cancellable); + g_object_unref (task); if (op->ret_error) g_error_free (op->ret_error); @@ -1564,7 +1564,7 @@ async_query_done (GOutputStream *stream, GCancellable *cancellable, GError *io_error) { - GSimpleAsyncResult *simple; + GTask *task; QueryOperation *op; GFileInfo *info; GError *error; @@ -1582,19 +1582,19 @@ async_query_done (GOutputStream *stream, error = op->ret_error; } - simple = g_simple_async_result_new (G_OBJECT (stream), + task = g_task_new (stream, callback, user_data, g_daemon_file_output_stream_query_info_async); if (info == NULL) - g_simple_async_result_set_from_error (simple, error); + g_task_return_error (task, error); else - g_simple_async_result_set_op_res_gpointer (simple, info, + g_task_return_pointer (task, info, g_object_unref); /* Complete immediately, not in idle, since we're already in a mainloop callout */ - _g_simple_async_result_complete_with_cancellable (simple, cancellable); - g_object_unref (simple); + _g_task_async_result_complete_with_cancellable (task, cancellable); + g_object_unref (task); if (op->ret_error) g_error_free (op->ret_error); @@ -1635,13 +1635,13 @@ g_daemon_file_output_stream_query_info_finish (GFileOutputStream *stream, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; GFileInfo *info; - simple = G_SIMPLE_ASYNC_RESULT (result); - g_assert (g_simple_async_result_get_source_tag (simple) == g_daemon_file_output_stream_query_info_async); + task = G_TASK (result); + g_assert (g_task_async_result_get_source_tag (task) == g_daemon_file_output_stream_query_info_async); - info = g_simple_async_result_get_op_res_gpointer (simple); + info = g_task_propagate_pointer (task, error); return g_object_ref (info); diff --git a/client/gdaemonmount.c b/client/gdaemonmount.c index f5bc5a62..743c155b 100644 --- a/client/gdaemonmount.c +++ b/client/gdaemonmount.c @@ -179,12 +179,12 @@ unmount_reply (DBusMessage *reply, GError *io_error, gpointer _data) { - GSimpleAsyncResult *result = _data; + GTask *result = _data; if (io_error != NULL) - g_simple_async_result_set_from_error (result, io_error); + g_task_return_error (result, io_error); - g_simple_async_result_complete (result); + g_task_async_result_complete (result); g_object_unref (result); } @@ -199,7 +199,7 @@ g_daemon_mount_unmount_with_operation (GMount *mount, GDaemonMount *daemon_mount = G_DAEMON_MOUNT (mount); DBusMessage *message; GMountInfo *mount_info; - GSimpleAsyncResult *res; + GTask *res; guint32 dbus_flags; GMountSource *mount_source; const char *dbus_id, *obj_path; @@ -222,7 +222,7 @@ g_daemon_mount_unmount_with_operation (GMount *mount, DBUS_TYPE_UINT32, &dbus_flags, 0); - res = g_simple_async_result_new (G_OBJECT (mount), + res = g_task_new (mount, callback, user_data, g_daemon_mount_unmount_with_operation); @@ -288,13 +288,13 @@ g_daemon_mount_guess_content_type (GMount *mount, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new (G_OBJECT (mount), + GTask *task; + task = g_task_new (mount, callback, user_data, NULL); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } static char ** diff --git a/client/gvfsdaemondbus.c b/client/gvfsdaemondbus.c index 2cfd2e63..47e44415 100644 --- a/client/gvfsdaemondbus.c +++ b/client/gvfsdaemondbus.c @@ -1039,28 +1039,3 @@ _g_dbus_connection_get_sync (const char *dbus_id, return connection; } - -/** - * _g_simple_async_result_complete_with_cancellable: - * @result: the result - * @cancellable: a cancellable to check - * - * If @cancellable is cancelled, sets @result into the cancelled error - * state. Then calls g_simple_async_result_complete(). - * This function is useful to ensure that @result is properly set into - * an error state on cancellation. - **/ -void -_g_simple_async_result_complete_with_cancellable (GSimpleAsyncResult *result, - GCancellable *cancellable) -{ - if (cancellable && - g_cancellable_is_cancelled (cancellable)) - g_simple_async_result_set_error (result, - G_IO_ERROR, - G_IO_ERROR_CANCELLED, - "%s", _("Operation was cancelled")); - - g_simple_async_result_complete (result); -} - diff --git a/client/gvfsdaemondbus.h b/client/gvfsdaemondbus.h index c60108f5..7a132cdc 100644 --- a/client/gvfsdaemondbus.h +++ b/client/gvfsdaemondbus.h @@ -75,10 +75,6 @@ DBusMessage * _g_vfs_daemon_call_sync (DBusMessage GFileInfo * _g_dbus_get_file_info (DBusMessageIter *iter, GError **error); -void _g_simple_async_result_complete_with_cancellable - (GSimpleAsyncResult *result, - GCancellable *cancellable); - G_END_DECLS #endif /* __G_VFS_DAEMON_DBUS_H__ */ diff --git a/client/gvfsiconloadable.c b/client/gvfsiconloadable.c index 0660b303..80b29cd7 100644 --- a/client/gvfsiconloadable.c +++ b/client/gvfsiconloadable.c @@ -162,13 +162,13 @@ g_vfs_icon_load (GLoadableIcon *icon, typedef void (*AsyncPathCallCallback) (DBusMessage *reply, DBusConnection *connection, - GSimpleAsyncResult *result, + GTask *result, GCancellable *cancellable, gpointer callback_data); typedef struct { - GSimpleAsyncResult *result; + GTask *result; GVfsIcon *vfs_icon; char *op; GCancellable *cancellable; @@ -203,12 +203,12 @@ async_path_call_done (DBusMessage *reply, gpointer _data) { AsyncPathCall *data = _data; - GSimpleAsyncResult *result; + GTask *result; if (io_error != NULL) { - g_simple_async_result_set_from_error (data->result, io_error); - _g_simple_async_result_complete_with_cancellable (data->result, data->cancellable); + g_task_return_error (data->result, io_error); + _g_task_async_result_complete_with_cancellable (data->result, data->cancellable); async_path_call_free (data); } else @@ -238,8 +238,8 @@ do_async_path_call_callback (GMountInfo *mount_info, if (error != NULL) { - g_simple_async_result_set_from_error (data->result, error); - _g_simple_async_result_complete_with_cancellable (data->result, data->cancellable); + g_task_return_error (data->result, error); + _g_task_async_result_complete_with_cancellable (data->result, data->cancellable); async_path_call_free (data); return; } @@ -287,7 +287,7 @@ do_async_path_call (GVfsIcon *vfs_icon, data = g_new0 (AsyncPathCall, 1); - data->result = g_simple_async_result_new (G_OBJECT (vfs_icon), + data->result = g_task_new (vfs_icon, op_callback, op_callback_data, NULL); @@ -320,7 +320,7 @@ do_async_path_call (GVfsIcon *vfs_icon, } typedef struct { - GSimpleAsyncResult *result; + GTask *result; GCancellable *cancellable; gboolean can_seek; } GetFDData; @@ -334,17 +334,17 @@ load_async_get_fd_cb (int fd, if (fd == -1) { - g_simple_async_result_set_error (data->result, + g_task_return_new_error (data->result, G_IO_ERROR, G_IO_ERROR_FAILED, _("Couldn't get stream file descriptor")); } else { stream = g_daemon_file_input_stream_new (fd, data->can_seek); - g_simple_async_result_set_op_res_gpointer (data->result, stream, g_object_unref); + g_task_return_pointer (data->result, stream, g_object_unref); } - _g_simple_async_result_complete_with_cancellable (data->result, + _g_task_async_result_complete_with_cancellable (data->result, data->cancellable); g_object_unref (data->result); @@ -356,7 +356,7 @@ load_async_get_fd_cb (int fd, static void load_async_cb (DBusMessage *reply, DBusConnection *connection, - GSimpleAsyncResult *result, + GTask *result, GCancellable *cancellable, gpointer callback_data) { @@ -369,10 +369,10 @@ load_async_cb (DBusMessage *reply, DBUS_TYPE_BOOLEAN, &can_seek, DBUS_TYPE_INVALID)) { - g_simple_async_result_set_error (result, + g_task_return_new_error (result, G_IO_ERROR, G_IO_ERROR_FAILED, _("Invalid return value from %s"), "open"); - _g_simple_async_result_complete_with_cancellable (result, cancellable); + _g_task_async_result_complete_with_cancellable (result, cancellable); return; } @@ -407,10 +407,10 @@ g_vfs_icon_load_finish (GLoadableIcon *icon, char **type, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); + GTask *task = G_TASK (res); gpointer op; - op = g_simple_async_result_get_op_res_gpointer (simple); + op = g_task_propagate_pointer (task, error); if (op) return g_object_ref (op); diff --git a/common/gmountsource.c b/common/gmountsource.c index cf567fcb..43181573 100644 --- a/common/gmountsource.c +++ b/common/gmountsource.c @@ -162,18 +162,17 @@ ask_password_reply (DBusMessage *reply, GError *error, gpointer _data) { - GSimpleAsyncResult *result; + GTask *task; AskPasswordData *data; dbus_bool_t handled, aborted, anonymous; guint32 password_save; const char *password, *username, *domain; DBusMessageIter iter; - result = G_SIMPLE_ASYNC_RESULT (_data); + task = G_TASK (_data); handled = TRUE; data = g_new0 (AskPasswordData, 1); - g_simple_async_result_set_op_res_gpointer (result, data, ask_password_data_free); if (reply == NULL) { @@ -209,13 +208,15 @@ ask_password_reply (DBusMessage *reply, } } - if (handled == FALSE) + if (handled == TRUE) + g_task_return_pointer (task, data, ask_password_data_free); + else { - g_simple_async_result_set_error (result, G_IO_ERROR, G_IO_ERROR_FAILED, "Internal Error"); + ask_password_data_free (data); + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, "Internal Error"); } - g_simple_async_result_complete (result); - g_object_unref (result); + g_object_unref (task); } void @@ -227,7 +228,7 @@ g_mount_source_ask_password_async (GMountSource *source, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *result; + GTask *task; DBusMessage *message; guint32 flags_as_int; @@ -235,11 +236,9 @@ g_mount_source_ask_password_async (GMountSource *source, /* If no dbus id specified, reply that we weren't handled */ if (source->dbus_id[0] == 0) { - g_simple_async_report_error_in_idle (G_OBJECT (source), - callback, - user_data, - G_IO_ERROR, G_IO_ERROR_FAILED, - "Internal Error"); + g_task_report_new_error (source, callback, user_data, + G_IO_ERROR, G_IO_ERROR_FAILED, + "Internal Error"); return; } @@ -264,13 +263,11 @@ g_mount_source_ask_password_async (GMountSource *source, DBUS_TYPE_UINT32, &flags_as_int, 0); - result = g_simple_async_result_new (G_OBJECT (source), callback, user_data, - g_mount_source_ask_password_async); + task = g_task_new (source, cancellable, callback, user_data); /* 30 minute timeout */ _g_dbus_connection_call_async (NULL, message, 1000 * 60 * 30, - ask_password_reply, result); + ask_password_reply, task); dbus_message_unref (message); - } /** @@ -306,35 +303,26 @@ g_mount_source_ask_password_finish (GMountSource *source, GPasswordSave *password_save_out) { AskPasswordData *data, def = { TRUE, }; - GSimpleAsyncResult *simple; + GTask *task; - simple = G_SIMPLE_ASYNC_RESULT (result); + task = G_TASK (result); - if (g_simple_async_result_propagate_error (simple, NULL)) + if (g_task_had_error (task)) data = &def; else - data = (AskPasswordData *) g_simple_async_result_get_op_res_gpointer (simple); + data = g_task_propagate_pointer (task, NULL); if (aborted) *aborted = data->aborted; if (password_out) - { - *password_out = data->password; - data->password = NULL; - } + *password_out = data->password; if (user_out) - { - *user_out = data->username; - data->username = NULL; - } + *user_out = data->username; if (domain_out) - { - *domain_out = data->domain; - data->domain = NULL; - } + *domain_out = data->domain; if (anonymous_out) *anonymous_out = data->anonymous; @@ -342,7 +330,13 @@ g_mount_source_ask_password_finish (GMountSource *source, if (password_save_out) *password_save_out = data->password_save; - return data != &def; + if (data == &def) + return FALSE; + else + { + g_free (data); + return TRUE; + } } @@ -497,17 +491,16 @@ ask_question_reply (DBusMessage *reply, GError *error, gpointer _data) { - GSimpleAsyncResult *result; + GTask *task; AskQuestionData *data; dbus_bool_t handled, aborted; guint32 choice; DBusMessageIter iter; - result = G_SIMPLE_ASYNC_RESULT (_data); + task = G_TASK (_data); handled = TRUE; data = g_new0 (AskQuestionData, 1); - g_simple_async_result_set_op_res_gpointer (result, data, g_free); if (reply == NULL) { @@ -529,13 +522,15 @@ ask_question_reply (DBusMessage *reply, } } - if (handled == FALSE) + if (handled == TRUE) + g_task_return_pointer (task, data, g_free); + else { - g_simple_async_result_set_error (result, G_IO_ERROR, G_IO_ERROR_FAILED, "Internal Error"); + g_free (data); + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, "Internal Error"); } - g_simple_async_result_complete (result); - g_object_unref (result); + g_object_unref (task); } gboolean @@ -592,17 +587,15 @@ g_mount_source_ask_question_async (GMountSource *source, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *result; + GTask *task; DBusMessage *message; /* If no dbus id specified, reply that we weren't handled */ if (source->dbus_id[0] == 0) { - g_simple_async_report_error_in_idle (G_OBJECT (source), - callback, - user_data, - G_IO_ERROR, G_IO_ERROR_FAILED, - "Internal Error"); + g_task_report_new_error (source, callback, user_data, + G_IO_ERROR, G_IO_ERROR_FAILED, + "Internal Error"); return; } @@ -620,11 +613,10 @@ g_mount_source_ask_question_async (GMountSource *source, &choices, n_choices, 0); - result = g_simple_async_result_new (G_OBJECT (source), callback, user_data, - g_mount_source_ask_question_async); + task = g_task_new (source, cancellable, callback, user_data); /* 30 minute timeout */ _g_dbus_connection_call_async (NULL, message, 1000 * 60 * 30, - ask_question_reply, result); + ask_question_reply, task); dbus_message_unref (message); } @@ -636,14 +628,14 @@ g_mount_source_ask_question_finish (GMountSource *source, gint *choice_out) { AskQuestionData *data, def= { FALSE, }; - GSimpleAsyncResult *simple; + GTask *task; - simple = G_SIMPLE_ASYNC_RESULT (result); + task = G_TASK (result); - if (g_simple_async_result_propagate_error (simple, NULL)) + if (g_task_had_error (task)) data = &def; else - data = (AskQuestionData *) g_simple_async_result_get_op_res_gpointer (simple); + data = (AskQuestionData *) g_task_propaget_pointer (task, NULL); if (aborted) *aborted = data->aborted; @@ -651,7 +643,13 @@ g_mount_source_ask_question_finish (GMountSource *source, if (choice_out) *choice_out = data->choice; - return data != &def; + if (data == &def) + return FALSE; + else + { + g_free (data); + return TRUE; + } } static void @@ -718,17 +716,16 @@ show_processes_reply (DBusMessage *reply, GError *error, gpointer _data) { - GSimpleAsyncResult *result; + GTask *task; ShowProcessesData *data; dbus_bool_t handled, aborted; guint32 choice; DBusMessageIter iter; - result = G_SIMPLE_ASYNC_RESULT (_data); + task = G_TASK (_data); handled = TRUE; data = g_new0 (ShowProcessesData, 1); - g_simple_async_result_set_op_res_gpointer (result, data, g_free); if (reply == NULL) { @@ -750,13 +747,15 @@ show_processes_reply (DBusMessage *reply, } } - if (handled == FALSE) + if (handled == TRUE) + g_task_return_pointer (task, data, g_free); + else { - g_simple_async_result_set_error (result, G_IO_ERROR, G_IO_ERROR_FAILED, "Internal Error"); + g_free (data); + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, "Internal Error"); } - g_simple_async_result_complete (result); - g_object_unref (result); + g_object_unref (task); } void @@ -768,22 +767,19 @@ g_mount_source_show_processes_async (GMountSource *source, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *result; + GTask *task; DBusMessage *message; /* If no dbus id specified, reply that we weren't handled */ if (source->dbus_id[0] == 0) { - g_simple_async_report_error_in_idle (G_OBJECT (source), - callback, - user_data, - G_IO_ERROR, G_IO_ERROR_FAILED, - "Internal Error"); + g_task_report_new_error (source, callback, user_data, + G_IO_ERROR, G_IO_ERROR_FAILED, + "Internal Error"); return; } - result = g_simple_async_result_new (G_OBJECT (source), callback, user_data, - g_mount_source_show_processes_async); + task = g_task_new (source, cancellable, callback, user_data); if (message_string == NULL) message_string = ""; @@ -803,7 +799,7 @@ g_mount_source_show_processes_async (GMountSource *source, /* 30 minute timeout */ _g_dbus_connection_call_async (NULL, message, 1000 * 60 * 30, - show_processes_reply, result); + show_processes_reply, task); dbus_message_unref (message); } @@ -814,14 +810,14 @@ g_mount_source_show_processes_finish (GMountSource *source, gint *choice_out) { ShowProcessesData *data, def= { FALSE, }; - GSimpleAsyncResult *simple; + GTask *task; - simple = G_SIMPLE_ASYNC_RESULT (result); + task = G_TASK (result); - if (g_simple_async_result_propagate_error (simple, NULL)) + if (g_task_had_error (task, NULL)) data = &def; else - data = (ShowProcessesData *) g_simple_async_result_get_op_res_gpointer (simple); + data = (ShowProcessesData *) g_task_propagate_pointer (task); if (aborted) *aborted = data->aborted; @@ -829,7 +825,13 @@ g_mount_source_show_processes_finish (GMountSource *source, if (choice_out) *choice_out = data->choice; - return data != &def; + if (data != &def) + return FALSE; + else + { + g_free (data); + return TRUE; + } } gboolean diff --git a/common/gvfsdnssdresolver.c b/common/gvfsdnssdresolver.c index 1bb92e94..318d96ac 100644 --- a/common/gvfsdnssdresolver.c +++ b/common/gvfsdnssdresolver.c @@ -1055,7 +1055,6 @@ service_resolver_cb (AvahiServiceResolver *avahi_resolver, typedef struct { GVfsDnsSdResolver *resolver; - GSimpleAsyncResult *simple; guint timeout_id; } ResolveData; @@ -1067,88 +1066,84 @@ resolve_data_free (ResolveData *data) if (data->timeout_id > 0) g_source_remove (data->timeout_id); g_signal_handlers_disconnect_by_func (data->resolver, service_resolver_changed, data); - g_object_unref (data->simple); g_free (data); } static void service_resolver_changed (GVfsDnsSdResolver *resolver, - ResolveData *data) + GTask *task) { if (resolver->is_resolved) { - g_simple_async_result_set_op_res_gboolean (data->simple, TRUE); - g_simple_async_result_complete (data->simple); - resolve_data_free (data); + g_task_return_boolean (task, TRUE); } else { - if (data->resolver->address != NULL) + if (resolver->address != NULL) { /* keep going until timeout if we're missing TXT records */ } else { - g_simple_async_result_set_error (data->simple, - G_IO_ERROR, - G_IO_ERROR_FAILED, + g_task_return_new_error (task, + G_IO_ERROR, + G_IO_ERROR_FAILED, /* Translators: * - the first %s refers to the service type * - the second %s refers to the service name * - the third %s refers to the domain */ - _("Error resolving \"%s\" service \"%s\" on domain \"%s\""), - data->resolver->service_type, - data->resolver->service_name, - data->resolver->domain); - g_simple_async_result_complete (data->simple); - resolve_data_free (data); + _("Error resolving \"%s\" service \"%s\" on domain \"%s\""), + resolver->service_type, + resolver->service_name, + resolver->domain); } } } static gboolean -service_resolver_timed_out (ResolveData *data) +service_resolver_timed_out (GTask *task) { + GVfsDnsSdResolver *resolver = g_task_get_source_object (task); + ResolveData *data = g_task_get_task_data (task); - if (data->resolver->address != NULL) + data->timeout_id = 0; + + if (resolver->address != NULL) { /* special case if one of the required TXT records are missing */ - g_simple_async_result_set_error (data->simple, - G_IO_ERROR, - G_IO_ERROR_FAILED, + g_task_return_new_error (task, + G_IO_ERROR, + G_IO_ERROR_FAILED, /* Translators: * - the first %s refers to the service type * - the second %s refers to the service name * - the third %s refers to the domain * - the fourth %s refers to the required TXT keys */ - _("Error resolving \"%s\" service \"%s\" on domain \"%s\". " - "One or more TXT records are missing. Keys required: \"%s\"."), - data->resolver->service_type, - data->resolver->service_name, - data->resolver->domain, - data->resolver->required_txt_keys); + _("Error resolving \"%s\" service \"%s\" on domain \"%s\". " + "One or more TXT records are missing. Keys required: \"%s\"."), + resolver->service_type, + resolver->service_name, + resolver->domain, + resolver->required_txt_keys); } else { - g_simple_async_result_set_error (data->simple, - G_IO_ERROR, - G_IO_ERROR_TIMED_OUT, + g_task_return_new_error (task, + G_IO_ERROR, + G_IO_ERROR_TIMED_OUT, /* Translators: * - the first %s refers to the service type * - the second %s refers to the service name * - the third %s refers to the domain */ - _("Timed out resolving \"%s\" service \"%s\" on domain \"%s\""), - data->resolver->service_type, - data->resolver->service_name, - data->resolver->domain); + _("Timed out resolving \"%s\" service \"%s\" on domain \"%s\""), + resolver->service_type, + resolver->service_name, + resolver->domain); } - g_simple_async_result_complete (data->simple); - data->timeout_id = 0; - resolve_data_free (data); return FALSE; } @@ -1157,14 +1152,9 @@ g_vfs_dns_sd_resolver_resolve_finish (GVfsDnsSdResolver *resolver, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - - g_return_val_if_fail (G_VFS_IS_DNS_SD_RESOLVER (resolver), FALSE); + g_return_val_if_fail (g_task_is_valid (res, resolver), FALSE); - g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_vfs_dns_sd_resolver_resolve); - g_simple_async_result_propagate_error (simple, error); - - return g_simple_async_result_get_op_res_gboolean (simple); + return g_task_propagate_boolean (G_TASK (res), error); } void @@ -1174,49 +1164,39 @@ g_vfs_dns_sd_resolver_resolve (GVfsDnsSdResolver *resolver, gpointer user_data) { ResolveData *data; - GSimpleAsyncResult *simple; + GTask *task; GError *error; g_return_if_fail (G_VFS_IS_DNS_SD_RESOLVER (resolver)); - simple = g_simple_async_result_new (G_OBJECT (resolver), - callback, - user_data, - g_vfs_dns_sd_resolver_resolve); - + task = g_task_new (resolver, cancellable, callback, user_data); if (resolver->is_resolved) { - g_simple_async_result_set_op_res_gboolean (simple, TRUE); - g_simple_async_result_complete (simple); - g_object_unref (simple); - goto out; + g_task_return_boolean (task, TRUE); + g_object_unref (task); + return; } error = NULL; if (!ensure_avahi_resolver (resolver, &error)) { - g_simple_async_result_set_from_error (simple, error); - g_simple_async_result_complete (simple); - g_object_unref (simple); - g_error_free (error); - goto out; + g_task_return_error (task, error); + g_object_unref (task); + return; } data = g_new0 (ResolveData, 1); data->resolver = resolver; - data->simple = simple; data->timeout_id = g_timeout_add (resolver->timeout_msec, (GSourceFunc) service_resolver_timed_out, - data); + task); + g_task_set_task_data (task, data, (GDestroyNotify) resolve_data_free); g_signal_connect (resolver, "changed", (GCallback) service_resolver_changed, - data); - - out: - ; + task); } diff --git a/common/gvfsmountinfo.c b/common/gvfsmountinfo.c index c49b0554..342fe5bf 100644 --- a/common/gvfsmountinfo.c +++ b/common/gvfsmountinfo.c @@ -52,7 +52,7 @@ on_icon_file_located (GObject *source_object, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GFile *icon_file; GError *error; @@ -61,17 +61,10 @@ on_icon_file_located (GObject *source_object, res, &error); if (icon_file != NULL) - { - g_simple_async_result_set_op_res_gpointer (simple, g_file_icon_new (icon_file), NULL); - g_object_unref (icon_file); - } + g_task_return_pointer (task, g_file_icon_new (icon_file), g_object_unref); else - { - g_simple_async_result_set_from_error (simple, error); - g_error_free (error); - } - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_return_error (task, error); + g_object_unref (task); } static void @@ -79,7 +72,7 @@ on_autorun_loaded (GObject *source_object, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GFile *autorun_file; gchar *content; gchar *relative_icon_path; @@ -163,7 +156,7 @@ on_autorun_loaded (GObject *source_object, relative_icon_path, NULL, on_icon_file_located, - simple); + task); g_object_unref (root); } @@ -181,10 +174,8 @@ on_autorun_loaded (GObject *source_object, if (error != NULL) { - g_simple_async_result_set_from_error (simple, error); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); - g_error_free (error); + g_task_return_error (task, error); + g_object_unref (task); } g_free (relative_icon_path); @@ -195,7 +186,7 @@ on_autorun_located (GObject *source_object, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GFile *autorun_path; GError *error; @@ -205,17 +196,15 @@ on_autorun_located (GObject *source_object, &error); if (error != NULL) { - g_simple_async_result_set_from_error (simple, error); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); - g_error_free (error); + g_task_return_error (task, error); + g_object_unref (task); } else { g_file_load_contents_async (autorun_path, - g_object_get_data (G_OBJECT (simple), "cancellable"), + g_task_get_cancellable (task), on_autorun_loaded, - simple); + task); g_object_unref (autorun_path); } } @@ -226,21 +215,14 @@ g_vfs_mount_info_query_autorun_info (GFile *directory, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; - - simple = g_simple_async_result_new (G_OBJECT (directory), - callback, - user_data, - g_vfs_mount_info_query_autorun_info); - - if (cancellable != NULL) - g_object_set_data_full (G_OBJECT (simple), "cancellable", g_object_ref (cancellable), g_object_unref); + GTask *task; + task = g_task_new (directory, cancellable, callback, user_data); _g_find_file_insensitive_async (directory, "autorun.inf", cancellable, on_autorun_located, - simple); + task); } GIcon * @@ -248,20 +230,9 @@ g_vfs_mount_info_query_autorun_info_finish (GFile *directory, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - GIcon *ret; + g_return_val_if_fail (g_task_is_valid (res, directory), NULL); - g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_vfs_mount_info_query_autorun_info); - - ret = NULL; - - if (g_simple_async_result_propagate_error (simple, error)) - goto out; - - ret = g_simple_async_result_get_op_res_gpointer (simple); - - out: - return ret; + return g_task_propagate_pointer (G_TASK (res), error); } /* ---------------------------------------------------------------------------------------------------- */ @@ -271,7 +242,7 @@ on_xdg_volume_info_loaded (GObject *source_object, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GFile *xdg_volume_info_file; gchar *content; gsize content_length; @@ -351,11 +322,10 @@ on_xdg_volume_info_loaded (GObject *source_object, g_themed_icon_append_name (G_THEMED_ICON (icon), "drive"); } - g_simple_async_result_set_op_res_gpointer (simple, icon, NULL); - g_object_set_data_full (G_OBJECT (simple), "name", name, g_free); + g_object_set_data_full (G_OBJECT (task), "name", name, g_free); name = NULL; /* steals name */ - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_return_pointer (task, icon, g_object_unref); + g_object_unref (task); } out: @@ -365,10 +335,8 @@ on_xdg_volume_info_loaded (GObject *source_object, if (error != NULL) { - g_simple_async_result_set_from_error (simple, error); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); - g_error_free (error); + g_task_return_error (task, error); + g_object_unref (task); } g_free (name); @@ -383,44 +351,34 @@ g_vfs_mount_info_query_xdg_volume_info (GFile *directory, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; + GTask *task; GFile *file; - simple = g_simple_async_result_new (G_OBJECT (directory), - callback, - user_data, - g_vfs_mount_info_query_xdg_volume_info); + task = g_task_new (directory, cancellable, callback, user_data); file = g_file_resolve_relative_path (directory, ".xdg-volume-info"); g_file_load_contents_async (file, cancellable, on_xdg_volume_info_loaded, - simple); + task); g_object_unref (file); } -GIcon *g_vfs_mount_info_query_xdg_volume_info_finish (GFile *directory, - GAsyncResult *res, - gchar **out_name, - GError **error) +GIcon * +g_vfs_mount_info_query_xdg_volume_info_finish (GFile *directory, + GAsyncResult *res, + gchar **out_name, + GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - GIcon *ret; + GTask *task; - g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_vfs_mount_info_query_xdg_volume_info); + g_return_val_if_fail (g_task_is_valid (res, directory), NULL); - ret = NULL; + task = G_TASK (res); + if (out_name != NULL && !g_task_had_error (task)) + *out_name = g_strdup (g_object_get_data (G_OBJECT (task), "name")); - if (g_simple_async_result_propagate_error (simple, error)) - goto out; - - ret = g_simple_async_result_get_op_res_gpointer (simple); - - if (out_name != NULL) - *out_name = g_strdup (g_object_get_data (G_OBJECT (simple), "name")); - - out: - return ret; + return g_task_propagate_pointer (task, error); } /* ---------------------------------------------------------------------------------------------------- */ @@ -465,8 +423,9 @@ get_icon (META_DL *meta) } static void -bdmv_metadata_thread (GSimpleAsyncResult *result, - GObject *object, +bdmv_metadata_thread (GTask *task, + gpointer object, + gpointer task_data, GCancellable *cancellable) { BLURAY *bd; @@ -486,10 +445,11 @@ bdmv_metadata_thread (GSimpleAsyncResult *result, if (bd == NULL) { - error = g_error_new_literal (G_IO_ERROR, - G_IO_ERROR_FAILED, - "Device is not a Blu-Ray disc"); - goto error; + g_task_return_new_error (task, + G_IO_ERROR, + G_IO_ERROR_FAILED, + "Device is not a Blu-Ray disc"); + return; } lang = get_iso_639_3_for_locale (); @@ -499,11 +459,12 @@ bdmv_metadata_thread (GSimpleAsyncResult *result, meta = bd_get_meta (bd); if (meta == NULL) { - error = g_error_new_literal (G_IO_ERROR, - G_IO_ERROR_FAILED, - "Device is not a Blu-Ray disc, or has no metadata"); + g_task_return_new_error (task, + G_IO_ERROR, + G_IO_ERROR_FAILED, + "Device is not a Blu-Ray disc, or has no metadata"); bd_close (bd); - goto error; + return; } name = icon = NULL; @@ -528,6 +489,9 @@ bdmv_metadata_thread (GSimpleAsyncResult *result, } /* Set the results */ + if (name != NULL) + g_object_set_data_full (G_OBJECT (task), "name", name, g_free); + if (icon != NULL) { char *icon_path; @@ -538,26 +502,14 @@ bdmv_metadata_thread (GSimpleAsyncResult *result, icon_file = g_file_resolve_relative_path (file, icon_path); g_free (icon_path); - g_simple_async_result_set_op_res_gpointer (result, - g_file_icon_new (icon_file), - NULL); + g_task_return_pointer (task, g_file_icon_new (icon_file), g_object_unref); } else { - g_simple_async_result_set_op_res_gpointer (result, NULL, NULL); + g_task_return_pointer (task, NULL, NULL); } - if (name != NULL) - g_object_set_data_full (G_OBJECT (result), "name", name, g_free); - bd_close (bd); - - return; - -error: - g_simple_async_result_set_from_error (result, error); - g_simple_async_result_set_op_res_gpointer (result, NULL, NULL); - g_error_free (error); } #endif /* HAVE_BLURAY */ @@ -567,55 +519,38 @@ g_vfs_mount_info_query_bdmv_volume_info (GFile *directory, GAsyncReadyCallback callback, gpointer user_data) { + GTask *task; + + task = g_task_new (directory, cancellable, callback, user_data); + #ifdef HAVE_BLURAY - GSimpleAsyncResult *simple; - - simple = g_simple_async_result_new (G_OBJECT (directory), - callback, - user_data, - g_vfs_mount_info_query_bdmv_volume_info); - g_simple_async_result_run_in_thread (simple, - (GSimpleAsyncThreadFunc) bdmv_metadata_thread, - G_PRIORITY_DEFAULT, - cancellable); - g_object_unref (simple); + g_task_run_in_thread (task, bdmv_metadata_thread); #else - GSimpleAsyncResult *simple; - - simple = g_simple_async_result_new (G_OBJECT (directory), - callback, - user_data, - g_vfs_mount_info_query_bdmv_volume_info); - g_simple_async_result_set_error (simple, - G_IO_ERROR, - G_IO_ERROR_NOT_SUPPORTED, - "gvfs built without Expat support, no BDMV support"); - g_object_unref (simple); + g_task_return_new_error (task, + G_IO_ERROR, + G_IO_ERROR_NOT_SUPPORTED, + "gvfs built without Expat support, no BDMV support"); #endif /* HAVE_BLURAY */ + + g_object_unref (task); } -GIcon *g_vfs_mount_info_query_bdmv_volume_info_finish (GFile *directory, - GAsyncResult *res, - gchar **out_name, - GError **error) +GIcon * +g_vfs_mount_info_query_bdmv_volume_info_finish (GFile *directory, + GAsyncResult *res, + gchar **out_name, + GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); - GIcon *ret; - - g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_vfs_mount_info_query_bdmv_volume_info); + GTask *task; - ret = NULL; + g_warn_if_fail (g_task_async_result_get_source_tag (task) == g_vfs_mount_info_query_bdmv_volume_info); - if (g_simple_async_result_propagate_error (simple, error)) - goto out; + task = G_TASK (res); - ret = g_simple_async_result_get_op_res_gpointer (simple); + if (out_name != NULL && !g_task_had_error (task)) + *out_name = g_strdup (g_object_get_data (G_OBJECT (task), "name")); - if (out_name != NULL) - *out_name = g_strdup (g_object_get_data (G_OBJECT (simple), "name")); - - out: - return ret; + return g_task_propagate_pointer (task, error); } /* ---------------------------------------------------------------------------------------------------- */ @@ -643,10 +578,6 @@ typedef struct _InsensitiveFileSearchData gint index; GFileEnumerator *enumerator; GFile *current_file; - - GCancellable *cancellable; - GAsyncReadyCallback callback; - gpointer user_data; } InsensitiveFileSearchData; static void @@ -656,22 +587,22 @@ _g_find_file_insensitive_async (GFile *parent, GAsyncReadyCallback callback, gpointer user_data) { + GTask *task; InsensitiveFileSearchData *data; GFile *direct_file = g_file_get_child (parent, name); + task = g_task_new (parent, cancellable, callback, user_data); + data = g_new0 (InsensitiveFileSearchData, 1); - data->cancellable = cancellable; - data->callback = callback; - data->user_data = user_data; data->root = g_object_ref (parent); data->original_path = g_strdup (name); + g_task_set_task_data (task, data, + (GDestroyNotify)clear_file_file_insensitive_state); g_file_query_info_async (direct_file, G_FILE_ATTRIBUTE_STANDARD_TYPE, G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, cancellable, - find_file_insensitive_exists_callback, data); - - + find_file_insensitive_exists_callback, task); } static void @@ -695,25 +626,16 @@ find_file_insensitive_exists_callback (GObject *source_object, gpointer user_data) { GFileInfo *info; - InsensitiveFileSearchData *data = (InsensitiveFileSearchData *) (user_data); + GTask *task = user_data; + InsensitiveFileSearchData *data = g_task_get_task_data (task); /* The file exists and can be found with the given path, no need to search. */ if ((info = g_file_query_info_finish (G_FILE (source_object), res, NULL))) { - GSimpleAsyncResult *simple; - - simple = g_simple_async_result_new (G_OBJECT (data->root), - data->callback, - data->user_data, - _g_find_file_insensitive_async); - - g_simple_async_result_set_op_res_gpointer (simple, g_object_ref (source_object), g_object_unref); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); - clear_find_file_insensitive_state (data); + g_task_return_pointer (task, g_object_ref (source_object), g_object_unref); + g_object_unref (task); g_object_unref (info); } - else { data->split_path = g_strsplit (data->original_path, G_DIR_SEPARATOR_S, -1); @@ -727,10 +649,10 @@ find_file_insensitive_exists_callback (GObject *source_object, data->index++; g_file_enumerate_children_async (data->current_file, - G_FILE_ATTRIBUTE_STANDARD_NAME, - 0, G_PRIORITY_DEFAULT, - data->cancellable, - enumerated_children_callback, data); + G_FILE_ATTRIBUTE_STANDARD_NAME, 0, + g_task_get_priority (task), + g_task_get_cancellable (task), + enumerated_children_callback, task); } g_object_unref (source_object); @@ -741,27 +663,20 @@ enumerated_children_callback (GObject *source_object, GAsyncResult *res, gpointer user_data) { GFileEnumerator *enumerator; - InsensitiveFileSearchData *data = (InsensitiveFileSearchData *) (user_data); + GTask *task = user_data; + InsensitiveFileSearchData *data = g_task_get_task_data (task); enumerator = g_file_enumerate_children_finish (G_FILE (source_object), res, NULL); if (enumerator == NULL) { - GSimpleAsyncResult *simple; GFile *file; - simple = g_simple_async_result_new (G_OBJECT (data->root), - data->callback, - data->user_data, - _g_find_file_insensitive_async); - file = g_file_get_child (data->root, data->original_path); - g_simple_async_result_set_op_res_gpointer (simple, g_object_ref (file), g_object_unref); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); - clear_find_file_insensitive_state (data); + g_task_return_pointer (task, g_object_ref (file), g_object_unref); + g_object_unref (task); return; } @@ -771,14 +686,15 @@ enumerated_children_callback (GObject *source_object, GAsyncResult *res, G_PRIORITY_DEFAULT, data->cancellable, more_files_callback, - data); + task); } static void more_files_callback (GObject *source_object, GAsyncResult *res, gpointer user_data) { - InsensitiveFileSearchData *data = (InsensitiveFileSearchData *) (user_data); + GTask *task = user_data; + InsensitiveFileSearchData *data = g_task_get_task_data (task); GList *files, *l; gchar *filename = NULL, *component, *case_folded_name, *name_collation_key; @@ -864,49 +780,32 @@ more_files_callback (GObject *source_object, GAsyncResult *res, if (data->split_path[data->index] == NULL) { /* Search is complete, file was found */ - GSimpleAsyncResult *simple; - - simple = g_simple_async_result_new (G_OBJECT (data->root), - data->callback, - data->user_data, - _g_find_file_insensitive_async); - - g_simple_async_result_set_op_res_gpointer (simple, g_object_ref (data->current_file), g_object_unref); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); - clear_find_file_insensitive_state (data); + g_task_return_pointer (task, g_object_ref (data->current_file), g_object_unref); + g_object_unref (task); return; } /* Continue searching down the tree */ g_file_enumerate_children_async (data->current_file, - G_FILE_ATTRIBUTE_STANDARD_NAME, - 0, G_PRIORITY_DEFAULT, - data->cancellable, + G_FILE_ATTRIBUTE_STANDARD_NAME, 0, + g_task_get_priority (task), + g_task_get_cancellable (task), enumerated_children_callback, - data); + task); return; } if (end_of_files) { /* Could not find the given file, abort the search */ - GSimpleAsyncResult *simple; GFile *file; g_object_unref (data->enumerator); data->enumerator = NULL; - simple = g_simple_async_result_new (G_OBJECT (data->root), - data->callback, - data->user_data, - _g_find_file_insensitive_async); - file = g_file_get_child (data->root, data->original_path); - g_simple_async_result_set_op_res_gpointer (simple, file, g_object_unref); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); - clear_find_file_insensitive_state (data); + g_task_return_pointer (task, file, g_object_unref); + g_object_unref (task); return; } @@ -924,16 +823,9 @@ _g_find_file_insensitive_finish (GFile *parent, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; GFile *file; - g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL); - - simple = G_SIMPLE_ASYNC_RESULT (result); - - if (g_simple_async_result_propagate_error (simple, error)) - return NULL; + g_return_val_if_fail (g_task_is_valid (result, parent), NULL); - file = G_FILE (g_simple_async_result_get_op_res_gpointer (simple)); - return g_object_ref (file); + return g_task_propagate_pointer (G_TASK (result), error); } diff --git a/daemon/gvfsafpconnection.c b/daemon/gvfsafpconnection.c index be489c54..b49f915a 100644 --- a/daemon/gvfsafpconnection.c +++ b/daemon/gvfsafpconnection.c @@ -662,7 +662,7 @@ typedef struct GVfsAfpCommand *command; char *reply_buf; - GSimpleAsyncResult *simple; + GTask *task; GCancellable *cancellable; } RequestData; @@ -671,8 +671,8 @@ free_request_data (RequestData *req_data) { if (req_data->command) g_object_unref (req_data->command); - if (req_data->simple) - g_object_unref (req_data->simple); + if (req_data->task) + g_object_unref (req_data->task); if (req_data->cancellable) g_object_unref (req_data->cancellable); @@ -785,7 +785,7 @@ static void read_all_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GInputStream *stream = G_INPUT_STREAM (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); gsize bytes_read; GError *err = NULL; @@ -794,11 +794,11 @@ read_all_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) bytes_read = g_input_stream_read_finish (stream, res, &err); if (bytes_read == -1) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } - read_data = g_simple_async_result_get_op_res_gpointer (simple); + read_data = g_task_propagate_pointer (task, error); read_data->bytes_read += bytes_read; if (read_data->bytes_read < read_data->count) @@ -806,13 +806,13 @@ read_all_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) g_input_stream_read_async (stream, (guint8 *)read_data->buffer + read_data->bytes_read, read_data->count - read_data->bytes_read, 0, - read_data->cancellable, read_all_cb, simple); + read_data->cancellable, read_all_cb, task); return; } done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static void @@ -825,7 +825,7 @@ read_all_async (GInputStream *stream, gpointer user_data) { ReadAllData *read_data; - GSimpleAsyncResult *simple; + GTask *task; read_data = g_slice_new0 (ReadAllData); read_data->buffer = buffer; @@ -834,13 +834,13 @@ read_all_async (GInputStream *stream, if (cancellable) read_data->cancellable = g_object_ref (cancellable); - simple = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, + task = g_task_new (stream, callback, user_data, read_all_async); - g_simple_async_result_set_op_res_gpointer (simple, read_data, + g_task_return_pointer (task, read_data, (GDestroyNotify)free_read_all_data); g_input_stream_read_async (stream, buffer, count, io_priority, cancellable, - read_all_cb, simple); + read_all_cb, task); } static gboolean @@ -849,22 +849,22 @@ read_all_finish (GInputStream *stream, gsize *bytes_read, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (stream), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (stream), read_all_async), FALSE); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; if (bytes_read) { ReadAllData *read_data; - read_data = g_simple_async_result_get_op_res_gpointer (simple); + read_data = g_task_propagate_pointer (task, error); *bytes_read = read_data->bytes_read; } @@ -923,9 +923,9 @@ dispatch_reply (GVfsAfpConnection *afp_connection) dsi_header->totalDataLength, priv->free_reply_buf); priv->free_reply_buf = FALSE; - g_simple_async_result_set_op_res_gpointer (req_data->simple, reply, + g_task_return_pointer (req_data->task, reply, g_object_unref); - g_simple_async_result_complete (req_data->simple); + g_task_async_result_complete (req_data->task); g_hash_table_remove (priv->request_hash, GUINT_TO_POINTER ((guint)dsi_header->requestID)); @@ -1051,7 +1051,7 @@ write_all_cb (GObject *source_object, gpointer user_data) { GOutputStream *stream = G_OUTPUT_STREAM (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); gssize bytes_written; GError *err = NULL; @@ -1060,11 +1060,11 @@ write_all_cb (GObject *source_object, bytes_written = g_output_stream_write_finish (stream, res, &err); if (bytes_written == -1) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } - write_data = g_simple_async_result_get_op_res_gpointer (simple); + write_data = g_task_propagate_pointer (task, error); write_data->bytes_written += bytes_written; if (write_data->bytes_written < write_data->count) @@ -1073,13 +1073,13 @@ write_all_cb (GObject *source_object, (const guint8 *)write_data->buffer + write_data->bytes_written, write_data->count - write_data->bytes_written, write_data->io_priority, write_data->cancellable, - write_all_cb, simple); + write_all_cb, task); return; } done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static void @@ -1091,7 +1091,7 @@ write_all_async (GOutputStream *stream, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; + GTask *task; WriteAllData *write_data; write_data = g_slice_new0 (WriteAllData); @@ -1101,13 +1101,13 @@ write_all_async (GOutputStream *stream, if (cancellable) write_data->cancellable = g_object_ref (cancellable); - simple = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, + task = g_task_new (stream, callback, user_data, write_all_async); - g_simple_async_result_set_op_res_gpointer (simple, write_data, + g_task_return_pointer (task, write_data, (GDestroyNotify)free_write_all_data); g_output_stream_write_async (stream, buffer, count, io_priority, cancellable, - write_all_cb, simple); + write_all_cb, task); } static gboolean @@ -1116,14 +1116,14 @@ write_all_finish (GOutputStream *stream, gsize *bytes_written, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (stream), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (stream), write_all_async), FALSE); - simple = (GSimpleAsyncResult *)res; - if (g_simple_async_result_propagate_error (simple, error)) + task = (GTask *)res; + if (g_task_async_result_propagate_error (task, error)) return FALSE; @@ -1131,7 +1131,7 @@ write_all_finish (GOutputStream *stream, { WriteAllData *write_data; - write_data = g_simple_async_result_get_op_res_gpointer (simple); + write_data = g_task_propagate_pointer (task, error); *bytes_written = write_data->bytes_written; } @@ -1154,10 +1154,10 @@ remove_first (GQueue *request_queue) result = write_all_finish (output, res, NULL, &err); \ if (!result) \ { \ - if (req_data->simple) \ + if (req_data->task) \ { \ - g_simple_async_result_set_from_error (req_data->simple, err); \ - g_simple_async_result_complete (req_data->simple); \ + g_task_return_error (req_data->task, err); \ + g_task_async_result_complete (req_data->task); \ } \ \ remove_first (priv->request_queue); \ @@ -1261,13 +1261,13 @@ send_request (GVfsAfpConnection *afp_connection) { if (req_data->cancellable && g_cancellable_is_cancelled (req_data->cancellable)) { - if (req_data->simple) + if (req_data->task) { GError *err = NULL; g_cancellable_set_error_if_cancelled (req_data->cancellable, &err); - g_simple_async_result_take_error (req_data->simple, err); - g_simple_async_result_complete (req_data->simple); + g_task_async_result_take_error (req_data->task, err); + g_task_async_result_complete (req_data->task); } remove_first (priv->request_queue); } @@ -1354,7 +1354,7 @@ g_vfs_afp_connection_send_command (GVfsAfpConnection *afp_connection, req_data->command = g_object_ref (command); req_data->reply_buf = reply_buf; - req_data->simple = g_simple_async_result_new (G_OBJECT (afp_connection), callback, + req_data->task = g_task_new (afp_connection, callback, user_data, g_vfs_afp_connection_send_command); if (cancellable) @@ -1370,19 +1370,19 @@ g_vfs_afp_connection_send_command_finish (GVfsAfpConnection *afp_connection, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (afp_connection), g_vfs_afp_connection_send_command), NULL); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return NULL; - return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple)); + return g_object_ref (g_task_propagate_pointer (task, error)); } static gboolean diff --git a/daemon/gvfsafpserver.c b/daemon/gvfsafpserver.c index 8dbd3077..5992b6b4 100644 --- a/daemon/gvfsafpserver.c +++ b/daemon/gvfsafpserver.c @@ -1132,7 +1132,7 @@ static void get_volumes_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *afp_conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -1144,7 +1144,7 @@ get_volumes_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) reply = g_vfs_afp_connection_send_command_finish (afp_conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -1153,7 +1153,7 @@ get_volumes_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { g_object_unref (reply); - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); goto done; } @@ -1185,11 +1185,11 @@ get_volumes_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) } g_object_unref (reply); - g_simple_async_result_set_op_res_gpointer (simple, volumes, + g_task_return_pointer (task, volumes, (GDestroyNotify)g_ptr_array_unref); done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -1209,18 +1209,18 @@ g_vfs_afp_server_get_volumes (GVfsAfpServer *server, gpointer user_data) { GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; /* Get Server Parameters */ comm = g_vfs_afp_command_new (AFP_COMMAND_GET_SRVR_PARMS); /* pad byte */ g_vfs_afp_command_put_byte (comm, 0); - simple = g_simple_async_result_new (G_OBJECT (server), callback, user_data, + task = g_task_new (server, callback, user_data, g_vfs_afp_server_get_volumes); g_vfs_afp_connection_send_command (server->conn, comm, NULL, get_volumes_cb, - cancellable, simple); + cancellable, task); } /* @@ -1242,19 +1242,19 @@ g_vfs_afp_server_get_volumes_finish (GVfsAfpServer *server, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (result, + g_return_val_if_fail (g_task_async_result_is_valid (result, G_OBJECT (server), g_vfs_afp_server_get_volumes), NULL); - simple = (GSimpleAsyncResult *)result; + task = (GTask *)result; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return NULL; - return g_ptr_array_ref ((GPtrArray *)g_simple_async_result_get_op_res_gpointer (simple)); + return g_ptr_array_ref ((GPtrArray *)g_task_propagate_pointer (task, error)); } GVfsAfpVolume * diff --git a/daemon/gvfsafpvolume.c b/daemon/gvfsafpvolume.c index 3fd33f28..a56386bd 100644 --- a/daemon/gvfsafpvolume.c +++ b/daemon/gvfsafpvolume.c @@ -173,9 +173,9 @@ static void get_vol_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *connection = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); - GVfsAfpVolume *volume = G_VFS_AFP_VOLUME (g_async_result_get_source_object (G_ASYNC_RESULT (simple))); + GVfsAfpVolume *volume = G_VFS_AFP_VOLUME (g_async_result_get_source_object (G_ASYNC_RESULT (task))); GVfsAfpVolumePrivate *priv = volume->priv; GVfsAfpReply *reply; @@ -188,7 +188,7 @@ get_vol_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) reply = g_vfs_afp_connection_send_command_finish (connection, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -197,7 +197,7 @@ get_vol_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { g_object_unref (reply); - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); goto done; } @@ -259,11 +259,11 @@ get_vol_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) g_object_unref (reply); - g_simple_async_result_set_op_res_gpointer (simple, info, g_object_unref); + g_task_return_pointer (task, info, g_object_unref); done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -286,7 +286,7 @@ g_vfs_afp_volume_get_parms (GVfsAfpVolume *volume, { GVfsAfpVolumePrivate *priv; GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; priv = volume->priv; @@ -298,12 +298,12 @@ g_vfs_afp_volume_get_parms (GVfsAfpVolume *volume, /* Volume Bitmap */ g_vfs_afp_command_put_uint16 (comm, vol_bitmap); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, user_data, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_get_parms); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, get_vol_parms_cb, - cancellable, simple); + cancellable, task); g_object_unref (comm); } @@ -325,19 +325,19 @@ g_vfs_afp_volume_get_parms_finish (GVfsAfpVolume *volume, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (result, + g_return_val_if_fail (g_task_async_result_is_valid (result, G_OBJECT (volume), g_vfs_afp_volume_get_parms), NULL); - simple = (GSimpleAsyncResult *)result; + task = (GTask *)result; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return NULL; - return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple)); + return g_object_ref (g_task_propagate_pointer (task, error)); } typedef struct @@ -358,7 +358,7 @@ static void open_fork_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpVolume *volume; GVfsAfpVolumePrivate *priv; @@ -369,13 +369,13 @@ open_fork_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) OpenForkData *data; guint16 file_bitmap; - volume = G_VFS_AFP_VOLUME (g_async_result_get_source_object (G_ASYNC_RESULT (simple))); + volume = G_VFS_AFP_VOLUME (g_async_result_get_source_object (G_ASYNC_RESULT (task))); priv = volume->priv; reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -387,23 +387,23 @@ open_fork_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Permission denied")); break; case AFP_RESULT_OBJECT_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("File doesn't exist")); break; case AFP_RESULT_OBJECT_TYPE_ERR: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY, _("File is directory")); break; case AFP_RESULT_TOO_MANY_FILES_OPEN: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_TOO_MANY_OPEN_FILES, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_TOO_MANY_OPEN_FILES, _("Too many files open")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } goto done; @@ -418,12 +418,12 @@ open_fork_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) g_vfs_afp_server_fill_info (priv->server, data->info, reply, FALSE, file_bitmap); g_object_unref (reply); - g_simple_async_result_set_op_res_gpointer (simple, data, + g_task_return_pointer (task, data, (GDestroyNotify)open_fork_data_free); done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -451,7 +451,7 @@ g_vfs_afp_volume_open_fork (GVfsAfpVolume *volume, { GVfsAfpVolumePrivate *priv; GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -459,7 +459,7 @@ g_vfs_afp_volume_open_fork (GVfsAfpVolume *volume, if (is_root (filename)) { - g_simple_async_report_error_in_idle (G_OBJECT (volume), callback, + g_task_async_report_error_in_idle (G_OBJECT (volume), callback, user_data, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY, _("File is directory")); return; @@ -483,11 +483,11 @@ g_vfs_afp_volume_open_fork (GVfsAfpVolume *volume, /* Pathname */ g_vfs_afp_command_put_pathname (comm, filename); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_open_fork); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, - open_fork_cb, cancellable, simple); + open_fork_cb, cancellable, task); g_object_unref (comm); } @@ -512,20 +512,20 @@ g_vfs_afp_volume_open_fork_finish (GVfsAfpVolume *volume, GFileInfo **info, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; OpenForkData *data; - g_return_val_if_fail (g_simple_async_result_is_valid (res, + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (volume), g_vfs_afp_volume_open_fork), FALSE); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; - data = g_simple_async_result_get_op_res_gpointer (simple); + data = g_task_propagate_pointer (task, error); if (fork_refnum) *fork_refnum = data->fork_refnum; if (info) @@ -538,7 +538,7 @@ static void close_fork_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -547,7 +547,7 @@ close_fork_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -555,11 +555,11 @@ close_fork_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) g_object_unref (reply); if (res_code != AFP_RESULT_NO_ERROR) - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -582,7 +582,7 @@ g_vfs_afp_volume_close_fork (GVfsAfpVolume *volume, { GVfsAfpVolumePrivate *priv; GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -595,11 +595,11 @@ g_vfs_afp_volume_close_fork (GVfsAfpVolume *volume, /* OForkRefNum */ g_vfs_afp_command_put_int16 (comm, fork_refnum); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, user_data, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_close_fork); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, - close_fork_cb, cancellable, simple); + close_fork_cb, cancellable, task); g_object_unref (comm); } @@ -620,16 +620,16 @@ g_vfs_afp_volume_close_fork_finish (GVfsAfpVolume *volume, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (result, + g_return_val_if_fail (g_task_async_result_is_valid (result, G_OBJECT (volume), g_vfs_afp_volume_close_fork), FALSE); - simple = (GSimpleAsyncResult *)result; + task = (GTask *)result; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; return TRUE; @@ -639,7 +639,7 @@ static void delete_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -648,7 +648,7 @@ delete_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -660,38 +660,38 @@ delete_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Permission denied")); break; case AFP_RESULT_FILE_BUSY: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_BUSY, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_BUSY, _("Target file is open")); break; case AFP_RESULT_DIR_NOT_EMPTY: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_EMPTY, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_EMPTY, _("Directory not empty")); break; case AFP_RESULT_OBJECT_LOCKED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, _("Target object is marked as not deletable (DeleteInhibit)")); break; case AFP_RESULT_OBJECT_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Target object doesn't exist")); break; case AFP_RESULT_VOL_LOCKED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Volume is read-only")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } } done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -714,7 +714,7 @@ g_vfs_afp_volume_delete (GVfsAfpVolume *volume, { GVfsAfpVolumePrivate *priv; GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -731,11 +731,11 @@ g_vfs_afp_volume_delete (GVfsAfpVolume *volume, /* Pathname */ g_vfs_afp_command_put_pathname (comm, filename); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_delete); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, - delete_cb, cancellable, simple); + delete_cb, cancellable, task); g_object_unref (comm); } @@ -756,16 +756,16 @@ g_vfs_afp_volume_delete_finish (GVfsAfpVolume *volume, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (result, + g_return_val_if_fail (g_task_async_result_is_valid (result, G_OBJECT (volume), g_vfs_afp_volume_delete), FALSE); - simple = (GSimpleAsyncResult *)result; + task = (GTask *)result; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; return TRUE; @@ -792,7 +792,7 @@ static void create_file_cb (GObject *object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -802,7 +802,7 @@ create_file_cb (GObject *object, GAsyncResult *res, gpointer user_data) reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -813,38 +813,38 @@ create_file_cb (GObject *object, GAsyncResult *res, gpointer user_data) switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Permission denied")); break; case AFP_RESULT_DISK_FULL: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NO_SPACE, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NO_SPACE, _("Not enough space on volume")); break; case AFP_RESULT_FILE_BUSY: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_EXISTS, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_EXISTS, _("Target file is open")); break; case AFP_RESULT_OBJECT_EXISTS: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_EXISTS, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_EXISTS, _("Target file already exists")); break; case AFP_RESULT_OBJECT_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Ancestor directory doesn't exist")); break; case AFP_RESULT_VOL_LOCKED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Volume is read-only")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } } done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static void @@ -852,9 +852,9 @@ create_file_get_filedir_parms_cb (GObject *source_object, GAsyncResult *res, gpo { GVfsAfpVolume *volume = G_VFS_AFP_VOLUME (source_object); GVfsAfpVolumePrivate *priv = volume->priv; - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); - CreateFileData *cfd = g_simple_async_result_get_op_res_gpointer (simple); + CreateFileData *cfd = g_task_propagate_pointer (task, error); GFileInfo *info; GError *err = NULL; @@ -866,9 +866,9 @@ create_file_get_filedir_parms_cb (GObject *source_object, GAsyncResult *res, gpo info = g_vfs_afp_volume_get_filedir_parms_finish (volume, res, &err); if (!info) { - g_simple_async_result_take_error (simple, err); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_take_error (task, err); + g_task_async_result_complete (task); + g_object_unref (task); return; } @@ -889,7 +889,7 @@ create_file_get_filedir_parms_cb (GObject *source_object, GAsyncResult *res, gpo g_free (basename); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, - create_file_cb, cfd->cancellable, simple); + create_file_cb, cfd->cancellable, task); g_object_unref (comm); } @@ -915,7 +915,7 @@ g_vfs_afp_volume_create_file (GVfsAfpVolume *volume, gpointer user_data) { CreateFileData *cfd; - GSimpleAsyncResult *simple; + GTask *task; char *dirname; cfd = g_slice_new0 (CreateFileData); @@ -924,14 +924,14 @@ g_vfs_afp_volume_create_file (GVfsAfpVolume *volume, if (cancellable) cfd->cancellable = g_object_ref (cancellable); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, user_data, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_create_file); - g_simple_async_result_set_op_res_gpointer (simple, cfd, + g_task_return_pointer (task, cfd, (GDestroyNotify)create_file_data_free); dirname = g_path_get_dirname (filename); g_vfs_afp_volume_get_filedir_parms (volume, dirname, 0, AFP_DIR_BITMAP_NODE_ID_BIT, - cancellable, create_file_get_filedir_parms_cb, simple); + cancellable, create_file_get_filedir_parms_cb, task); g_free (dirname); } @@ -952,16 +952,16 @@ g_vfs_afp_volume_create_file_finish (GVfsAfpVolume *volume, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (result, + g_return_val_if_fail (g_task_async_result_is_valid (result, G_OBJECT (volume), g_vfs_afp_volume_create_file), FALSE); - simple = (GSimpleAsyncResult *)result; + task = (GTask *)result; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; return TRUE; @@ -986,7 +986,7 @@ static void make_directory_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -995,7 +995,7 @@ make_directory_cb (GObject *source_object, GAsyncResult *res, gpointer user_data reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -1007,47 +1007,47 @@ make_directory_cb (GObject *source_object, GAsyncResult *res, gpointer user_data switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Permission denied")); break; case AFP_RESULT_DISK_FULL: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NO_SPACE, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NO_SPACE, _("Not enough space on volume")); break; case AFP_RESULT_FLAT_VOL: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("Volume is flat and doesn't support directories")); break; case AFP_RESULT_OBJECT_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Ancestor directory doesn't exist")); break; case AFP_RESULT_OBJECT_EXISTS: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_EXISTS, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_EXISTS, _("Target directory already exists")); break; case AFP_RESULT_VOL_LOCKED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Volume is read-only")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } goto done; } done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static void create_directory_get_filedir_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpVolume *volume = G_VFS_AFP_VOLUME (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); - CreateDirData *cdd = g_simple_async_result_get_op_res_gpointer (simple); + GTask *task = G_TASK (user_data); + CreateDirData *cdd = g_task_propagate_pointer (task, error); GFileInfo *info = NULL; GError *err = NULL; @@ -1077,15 +1077,15 @@ create_directory_get_filedir_parms_cb (GObject *source_object, GAsyncResult *res g_vfs_afp_command_put_pathname (comm, cdd->basename); g_vfs_afp_connection_send_command (volume->priv->server->conn, comm, NULL, - make_directory_cb, cdd->cancellable, simple); + make_directory_cb, cdd->cancellable, task); g_object_unref (comm); return; error: g_clear_object (info); - g_simple_async_result_take_error (simple, err); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_take_error (task, err); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -1108,20 +1108,20 @@ g_vfs_afp_volume_create_directory (GVfsAfpVolume *volume, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; + GTask *task; CreateDirData *cdd; char *dirname; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, user_data, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_create_directory); cdd = g_slice_new (CreateDirData); cdd->basename = g_path_get_basename (directory); cdd->cancellable = cancellable ? g_object_ref (cancellable) : NULL; - g_simple_async_result_set_op_res_gpointer (simple, cdd, + g_task_return_pointer (task, cdd, (GDestroyNotify)create_dir_data_free); dirname = g_path_get_dirname (directory); @@ -1129,7 +1129,7 @@ g_vfs_afp_volume_create_directory (GVfsAfpVolume *volume, AFP_DIR_BITMAP_NODE_ID_BIT, cancellable, create_directory_get_filedir_parms_cb, - simple); + task); g_free (dirname); } @@ -1150,16 +1150,16 @@ g_vfs_afp_volume_create_directory_finish (GVfsAfpVolume *volume, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (result, + g_return_val_if_fail (g_task_async_result_is_valid (result, G_OBJECT (volume), g_vfs_afp_volume_create_directory), FALSE); - simple = (GSimpleAsyncResult *)result; + task = (GTask *)result; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; return TRUE; @@ -1186,7 +1186,7 @@ static void rename_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -1195,7 +1195,7 @@ rename_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -1207,39 +1207,39 @@ rename_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Permission denied")); break; case AFP_RESULT_CANT_RENAME: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_INVALID_FILENAME, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_INVALID_FILENAME, _("Can't rename volume")); break; case AFP_RESULT_OBJECT_EXISTS: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_EXISTS, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_EXISTS, _("Object with that name already exists")); break; case AFP_RESULT_OBJECT_LOCKED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, _("Target object is marked as not renameable (RenameInhibit)")); break; case AFP_RESULT_OBJECT_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Target object doesn't exist")); break; case AFP_RESULT_VOL_LOCKED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Volume is read-only")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } goto done; } done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static void @@ -1248,8 +1248,8 @@ rename_get_filedir_parms_cb (GObject *source_object, gpointer user_data) { GVfsAfpVolume *volume = G_VFS_AFP_VOLUME (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); - RenameData *rd = g_simple_async_result_get_op_res_gpointer (simple); + GTask *task = G_TASK (user_data); + RenameData *rd = g_task_propagate_pointer (task, error); GFileInfo *info; GError *err = NULL; @@ -1261,9 +1261,9 @@ rename_get_filedir_parms_cb (GObject *source_object, info = g_vfs_afp_volume_get_filedir_parms_finish (volume, res, &err); if (!info) { - g_simple_async_result_take_error (simple, err); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_take_error (task, err); + g_task_async_result_complete (task); + g_object_unref (task); return; } @@ -1287,7 +1287,7 @@ rename_get_filedir_parms_cb (GObject *source_object, g_vfs_afp_command_put_pathname (comm, rd->new_name); g_vfs_afp_connection_send_command (volume->priv->server->conn, comm, NULL, - rename_cb, rd->cancellable, simple); + rename_cb, rd->cancellable, task); g_object_unref (comm); } @@ -1311,26 +1311,26 @@ g_vfs_afp_volume_rename (GVfsAfpVolume *volume, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; + GTask *task; RenameData *rd; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, user_data, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_rename); rd = g_slice_new (RenameData); rd->filename = g_strdup (filename); rd->new_name = g_strdup (new_name); rd->cancellable = g_object_ref (cancellable); - g_simple_async_result_set_op_res_gpointer (simple, rd, + g_task_return_pointer (task, rd, (GDestroyNotify)rename_data_free); g_vfs_afp_volume_get_filedir_parms (volume, filename, AFP_FILEDIR_BITMAP_PARENT_DIR_ID_BIT, AFP_FILEDIR_BITMAP_PARENT_DIR_ID_BIT, cancellable, rename_get_filedir_parms_cb, - simple); + task); } /* @@ -1350,15 +1350,15 @@ g_vfs_afp_volume_rename_finish (GVfsAfpVolume *volume, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (volume), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (volume), g_vfs_afp_volume_rename), FALSE); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; return TRUE; @@ -1368,7 +1368,7 @@ static void move_and_rename_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -1378,7 +1378,7 @@ move_and_rename_cb (GObject *source_object, GAsyncResult *res, gpointer user_dat reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -1390,42 +1390,42 @@ move_and_rename_cb (GObject *source_object, GAsyncResult *res, gpointer user_dat switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Permission denied")); break; case AFP_RESULT_CANT_MOVE: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_WOULD_RECURSE, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_WOULD_RECURSE, _("Can't move directory into one of its descendants")); break; case AFP_RESULT_INSIDE_SHARE_ERR: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, _("Can't move sharepoint into a shared directory")); break; case AFP_RESULT_INSIDE_TRASH_ERR: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, _("Can't move a shared directory into the Trash")); break; case AFP_RESULT_OBJECT_EXISTS: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_EXISTS, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_EXISTS, _("Target file already exists")); break; case AFP_RESULT_OBJECT_LOCKED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Object being moved is marked as not renameable (RenameInhibit)")); break; case AFP_RESULT_OBJECT_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Object being moved doesn't exist")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } } done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -1451,7 +1451,7 @@ g_vfs_afp_volume_move_and_rename (GVfsAfpVolume *volume, GVfsAfpVolumePrivate *priv; GVfsAfpCommand *comm; char *dirname, *basename; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -1482,11 +1482,11 @@ g_vfs_afp_volume_move_and_rename (GVfsAfpVolume *volume, g_vfs_afp_command_put_pathname (comm, basename); g_free (basename); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_move_and_rename); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, - move_and_rename_cb, cancellable, simple); + move_and_rename_cb, cancellable, task); g_object_unref (comm); } @@ -1507,15 +1507,15 @@ g_vfs_afp_volume_move_and_rename_finish (GVfsAfpVolume *volume, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (volume), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (volume), g_vfs_afp_volume_move_and_rename), FALSE); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; return TRUE; @@ -1525,7 +1525,7 @@ static void copy_file_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -1535,7 +1535,7 @@ copy_file_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -1547,42 +1547,42 @@ copy_file_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Permission denied")); break; case AFP_RESULT_CALL_NOT_SUPPORTED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("Server doesn't support the FPCopyFile operation")); break; case AFP_RESULT_DENY_CONFLICT: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, _("Unable to open source file for reading")); break; case AFP_RESULT_DISK_FULL: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NO_SPACE, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NO_SPACE, _("Not enough space on volume")); break; case AFP_RESULT_OBJECT_EXISTS: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_EXISTS, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_EXISTS, _("Target file already exists")); break; case AFP_RESULT_OBJECT_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Source file and/or destination directory doesn't exist")); break; case AFP_RESULT_OBJECT_TYPE_ERR: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY, _("Source file is a directory")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } } done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -1609,7 +1609,7 @@ g_vfs_afp_volume_copy_file (GVfsAfpVolume *volume, GVfsAfpCommand *comm; char *dirname, *basename; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -1642,11 +1642,11 @@ g_vfs_afp_volume_copy_file (GVfsAfpVolume *volume, g_vfs_afp_command_put_pathname (comm, basename); g_free (basename); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_copy_file); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, - copy_file_cb, cancellable, simple); + copy_file_cb, cancellable, task); g_object_unref (comm); } @@ -1667,15 +1667,15 @@ g_vfs_afp_volume_copy_file_finish (GVfsAfpVolume *volume, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (volume), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (volume), g_vfs_afp_volume_copy_file), FALSE); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; return TRUE; @@ -1699,7 +1699,7 @@ static void map_id_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -1710,8 +1710,8 @@ map_id_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); - g_simple_async_result_complete (simple); + g_task_async_result_take_error (task, err); + g_task_async_result_complete (task); return; } @@ -1721,19 +1721,19 @@ map_id_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) switch (res_code) { case AFP_RESULT_ITEM_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, _("ID not found")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } - g_simple_async_result_complete (simple); + g_task_async_result_complete (task); return; } - map_data = g_simple_async_result_get_op_res_gpointer (simple); + map_data = g_task_propagate_pointer (task, error); if (map_data->function == AFP_MAP_ID_FUNCTION_USER_UUID_TO_UTF8_NAME || map_data->function == AFP_MAP_ID_FUNCTION_GROUP_UUID_TO_UTF8_NAME) @@ -1758,7 +1758,7 @@ map_id_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) g_vfs_afp_name_unref (afp_name); } - g_simple_async_result_complete (simple); + g_task_async_result_complete (task); } /* @@ -1783,7 +1783,7 @@ g_vfs_afp_volume_map_id (GVfsAfpVolume *volume, { GVfsAfpVolumePrivate *priv; GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; MapIDData *map_data; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -1802,16 +1802,16 @@ g_vfs_afp_volume_map_id (GVfsAfpVolume *volume, else g_vfs_afp_command_put_int64 (comm, id); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_map_id); map_data = g_slice_new0 (MapIDData); map_data->function = map_function; - g_simple_async_result_set_op_res_gpointer (simple, map_data, + g_task_return_pointer (task, map_data, (GDestroyNotify)map_id_data_free); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, - map_id_cb, cancellable, simple); + map_id_cb, cancellable, task); g_object_unref (comm); } @@ -1836,19 +1836,19 @@ g_vfs_afp_volume_map_id_finish (GVfsAfpVolume *volume, AfpMapIDFunction *map_function, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; MapIDData *map_data; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (volume), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (volume), g_vfs_afp_volume_map_id), NULL); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return NULL; - map_data = g_simple_async_result_get_op_res_gpointer (simple); + map_data = g_task_propagate_pointer (task, error); if (map_function) *map_function = map_data->function; @@ -1860,8 +1860,8 @@ static void get_filedir_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); - GVfsAfpVolume *volume = G_VFS_AFP_VOLUME (g_async_result_get_source_object (G_ASYNC_RESULT (simple))); + GTask *task = G_TASK (user_data); + GVfsAfpVolume *volume = G_VFS_AFP_VOLUME (g_async_result_get_source_object (G_ASYNC_RESULT (task))); GVfsAfpReply *reply; GError *err = NULL; @@ -1875,7 +1875,7 @@ get_filedir_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_d reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -1887,11 +1887,11 @@ get_filedir_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_d switch (res_code) { case AFP_RESULT_OBJECT_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("File doesn't exist")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } goto done; @@ -1912,11 +1912,11 @@ get_filedir_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_d g_object_unref (reply); - g_simple_async_result_set_op_res_gpointer (simple, info, g_object_unref); + g_task_return_pointer (task, info, g_object_unref); done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -1946,7 +1946,7 @@ g_vfs_afp_volume_get_filedir_parms (GVfsAfpVolume *volume, { GVfsAfpVolumePrivate *priv; GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -1966,13 +1966,13 @@ g_vfs_afp_volume_get_filedir_parms (GVfsAfpVolume *volume, /* PathName */ g_vfs_afp_command_put_pathname (comm, filename); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, user_data, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_get_filedir_parms); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, get_filedir_parms_cb, cancellable, - simple); + task); g_object_unref (comm); } @@ -1994,27 +1994,27 @@ g_vfs_afp_volume_get_filedir_parms_finish (GVfsAfpVolume *volume, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (result, + g_return_val_if_fail (g_task_async_result_is_valid (result, G_OBJECT (volume), g_vfs_afp_volume_get_filedir_parms), NULL); - simple = (GSimpleAsyncResult *)result; + task = (GTask *)result; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return NULL; - return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple)); + return g_object_ref (g_task_propagate_pointer (task, error)); } static void get_fork_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); - GVfsAfpVolume *volume = G_VFS_AFP_VOLUME (g_async_result_get_source_object (G_ASYNC_RESULT (simple))); + GTask *task = G_TASK (user_data); + GVfsAfpVolume *volume = G_VFS_AFP_VOLUME (g_async_result_get_source_object (G_ASYNC_RESULT (task))); GVfsAfpVolumePrivate *priv = volume->priv; GVfsAfpReply *reply; @@ -2027,7 +2027,7 @@ get_fork_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -2036,7 +2036,7 @@ get_fork_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data { g_object_unref (reply); - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); goto done; } @@ -2047,11 +2047,11 @@ get_fork_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data g_object_unref (reply); - g_simple_async_result_set_op_res_gpointer (simple, info, g_object_unref); + g_task_return_pointer (task, info, g_object_unref); done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -2077,7 +2077,7 @@ g_vfs_afp_volume_get_fork_parms (GVfsAfpVolume *volume, { GVfsAfpVolumePrivate *priv; GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -2091,13 +2091,13 @@ g_vfs_afp_volume_get_fork_parms (GVfsAfpVolume *volume, /* Bitmap */ g_vfs_afp_command_put_uint16 (comm, file_bitmap); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, user_data, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_get_fork_parms); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, get_fork_parms_cb, cancellable, - simple); + task); g_object_unref (comm); } @@ -2119,26 +2119,26 @@ g_vfs_afp_volume_get_fork_parms_finish (GVfsAfpVolume *volume, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (result, + g_return_val_if_fail (g_task_async_result_is_valid (result, G_OBJECT (volume), g_vfs_afp_volume_get_fork_parms), NULL); - simple = (GSimpleAsyncResult *)result; + task = (GTask *)result; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return NULL; - return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple)); + return g_object_ref (g_task_propagate_pointer (task, error)); } static void set_fork_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -2147,7 +2147,7 @@ set_fork_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -2158,27 +2158,27 @@ set_fork_parms_cb (GObject *source_object, GAsyncResult *res, gpointer user_data switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, _("Permission denied")); break; case AFP_RESULT_DISK_FULL: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NO_SPACE, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NO_SPACE, _("Not enough space on volume")); break; case AFP_RESULT_LOCK_ERR: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, _("Range lock conflict exists")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } goto done; } done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -2203,7 +2203,7 @@ g_vfs_afp_volume_set_fork_size (GVfsAfpVolume *volume, { GVfsAfpVolumePrivate *priv; GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -2220,11 +2220,11 @@ g_vfs_afp_volume_set_fork_size (GVfsAfpVolume *volume, /* ForkLen */ g_vfs_afp_command_put_int64 (comm, size); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, user_data, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_set_fork_size); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, - set_fork_parms_cb, cancellable, simple); + set_fork_parms_cb, cancellable, task); g_object_unref (comm); } @@ -2245,16 +2245,16 @@ g_vfs_afp_volume_set_fork_size_finish (GVfsAfpVolume *volume, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (result, + g_return_val_if_fail (g_task_async_result_is_valid (result, G_OBJECT (volume), g_vfs_afp_volume_set_fork_size), FALSE); - simple = (GSimpleAsyncResult *)result; + task = (GTask *)result; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; return TRUE; @@ -2264,7 +2264,7 @@ static void set_unix_privs_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -2273,7 +2273,7 @@ set_unix_privs_cb (GObject *source_object, GAsyncResult *res, gpointer user_data reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -2284,27 +2284,27 @@ set_unix_privs_cb (GObject *source_object, GAsyncResult *res, gpointer user_data switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Permission denied")); break; case AFP_RESULT_OBJECT_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Target object doesn't exist")); break; case AFP_RESULT_VOL_LOCKED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Volume is read-only")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } goto done; } done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -2336,7 +2336,7 @@ g_vfs_afp_volume_set_unix_privs (GVfsAfpVolume *volume, { GVfsAfpVolumePrivate *priv; GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -2366,11 +2366,11 @@ g_vfs_afp_volume_set_unix_privs (GVfsAfpVolume *volume, /* UAPermissions */ g_vfs_afp_command_put_uint32 (comm, ua_permissions); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_set_unix_privs); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, - set_unix_privs_cb, cancellable, simple); + set_unix_privs_cb, cancellable, task); g_object_unref (comm); } @@ -2391,15 +2391,15 @@ g_vfs_afp_volume_set_unix_privs_finish (GVfsAfpVolume *volume, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (volume), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (volume), g_vfs_afp_volume_set_unix_privs), FALSE); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; return TRUE; @@ -2413,9 +2413,9 @@ static void enumerate_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); - GVfsAfpVolume *volume = G_VFS_AFP_VOLUME (g_async_result_get_source_object (G_ASYNC_RESULT (simple))); + GVfsAfpVolume *volume = G_VFS_AFP_VOLUME (g_async_result_get_source_object (G_ASYNC_RESULT (task))); GVfsAfpVolumePrivate *priv = volume->priv; GVfsAfpReply *reply; @@ -2430,7 +2430,7 @@ enumerate_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -2442,23 +2442,23 @@ enumerate_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) switch (res_code) { case AFP_RESULT_OBJECT_NOT_FOUND: - g_simple_async_result_set_op_res_gpointer (simple, NULL, NULL); + g_task_return_pointer (task, NULL, NULL); break; case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, _("Permission denied")); break; case AFP_RESULT_DIR_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Directory doesn't exist")); break; case AFP_RESULT_OBJECT_TYPE_ERR: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY, _("Target object is not a directory")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } goto done; @@ -2498,12 +2498,12 @@ enumerate_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) } g_object_unref (reply); - g_simple_async_result_set_op_res_gpointer (simple, infos, + g_task_return_pointer (task, infos, (GDestroyNotify)g_ptr_array_unref); done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -2531,21 +2531,21 @@ g_vfs_afp_volume_enumerate (GVfsAfpVolume *volume, gint32 max; GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); priv = volume->priv; - simple = g_simple_async_result_new (G_OBJECT (volume), callback, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_enumerate); max = (priv->server->version >= AFP_VERSION_3_1) ? G_MAXINT32 : G_MAXINT16; /* Can't enumerate any more files */ if (start_index > max) { - g_simple_async_result_set_op_res_gpointer (simple, NULL, NULL); - g_simple_async_result_complete_in_idle (simple); + g_task_return_pointer (task, NULL, NULL); + g_task_async_result_complete_in_idle (task); return; } @@ -2588,7 +2588,7 @@ g_vfs_afp_volume_enumerate (GVfsAfpVolume *volume, g_vfs_afp_command_put_pathname (comm, directory); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, - enumerate_cb, cancellable, simple); + enumerate_cb, cancellable, task); g_object_unref (comm); } @@ -2612,19 +2612,19 @@ g_vfs_afp_volume_enumerate_finish (GVfsAfpVolume *volume, GPtrArray **infos, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (volume), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (volume), g_vfs_afp_volume_enumerate), FALSE); g_return_val_if_fail (infos != NULL, FALSE); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; - *infos = g_simple_async_result_get_op_res_gpointer (simple); + *infos = g_task_propagate_pointer (task, error); if (*infos) g_ptr_array_ref (*infos); @@ -2635,7 +2635,7 @@ static void close_replace_exchange_files_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -2644,7 +2644,7 @@ close_replace_exchange_files_cb (GObject *source_object, GAsyncResult *res, gpoi reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -2656,27 +2656,27 @@ close_replace_exchange_files_cb (GObject *source_object, GAsyncResult *res, gpoi switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, _("Permission denied")); break; case AFP_RESULT_ID_NOT_FOUND: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("File doesn't exist")); break; case AFP_RESULT_OBJECT_TYPE_ERR: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY, _("File is directory")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } goto done; } done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -2702,7 +2702,7 @@ g_vfs_afp_volume_exchange_files (GVfsAfpVolume *volume, { GVfsAfpVolumePrivate *priv; GVfsAfpCommand *comm; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -2724,12 +2724,12 @@ g_vfs_afp_volume_exchange_files (GVfsAfpVolume *volume, /* DestPath */ g_vfs_afp_command_put_pathname (comm, destination); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, user_data, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_exchange_files); g_vfs_afp_connection_send_command (priv->server->conn, comm, NULL, close_replace_exchange_files_cb, - cancellable, simple); + cancellable, task); g_object_unref (comm); } @@ -2750,15 +2750,15 @@ g_vfs_afp_volume_exchange_files_finish (GVfsAfpVolume *volume, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (volume), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (volume), g_vfs_afp_volume_exchange_files), FALSE); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; return TRUE; @@ -2768,7 +2768,7 @@ static void write_ext_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -2778,7 +2778,7 @@ write_ext_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -2790,15 +2790,15 @@ write_ext_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, _("File is not open for write access")); break; case AFP_RESULT_DISK_FULL: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NO_SPACE, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NO_SPACE, _("Not enough space on volume")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } goto done; @@ -2808,11 +2808,11 @@ write_ext_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) g_vfs_afp_reply_read_int64 (reply, last_written); g_object_unref (reply); - g_simple_async_result_set_op_res_gpointer (simple, last_written, g_free); + g_task_return_pointer (task, last_written, g_free); done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -2843,7 +2843,7 @@ g_vfs_afp_volume_write_to_fork (GVfsAfpVolume *volume, { GVfsAfpCommand *comm; guint32 req_count; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -2861,11 +2861,11 @@ g_vfs_afp_volume_write_to_fork (GVfsAfpVolume *volume, g_vfs_afp_command_set_buffer (comm, buffer, buffer_size); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, user_data, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_write_to_fork); g_vfs_afp_connection_send_command (volume->priv->server->conn, comm, NULL, - write_ext_cb, cancellable, simple); + write_ext_cb, cancellable, task); g_object_unref (comm); } @@ -2888,19 +2888,19 @@ g_vfs_afp_volume_write_to_fork_finish (GVfsAfpVolume *volume, gint64 *last_written, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (volume), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (volume), g_vfs_afp_volume_write_to_fork), FALSE); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; if (last_written) - *last_written = *((gint64 *)g_simple_async_result_get_op_res_gpointer (simple)); + *last_written = *((gint64 *)g_task_propagate_pointer (task, error)); return TRUE; } @@ -2909,7 +2909,7 @@ static void read_ext_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpConnection *conn = G_VFS_AFP_CONNECTION (source_object); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GVfsAfpReply *reply; GError *err = NULL; @@ -2918,7 +2918,7 @@ read_ext_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) reply = g_vfs_afp_connection_send_command_finish (conn, res, &err); if (!reply) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -2931,22 +2931,22 @@ read_ext_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) switch (res_code) { case AFP_RESULT_ACCESS_DENIED: - g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, _("File is not open for read access")); break; default: - g_simple_async_result_take_error (simple, afp_result_code_to_gerror (res_code)); + g_task_async_result_take_error (task, afp_result_code_to_gerror (res_code)); break; } goto done; } - g_simple_async_result_set_op_res_gssize (simple, g_vfs_afp_reply_get_size (reply)); + g_task_return_int (task, g_vfs_afp_reply_get_size (reply)); g_object_unref (reply); done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } /* @@ -2975,7 +2975,7 @@ g_vfs_afp_volume_read_from_fork (GVfsAfpVolume *volume, { GVfsAfpCommand *comm; guint32 req_count; - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (G_VFS_IS_AFP_VOLUME (volume)); @@ -2991,11 +2991,11 @@ g_vfs_afp_volume_read_from_fork (GVfsAfpVolume *volume, req_count = MIN (bytes_requested, G_MAXUINT32); g_vfs_afp_command_put_int64 (comm, req_count); - simple = g_simple_async_result_new (G_OBJECT (volume), callback, user_data, + task = g_task_new (volume, callback, user_data, g_vfs_afp_volume_read_from_fork); g_vfs_afp_connection_send_command (volume->priv->server->conn, comm, buffer, - read_ext_cb, cancellable, simple); + read_ext_cb, cancellable, task); g_object_unref (comm); } @@ -3018,19 +3018,19 @@ g_vfs_afp_volume_read_from_fork_finish (GVfsAfpVolume *volume, gsize *bytes_read, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (volume), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (volume), g_vfs_afp_volume_read_from_fork), FALSE); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; if (bytes_read) - *bytes_read = g_simple_async_result_get_op_res_gssize (simple); + *bytes_read = g_task_propagate_ssize (task, error); return TRUE; }
\ No newline at end of file diff --git a/daemon/gvfsbackend.c b/daemon/gvfsbackend.c index ced4fd9b..f12eacb9 100644 --- a/daemon/gvfsbackend.c +++ b/daemon/gvfsbackend.c @@ -788,7 +788,7 @@ static void complete_unmount_with_op (UnmountWithOpData *data) { gboolean ret; - GSimpleAsyncResult *simple; + GTask *task; g_source_remove (data->timeout_id); @@ -806,13 +806,13 @@ complete_unmount_with_op (UnmountWithOpData *data) } } - simple = g_simple_async_result_new (G_OBJECT (data->backend), + task = g_task_new (data->backend, data->callback, data->user_data, NULL); - g_simple_async_result_set_op_res_gboolean (simple, ret); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_return_boolean (task, ret); + g_task_async_result_complete (task); + g_object_unref (task); } static void @@ -891,15 +891,15 @@ g_vfs_backend_unmount_with_operation_finish (GVfsBackend *backend, GAsyncResult *res) { gboolean ret; - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); + GTask *task = G_TASK (res); - if (g_simple_async_result_propagate_error (simple, NULL)) + if (g_task_async_result_propagate_error (task, NULL)) { ret = FALSE; } else { - ret = g_simple_async_result_get_op_res_gboolean (simple); + ret = g_task_propagate_boolean (task, error); } return ret; @@ -942,14 +942,14 @@ g_vfs_backend_unmount_with_operation (GVfsBackend *backend, /* if no processes are blocking, complete immediately */ if (processes->len == 0) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new (G_OBJECT (backend), + GTask *task; + task = g_task_new (backend, callback, user_data, NULL); - g_simple_async_result_set_op_res_gboolean (simple, TRUE); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_return_boolean (task, TRUE); + g_task_async_result_complete (task); + g_object_unref (task); goto out; } diff --git a/daemon/gvfsbackendafpbrowse.c b/daemon/gvfsbackendafpbrowse.c index d3de8961..952e9be3 100644 --- a/daemon/gvfsbackendafpbrowse.c +++ b/daemon/gvfsbackendafpbrowse.c @@ -69,18 +69,18 @@ static void get_volumes_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVfsAfpServer *server = G_VFS_AFP_SERVER (source_object); - GSimpleAsyncResult *simple = user_data; + GTask *task = user_data; GVfsBackendAfpBrowse *afp_backend; GPtrArray *volumes; GError *err = NULL; - afp_backend = G_VFS_BACKEND_AFP_BROWSE (g_async_result_get_source_object (G_ASYNC_RESULT (simple))); + afp_backend = G_VFS_BACKEND_AFP_BROWSE (g_async_result_get_source_object (G_ASYNC_RESULT (task))); volumes = g_vfs_afp_server_get_volumes_finish (server, res, &err); if (!volumes) { - g_simple_async_result_take_error (simple, err); + g_task_async_result_take_error (task, err); goto done; } @@ -89,8 +89,8 @@ get_volumes_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) afp_backend->volumes = volumes; done: - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static void @@ -99,13 +99,13 @@ update_cache (GVfsBackendAfpBrowse *afp_backend, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; + GTask *task; - simple = g_simple_async_result_new (G_OBJECT (afp_backend), callback, + task = g_task_new (afp_backend, callback, user_data, update_cache); g_vfs_afp_server_get_volumes (afp_backend->server, cancellable, get_volumes_cb, - simple); + task); } static gboolean @@ -113,15 +113,15 @@ update_cache_finish (GVfsBackendAfpBrowse *afp_backend, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (afp_backend), + g_return_val_if_fail (g_task_async_result_is_valid (res, G_OBJECT (afp_backend), update_cache), FALSE); - simple = (GSimpleAsyncResult *)res; + task = (GTask *)res; - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; return TRUE; diff --git a/daemon/soup-input-stream.c b/daemon/soup-input-stream.c index cb730a30..e787284f 100644 --- a/daemon/soup-input-stream.c +++ b/daemon/soup-input-stream.c @@ -57,7 +57,7 @@ typedef struct { guchar *caller_buffer; gsize caller_bufsize, caller_nread; GAsyncReadyCallback outstanding_callback; - GSimpleAsyncResult *result; + GTask *result; } SoupInputStreamPrivate; #define SOUP_INPUT_STREAM_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_INPUT_STREAM, SoupInputStreamPrivate)) @@ -532,7 +532,7 @@ wrapper_callback (GObject *source_object, GAsyncResult *res, } static void -send_async_thread (GSimpleAsyncResult *res, +send_async_thread (GTask *res, GObject *object, GCancellable *cancellable) { @@ -541,10 +541,10 @@ send_async_thread (GSimpleAsyncResult *res, success = soup_input_stream_send_internal (G_INPUT_STREAM (object), cancellable, &error); - g_simple_async_result_set_op_res_gboolean (res, success); + g_task_return_boolean (res, success); if (error) { - g_simple_async_result_set_from_error (res, error); + g_task_return_error (res, error); g_error_free (error); } } @@ -556,11 +556,11 @@ soup_input_stream_send_async_in_thread (GInputStream *stream, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *res; + GTask *res; - res = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, + res = g_task_new (stream, callback, user_data, soup_input_stream_send_async_in_thread); - g_simple_async_result_run_in_thread (res, send_async_thread, + g_task_run_in_thread (res, send_async_thread, io_priority, cancellable); g_object_unref (res); } @@ -569,7 +569,7 @@ static void send_async_finished (GInputStream *stream) { SoupInputStreamPrivate *priv = SOUP_INPUT_STREAM_GET_PRIVATE (stream); - GSimpleAsyncResult *result; + GTask *result; GError *error = NULL; if (!g_cancellable_set_error_if_cancelled (priv->cancellable, &error)) @@ -582,13 +582,13 @@ send_async_finished (GInputStream *stream) result = priv->result; priv->result = NULL; - g_simple_async_result_set_op_res_gboolean (result, error == NULL); + g_task_return_boolean (result, error == NULL); if (error) { - g_simple_async_result_set_from_error (result, error); + g_task_return_error (result, error); g_error_free (error); } - g_simple_async_result_complete (result); + g_task_async_result_complete (result); g_object_unref (result); } @@ -619,7 +619,7 @@ soup_input_stream_send_async_internal (GInputStream *stream, priv->finished_cb = send_async_finished; soup_input_stream_prepare_for_io (stream, cancellable, NULL, 0); - priv->result = g_simple_async_result_new (G_OBJECT (stream), + priv->result = g_task_new (stream, wrapper_callback, user_data, soup_input_stream_send_async); } @@ -650,7 +650,7 @@ soup_input_stream_send_async (GInputStream *stream, if (!g_input_stream_set_pending (stream, &error)) { - g_simple_async_report_gerror_in_idle (G_OBJECT (stream), + g_task_async_report_gerror_in_idle (G_OBJECT (stream), callback, user_data, error); @@ -678,24 +678,24 @@ soup_input_stream_send_finish (GInputStream *stream, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE); - simple = G_SIMPLE_ASYNC_RESULT (result); + task = G_TASK (result); - g_return_val_if_fail (g_simple_async_result_get_source_tag (simple) == soup_input_stream_send_async, FALSE); + g_return_val_if_fail (g_task_async_result_get_source_tag (task) == soup_input_stream_send_async, FALSE); - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) return FALSE; - return g_simple_async_result_get_op_res_gboolean (simple); + return g_task_propagate_boolean (task, error); } static void read_async_done (GInputStream *stream) { SoupInputStreamPrivate *priv = SOUP_INPUT_STREAM_GET_PRIVATE (stream); - GSimpleAsyncResult *result; + GTask *result; GError *error = NULL; result = priv->result; @@ -704,18 +704,18 @@ read_async_done (GInputStream *stream) if (g_cancellable_set_error_if_cancelled (priv->cancellable, &error) || set_error_if_http_failed (priv->msg, &error)) { - g_simple_async_result_set_from_error (result, error); + g_task_return_error (result, error); g_error_free (error); } else - g_simple_async_result_set_op_res_gssize (result, priv->caller_nread); + g_task_return_int (result, priv->caller_nread); priv->got_chunk_cb = NULL; priv->finished_cb = NULL; priv->cancelled_cb = NULL; soup_input_stream_done_io (stream); - g_simple_async_result_complete (result); + g_task_async_result_complete (result); g_object_unref (result); } @@ -729,7 +729,7 @@ soup_input_stream_read_async (GInputStream *stream, gpointer user_data) { SoupInputStreamPrivate *priv = SOUP_INPUT_STREAM_GET_PRIVATE (stream); - GSimpleAsyncResult *result; + GTask *result; /* If the session uses the default GMainContext, then we can do * async I/O directly. But if it has its own main context, we fall @@ -743,14 +743,14 @@ soup_input_stream_read_async (GInputStream *stream, return; } - result = g_simple_async_result_new (G_OBJECT (stream), + result = g_task_new (stream, callback, user_data, soup_input_stream_read_async); if (priv->finished) { - g_simple_async_result_set_op_res_gssize (result, 0); - g_simple_async_result_complete_in_idle (result); + g_task_return_int (result, 0); + g_task_async_result_complete_in_idle (result); g_object_unref (result); return; } @@ -758,8 +758,8 @@ soup_input_stream_read_async (GInputStream *stream, if (priv->leftover_bufsize) { gsize nread = read_from_leftover (priv, buffer, count); - g_simple_async_result_set_op_res_gssize (result, nread); - g_simple_async_result_complete_in_idle (result); + g_task_return_int (result, nread); + g_task_async_result_complete_in_idle (result); g_object_unref (result); return; } @@ -777,13 +777,13 @@ soup_input_stream_read_finish (GInputStream *stream, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), -1); - simple = G_SIMPLE_ASYNC_RESULT (result); - g_return_val_if_fail (g_simple_async_result_get_source_tag (simple) == soup_input_stream_read_async, -1); + task = G_TASK (result); + g_return_val_if_fail (g_task_async_result_get_source_tag (task) == soup_input_stream_read_async, -1); - return g_simple_async_result_get_op_res_gssize (simple); + return g_task_propagate_ssize (task, error); } static void @@ -793,22 +793,22 @@ soup_input_stream_close_async (GInputStream *stream, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *result; + GTask *result; gboolean success; GError *error = NULL; - result = g_simple_async_result_new (G_OBJECT (stream), + result = g_task_new (stream, callback, user_data, soup_input_stream_close_async); success = soup_input_stream_close (stream, cancellable, &error); - g_simple_async_result_set_op_res_gboolean (result, success); + g_task_return_boolean (result, success); if (error) { - g_simple_async_result_set_from_error (result, error); + g_task_return_error (result, error); g_error_free (error); } - g_simple_async_result_complete_in_idle (result); + g_task_async_result_complete_in_idle (result); g_object_unref (result); } diff --git a/daemon/soup-output-stream.c b/daemon/soup-output-stream.c index 885a8ca7..57099009 100644 --- a/daemon/soup-output-stream.c +++ b/daemon/soup-output-stream.c @@ -48,7 +48,7 @@ typedef struct { SoupOutputStreamCallback finished_cb; SoupOutputStreamCallback cancelled_cb; - GSimpleAsyncResult *result; + GTask *result; } SoupOutputStreamPrivate; #define SOUP_OUTPUT_STREAM_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_OUTPUT_STREAM, SoupOutputStreamPrivate)) @@ -298,9 +298,9 @@ soup_output_stream_write_async (GOutputStream *stream, gpointer user_data) { SoupOutputStreamPrivate *priv = SOUP_OUTPUT_STREAM_GET_PRIVATE (stream); - GSimpleAsyncResult *result; + GTask *result; - result = g_simple_async_result_new (G_OBJECT (stream), + result = g_task_new (stream, callback, user_data, soup_output_stream_write_async); @@ -310,17 +310,17 @@ soup_output_stream_write_async (GOutputStream *stream, error = g_error_new (G_IO_ERROR, G_IO_ERROR_NO_SPACE, "Write would exceed caller-defined file size"); - g_simple_async_result_set_from_error (result, error); + g_task_return_error (result, error); g_error_free (error); } else { g_byte_array_append (priv->ba, buffer, count); priv->offset += count; - g_simple_async_result_set_op_res_gssize (result, count); + g_task_return_int (result, count); } - g_simple_async_result_complete_in_idle (result); + g_task_async_result_complete_in_idle (result); g_object_unref (result); } @@ -329,13 +329,13 @@ soup_output_stream_write_finish (GOutputStream *stream, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + GTask *task; gssize nwritten; - simple = G_SIMPLE_ASYNC_RESULT (result); - g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == soup_output_stream_write_async); + task = G_TASK (result); + g_warn_if_fail (g_task_async_result_get_source_tag (task) == soup_output_stream_write_async); - nwritten = g_simple_async_result_get_op_res_gssize (simple); + nwritten = g_task_propagate_ssize (task, error); return nwritten; } @@ -343,7 +343,7 @@ static void close_async_done (GOutputStream *stream) { SoupOutputStreamPrivate *priv = SOUP_OUTPUT_STREAM_GET_PRIVATE (stream); - GSimpleAsyncResult *result; + GTask *result; GError *error = NULL; result = priv->result; @@ -352,17 +352,17 @@ close_async_done (GOutputStream *stream) if (g_cancellable_set_error_if_cancelled (priv->cancellable, &error) || set_error_if_http_failed (priv->msg, &error)) { - g_simple_async_result_set_from_error (result, error); + g_task_return_error (result, error); g_error_free (error); } else - g_simple_async_result_set_op_res_gboolean (result, TRUE); + g_task_return_boolean (result, TRUE); priv->finished_cb = NULL; priv->cancelled_cb = NULL; soup_output_stream_done_io (stream); - g_simple_async_result_complete (result); + g_task_async_result_complete (result); g_object_unref (result); } @@ -385,9 +385,9 @@ soup_output_stream_close_async (GOutputStream *stream, gpointer user_data) { SoupOutputStreamPrivate *priv = SOUP_OUTPUT_STREAM_GET_PRIVATE (stream); - GSimpleAsyncResult *result; + GTask *result; - result = g_simple_async_result_new (G_OBJECT (stream), + result = g_task_new (stream, callback, user_data, soup_output_stream_close_async); @@ -397,9 +397,9 @@ soup_output_stream_close_async (GOutputStream *stream, error = g_error_new (G_IO_ERROR, G_IO_ERROR_NO_SPACE, "File is incomplete"); - g_simple_async_result_set_from_error (result, error); + g_task_return_error (result, error); g_error_free (error); - g_simple_async_result_complete_in_idle (result); + g_task_async_result_complete_in_idle (result); g_object_unref (result); return; } diff --git a/monitor/gdu/ggdudrive.c b/monitor/gdu/ggdudrive.c index 4e511683..6f1491f1 100644 --- a/monitor/gdu/ggdudrive.c +++ b/monitor/gdu/ggdudrive.c @@ -548,7 +548,7 @@ unmount_mounts_cb (GObject *source_object, { UnmountMountsOp *data = user_data; GMount *mount = G_MOUNT (source_object); - GSimpleAsyncResult *simple; + GTask *task; GError *error = NULL; if (!g_mount_unmount_with_operation_finish (mount, res, &error)) @@ -562,13 +562,13 @@ unmount_mounts_cb (GObject *source_object, } /* unmount failed; need to fail the whole eject operation */ - simple = g_simple_async_result_new_from_error (G_OBJECT (data->drive), + task = g_task_new_from_error (G_OBJECT (data->drive), data->callback, data->user_data, error); g_error_free (error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); free_unmount_mounts_op (data); } @@ -626,7 +626,7 @@ detach_after_eject_cb (GduDevice *device, GError *error, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); /* Don't return an error here - this is because some devices, such as * the Kindle, can do Eject() but not Detach() e.g. the STOP UNIT @@ -638,8 +638,8 @@ detach_after_eject_cb (GduDevice *device, g_error_free (error); } - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static void @@ -647,11 +647,11 @@ eject_cb (GduDevice *device, GError *error, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GGduDrive *drive; gboolean drive_detachable; - drive = G_GDU_DRIVE (g_async_result_get_source_object (G_ASYNC_RESULT (simple))); + drive = G_GDU_DRIVE (g_async_result_get_source_object (G_ASYNC_RESULT (task))); drive_detachable = drive->can_stop == FALSE && drive->start_stop_type == G_DRIVE_START_STOP_TYPE_SHUTDOWN; if (error != NULL && error->code == G_IO_ERROR_FAILED && @@ -664,9 +664,9 @@ eject_cb (GduDevice *device, if (error != NULL) { - g_simple_async_result_set_from_error (simple, error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_return_error (task, error); + g_task_async_result_complete (task); + g_object_unref (task); g_error_free (error); goto out; } @@ -676,13 +676,13 @@ eject_cb (GduDevice *device, /* If device is not ejectable but it is detachable and we don't support stop(), * then also run Detach() after Eject() - see update_drive() for details for why... */ - gdu_device_op_drive_detach (device, detach_after_eject_cb, simple); + gdu_device_op_drive_detach (device, detach_after_eject_cb, task); } else { /* otherwise we are done */ - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } g_object_unref (drive); @@ -698,29 +698,29 @@ g_gdu_drive_eject_on_all_unmounted (GDrive *_drive, gpointer on_all_unmounted_data) { GGduDrive *drive = G_GDU_DRIVE (_drive); - GSimpleAsyncResult *simple; + GTask *task; GduDevice *device; device = gdu_presentable_get_device (drive->presentable); if (device == NULL) { - simple = g_simple_async_result_new_error (G_OBJECT (drive), + task = g_task_new_error (G_OBJECT (drive), callback, user_data, G_IO_ERROR, G_IO_ERROR_FAILED, "Drive is activatable and not running"); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } else { - simple = g_simple_async_result_new (G_OBJECT (drive), + task = g_task_new (drive, callback, user_data, NULL); - gdu_device_op_drive_eject (device, eject_cb, simple); + gdu_device_op_drive_eject (device, eject_cb, task); } } @@ -750,7 +750,7 @@ g_gdu_drive_eject_with_operation_finish (GDrive *drive, GAsyncResult *result, GError **error) { - return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error); + return !g_task_async_result_propagate_error (G_TASK (result), error); } static void @@ -778,16 +778,16 @@ stop_cb (GduDevice *device, GError *error, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); if (error != NULL) { - g_simple_async_result_set_from_error (simple, error); + g_task_return_error (task, error); g_error_free (error); } - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static void @@ -795,16 +795,16 @@ drive_deactivate_cb (GduDrive *drive, GError *error, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); if (error != NULL) { - g_simple_async_result_set_from_error (simple, error); + g_task_return_error (task, error); g_error_free (error); } - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static void @@ -815,10 +815,10 @@ g_gdu_drive_stop_on_all_unmounted (GDrive *_drive, gpointer on_all_unmounted_data) { GGduDrive *drive = G_GDU_DRIVE (_drive); - GSimpleAsyncResult *simple; + GTask *task; GduDevice *device; - simple = g_simple_async_result_new (G_OBJECT (drive), + task = g_task_new (drive, callback, user_data, NULL); @@ -829,32 +829,32 @@ g_gdu_drive_stop_on_all_unmounted (GDrive *_drive, device = gdu_presentable_get_device (drive->presentable); if (device == NULL) { - g_simple_async_result_set_error (simple, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, "Cannot detach: drive has no GduDevice object"); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } else { - gdu_device_op_drive_detach (device, stop_cb, simple); + gdu_device_op_drive_detach (device, stop_cb, task); g_object_unref (device); } break; case G_DRIVE_START_STOP_TYPE_MULTIDISK: - gdu_drive_deactivate (GDU_DRIVE (drive->presentable), drive_deactivate_cb, simple); + gdu_drive_deactivate (GDU_DRIVE (drive->presentable), drive_deactivate_cb, task); break; default: - g_simple_async_result_set_error (simple, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "start_stop_type %d not supported", drive->start_stop_type); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); break; } } @@ -885,7 +885,7 @@ g_gdu_drive_stop_finish (GDrive *drive, GAsyncResult *result, GError **error) { - return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error); + return !g_task_async_result_propagate_error (G_TASK (result), error); } /* ---------------------------------------------------------------------------------------------------- */ @@ -896,11 +896,11 @@ start_cb (GduDrive *drive, GError *error, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); if (error != NULL) { - g_simple_async_result_set_error (simple, + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, "Failed activating drive: %s", @@ -911,14 +911,14 @@ start_cb (GduDrive *drive, { g_free (assembled_drive_object_path); } - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } typedef struct { GGduDrive *drive; - GSimpleAsyncResult *simple; + GTask *task; GMountOperation *start_operation; gulong start_operation_reply_handler_id; @@ -944,7 +944,7 @@ start_operation_reply (GMountOperation *op, if (result == G_MOUNT_OPERATION_ABORTED) { /* The user aborted the operation so consider it "handled" */ - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED, "Start operation dialog aborted (user should never see this error since " @@ -952,12 +952,12 @@ start_operation_reply (GMountOperation *op, } else { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, "Expected G_MOUNT_OPERATION_HANDLED but got %d", result); } - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); goto out; } @@ -965,21 +965,21 @@ start_operation_reply (GMountOperation *op, choice = g_mount_operation_get_choice (data->start_operation); if (choice == 1) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED, "User refused to start degraded array (user should never see this error since " "it is G_IO_ERROR_FAILED_HANDLED)"); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); goto out; } - gdu_drive_activate (GDU_DRIVE (data->drive->presentable), start_cb, g_object_ref (data->simple)); + gdu_drive_activate (GDU_DRIVE (data->drive->presentable), start_cb, g_object_ref (data->task)); out: g_object_unref (data->drive); g_object_unref (data->start_operation); - g_object_unref (data->simple); + g_object_unref (data->task); g_free (data); } @@ -992,7 +992,7 @@ g_gdu_drive_start (GDrive *_drive, gpointer user_data) { GGduDrive *drive = G_GDU_DRIVE (_drive); - GSimpleAsyncResult *simple; + GTask *task; gboolean degraded; /* TODO: handle GCancellable */ @@ -1003,7 +1003,7 @@ g_gdu_drive_start (GDrive *_drive, if (start_operation == NULL && degraded) goto refuse_degraded_without_confirmation; - simple = g_simple_async_result_new (G_OBJECT (drive), + task = g_task_new (drive, callback, user_data, NULL); @@ -1026,7 +1026,7 @@ g_gdu_drive_start (GDrive *_drive, data = g_new0 (StartOpData, 1); data->drive = g_object_ref (drive); - data->simple = simple; + data->task = task; data->start_operation = g_object_ref (start_operation); data->start_operation_reply_handler_id = g_signal_connect (start_operation, "reply", @@ -1040,32 +1040,32 @@ g_gdu_drive_start (GDrive *_drive, } else { - gdu_drive_activate (GDU_DRIVE (drive->presentable), start_cb, simple); + gdu_drive_activate (GDU_DRIVE (drive->presentable), start_cb, task); } return; not_supported: - simple = g_simple_async_result_new_error (G_OBJECT (drive), + task = g_task_new_error (G_OBJECT (drive), callback, user_data, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "Starting drive with start_stop_type %d is not supported", drive->start_stop_type); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); return; refuse_degraded_without_confirmation: - simple = g_simple_async_result_new_error (G_OBJECT (drive), + task = g_task_new_error (G_OBJECT (drive), callback, user_data, G_IO_ERROR, G_IO_ERROR_FAILED, "Refusing to start degraded multidisk drive without user confirmation"); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } @@ -1074,7 +1074,7 @@ g_gdu_drive_start_finish (GDrive *drive, GAsyncResult *result, GError **error) { - return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error); + return !g_task_async_result_propagate_error (G_TASK (result), error); } /* ---------------------------------------------------------------------------------------------------- */ @@ -1084,19 +1084,19 @@ poll_media_cb (GduDevice *device, GError *error, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); if (error != NULL) { /* We could handle PolicyKit integration here but this action is allowed by default * and this won't be needed when porting to PolicyKit 1.0 anyway */ - g_simple_async_result_set_from_error (simple, error); + g_task_return_error (task, error); g_error_free (error); } - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static void @@ -1106,29 +1106,29 @@ g_gdu_drive_poll_for_media (GDrive *_drive, gpointer user_data) { GGduDrive *drive = G_GDU_DRIVE (_drive); - GSimpleAsyncResult *simple; + GTask *task; GduDevice *device; device = gdu_presentable_get_device (drive->presentable); if (device == NULL) { - simple = g_simple_async_result_new_error (G_OBJECT (drive), + task = g_task_new_error (G_OBJECT (drive), callback, user_data, G_IO_ERROR, G_IO_ERROR_FAILED, "Device is not active"); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } else { - simple = g_simple_async_result_new (G_OBJECT (drive), + task = g_task_new (drive, callback, user_data, NULL); - gdu_device_op_drive_poll_media (device, poll_media_cb, simple); + gdu_device_op_drive_poll_media (device, poll_media_cb, task); g_object_unref (device); } } @@ -1138,7 +1138,7 @@ g_gdu_drive_poll_for_media_finish (GDrive *drive, GAsyncResult *result, GError **error) { - return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error); + return !g_task_async_result_propagate_error (G_TASK (result), error); } /* ---------------------------------------------------------------------------------------------------- */ diff --git a/monitor/gdu/ggdumount.c b/monitor/gdu/ggdumount.c index b7e8545a..92a8c392 100644 --- a/monitor/gdu/ggdumount.c +++ b/monitor/gdu/ggdumount.c @@ -517,7 +517,7 @@ static void bin_unmount_cb (GPid pid, gint status, gpointer user_data) { BinUnmountData *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; g_spawn_close_pid (pid); @@ -534,7 +534,7 @@ bin_unmount_cb (GPid pid, gint status, gpointer user_data) error = g_error_new_literal (G_IO_ERROR, error_code, data->error_string->str); - simple = g_simple_async_result_new_from_error (G_OBJECT (data->mount), + task = g_task_new_from_error (G_OBJECT (data->mount), data->callback, data->user_data, error); @@ -542,14 +542,14 @@ bin_unmount_cb (GPid pid, gint status, gpointer user_data) } else { - simple = g_simple_async_result_new (G_OBJECT (data->mount), + task = g_task_new (data->mount, data->callback, data->user_data, NULL); } - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); g_source_remove (data->error_channel_source_id); g_io_channel_unref (data->error_channel); @@ -630,13 +630,13 @@ handle_error: if (error != NULL) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_from_error (G_OBJECT (data->mount), + GTask *task; + task = g_task_new_from_error (G_OBJECT (data->mount), data->callback, data->user_data, error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); if (data->error_string != NULL) g_string_free (data->error_string, TRUE); @@ -756,7 +756,7 @@ _gdu_unmount_luks_lock_cb (GduDevice *device, gpointer user_data) { _GduUnmountData *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; if (error != NULL) { @@ -769,15 +769,15 @@ _gdu_unmount_luks_lock_cb (GduDevice *device, if (!data->completed) { - simple = g_simple_async_result_new_from_error (G_OBJECT (data->mount), + task = g_task_new_from_error (G_OBJECT (data->mount), data->callback, data->user_data, error); g_error_free (error); data->completed = TRUE; _gdu_unmount_data_unref (data); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } goto out; } @@ -785,14 +785,14 @@ _gdu_unmount_luks_lock_cb (GduDevice *device, /* we're done */ if (!data->completed) { - simple = g_simple_async_result_new (G_OBJECT (data->mount), + task = g_task_new (data->mount, data->callback, data->user_data, NULL); data->completed = TRUE; _gdu_unmount_data_unref (data); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } out: @@ -809,7 +809,7 @@ _gdu_unmount_on_mount_op_reply (GMountOperation *mount_operation, gpointer user_data) { _GduUnmountData *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; gint choice; /* disconnect the signal handler */ @@ -826,7 +826,7 @@ _gdu_unmount_on_mount_op_reply (GMountOperation *mount_operation, /* don't show an error dialog here */ if (!data->completed) { - simple = g_simple_async_result_new_error (G_OBJECT (data->mount), + task = g_task_new_error (G_OBJECT (data->mount), data->callback, data->user_data, G_IO_ERROR, @@ -835,8 +835,8 @@ _gdu_unmount_on_mount_op_reply (GMountOperation *mount_operation, "error since it is G_IO_ERROR_FAILED_HANDLED)"); data->completed = TRUE; _gdu_unmount_data_unref (data); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } } else if (result == G_MOUNT_OPERATION_HANDLED) @@ -852,7 +852,7 @@ _gdu_unmount_on_mount_op_reply (GMountOperation *mount_operation, */ if (!data->completed) { - simple = g_simple_async_result_new_error (G_OBJECT (data->mount), + task = g_task_new_error (G_OBJECT (data->mount), data->callback, data->user_data, G_IO_ERROR, @@ -860,8 +860,8 @@ _gdu_unmount_on_mount_op_reply (GMountOperation *mount_operation, _("One or more programs are preventing the unmount operation.")); data->completed = TRUE; _gdu_unmount_data_unref (data); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } } } @@ -891,7 +891,7 @@ _gdu_unmount_cb (GduDevice *device, gpointer user_data) { _GduUnmountData *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; if (error != NULL) { @@ -955,15 +955,15 @@ _gdu_unmount_cb (GduDevice *device, if (!data->completed) { - simple = g_simple_async_result_new_from_error (G_OBJECT (data->mount), + task = g_task_new_from_error (G_OBJECT (data->mount), data->callback, data->user_data, error); g_error_free (error); data->completed = TRUE; _gdu_unmount_data_unref (data); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } goto out; } @@ -980,7 +980,7 @@ _gdu_unmount_cb (GduDevice *device, { if (!data->completed) { - simple = g_simple_async_result_new_error (G_OBJECT (data->mount), + task = g_task_new_error (G_OBJECT (data->mount), data->callback, data->user_data, G_IO_ERROR, @@ -988,8 +988,8 @@ _gdu_unmount_cb (GduDevice *device, _("Cannot get LUKS cleartext slave")); data->completed = TRUE; _gdu_unmount_data_unref (data); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } goto out; } @@ -1002,7 +1002,7 @@ _gdu_unmount_cb (GduDevice *device, { if (!data->completed) { - simple = g_simple_async_result_new_error (G_OBJECT (data->mount), + task = g_task_new_error (G_OBJECT (data->mount), data->callback, data->user_data, G_IO_ERROR, @@ -1011,8 +1011,8 @@ _gdu_unmount_cb (GduDevice *device, luks_cleartext_slave_object_path); data->completed = TRUE; _gdu_unmount_data_unref (data); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } goto out; } @@ -1029,14 +1029,14 @@ _gdu_unmount_cb (GduDevice *device, /* not a cleartext device => we're done */ if (!data->completed) { - simple = g_simple_async_result_new (G_OBJECT (data->mount), + task = g_task_new (data->mount, data->callback, data->user_data, NULL); data->completed = TRUE; _gdu_unmount_data_unref (data); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } out: @@ -1063,9 +1063,9 @@ _gdu_unmount_on_cancelled (GMount *mount, if (!data->completed) { - GSimpleAsyncResult *simple; + GTask *task; - simple = g_simple_async_result_new_error (G_OBJECT (data->mount), + task = g_task_new_error (G_OBJECT (data->mount), data->callback, data->user_data, G_IO_ERROR, @@ -1073,8 +1073,8 @@ _gdu_unmount_on_cancelled (GMount *mount, _("Operation was cancelled")); data->completed = TRUE; _gdu_unmount_data_unref (data); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } } @@ -1150,13 +1150,13 @@ g_gdu_mount_unmount_with_operation (GMount *_mount, if (mount->is_burn_mount) { /* burn mounts are really never mounted so complete successfully immediately */ - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new (G_OBJECT (mount), + GTask *task; + task = g_task_new (mount, callback, user_data, NULL); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } else { @@ -1168,15 +1168,15 @@ g_gdu_mount_unmount_with_operation (GMount *_mount, } else { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_error (G_OBJECT (mount), + GTask *task; + task = g_task_new_error (G_OBJECT (mount), callback, user_data, G_IO_ERROR, G_IO_ERROR_FAILED, _("Operation not supported by backend")); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } } @@ -1185,7 +1185,7 @@ g_gdu_mount_unmount_with_operation_finish (GMount *mount, GAsyncResult *result, GError **error) { - return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error); + return !g_task_async_result_propagate_error (G_TASK (result), error); } static void @@ -1252,15 +1252,15 @@ g_gdu_mount_eject_with_operation (GMount *mount, } else { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_error (G_OBJECT (mount), + GTask *task; + task = g_task_new_error (G_OBJECT (mount), callback, user_data, G_IO_ERROR, G_IO_ERROR_FAILED, _("Operation not supported by backend")); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } } @@ -1287,7 +1287,7 @@ g_gdu_mount_eject_with_operation_finish (GMount *_mount, } else { - g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error); + g_task_async_result_propagate_error (G_TASK (result), error); res = FALSE; } @@ -1420,15 +1420,15 @@ g_gdu_mount_guess_content_type (GMount *mount, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; + GTask *task; /* TODO: handle force_rescan */ - simple = g_simple_async_result_new (G_OBJECT (mount), + task = g_task_new (mount, callback, user_data, NULL); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static gchar ** diff --git a/monitor/gdu/ggduvolume.c b/monitor/gdu/ggduvolume.c index eb15d220..15518e78 100644 --- a/monitor/gdu/ggduvolume.c +++ b/monitor/gdu/ggduvolume.c @@ -735,7 +735,7 @@ struct MountOpData { GGduVolume *volume; GduDevice *device_to_mount; - GSimpleAsyncResult *simple; + GTask *task; GCancellable *cancellable; gulong cancelled_handler_id; @@ -751,7 +751,7 @@ mount_op_data_unref (MountOpData *data) g_object_unref (data->volume); if (data->device_to_mount != NULL) g_object_unref (data->device_to_mount); - g_object_unref (data->simple); + g_object_unref (data->task); if (data->cancelled_handler_id != 0) g_signal_handler_disconnect (data->cancellable, data->cancelled_handler_id); if (data->cancellable != NULL) @@ -776,11 +776,11 @@ cancel_pending_mount_op (MountOpData *data) g_signal_emit_by_name (data->mount_operation, "aborted"); /* complete the operation (sends reply to caller) */ - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED, "Operation was cancelled"); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); } static void @@ -803,7 +803,7 @@ mount_cb (GduDevice *device, error->domain = G_IO_ERROR; error->code = G_IO_ERROR_FAILED_HANDLED; } - g_simple_async_result_set_from_error (data->simple, error); + g_task_return_error (data->task, error); g_error_free (error); } else @@ -811,7 +811,7 @@ mount_cb (GduDevice *device, g_free (mount_point); } - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); bailout: data->volume->pending_mount_op = NULL; @@ -837,11 +837,11 @@ mount_cleartext_device (MountOpData *data, data->device_to_mount = gdu_pool_get_by_object_path (pool, object_path_of_cleartext_device); if (data->device_to_mount == NULL) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, "Successfully unlocked encrypted volume but cleartext device does not exist"); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); data->volume->pending_mount_op = NULL; mount_op_data_unref (data); } @@ -918,9 +918,9 @@ unlock_cb (GduDevice *device, error->domain = G_IO_ERROR; error->code = G_IO_ERROR_FAILED_HANDLED; } - g_simple_async_result_set_from_error (data->simple, error); + g_task_return_error (data->task, error); g_error_free (error); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); data->volume->pending_mount_op = NULL; mount_op_data_unref (data); } @@ -1000,19 +1000,19 @@ mount_operation_reply (GMountOperation *mount_operation, if (result == G_MOUNT_OPERATION_ABORTED) { /* The user aborted the operation so consider it "handled" */ - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED, "Password dialog aborted (user should never see this error since it is G_IO_ERROR_FAILED_HANDLED)"); } else { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, "Expected G_MOUNT_OPERATION_HANDLED but got %d", result); } - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); data->volume->pending_mount_op = NULL; mount_op_data_unref (data); goto out; @@ -1060,11 +1060,11 @@ mount_with_mount_operation (MountOpData *data) if (data->mount_operation == NULL) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, "Password required to access the encrypted data"); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); data->volume->pending_mount_op = NULL; mount_op_data_unref (data); goto out; @@ -1154,7 +1154,7 @@ g_gdu_volume_mount (GVolume *_volume, gpointer user_data) { GGduVolume *volume = G_GDU_VOLUME (_volume); - GSimpleAsyncResult *simple; + GTask *task; GduDevice *device; GduPool *pool; const gchar *usage; @@ -1178,14 +1178,14 @@ g_gdu_volume_mount (GVolume *_volume, if (volume->pending_mount_op != NULL) { - simple = g_simple_async_result_new_error (G_OBJECT (volume), + task = g_task_new_error (G_OBJECT (volume), callback, user_data, G_IO_ERROR, G_IO_ERROR_FAILED, "A mount operation is already pending"); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); goto out; } @@ -1193,14 +1193,14 @@ g_gdu_volume_mount (GVolume *_volume, if (device == NULL) { - simple = g_simple_async_result_new_error (G_OBJECT (volume), + task = g_task_new_error (G_OBJECT (volume), callback, user_data, G_IO_ERROR, G_IO_ERROR_FAILED, "Underlying device missing"); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); goto out; } @@ -1216,12 +1216,12 @@ g_gdu_volume_mount (GVolume *_volume, */ if (gdu_device_optical_disc_get_is_blank (device) || gdu_device_is_mounted (device)) { - simple = g_simple_async_result_new (G_OBJECT (volume), + task = g_task_new (volume, callback, user_data, g_gdu_volume_mount); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); goto out; } @@ -1229,7 +1229,7 @@ g_gdu_volume_mount (GVolume *_volume, data->volume = g_object_ref (volume); - data->simple = g_simple_async_result_new (G_OBJECT (volume), + data->task = g_task_new (volume, callback, user_data, g_gdu_volume_mount); @@ -1281,11 +1281,11 @@ g_gdu_volume_mount (GVolume *_volume, /* don't put up a password dialog if the daemon is inhibited */ if (gdu_pool_is_daemon_inhibited (pool)) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED, "Daemon is currently inhibited"); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); volume->pending_mount_op = NULL; mount_op_data_unref (data); goto out; @@ -1314,11 +1314,11 @@ g_gdu_volume_mount_finish (GVolume *volume, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result); + GTask *task = G_TASK (result); - //g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_gdu_volume_mount); + //g_warn_if_fail (g_task_async_result_get_source_tag (task) == g_gdu_volume_mount); - return !g_simple_async_result_propagate_error (simple, error); + return !g_task_async_result_propagate_error (task, error); } /* ---------------------------------------------------------------------------------------------------- */ @@ -1356,19 +1356,19 @@ mount_point_op_changed_cb (GVolume *volume, gpointer user_data) { MountPointOp *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; /* keep waiting if the mount hasn't appeared */ if (data->volume->mount == NULL) goto out; - simple = g_simple_async_result_new (G_OBJECT (data->volume), + task = g_task_new (data->volume, data->callback, data->user_data, NULL); /* complete in idle to make sure the mount is added before we return */ - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); g_signal_handler_disconnect (data->volume, data->wait_for_mount_changed_signal_handler_id); g_source_remove (data->wait_for_mount_timeout_id); @@ -1383,16 +1383,16 @@ static gboolean mount_point_op_never_appeared_cb (gpointer user_data) { MountPointOp *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; - simple = g_simple_async_result_new_error (G_OBJECT (data->volume), + task = g_task_new_error (G_OBJECT (data->volume), data->callback, data->user_data, G_IO_ERROR, G_IO_ERROR_FAILED, "Timeout waiting for mount to appear"); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); g_signal_handler_disconnect (data->volume, data->wait_for_mount_changed_signal_handler_id); g_source_remove (data->wait_for_mount_timeout_id); @@ -1406,7 +1406,7 @@ static void mount_point_op_cb (GPid pid, gint status, gpointer user_data) { MountPointOp *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; g_spawn_close_pid (pid); @@ -1416,13 +1416,13 @@ mount_point_op_cb (GPid pid, gint status, gpointer user_data) error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_FAILED, data->error_string->str); - simple = g_simple_async_result_new_from_error (G_OBJECT (data->volume), + task = g_task_new_from_error (G_OBJECT (data->volume), data->callback, data->user_data, error); g_error_free (error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); mount_point_op_free (data); } else @@ -1439,7 +1439,7 @@ mount_point_op_cb (GPid pid, gint status, gpointer user_data) */ if (data->volume->mount == NULL) { - /* no need to ref, GSimpleAsyncResult has a ref on data->volume */ + /* no need to ref, GTask has a ref on data->volume */ data->wait_for_mount_timeout_id = g_timeout_add (5 * 1000, mount_point_op_never_appeared_cb, data); @@ -1451,12 +1451,12 @@ mount_point_op_cb (GPid pid, gint status, gpointer user_data) else { /* have the mount already, finish up */ - simple = g_simple_async_result_new (G_OBJECT (data->volume), + task = g_task_new (data->volume, data->callback, data->user_data, NULL); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); mount_point_op_free (data); } } @@ -1550,13 +1550,13 @@ g_gdu_volume_mount_unix_mount_point (GGduVolume *volume, handle_error: if (error != NULL) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_from_error (G_OBJECT (data->volume), + GTask *task; + task = g_task_new_from_error (G_OBJECT (data->volume), data->callback, data->user_data, error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); mount_point_op_free (data); } @@ -1608,15 +1608,15 @@ g_gdu_volume_eject_with_operation (GVolume *volume, } else { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_error (G_OBJECT (volume), + GTask *task; + task = g_task_new_error (G_OBJECT (volume), callback, user_data, G_IO_ERROR, G_IO_ERROR_FAILED, _("Operation not supported by backend")); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } } @@ -1635,7 +1635,7 @@ g_gdu_volume_eject_with_operation_finish (GVolume *volume, } else { - g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error); + g_task_async_result_propagate_error (G_TASK (result), error); res = FALSE; } diff --git a/monitor/hal/ghaldrive.c b/monitor/hal/ghaldrive.c index e778f0ae..dad53a85 100644 --- a/monitor/hal/ghaldrive.c +++ b/monitor/hal/ghaldrive.c @@ -539,7 +539,7 @@ static void spawn_cb (GPid pid, gint status, gpointer user_data) { SpawnOp *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; if (WEXITSTATUS (status) != 0) @@ -548,7 +548,7 @@ spawn_cb (GPid pid, gint status, gpointer user_data) error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED, "You are not supposed to show G_IO_ERROR_FAILED_HANDLED in the UI"); - simple = g_simple_async_result_new_from_error (data->object, + task = g_task_new_from_error (data->object, data->callback, data->user_data, error); @@ -556,13 +556,13 @@ spawn_cb (GPid pid, gint status, gpointer user_data) } else { - simple = g_simple_async_result_new (data->object, + task = g_task_new (data->object, data->callback, data->user_data, NULL); } - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); g_object_unref (data->object); g_free (data); } @@ -597,14 +597,14 @@ g_hal_drive_eject_do (GDrive *drive, &child_pid, &error)) { - GSimpleAsyncResult *simple; + GTask *task; - simple = g_simple_async_result_new_from_error (data->object, + task = g_task_new_from_error (data->object, data->callback, data->user_data, error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); g_object_unref (drive); g_error_free (error); g_free (data); @@ -649,7 +649,7 @@ _eject_unmount_mounts_cb (GObject *source_object, { UnmountMountsOp *data = user_data; GMount *mount = G_MOUNT (source_object); - GSimpleAsyncResult *simple; + GTask *task; GError *error = NULL; if (!g_mount_unmount_with_operation_finish (mount, res, &error)) @@ -663,13 +663,13 @@ _eject_unmount_mounts_cb (GObject *source_object, } /* unmount failed; need to fail the whole eject operation */ - simple = g_simple_async_result_new_from_error (G_OBJECT (data->drive), + task = g_task_new_from_error (G_OBJECT (data->drive), data->callback, data->user_data, error); g_error_free (error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); free_unmount_mounts_op (data); } @@ -791,7 +791,7 @@ static void poll_for_media_cb (DBusPendingCall *pending_call, void *user_data) { PollOp *data = (PollOp *) user_data; - GSimpleAsyncResult *simple; + GTask *task; DBusMessage *reply; reply = dbus_pending_call_steal_reply (pending_call); @@ -806,12 +806,12 @@ poll_for_media_cb (DBusPendingCall *pending_call, void *user_data) error = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED, "Cannot invoke CheckForMedia on HAL: %s: %s", dbus_error.name, dbus_error.message); - simple = g_simple_async_result_new_from_error (data->object, + task = g_task_new_from_error (data->object, data->callback, data->user_data, error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); g_error_free (error); dbus_error_free (&dbus_error); goto out; @@ -821,12 +821,12 @@ poll_for_media_cb (DBusPendingCall *pending_call, void *user_data) * (the result is whether the media availability state changed) */ - simple = g_simple_async_result_new (data->object, + task = g_task_new (data->object, data->callback, data->user_data, NULL); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); out: g_object_unref (data->object); @@ -864,16 +864,16 @@ g_hal_drive_poll_for_media (GDrive *drive, if (!dbus_connection_send_with_reply (con, msg, &pending_call, -1)) { GError *error; - GSimpleAsyncResult *simple; + GTask *task; error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_FAILED, "Cannot invoke CheckForMedia on HAL"); - simple = g_simple_async_result_new_from_error (data->object, + task = g_task_new_from_error (data->object, data->callback, data->user_data, error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); g_error_free (error); g_object_unref (data->object); g_free (data); diff --git a/monitor/hal/ghalmount.c b/monitor/hal/ghalmount.c index ad805a43..0b28b586 100644 --- a/monitor/hal/ghalmount.c +++ b/monitor/hal/ghalmount.c @@ -782,7 +782,7 @@ static void unmount_cb (GPid pid, gint status, gpointer user_data) { UnmountOp *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; if (WEXITSTATUS (status) != 0) { @@ -792,7 +792,7 @@ unmount_cb (GPid pid, gint status, gpointer user_data) error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_FAILED, data->error_string->str); - simple = g_simple_async_result_new_from_error (data->object, + task = g_task_new_from_error (data->object, data->callback, data->user_data, error); @@ -804,7 +804,7 @@ unmount_cb (GPid pid, gint status, gpointer user_data) error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED, "You are not supposed to show G_IO_ERROR_FAILED_HANDLED in the UI"); - simple = g_simple_async_result_new_from_error (data->object, + task = g_task_new_from_error (data->object, data->callback, data->user_data, error); @@ -813,14 +813,14 @@ unmount_cb (GPid pid, gint status, gpointer user_data) } else { - simple = g_simple_async_result_new (data->object, + task = g_task_new (data->object, data->callback, data->user_data, NULL); } - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); g_source_remove (data->error_channel_source_id); g_io_channel_unref (data->error_channel); @@ -868,13 +868,13 @@ unmount_do_cb (gpointer user_data) &(data->error_fd), &error)) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_from_error (data->object, + GTask *task; + task = g_task_new_from_error (data->object, data->callback, data->user_data, error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); g_error_free (error); g_strfreev (data->argv); g_free (data); @@ -1147,15 +1147,15 @@ g_hal_mount_guess_content_type (GMount *mount, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; + GTask *task; /* TODO: handle force_rescan */ - simple = g_simple_async_result_new (G_OBJECT (mount), + task = g_task_new (mount, callback, user_data, NULL); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static char ** diff --git a/monitor/hal/ghalvolume.c b/monitor/hal/ghalvolume.c index cef37f7b..0227eece 100644 --- a/monitor/hal/ghalvolume.c +++ b/monitor/hal/ghalvolume.c @@ -691,7 +691,7 @@ static void spawn_cb (GPid pid, gint status, gpointer user_data) { SpawnOp *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; /* ensure that the #GHalMount corrosponding to the #GHalVolume we've * mounted is made available before returning to the user (make sure @@ -705,7 +705,7 @@ spawn_cb (GPid pid, gint status, gpointer user_data) error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED, "You are not supposed to show G_IO_ERROR_FAILED_HANDLED in the UI"); - simple = g_simple_async_result_new_from_error (data->object, + task = g_task_new_from_error (data->object, data->callback, data->user_data, error); @@ -713,14 +713,14 @@ spawn_cb (GPid pid, gint status, gpointer user_data) } else { - simple = g_simple_async_result_new (data->object, + task = g_task_new (data->object, data->callback, data->user_data, NULL); } - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); g_object_unref (data->object); g_free (data); } @@ -752,7 +752,7 @@ spawn_do (GVolume *volume, &child_pid, &error)) { - g_simple_async_report_gerror_in_idle (data->object, + g_task_async_report_gerror_in_idle (data->object, data->callback, data->user_data, error); diff --git a/monitor/proxy/gproxydrive.c b/monitor/proxy/gproxydrive.c index be2b600f..0a17832e 100644 --- a/monitor/proxy/gproxydrive.c +++ b/monitor/proxy/gproxydrive.c @@ -526,21 +526,21 @@ operation_cancelled (GCancellable *cancellable, gpointer user_data) { DBusOp *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; DBusConnection *connection; DBusMessage *message; const char *name; G_LOCK (proxy_drive); - simple = g_simple_async_result_new_error (G_OBJECT (data->drive), + task = g_task_new_error (G_OBJECT (data->drive), data->callback, data->user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); /* Now tell the remote volume monitor that the op has been cancelled */ connection = g_proxy_volume_monitor_get_dbus_connection (data->drive->volume_monitor); @@ -577,20 +577,20 @@ eject_cb (DBusMessage *reply, if (!g_cancellable_is_cancelled (data->cancellable)) { - GSimpleAsyncResult *simple; + GTask *task; if (error != NULL) - simple = g_simple_async_result_new_from_error (G_OBJECT (data->drive), + task = g_task_new_from_error (G_OBJECT (data->drive), data->callback, data->user_data, error); else - simple = g_simple_async_result_new (G_OBJECT (data->drive), + task = g_task_new (data->drive, data->callback, data->user_data, NULL); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } g_proxy_mount_operation_destroy (data->mount_op_id); @@ -620,15 +620,15 @@ g_proxy_drive_eject_with_operation (GDrive *drive, if (g_cancellable_is_cancelled (cancellable)) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_error (G_OBJECT (drive), + GTask *task; + task = g_task_new_error (G_OBJECT (drive), callback, user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); G_UNLOCK (proxy_drive); goto out; } @@ -688,7 +688,7 @@ g_proxy_drive_eject_with_operation_finish (GDrive *drive, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error)) + if (g_task_async_result_propagate_error (G_TASK (result), error)) return FALSE; return TRUE; } @@ -725,20 +725,20 @@ stop_cb (DBusMessage *reply, if (!g_cancellable_is_cancelled (data->cancellable)) { - GSimpleAsyncResult *simple; + GTask *task; if (error != NULL) - simple = g_simple_async_result_new_from_error (G_OBJECT (data->drive), + task = g_task_new_from_error (G_OBJECT (data->drive), data->callback, data->user_data, error); else - simple = g_simple_async_result_new (G_OBJECT (data->drive), + task = g_task_new (data->drive, data->callback, data->user_data, NULL); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } g_proxy_mount_operation_destroy (data->mount_op_id); @@ -768,15 +768,15 @@ g_proxy_drive_stop (GDrive *drive, if (g_cancellable_is_cancelled (cancellable)) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_error (G_OBJECT (drive), + GTask *task; + task = g_task_new_error (G_OBJECT (drive), callback, user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); G_UNLOCK (proxy_drive); goto out; } @@ -836,7 +836,7 @@ g_proxy_drive_stop_finish (GDrive *drive, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error)) + if (g_task_async_result_propagate_error (G_TASK (result), error)) return FALSE; return TRUE; } @@ -865,20 +865,20 @@ start_cb (DBusMessage *reply, if (!g_cancellable_is_cancelled (data->cancellable)) { - GSimpleAsyncResult *simple; + GTask *task; if (error != NULL) - simple = g_simple_async_result_new_from_error (G_OBJECT (data->drive), + task = g_task_new_from_error (G_OBJECT (data->drive), data->callback, data->user_data, error); else - simple = g_simple_async_result_new (G_OBJECT (data->drive), + task = g_task_new (data->drive, data->callback, data->user_data, NULL); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } /* free DBusStartOp */ @@ -897,21 +897,21 @@ start_cancelled (GCancellable *cancellable, gpointer user_data) { DBusStartOp *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; DBusConnection *connection; DBusMessage *message; const char *name; G_LOCK (proxy_drive); - simple = g_simple_async_result_new_error (G_OBJECT (data->drive), + task = g_task_new_error (G_OBJECT (data->drive), data->callback, data->user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); /* Now tell the remote drive monitor that the op has been cancelled */ connection = g_proxy_volume_monitor_get_dbus_connection (data->drive->volume_monitor); @@ -954,15 +954,15 @@ g_proxy_drive_start (GDrive *drive, if (g_cancellable_is_cancelled (cancellable)) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_error (G_OBJECT (drive), + GTask *task; + task = g_task_new_error (G_OBJECT (drive), callback, user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); G_UNLOCK (proxy_drive); goto out; } @@ -1023,7 +1023,7 @@ g_proxy_drive_start_finish (GDrive *drive, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error)) + if (g_task_async_result_propagate_error (G_TASK (result), error)) return FALSE; return TRUE; } @@ -1037,20 +1037,20 @@ poll_for_media_cb (DBusMessage *reply, { if (!g_cancellable_is_cancelled (data->cancellable)) { - GSimpleAsyncResult *simple; + GTask *task; if (error != NULL) - simple = g_simple_async_result_new_from_error (G_OBJECT (data->drive), + task = g_task_new_from_error (G_OBJECT (data->drive), data->callback, data->user_data, error); else - simple = g_simple_async_result_new (G_OBJECT (data->drive), + task = g_task_new (data->drive, data->callback, data->user_data, NULL); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } g_object_unref (data->drive); @@ -1078,15 +1078,15 @@ g_proxy_drive_poll_for_media (GDrive *drive, if (g_cancellable_is_cancelled (cancellable)) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_error (G_OBJECT (drive), + GTask *task; + task = g_task_new_error (G_OBJECT (drive), callback, user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); G_UNLOCK (proxy_drive); goto out; } @@ -1141,7 +1141,7 @@ g_proxy_drive_poll_for_media_finish (GDrive *drive, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error)) + if (g_task_async_result_propagate_error (G_TASK (result), error)) return FALSE; return TRUE; } diff --git a/monitor/proxy/gproxymount.c b/monitor/proxy/gproxymount.c index cd3ca49b..f811690f 100644 --- a/monitor/proxy/gproxymount.c +++ b/monitor/proxy/gproxymount.c @@ -473,21 +473,21 @@ operation_cancelled (GCancellable *cancellable, gpointer user_data) { DBusOp *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; DBusConnection *connection; DBusMessage *message; const char *name; G_LOCK (proxy_mount); - simple = g_simple_async_result_new_error (G_OBJECT (data->mount), + task = g_task_new_error (G_OBJECT (data->mount), data->callback, data->user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); /* Now tell the remote volume monitor that the op has been cancelled */ connection = g_proxy_volume_monitor_get_dbus_connection (data->mount->volume_monitor); @@ -522,19 +522,19 @@ unmount_cb (DBusMessage *reply, if (!g_cancellable_is_cancelled (data->cancellable)) { - GSimpleAsyncResult *simple; + GTask *task; if (error != NULL) - simple = g_simple_async_result_new_from_error (G_OBJECT (data->mount), + task = g_task_new_from_error (G_OBJECT (data->mount), data->callback, data->user_data, error); else - simple = g_simple_async_result_new (G_OBJECT (data->mount), + task = g_task_new (data->mount, data->callback, data->user_data, NULL); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } g_proxy_mount_operation_destroy (data->mount_op_id); @@ -564,15 +564,15 @@ g_proxy_mount_unmount_with_operation (GMount *mount, if (g_cancellable_is_cancelled (cancellable)) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_error (G_OBJECT (mount), + GTask *task; + task = g_task_new_error (G_OBJECT (mount), callback, user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); G_UNLOCK (proxy_mount); goto out; } @@ -633,7 +633,7 @@ g_proxy_mount_unmount_with_operation_finish (GMount *mount, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error)) + if (g_task_async_result_propagate_error (G_TASK (result), error)) return FALSE; return TRUE; } @@ -663,15 +663,15 @@ g_proxy_mount_guess_content_type (GMount *mount, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; + GTask *task; /* TODO: handle force_rescan */ - simple = g_simple_async_result_new (G_OBJECT (mount), + task = g_task_new (mount, callback, user_data, NULL); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } static char ** diff --git a/monitor/proxy/gproxyvolume.c b/monitor/proxy/gproxyvolume.c index b6b8c91b..a6662f95 100644 --- a/monitor/proxy/gproxyvolume.c +++ b/monitor/proxy/gproxyvolume.c @@ -750,20 +750,20 @@ mount_cb (DBusMessage *reply, if (!g_cancellable_is_cancelled (data->cancellable)) { - GSimpleAsyncResult *simple; + GTask *task; if (error != NULL) - simple = g_simple_async_result_new_from_error (G_OBJECT (data->volume), + task = g_task_new_from_error (G_OBJECT (data->volume), data->callback, data->user_data, error); else - simple = g_simple_async_result_new (G_OBJECT (data->volume), + task = g_task_new (data->volume, data->callback, data->user_data, NULL); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); } /* free DBusOp */ @@ -811,21 +811,21 @@ mount_cancelled (GCancellable *cancellable, gpointer user_data) { DBusOp *data = user_data; - GSimpleAsyncResult *simple; + GTask *task; DBusConnection *connection; DBusMessage *message; const char *name; G_LOCK (proxy_volume); - simple = g_simple_async_result_new_error (G_OBJECT (data->volume), + task = g_task_new_error (G_OBJECT (data->volume), data->callback, data->user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); /* Now tell the remote volume monitor that the op has been cancelled */ connection = g_proxy_volume_monitor_get_dbus_connection (data->volume->volume_monitor); @@ -894,15 +894,15 @@ g_proxy_volume_mount (GVolume *volume, if (g_cancellable_is_cancelled (cancellable)) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_error (G_OBJECT (volume), + GTask *task; + task = g_task_new_error (G_OBJECT (volume), callback, user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_task_async_result_complete_in_idle (task); + g_object_unref (task); G_UNLOCK (proxy_volume); goto out; } @@ -964,7 +964,7 @@ g_proxy_volume_mount_finish (GVolume *volume, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error)) + if (g_task_async_result_propagate_error (G_TASK (result), error)) return FALSE; return TRUE; } diff --git a/monitor/udisks2/gvfsudisks2drive.c b/monitor/udisks2/gvfsudisks2drive.c index 454f340c..76f290d5 100644 --- a/monitor/udisks2/gvfsudisks2drive.c +++ b/monitor/udisks2/gvfsudisks2drive.c @@ -496,7 +496,7 @@ unmount_mounts_cb (GObject *source_object, { UnmountMountsOp *data = user_data; GMount *mount = G_MOUNT (source_object); - GSimpleAsyncResult *simple; + GTask *task; GError *error = NULL; if (!g_mount_unmount_with_operation_finish (mount, res, &error)) @@ -511,13 +511,13 @@ unmount_mounts_cb (GObject *source_object, } /* unmount failed; need to fail the whole eject operation */ - simple = g_simple_async_result_new_from_error (G_OBJECT (data->drive), + task = g_task_new_from_error (G_OBJECT (data->drive), data->callback, data->user_data, error); g_error_free (error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); free_unmount_mounts_op (data); } @@ -568,7 +568,7 @@ unmount_mounts (GVfsUDisks2Drive *drive, typedef struct { - GSimpleAsyncResult *simple; + GTask *task; GVfsUDisks2Drive *drive; } EjectData; @@ -576,7 +576,7 @@ typedef struct static void eject_data_free (EjectData *data) { - g_object_unref (data->simple); + g_object_unref (data->task); g_clear_object (&data->drive); g_free (data); } @@ -593,12 +593,12 @@ eject_cb (GObject *source_object, if (!udisks_drive_call_eject_finish (UDISKS_DRIVE (source_object), res, &error)) { gvfs_udisks2_utils_udisks_error_to_gio_error (error); - g_simple_async_result_take_error (data->simple, error); - g_simple_async_result_complete (data->simple); + g_task_async_result_take_error (data->task, error); + g_task_async_result_complete (data->task); goto out; } - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); out: eject_data_free (data); @@ -617,7 +617,7 @@ gvfs_udisks2_drive_eject_on_all_unmounted (GDrive *_drive, EjectData *data; data = g_new0 (EjectData, 1); - data->simple = g_simple_async_result_new (G_OBJECT (drive), + data->task = g_task_new (drive, callback, user_data, gvfs_udisks2_drive_eject_on_all_unmounted); @@ -663,7 +663,7 @@ gvfs_udisks2_drive_eject_with_operation_finish (GDrive *drive, GAsyncResult *result, GError **error) { - return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error); + return !g_task_async_result_propagate_error (G_TASK (result), error); } static void diff --git a/monitor/udisks2/gvfsudisks2mount.c b/monitor/udisks2/gvfsudisks2mount.c index 61f58a1f..947a91d4 100644 --- a/monitor/udisks2/gvfsudisks2mount.c +++ b/monitor/udisks2/gvfsudisks2mount.c @@ -514,7 +514,7 @@ gvfs_udisks2_mount_can_eject (GMount *_mount) typedef struct { volatile gint ref_count; - GSimpleAsyncResult *simple; + GTask *task; gboolean completed; GVfsUDisks2Mount *mount; @@ -543,7 +543,7 @@ unmount_data_unref (UnmountData *data) { if (g_atomic_int_dec_and_test (&data->ref_count)) { - g_object_unref (data->simple); + g_object_unref (data->task); if (data->mount_op_reply_handler_id > 0) { @@ -606,12 +606,12 @@ on_mount_op_reply (GMountOperation *mount_operation, (result == G_MOUNT_OPERATION_HANDLED && choice == 1)) { /* don't show an error dialog here */ - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED, "GMountOperation aborted (user should never see this " "error since it is G_IO_ERROR_FAILED_HANDLED)"); - g_simple_async_result_complete_in_idle (data->simple); + g_task_async_result_complete_in_idle (data->task); data->completed = TRUE; unmount_data_unref (data); } @@ -625,11 +625,11 @@ on_mount_op_reply (GMountOperation *mount_operation, /* result == G_MOUNT_OPERATION_UNHANDLED => GMountOperation instance doesn't * support :show-processes signal */ - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_BUSY, _("One or more programs are preventing the unmount operation.")); - g_simple_async_result_complete_in_idle (data->simple); + g_task_async_result_complete_in_idle (data->task); data->completed = TRUE; unmount_data_unref (data); } @@ -758,8 +758,8 @@ lock_cb (GObject *source_object, if (!udisks_encrypted_call_lock_finish (encrypted, res, &error)) - g_simple_async_result_take_error (data->simple, error); - g_simple_async_result_complete (data->simple); + g_task_async_result_take_error (data->task, error); + g_task_async_result_complete (data->task); data->completed = TRUE; unmount_data_unref (data); } @@ -786,7 +786,7 @@ unmount_cb (GObject *source_object, unmount_show_busy (data, udisks_filesystem_get_mount_points (filesystem)[0]); goto out; } - g_simple_async_result_take_error (data->simple, error); + g_task_async_result_take_error (data->task, error); } else { @@ -802,7 +802,7 @@ unmount_cb (GObject *source_object, } } - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); data->completed = TRUE; unmount_data_unref (data); out: @@ -829,9 +829,9 @@ umount_command_cb (GObject *source_object, &standard_error, &error)) { - g_simple_async_result_take_error (data->simple, error); - g_simple_async_result_take_error (data->simple, error); - g_simple_async_result_complete (data->simple); + g_task_async_result_take_error (data->task, error); + g_task_async_result_take_error (data->task, error); + g_task_async_result_complete (data->task); data->completed = TRUE; unmount_data_unref (data); goto out; @@ -840,7 +840,7 @@ umount_command_cb (GObject *source_object, if (WIFEXITED (exit_status) && WEXITSTATUS (exit_status) == 0) { gvfs_udisks2_volume_monitor_update (data->mount->monitor); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); data->completed = TRUE; unmount_data_unref (data); goto out; @@ -852,11 +852,11 @@ umount_command_cb (GObject *source_object, goto out; } - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, standard_error); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); data->completed = TRUE; unmount_data_unref (data); @@ -926,7 +926,7 @@ gvfs_udisks2_mount_unmount_with_operation (GMount *_mount, data = g_new0 (UnmountData, 1); data->ref_count = 1; - data->simple = g_simple_async_result_new (G_OBJECT (mount), + data->task = g_task_new (mount, callback, user_data, gvfs_udisks2_mount_unmount_with_operation); @@ -938,7 +938,7 @@ gvfs_udisks2_mount_unmount_with_operation (GMount *_mount, if (mount->is_burn_mount) { /* burn mounts are really never mounted so complete successfully immediately */ - g_simple_async_result_complete_in_idle (data->simple); + g_task_async_result_complete_in_idle (data->task); data->completed = TRUE; unmount_data_unref (data); goto out; @@ -953,11 +953,11 @@ gvfs_udisks2_mount_unmount_with_operation (GMount *_mount, object = g_dbus_interface_get_object (G_DBUS_INTERFACE (block)); if (object == NULL) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, "No object for D-Bus interface"); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); data->completed = TRUE; unmount_data_unref (data); goto out; @@ -970,11 +970,11 @@ gvfs_udisks2_mount_unmount_with_operation (GMount *_mount, data->encrypted = udisks_object_get_encrypted (UDISKS_OBJECT (object)); if (data->encrypted == NULL) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, "No filesystem or encrypted interface on D-Bus object"); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); data->completed = TRUE; unmount_data_unref (data); goto out; @@ -988,11 +988,11 @@ gvfs_udisks2_mount_unmount_with_operation (GMount *_mount, g_object_unref (cleartext_block); if (data->filesystem == NULL) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, "No filesystem interface on D-Bus object for cleartext device"); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); data->completed = TRUE; unmount_data_unref (data); goto out; @@ -1012,7 +1012,7 @@ gvfs_udisks2_mount_unmount_with_operation_finish (GMount *mount, GAsyncResult *result, GError **error) { - return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error); + return !g_task_async_result_propagate_error (G_TASK (result), error); } /* ---------------------------------------------------------------------------------------------------- */ @@ -1082,15 +1082,15 @@ gvfs_udisks2_mount_eject_with_operation (GMount *_mount, } else { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_error (G_OBJECT (mount), + GTask *task; + task = g_task_new_error (G_OBJECT (mount), callback, user_data, G_IO_ERROR, G_IO_ERROR_FAILED, _("Operation not supported by backend")); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } } @@ -1114,7 +1114,7 @@ gvfs_udisks2_mount_eject_with_operation_finish (GMount *_mount, } else { - g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error); + g_task_async_result_propagate_error (G_TASK (result), error); ret = FALSE; } return ret; @@ -1224,13 +1224,13 @@ gvfs_udisks2_mount_guess_content_type (GMount *mount, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new (G_OBJECT (mount), + GTask *task; + task = g_task_new (mount, callback, user_data, NULL); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } static gchar ** diff --git a/monitor/udisks2/gvfsudisks2utils.c b/monitor/udisks2/gvfsudisks2utils.c index 0dc8abe8..a5675f02 100644 --- a/monitor/udisks2/gvfsudisks2utils.c +++ b/monitor/udisks2/gvfsudisks2utils.c @@ -112,7 +112,7 @@ gvfs_udisks2_utils_lookup_fstab_options_value (const gchar *fstab_options, typedef struct { - GSimpleAsyncResult *simple; /* borrowed reference */ + GTask *task; /* borrowed reference */ GMainContext *main_context; /* may be NULL */ gchar *command_line; @@ -259,9 +259,9 @@ on_cancelled (GCancellable *cancellable, error = NULL; g_warn_if_fail (g_cancellable_set_error_if_cancelled (cancellable, &error)); - g_simple_async_result_take_error (data->simple, error); - g_simple_async_result_complete_in_idle (data->simple); - g_object_unref (data->simple); + g_task_async_result_take_error (data->task, error); + g_task_async_result_complete_in_idle (data->task); + g_object_unref (data->task); } static gboolean @@ -319,8 +319,8 @@ child_watch_cb (GPid pid, data->child_watch_source = NULL; /* we're done */ - g_simple_async_result_complete_in_idle (data->simple); - g_object_unref (data->simple); + g_task_async_result_complete_in_idle (data->task); + g_object_unref (data->task); } static gboolean @@ -334,8 +334,8 @@ timeout_cb (gpointer user_data) data->timeout_source = NULL; /* we're done */ - g_simple_async_result_complete_in_idle (data->simple); - g_object_unref (data->simple); + g_task_async_result_complete_in_idle (data->task); + g_object_unref (data->task); return FALSE; /* remove source */ } @@ -355,7 +355,7 @@ gvfs_udisks2_utils_spawn (guint timeout_seconds, gchar **child_argv = NULL; data = g_slice_new0 (SpawnData); - data->simple = g_simple_async_result_new (NULL, + data->task = g_task_new (NULL, callback, user_data, gvfs_udisks2_utils_spawn); @@ -374,8 +374,8 @@ gvfs_udisks2_utils_spawn (guint timeout_seconds, data->child_stdout_fd = -1; data->child_stderr_fd = -1; - /* the life-cycle of SpawnData is tied to its GSimpleAsyncResult */ - g_simple_async_result_set_op_res_gpointer (data->simple, data, (GDestroyNotify) spawn_data_free); + /* the life-cycle of SpawnData is tied to its GTask */ + g_task_return_pointer (data->task, data, (GDestroyNotify) spawn_data_free); error = NULL; if (data->cancellable != NULL) @@ -384,9 +384,9 @@ gvfs_udisks2_utils_spawn (guint timeout_seconds, error = NULL; if (g_cancellable_set_error_if_cancelled (data->cancellable, &error)) { - g_simple_async_result_take_error (data->simple, error); - g_simple_async_result_complete_in_idle (data->simple); - g_object_unref (data->simple); + g_task_async_result_take_error (data->task, error); + g_task_async_result_complete_in_idle (data->task); + g_object_unref (data->task); goto out; } @@ -405,9 +405,9 @@ gvfs_udisks2_utils_spawn (guint timeout_seconds, g_prefix_error (&error, "Error parsing command-line `%s': ", data->command_line); - g_simple_async_result_take_error (data->simple, error); - g_simple_async_result_complete_in_idle (data->simple); - g_object_unref (data->simple); + g_task_async_result_take_error (data->task, error); + g_task_async_result_complete_in_idle (data->task); + g_object_unref (data->task); goto out; } @@ -427,9 +427,9 @@ gvfs_udisks2_utils_spawn (guint timeout_seconds, g_prefix_error (&error, "Error spawning command-line `%s': ", data->command_line); - g_simple_async_result_take_error (data->simple, error); - g_simple_async_result_complete_in_idle (data->simple); - g_object_unref (data->simple); + g_task_async_result_take_error (data->task, error); + g_task_async_result_complete_in_idle (data->task); + g_object_unref (data->task); goto out; } @@ -472,19 +472,19 @@ gvfs_udisks2_utils_spawn_finish (GAsyncResult *res, gchar **out_standard_error, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); + GTask *task = G_TASK (res); SpawnData *data; gboolean ret = FALSE; g_return_val_if_fail (G_IS_ASYNC_RESULT (res), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); - g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == gvfs_udisks2_utils_spawn); + g_warn_if_fail (g_task_async_result_get_source_tag (task) == gvfs_udisks2_utils_spawn); - if (g_simple_async_result_propagate_error (simple, error)) + if (g_task_async_result_propagate_error (task, error)) goto out; - data = g_simple_async_result_get_op_res_gpointer (simple); + data = g_task_propagate_pointer (task, error); if (data->timed_out) { diff --git a/monitor/udisks2/gvfsudisks2volume.c b/monitor/udisks2/gvfsudisks2volume.c index af2cdf3b..7272105e 100644 --- a/monitor/udisks2/gvfsudisks2volume.c +++ b/monitor/udisks2/gvfsudisks2volume.c @@ -716,7 +716,7 @@ gvfs_udisks2_volume_get_activation_root (GVolume *_volume) struct MountData { - GSimpleAsyncResult *simple; + GTask *task; GVfsUDisks2Volume *volume; GCancellable *cancellable; @@ -738,7 +738,7 @@ mount_data_free (MountData *data) if (data->volume->mount_pending_op == data) data->volume->mount_pending_op = NULL; - g_object_unref (data->simple); + g_object_unref (data->task); g_clear_object (&data->volume); g_clear_object (&data->cancellable); @@ -794,8 +794,8 @@ mount_command_cb (GObject *source_object, &standard_error, &error)) { - g_simple_async_result_take_error (data->simple, error); - g_simple_async_result_complete (data->simple); + g_task_async_result_take_error (data->task, error); + g_task_async_result_complete (data->task); mount_data_free (data); goto out; } @@ -803,16 +803,16 @@ mount_command_cb (GObject *source_object, if (WIFEXITED (exit_status) && WEXITSTATUS (exit_status) == 0) { gvfs_udisks2_volume_monitor_update (data->volume->monitor); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); mount_data_free (data); goto out; } - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, standard_error); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); mount_data_free (data); out: @@ -837,13 +837,13 @@ mount_cb (GObject *source_object, &error)) { gvfs_udisks2_utils_udisks_error_to_gio_error (error); - g_simple_async_result_take_error (data->simple, error); - g_simple_async_result_complete (data->simple); + g_task_async_result_take_error (data->task, error); + g_task_async_result_complete (data->task); } else { gvfs_udisks2_volume_monitor_update (data->volume->monitor); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); g_free (mount_path); } mount_data_free (data); @@ -886,8 +886,8 @@ unlock_cb (GObject *source_object, &error)) { gvfs_udisks2_utils_udisks_error_to_gio_error (error); - g_simple_async_result_take_error (data->simple, error); - g_simple_async_result_complete (data->simple); + g_task_async_result_take_error (data->task, error); + g_task_async_result_complete (data->task); mount_data_free (data); goto out; } @@ -902,11 +902,11 @@ unlock_cb (GObject *source_object, data->filesystem_to_mount = object != NULL ? udisks_object_get_filesystem (object) : NULL; if (data->filesystem_to_mount == NULL) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, _("The unlocked device does not have a recognizable filesystem on it")); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); mount_data_free (data); goto out; } @@ -945,19 +945,19 @@ on_mount_operation_reply (GMountOperation *mount_operation, if (result == G_MOUNT_OPERATION_ABORTED) { /* The user aborted the operation so consider it "handled" */ - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED, "Password dialog aborted (user should never see this error since it is G_IO_ERROR_FAILED_HANDLED)"); } else { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, "Expected G_MOUNT_OPERATION_HANDLED but got %d", result); } - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); mount_data_free (data); goto out; } @@ -1025,11 +1025,11 @@ do_unlock (MountData *data) if (data->mount_operation == NULL) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, _("A passphrase is required to access the volume")); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); mount_data_free (data); goto out; } @@ -1106,7 +1106,7 @@ gvfs_udisks2_volume_mount (GVolume *_volume, MountData *data; data = g_new0 (MountData, 1); - data->simple = g_simple_async_result_new (G_OBJECT (volume), + data->task = g_task_new (volume, callback, user_data, gvfs_udisks2_volume_mount); @@ -1116,11 +1116,11 @@ gvfs_udisks2_volume_mount (GVolume *_volume, if (volume->mount_pending_op != NULL) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, "A mount operation is already pending"); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); mount_data_free (data); goto out; } @@ -1152,11 +1152,11 @@ gvfs_udisks2_volume_mount (GVolume *_volume, object = g_dbus_interface_get_object (G_DBUS_INTERFACE (block)); if (object == NULL) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, "No object for D-Bus interface"); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); mount_data_free (data); goto out; } @@ -1171,11 +1171,11 @@ gvfs_udisks2_volume_mount (GVolume *_volume, goto out; } - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, G_IO_ERROR, G_IO_ERROR_FAILED, "No .Filesystem or .Encrypted interface on D-Bus object"); - g_simple_async_result_complete (data->simple); + g_task_async_result_complete (data->task); mount_data_free (data); goto out; } @@ -1192,8 +1192,8 @@ gvfs_udisks2_volume_mount_finish (GVolume *volume, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result); - return !g_simple_async_result_propagate_error (simple, error); + GTask *task = G_TASK (result); + return !g_task_async_result_propagate_error (task, error); } /* ---------------------------------------------------------------------------------------------------- */ @@ -1243,15 +1243,15 @@ gvfs_udisks2_volume_eject_with_operation (GVolume *_volume, } else { - GSimpleAsyncResult *simple; - simple = g_simple_async_result_new_error (G_OBJECT (volume), + GTask *task; + task = g_task_new_error (G_OBJECT (volume), callback, user_data, G_IO_ERROR, G_IO_ERROR_FAILED, _("Operation not supported by backend")); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_async_result_complete (task); + g_object_unref (task); } } @@ -1269,7 +1269,7 @@ gvfs_udisks2_volume_eject_with_operation_finish (GVolume *_volume, } else { - g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error); + g_task_async_result_propagate_error (G_TASK (result), error); ret = FALSE; } return ret; |