[gvfs/wip/gtask-porting] Port to GTask
- From: Dan Winship <danw src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gvfs/wip/gtask-porting] Port to GTask
- Date: Mon, 6 Apr 2015 14:47:44 +0000 (UTC)
commit 8f5d05c27fbf79e1a77d0d1ae294db7da4eeecd9
Author: Dan Winship <danw gnome org>
Date: Sun Oct 21 18:18:46 2012 +0200
Port to GTask
client/gdaemonfile.c | 506 +++++++++------------------
client/gdaemonfileenumerator.c | 99 ++----
client/gdaemonfileinputstream.c | 50 ++--
client/gdaemonfileoutputstream.c | 50 ++--
client/gdaemonmount.c | 18 +-
client/gvfsdaemondbus.c | 25 --
client/gvfsdaemondbus.h | 4 -
client/gvfsiconloadable.c | 34 +-
common/gmountsource.c | 154 +++++----
common/gvfsdnssdresolver.c | 110 +++----
common/gvfsmountinfo.c | 326 ++++++------------
daemon/gvfsafpconnection.c | 94 +++---
daemon/gvfsafpserver.c | 28 +-
daemon/gvfsafpvolume.c | 646 +++++++++++++++++-----------------
daemon/gvfsbackend.c | 26 +-
daemon/gvfsbackendafpbrowse.c | 24 +-
daemon/soup-input-stream.c | 74 ++--
daemon/soup-output-stream.c | 36 +-
monitor/gdu/ggdudrive.c | 150 ++++----
monitor/gdu/ggdumount.c | 116 ++++----
monitor/gdu/ggduvolume.c | 112 +++---
monitor/hal/ghaldrive.c | 48 ++--
monitor/hal/ghalmount.c | 28 +-
monitor/hal/ghalvolume.c | 12 +-
monitor/proxy/gproxydrive.c | 96 +++---
monitor/proxy/gproxymount.c | 36 +-
monitor/proxy/gproxyvolume.c | 28 +-
monitor/udisks2/gvfsudisks2drive.c | 22 +-
monitor/udisks2/gvfsudisks2mount.c | 68 ++--
monitor/udisks2/gvfsudisks2utils.c | 48 ++--
monitor/udisks2/gvfsudisks2volume.c | 66 ++--
31 files changed, 1379 insertions(+), 1755 deletions(-)
---
diff --git a/client/gdaemonfile.c b/client/gdaemonfile.c
index 15c368c..1cd37c4 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 d8ca8ab..6302b91 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 4591832..5ba28b9 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 74e4caf..5887914 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 f5bc5a6..743c155 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 2cfd2e6..47e4441 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 c60108f..7a132cd 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 0660b30..80b29cd 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 cf567fc..4318157 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 1bb92e9..318d96a 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 c49b055..342fe5b 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 be489c5..b49f915 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 8dbd307..5992b6b 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 3fd33f2..a56386b 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 ced4fd9..f12eacb 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 d3de896..952e9be 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 cb730a3..e787284 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 885a8ca..5709900 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 4e51168..6f1491f 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 b7e8545..92a8c39 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 eb15d22..15518e7 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 e778f0a..dad53a8 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 ad805a4..0b28b58 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 cef37f7..0227eec 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 be2b600..0a17832 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 cd3ca49..f811690 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 b6b8c91..a6662f9 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 454f340..76f290d 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 61f58a1..947a91d 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 0dc8abe..a5675f0 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 af2cdf3..7272105 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;
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
