[Spice-commits] 13 commits - configure.ac src/channel-base.c src/channel-main.c src/channel-port.c src/channel-usbredir.c src/smartcard-manager.c src/spice-channel.c src/spice-gstaudio.c src/spice-pulse.c src/usb-acl-helper.c src/usb-device-manager.c src/vmcstream.c src/win-usb-driver-install.c src/wocky-http-proxy.c
Fabiano Fidêncio
fidencio at kemper.freedesktop.org
Mon Mar 14 21:53:12 UTC 2016
configure.ac | 6 +-
src/channel-base.c | 29 ++++-----
src/channel-main.c | 82 +++++++++++----------------
src/channel-port.c | 3 -
src/channel-usbredir.c | 38 +++++-------
src/smartcard-manager.c | 38 ++++--------
src/spice-channel.c | 32 ++++------
src/spice-gstaudio.c | 44 ++++----------
src/spice-pulse.c | 92 +++++++++++-------------------
src/usb-acl-helper.c | 61 +++++++++-----------
src/usb-device-manager.c | 58 +++++++++----------
src/vmcstream.c | 129 +++++++++++++++++--------------------------
src/win-usb-driver-install.c | 90 ++++++++++++++----------------
src/wocky-http-proxy.c | 48 +++++-----------
14 files changed, 308 insertions(+), 442 deletions(-)
New commits:
commit f2f9ed4f902af23a8a80607de1d487210448b3c0
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 15:04:29 2016 +0100
wocky-http-proxy: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/wocky-http-proxy.c b/src/wocky-http-proxy.c
index d84cd72..afe8be6 100644
--- a/src/wocky-http-proxy.c
+++ b/src/wocky-http-proxy.c
@@ -254,14 +254,13 @@ error:
typedef struct
{
- GSimpleAsyncResult *simple;
+ GTask *task;
GIOStream *io_stream;
gchar *buffer;
gssize length;
gssize offset;
GDataInputStream *data_in;
gboolean has_cred;
- GCancellable *cancellable;
} ConnectAsyncData;
static void request_write_cb (GObject *source,
@@ -282,26 +281,20 @@ free_connect_data (ConnectAsyncData *data)
if (data->data_in != NULL)
g_object_unref (data->data_in);
- if (data->cancellable != NULL)
- g_object_unref (data->cancellable);
-
g_free (data);
}
static void
complete_async_from_error (ConnectAsyncData *data, GError *error)
{
- GSimpleAsyncResult *simple = data->simple;
+ GTask *task = data->task;
if (error == NULL)
g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_PROXY_FAILED,
"HTTP proxy server closed connection unexpectedly.");
- g_simple_async_result_set_from_error (data->simple, error);
- g_error_free (error);
- g_simple_async_result_set_op_res_gpointer (simple, NULL, NULL);
- g_simple_async_result_complete (simple);
- g_object_unref (simple);
+ g_task_return_error(data->task, error);
+ g_object_unref (task);
}
static void
@@ -312,7 +305,7 @@ do_write (GAsyncReadyCallback callback, ConnectAsyncData *data)
g_output_stream_write_async (out,
data->buffer + data->offset,
data->length - data->offset,
- G_PRIORITY_DEFAULT, data->cancellable,
+ G_PRIORITY_DEFAULT, g_task_get_cancellable(data->task),
callback, data);
}
@@ -357,25 +350,21 @@ wocky_http_proxy_connect_async (GProxy *proxy,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *simple;
+ GTask *task;
ConnectAsyncData *data;
- simple = g_simple_async_result_new (G_OBJECT (proxy),
- callback, user_data,
- wocky_http_proxy_connect_async);
+ task = g_task_new (proxy,
+ cancellable,
+ callback,
+ user_data);
data = g_new0 (ConnectAsyncData, 1);
- if (cancellable != NULL)
- data->cancellable = g_object_ref (cancellable);
- data->simple = simple;
+ data->task = task;
data->buffer = create_request (proxy_address, &data->has_cred);
data->length = strlen (data->buffer);
data->offset = 0;
- g_simple_async_result_set_op_res_gpointer (simple, data,
- (GDestroyNotify) free_connect_data);
-
if (WOCKY_IS_HTTPS_PROXY (proxy))
{
GError *error = NULL;
@@ -435,7 +424,7 @@ request_write_cb (GObject *source,
g_data_input_stream_read_until_async (data->data_in,
HTTP_END_MARKER,
G_PRIORITY_DEFAULT,
- data->cancellable,
+ g_task_get_cancellable(data->task),
reply_read_cb, data);
}
@@ -468,8 +457,8 @@ reply_read_cb (GObject *source,
return;
}
- g_simple_async_result_complete (data->simple);
- g_object_unref (data->simple);
+ g_task_return_pointer (data->task, data, (GDestroyNotify) free_connect_data);
+ g_object_unref (data->task);
}
static GIOStream *
@@ -477,13 +466,10 @@ wocky_http_proxy_connect_finish (GProxy *proxy,
GAsyncResult *result,
GError **error)
{
- GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
- ConnectAsyncData *data = g_simple_async_result_get_op_res_gpointer (simple);
-
- if (g_simple_async_result_propagate_error (simple, error))
- return NULL;
+ GTask *task = G_TASK (result);
+ ConnectAsyncData *data = g_task_propagate_pointer (task, error);
- return g_object_ref (data->io_stream);
+ return data ? g_object_ref (data->io_stream) : NULL;
}
static gboolean
commit ef02f447e5f2df457fb691ece0cffe64eb3dc633
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 15:04:10 2016 +0100
win-usb-driver-install: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/win-usb-driver-install.c b/src/win-usb-driver-install.c
index 54e9b14..0d4627a 100644
--- a/src/win-usb-driver-install.c
+++ b/src/win-usb-driver-install.c
@@ -44,8 +44,7 @@
struct _SpiceWinUsbDriverPrivate {
USBClerkReply reply;
- GSimpleAsyncResult *result;
- GCancellable *cancellable;
+ GTask *task;
HANDLE handle;
SpiceUsbDevice *device;
};
@@ -95,7 +94,7 @@ static void spice_win_usb_driver_finalize(GObject *gobject)
if (priv->handle)
CloseHandle(priv->handle);
- g_clear_object(&priv->result);
+ g_clear_object(&priv->task);
if (G_OBJECT_CLASS(spice_win_usb_driver_parent_class)->finalize)
G_OBJECT_CLASS(spice_win_usb_driver_parent_class)->finalize(gobject);
@@ -144,16 +143,16 @@ void win_usb_driver_handle_reply_cb(GObject *gobject,
if (err) {
g_warning("failed to read reply from usbclerk (%s)", err->message);
- g_simple_async_result_take_error(priv->result, err);
+ g_task_return_error(priv->task, err);
goto failed_reply;
}
if (bytes == 0) {
g_warning("unexpected EOF from usbclerk");
- g_simple_async_result_set_error(priv->result,
- SPICE_WIN_USB_DRIVER_ERROR,
- SPICE_WIN_USB_DRIVER_ERROR_FAILED,
- "unexpected EOF from usbclerk");
+ g_task_return_new_error(priv->task,
+ SPICE_WIN_USB_DRIVER_ERROR,
+ SPICE_WIN_USB_DRIVER_ERROR_FAILED,
+ "unexpected EOF from usbclerk");
goto failed_reply;
}
@@ -167,53 +166,54 @@ void win_usb_driver_handle_reply_cb(GObject *gobject,
if (priv->reply.hdr.magic != USB_CLERK_MAGIC) {
g_warning("usbclerk magic mismatch: mine=0x%04x server=0x%04x",
USB_CLERK_MAGIC, priv->reply.hdr.magic);
- g_simple_async_result_set_error(priv->result,
- SPICE_WIN_USB_DRIVER_ERROR,
- SPICE_WIN_USB_DRIVER_ERROR_MESSAGE,
- "usbclerk magic mismatch");
+ g_task_return_new_error(priv->task,
+ SPICE_WIN_USB_DRIVER_ERROR,
+ SPICE_WIN_USB_DRIVER_ERROR_MESSAGE,
+ "usbclerk magic mismatch");
goto failed_reply;
}
if (priv->reply.hdr.version != USB_CLERK_VERSION) {
g_warning("usbclerk version mismatch: mine=0x%04x server=0x%04x",
USB_CLERK_VERSION, priv->reply.hdr.version);
- g_simple_async_result_set_error(priv->result,
- SPICE_WIN_USB_DRIVER_ERROR,
- SPICE_WIN_USB_DRIVER_ERROR_MESSAGE,
- "usbclerk version mismatch");
+ g_task_return_new_error(priv->task,
+ SPICE_WIN_USB_DRIVER_ERROR,
+ SPICE_WIN_USB_DRIVER_ERROR_MESSAGE,
+ "usbclerk version mismatch");
}
if (priv->reply.hdr.type != USB_CLERK_REPLY) {
g_warning("usbclerk message with unexpected type %d",
priv->reply.hdr.type);
- g_simple_async_result_set_error(priv->result,
- SPICE_WIN_USB_DRIVER_ERROR,
- SPICE_WIN_USB_DRIVER_ERROR_MESSAGE,
- "usbclerk message with unexpected type");
+ g_task_return_new_error(priv->task,
+ SPICE_WIN_USB_DRIVER_ERROR,
+ SPICE_WIN_USB_DRIVER_ERROR_MESSAGE,
+ "usbclerk message with unexpected type");
goto failed_reply;
}
if (priv->reply.hdr.size != bytes) {
g_warning("usbclerk message size mismatch: read %"G_GSSIZE_FORMAT" bytes hdr.size=%d",
bytes, priv->reply.hdr.size);
- g_simple_async_result_set_error(priv->result,
- SPICE_WIN_USB_DRIVER_ERROR,
- SPICE_WIN_USB_DRIVER_ERROR_MESSAGE,
- "usbclerk message with unexpected size");
+ g_task_return_new_error(priv->task,
+ SPICE_WIN_USB_DRIVER_ERROR,
+ SPICE_WIN_USB_DRIVER_ERROR_MESSAGE,
+ "usbclerk message with unexpected size");
goto failed_reply;
}
if (priv->reply.status == 0) {
- g_simple_async_result_set_error(priv->result,
- SPICE_WIN_USB_DRIVER_ERROR,
- SPICE_WIN_USB_DRIVER_ERROR_MESSAGE,
- "usbclerk error reply");
+ g_task_return_new_error(priv->task,
+ SPICE_WIN_USB_DRIVER_ERROR,
+ SPICE_WIN_USB_DRIVER_ERROR_MESSAGE,
+ "usbclerk error reply");
goto failed_reply;
}
+ g_task_return_boolean (priv->task, TRUE);
+
failed_reply:
- g_simple_async_result_complete_in_idle(priv->result);
- g_clear_object(&priv->result);
+ g_clear_object(&priv->task);
}
/* ------------------------------------------------------------------ */
@@ -268,7 +268,8 @@ void spice_win_usb_driver_read_reply_async(SpiceWinUsbDriver *self)
istream = g_win32_input_stream_new(priv->handle, FALSE);
g_input_stream_read_async(istream, &priv->reply, sizeof(priv->reply),
- G_PRIORITY_DEFAULT, priv->cancellable,
+ G_PRIORITY_DEFAULT,
+ g_task_get_cancellable(priv->task),
win_usb_driver_handle_reply_cb, self);
}
@@ -299,7 +300,7 @@ void spice_win_usb_driver_op(SpiceWinUsbDriver *self,
{
guint16 vid, pid;
GError *err = NULL;
- GSimpleAsyncResult *result;
+ GTask *task;
SpiceWinUsbDriverPrivate *priv;
g_return_if_fail(SPICE_IS_WIN_USB_DRIVER(self));
@@ -307,12 +308,11 @@ void spice_win_usb_driver_op(SpiceWinUsbDriver *self,
priv = self->priv;
- result = g_simple_async_result_new(G_OBJECT(self), callback, user_data,
- spice_win_usb_driver_op);
+ task = g_task_new(self, cancellable, callback, user_data);
- if (priv->result) { /* allow one install/uninstall request at a time */
+ if (priv->task) { /* allow one install/uninstall request at a time */
g_warning("Another request exists -- try later");
- g_simple_async_result_set_error(result,
+ g_task_return_new_error(task,
SPICE_WIN_USB_DRIVER_ERROR, SPICE_WIN_USB_DRIVER_ERROR_FAILED,
"Another request exists -- try later");
goto failed_request;
@@ -325,22 +325,20 @@ void spice_win_usb_driver_op(SpiceWinUsbDriver *self,
if (!spice_win_usb_driver_send_request(self, op_type,
vid, pid, &err)) {
g_warning("failed to send a request to usbclerk %s", err->message);
- g_simple_async_result_take_error(result, err);
+ g_task_return_error(task, err);
goto failed_request;
}
/* set up for async read */
- priv->result = result;
+ priv->task = task;
priv->device = device;
- priv->cancellable = cancellable;
spice_win_usb_driver_read_reply_async(self);
return;
failed_request:
- g_simple_async_result_complete_in_idle(result);
- g_clear_object(&result);
+ g_clear_object(&task);
}
/**
@@ -351,16 +349,12 @@ static gboolean
spice_win_usb_driver_op_finish(SpiceWinUsbDriver *self,
GAsyncResult *res, GError **err)
{
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT(res);
+ GTask *task = G_TASK(res);
g_return_val_if_fail(SPICE_IS_WIN_USB_DRIVER(self), 0);
- g_return_val_if_fail(g_simple_async_result_is_valid(res, G_OBJECT(self),
- spice_win_usb_driver_op),
- FALSE);
- if (g_simple_async_result_propagate_error(result, err))
- return FALSE;
+ g_return_val_if_fail(g_task_is_valid(task, self), FALSE);
- return TRUE;
+ return g_task_propagate_boolean(task, err);
}
/**
commit 9d20a84b3c8738fc2de1a1e27fbdb07b42e79661
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 15:03:23 2016 +0100
vmcstream: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/vmcstream.c b/src/vmcstream.c
index 483dd5a..05dba7d 100644
--- a/src/vmcstream.c
+++ b/src/vmcstream.c
@@ -27,7 +27,7 @@
struct _SpiceVmcInputStream
{
GInputStream parent_instance;
- GSimpleAsyncResult *result;
+ GTask *task;
struct coroutine *coroutine;
SpiceChannel *channel;
@@ -36,7 +36,6 @@ struct _SpiceVmcInputStream
gsize count;
gsize pos;
- GCancellable *cancellable;
gulong cancel_id;
};
@@ -118,11 +117,12 @@ spice_vmc_input_stream_co_data(SpiceVmcInputStream *self,
self->coroutine = coroutine_self();
while (size > 0) {
- SPICE_DEBUG("spicevmc co_data %p", self->result);
- if (!self->result)
+ GCancellable *cancellable;
+ SPICE_DEBUG("spicevmc co_data %p", self->task);
+ if (!self->task)
coroutine_yield(NULL);
- g_return_if_fail(self->result != NULL);
+ g_return_if_fail(self->task != NULL);
gsize min = MIN(self->count, size);
memcpy(self->buffer, data, min);
@@ -139,14 +139,13 @@ spice_vmc_input_stream_co_data(SpiceVmcInputStream *self,
if (self->all && min > 0 && self->pos != self->count)
continue;
- g_simple_async_result_set_op_res_gssize(self->result, self->pos);
+ g_task_return_int(self->task, self->pos);
+
+ cancellable = g_task_get_cancellable(self->task);
+ if (cancellable)
+ g_cancellable_disconnect(cancellable, self->cancel_id);
- g_simple_async_result_complete_in_idle(self->result);
- g_clear_object(&self->result);
- if (self->cancellable) {
- g_cancellable_disconnect(self->cancellable, self->cancel_id);
- g_clear_object(&self->cancellable);
- }
+ g_clear_object(&self->task);
}
self->coroutine = NULL;
@@ -158,13 +157,12 @@ read_cancelled(GCancellable *cancellable,
{
SpiceVmcInputStream *self = SPICE_VMC_INPUT_STREAM(user_data);
- SPICE_DEBUG("read cancelled, %p", self->result);
- g_simple_async_result_set_error(self->result,
- G_IO_ERROR, G_IO_ERROR_CANCELLED,
- "read cancelled");
- g_simple_async_result_complete_in_idle(self->result);
+ SPICE_DEBUG("read cancelled, %p", self->task);
+ g_task_return_new_error(self->task,
+ G_IO_ERROR, G_IO_ERROR_CANCELLED,
+ "read cancelled");
- g_clear_object(&self->result);
+ g_clear_object(&self->task);
/* See FIXME */
/* if (self->cancellable) { */
@@ -183,21 +181,20 @@ spice_vmc_input_stream_read_all_async(GInputStream *stream,
gpointer user_data)
{
SpiceVmcInputStream *self = SPICE_VMC_INPUT_STREAM(stream);
- GSimpleAsyncResult *result;
+ GTask *task;
/* no concurrent read permitted by ginputstream */
- g_return_if_fail(self->result == NULL);
- g_return_if_fail(self->cancellable == NULL);
+ g_return_if_fail(self->task == NULL);
+ g_return_if_fail(g_task_get_cancellable(self->task) == NULL);
self->all = TRUE;
self->buffer = buffer;
self->count = count;
self->pos = 0;
- result = g_simple_async_result_new(G_OBJECT(self),
- callback,
- user_data,
- spice_vmc_input_stream_read_async);
- self->result = result;
- self->cancellable = g_object_ref(cancellable);
+ task = g_task_new(self,
+ cancellable,
+ callback,
+ user_data);
+ self->task = task;
if (cancellable)
self->cancel_id =
g_cancellable_connect(cancellable, G_CALLBACK(read_cancelled), self, NULL);
@@ -211,27 +208,19 @@ spice_vmc_input_stream_read_all_finish(GInputStream *stream,
GAsyncResult *result,
GError **error)
{
- GSimpleAsyncResult *simple;
+ GTask *task = G_TASK(result);
+ GCancellable *cancellable;
SpiceVmcInputStream *self = SPICE_VMC_INPUT_STREAM(stream);
- g_return_val_if_fail(g_simple_async_result_is_valid(result,
- G_OBJECT(self),
- spice_vmc_input_stream_read_async),
- -1);
-
- simple = (GSimpleAsyncResult *)result;
+ g_return_val_if_fail(g_task_is_valid(task, self), -1);
/* FIXME: calling _finish() is required. Disconnecting in
read_cancelled() causes a deadlock. #705395 */
- if (self->cancellable) {
- g_cancellable_disconnect(self->cancellable, self->cancel_id);
- g_clear_object(&self->cancellable);
- }
-
- if (g_simple_async_result_propagate_error(simple, error))
- return -1;
+ cancellable = g_task_get_cancellable(task);
+ if (cancellable)
+ g_cancellable_disconnect(cancellable, self->cancel_id);
- return g_simple_async_result_get_op_res_gssize(simple);
+ return g_task_propagate_int(task, error);
}
static void
@@ -244,21 +233,18 @@ spice_vmc_input_stream_read_async(GInputStream *stream,
gpointer user_data)
{
SpiceVmcInputStream *self = SPICE_VMC_INPUT_STREAM(stream);
- GSimpleAsyncResult *result;
+ GTask *task;
/* no concurrent read permitted by ginputstream */
- g_return_if_fail(self->result == NULL);
- g_return_if_fail(self->cancellable == NULL);
+ g_return_if_fail(self->task == NULL);
+ g_return_if_fail(g_task_get_cancellable(self->task) == NULL);
self->all = FALSE;
self->buffer = buffer;
self->count = count;
self->pos = 0;
- result = g_simple_async_result_new(G_OBJECT(self),
- callback,
- user_data,
- spice_vmc_input_stream_read_async);
- self->result = result;
- self->cancellable = g_object_ref(cancellable);
+
+ task = g_task_new(self, cancellable, callback, user_data);
+ self->task = task;
if (cancellable)
self->cancel_id =
g_cancellable_connect(cancellable, G_CALLBACK(read_cancelled), self, NULL);
@@ -272,27 +258,19 @@ spice_vmc_input_stream_read_finish(GInputStream *stream,
GAsyncResult *result,
GError **error)
{
- GSimpleAsyncResult *simple;
+ GTask *task = G_TASK(result);
+ GCancellable *cancellable;
SpiceVmcInputStream *self = SPICE_VMC_INPUT_STREAM(stream);
- g_return_val_if_fail(g_simple_async_result_is_valid(result,
- G_OBJECT(self),
- spice_vmc_input_stream_read_async),
- -1);
-
- simple = (GSimpleAsyncResult *)result;
+ g_return_val_if_fail(g_task_is_valid(task, self), -1);
/* FIXME: calling _finish() is required. Disconnecting in
read_cancelled() causes a deadlock. #705395 */
- if (self->cancellable) {
- g_cancellable_disconnect(self->cancellable, self->cancel_id);
- g_clear_object(&self->cancellable);
- }
-
- if (g_simple_async_result_propagate_error(simple, error))
- return -1;
+ cancellable = g_task_get_cancellable(task);
+ if (cancellable)
+ g_cancellable_disconnect(cancellable, self->cancel_id);
- return g_simple_async_result_get_op_res_gssize(simple);
+ return g_task_propagate_int(task, error);
}
static gssize
@@ -407,11 +385,10 @@ spice_vmc_output_stream_write_finish(GOutputStream *stream,
GError **error)
{
SpiceVmcOutputStream *self = SPICE_VMC_OUTPUT_STREAM(stream);
- GSimpleAsyncResult *res =
- g_simple_async_result_get_op_res_gpointer(G_SIMPLE_ASYNC_RESULT(simple));
+ GAsyncResult *res = g_task_propagate_pointer(G_TASK(simple), error);
SPICE_DEBUG("spicevmc write finish");
- return spice_vmc_write_finish(self->channel, G_ASYNC_RESULT(res), error);
+ return spice_vmc_write_finish(self->channel, res, error);
}
static void
@@ -419,12 +396,11 @@ write_cb(GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
- GSimpleAsyncResult *simple = user_data;
+ GTask *task = user_data;
- g_simple_async_result_set_op_res_gpointer(simple, res, NULL);
+ g_task_return_pointer(task, g_object_ref(task), g_object_unref);
- g_simple_async_result_complete(simple);
- g_object_unref(simple);
+ g_object_unref(task);
}
static void
@@ -437,16 +413,15 @@ spice_vmc_output_stream_write_async(GOutputStream *stream,
gpointer user_data)
{
SpiceVmcOutputStream *self = SPICE_VMC_OUTPUT_STREAM(stream);
- GSimpleAsyncResult *simple;
+ GTask *task;
SPICE_DEBUG("spicevmc write async");
/* an AsyncResult to forward async op to channel */
- simple = g_simple_async_result_new(G_OBJECT(self), callback, user_data,
- spice_vmc_output_stream_write_async);
+ task = g_task_new(self, cancellable, callback, user_data);
spice_vmc_write_async(self->channel, buffer, count,
cancellable, write_cb,
- simple);
+ task);
}
/* STREAM */
commit 379aac1dc7790eb896c98a6197c3dd5d8bdade75
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 15:02:55 2016 +0100
usb-device-manager: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/usb-device-manager.c b/src/usb-device-manager.c
index a8dd4e7..1b9a227 100644
--- a/src/usb-device-manager.c
+++ b/src/usb-device-manager.c
@@ -1086,15 +1086,16 @@ static void spice_usb_device_manager_channel_connect_cb(
GObject *gobject, GAsyncResult *channel_res, gpointer user_data)
{
SpiceUsbredirChannel *channel = SPICE_USBREDIR_CHANNEL(gobject);
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT(user_data);
+ GTask *task = G_TASK(user_data);
GError *err = NULL;
spice_usbredir_channel_connect_device_finish(channel, channel_res, &err);
- if (err) {
- g_simple_async_result_take_error(result, err);
- }
- g_simple_async_result_complete(result);
- g_object_unref(result);
+ if (err)
+ g_task_return_error(task, err);
+ else
+ g_task_return_boolean(task, TRUE);
+
+ g_object_unref(task);
}
#ifdef G_OS_WIN32
@@ -1260,7 +1261,7 @@ static void spice_usb_device_manager_check_redir_on_connect(
SpiceUsbDeviceManager *self, SpiceChannel *channel)
{
SpiceUsbDeviceManagerPrivate *priv = self->priv;
- GSimpleAsyncResult *result;
+ GTask *task;
SpiceUsbDevice *device;
libusb_device *libdev;
guint i;
@@ -1285,15 +1286,16 @@ static void spice_usb_device_manager_check_redir_on_connect(
libdev, 0) == 0) {
/* Note: re-uses spice_usb_device_manager_connect_device_async's
completion handling code! */
- result = g_simple_async_result_new(G_OBJECT(self),
- spice_usb_device_manager_auto_connect_cb,
- spice_usb_device_ref(device),
- spice_usb_device_manager_connect_device_async);
+ task = g_task_new(self,
+ NULL,
+ spice_usb_device_manager_auto_connect_cb,
+ spice_usb_device_ref(device));
+
spice_usbredir_channel_connect_device_async(
SPICE_USBREDIR_CHANNEL(channel),
libdev, device, NULL,
spice_usb_device_manager_channel_connect_cb,
- result);
+ task);
libusb_unref_device(libdev);
return; /* We've taken the channel! */
}
@@ -1432,15 +1434,14 @@ _spice_usb_device_manager_connect_device_async(SpiceUsbDeviceManager *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *result;
+ GTask *task;
g_return_if_fail(SPICE_IS_USB_DEVICE_MANAGER(self));
g_return_if_fail(device != NULL);
SPICE_DEBUG("connecting device %p", device);
- result = g_simple_async_result_new(G_OBJECT(self), callback, user_data,
- spice_usb_device_manager_connect_device_async);
+ task = g_task_new(self, cancellable, callback, user_data);
#ifdef USE_USBREDIR
SpiceUsbDeviceManagerPrivate *priv = self->priv;
@@ -1448,7 +1449,7 @@ _spice_usb_device_manager_connect_device_async(SpiceUsbDeviceManager *self,
guint i;
if (spice_usb_device_manager_is_device_connected(self, device)) {
- g_simple_async_result_set_error(result,
+ g_task_return_new_error(task,
SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
"Cannot connect an already connected usb device");
goto done;
@@ -1472,10 +1473,10 @@ _spice_usb_device_manager_connect_device_async(SpiceUsbDeviceManager *self,
g_ptr_array_remove(priv->devices, device);
g_signal_emit(self, signals[DEVICE_REMOVED], 0, device);
spice_usb_device_unref(device);
- g_simple_async_result_set_error(result,
- SPICE_CLIENT_ERROR,
- SPICE_CLIENT_ERROR_FAILED,
- _("Device was not found"));
+ g_task_return_new_error(task,
+ SPICE_CLIENT_ERROR,
+ SPICE_CLIENT_ERROR_FAILED,
+ _("Device was not found"));
goto done;
}
#endif
@@ -1484,20 +1485,19 @@ _spice_usb_device_manager_connect_device_async(SpiceUsbDeviceManager *self,
device,
cancellable,
spice_usb_device_manager_channel_connect_cb,
- result);
+ task);
libusb_unref_device(libdev);
return;
}
#endif
- g_simple_async_result_set_error(result,
+ g_task_return_new_error(task,
SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
_("No free USB channel"));
#ifdef USE_USBREDIR
done:
#endif
- g_simple_async_result_complete_in_idle(result);
- g_object_unref(result);
+ g_object_unref(task);
}
/**
@@ -1561,16 +1561,12 @@ void spice_usb_device_manager_connect_device_async(SpiceUsbDeviceManager *self,
gboolean spice_usb_device_manager_connect_device_finish(
SpiceUsbDeviceManager *self, GAsyncResult *res, GError **err)
{
- GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT(res);
+ GTask *task = G_TASK(res);
- g_return_val_if_fail(g_simple_async_result_is_valid(res, G_OBJECT(self),
- spice_usb_device_manager_connect_device_async),
+ g_return_val_if_fail(g_task_is_valid(task, self),
FALSE);
- if (g_simple_async_result_propagate_error(simple, err))
- return FALSE;
-
- return TRUE;
+ return g_task_propagate_boolean(task, err);
}
/**
commit 79ed45373f4f6eb53d08e0d9b42b938b93eff4a8
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 15:02:23 2016 +0100
usb-acl-helper: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/usb-acl-helper.c b/src/usb-acl-helper.c
index cc5ce9f..03d6c67 100644
--- a/src/usb-acl-helper.c
+++ b/src/usb-acl-helper.c
@@ -35,7 +35,7 @@
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), SPICE_TYPE_USB_ACL_HELPER, SpiceUsbAclHelperPrivate))
struct _SpiceUsbAclHelperPrivate {
- GSimpleAsyncResult *result;
+ GTask *task;
GIOChannel *in_ch;
GIOChannel *out_ch;
GCancellable *cancellable;
@@ -57,7 +57,7 @@ static void spice_usb_acl_helper_cleanup(SpiceUsbAclHelper *self)
priv->cancellable = NULL;
priv->cancellable_id = 0;
- g_clear_object(&priv->result);
+ g_clear_object(&priv->task);
if (priv->in_ch) {
g_io_channel_unref(priv->in_ch);
@@ -90,9 +90,9 @@ static void spice_usb_acl_helper_class_init(SpiceUsbAclHelperClass *klass)
/* ------------------------------------------------------------------ */
/* callbacks */
-static void async_result_set_cancelled(GSimpleAsyncResult *result)
+static void async_result_set_cancelled(GTask *task)
{
- g_simple_async_result_set_error(result,
+ g_task_return_new_error(task,
G_IO_ERROR, G_IO_ERROR_CANCELLED,
"Setting USB device node ACL cancelled");
}
@@ -110,7 +110,7 @@ static gboolean cb_out_watch(GIOChannel *channel,
gsize size;
/* Check that we've not been cancelled */
- if (priv->result == NULL)
+ if (priv->task == NULL)
goto done;
g_return_val_if_fail(channel == priv->out_ch, FALSE);
@@ -121,10 +121,11 @@ static gboolean cb_out_watch(GIOChannel *channel,
string[strlen(string) - 1] = 0;
if (!strcmp(string, "SUCCESS")) {
success = TRUE;
+ g_task_return_boolean(priv->task, TRUE);
} else if (!strcmp(string, "CANCELED")) {
- async_result_set_cancelled(priv->result);
+ async_result_set_cancelled(priv->task);
} else {
- g_simple_async_result_set_error(priv->result,
+ g_task_return_new_error(priv->task,
SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
"Error setting USB device node ACL: '%s'",
string);
@@ -132,10 +133,10 @@ static gboolean cb_out_watch(GIOChannel *channel,
g_free(string);
break;
case G_IO_STATUS_ERROR:
- g_simple_async_result_take_error(priv->result, err);
+ g_task_return_error(priv->task, err);
break;
case G_IO_STATUS_EOF:
- g_simple_async_result_set_error(priv->result,
+ g_task_return_new_error(priv->task,
SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
"Unexpected EOF reading from acl helper stdout");
break;
@@ -147,8 +148,7 @@ static gboolean cb_out_watch(GIOChannel *channel,
priv->cancellable = NULL;
priv->cancellable_id = 0;
- g_simple_async_result_complete_in_idle(priv->result);
- g_clear_object(&priv->result);
+ g_clear_object(&priv->task);
if (!success)
spice_usb_acl_helper_cleanup(self);
@@ -193,7 +193,7 @@ void spice_usb_acl_helper_open_acl_async(SpiceUsbAclHelper *self,
g_return_if_fail(SPICE_IS_USB_ACL_HELPER(self));
SpiceUsbAclHelperPrivate *priv = self->priv;
- GSimpleAsyncResult *result;
+ GTask *task;
GError *err = NULL;
GIOStatus status;
GPid helper_pid;
@@ -205,25 +205,24 @@ void spice_usb_acl_helper_open_acl_async(SpiceUsbAclHelper *self,
gint in, out;
gchar buf[128];
- result = g_simple_async_result_new(G_OBJECT(self), callback, user_data,
- spice_usb_acl_helper_open_acl_async);
+ task = g_task_new(self, cancellable, callback, user_data);
if (priv->out_ch) {
- g_simple_async_result_set_error(result,
+ g_task_return_new_error(task,
SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
"Error acl-helper already has an acl open");
goto done;
}
if (g_cancellable_set_error_if_cancelled(cancellable, &err)) {
- g_simple_async_result_take_error(result, err);
+ g_task_return_error(task, err);
goto done;
}
if (!g_spawn_async_with_pipes(NULL, argv, NULL,
G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH,
NULL, NULL, &helper_pid, &in, &out, NULL, &err)) {
- g_simple_async_result_take_error(result, err);
+ g_task_return_error(task, err);
goto done;
}
g_child_watch_add(helper_pid, helper_child_watch_cb, NULL);
@@ -235,7 +234,7 @@ void spice_usb_acl_helper_open_acl_async(SpiceUsbAclHelper *self,
g_io_channel_set_close_on_unref(priv->out_ch, TRUE);
status = g_io_channel_set_flags(priv->out_ch, G_IO_FLAG_NONBLOCK, &err);
if (status != G_IO_STATUS_NORMAL) {
- g_simple_async_result_take_error(result, err);
+ g_task_return_error(task, err);
goto done;
}
@@ -243,16 +242,16 @@ void spice_usb_acl_helper_open_acl_async(SpiceUsbAclHelper *self,
status = g_io_channel_write_chars(priv->in_ch, buf, -1,
&bytes_written, &err);
if (status != G_IO_STATUS_NORMAL) {
- g_simple_async_result_take_error(result, err);
+ g_task_return_error(task, err);
goto done;
}
status = g_io_channel_flush(priv->in_ch, &err);
if (status != G_IO_STATUS_NORMAL) {
- g_simple_async_result_take_error(result, err);
+ g_task_return_error(task, err);
goto done;
}
- priv->result = result;
+ priv->task = task;
if (cancellable) {
priv->cancellable = cancellable;
priv->cancellable_id = g_cancellable_connect(cancellable,
@@ -265,24 +264,19 @@ void spice_usb_acl_helper_open_acl_async(SpiceUsbAclHelper *self,
done:
spice_usb_acl_helper_cleanup(self);
- g_simple_async_result_complete_in_idle(result);
- g_object_unref(result);
+ g_object_unref(task);
}
G_GNUC_INTERNAL
gboolean spice_usb_acl_helper_open_acl_finish(
SpiceUsbAclHelper *self, GAsyncResult *res, GError **err)
{
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT(res);
+ GTask *task = G_TASK(res);
- g_return_val_if_fail(g_simple_async_result_is_valid(res, G_OBJECT(self),
- spice_usb_acl_helper_open_acl_async),
+ g_return_val_if_fail(g_task_is_valid(task, self),
FALSE);
- if (g_simple_async_result_propagate_error(result, err))
- return FALSE;
-
- return TRUE;
+ return g_task_propagate_boolean(task, err);
}
G_GNUC_INTERNAL
@@ -291,9 +285,8 @@ void spice_usb_acl_helper_cancel(SpiceUsbAclHelper *self)
g_return_if_fail(SPICE_IS_USB_ACL_HELPER(self));
SpiceUsbAclHelperPrivate *priv = self->priv;
- g_return_if_fail(priv->result != NULL);
+ g_return_if_fail(priv->task != NULL);
- async_result_set_cancelled(priv->result);
- g_simple_async_result_complete_in_idle(priv->result);
- g_clear_object(&priv->result);
+ async_result_set_cancelled(priv->task);
+ g_clear_object(&priv->task);
}
commit fe44cc70ed9a7971c4e9c9a9ea84bfe83011ec16
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 15:02:02 2016 +0100
spice-pulse: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/spice-pulse.c b/src/spice-pulse.c
index 553dfda..2339011 100644
--- a/src/spice-pulse.c
+++ b/src/spice-pulse.c
@@ -34,13 +34,12 @@
struct async_task {
SpicePulse *pulse;
SpiceMainChannel *main_channel;
- GSimpleAsyncResult *res;
+ GTask *gtask;
GAsyncReadyCallback callback;
gpointer user_data;
gboolean is_playback;
pa_operation *pa_op;
gulong cancel_id;
- GCancellable *cancellable;
};
struct stream {
@@ -941,19 +940,18 @@ static gboolean free_async_task(gpointer user_data)
g_object_unref(task->pulse);
}
- if (task->res)
- g_object_unref(task->res);
-
if (task->main_channel)
g_object_unref(task->main_channel);
if (task->pa_op != NULL)
pa_operation_unref(task->pa_op);
- if (task->cancel_id != 0) {
- g_cancellable_disconnect(task->cancellable, task->cancel_id);
- g_clear_object(&task->cancellable);
- }
+ if (task->cancel_id != 0)
+ g_cancellable_disconnect(g_task_get_cancellable(task->gtask),
+ task->cancel_id);
+
+ if (task->gtask)
+ g_object_unref(task->gtask);
g_free(task);
return G_SOURCE_REMOVE;
@@ -981,14 +979,6 @@ static void cancel_task(GCancellable *cancellable, gpointer user_data)
task->pulse->priv->pending_restore_task = NULL;
}
-#if !GLIB_CHECK_VERSION(2,32,0)
- /* g_simple_async_result_set_check_cancellable is not present. Set an error
- * in the GSimpleAsyncResult in case of _finish functions is called */
- g_simple_async_result_set_error(task->res,
- SPICE_CLIENT_ERROR,
- SPICE_CLIENT_ERROR_FAILED,
- "Operation was cancelled");
-#endif
/* FIXME: https://bugzilla.gnome.org/show_bug.cgi?id=705395
* Free the memory in idle */
g_idle_add(free_async_task, task);
@@ -1001,27 +991,21 @@ static void complete_task(SpicePulse *pulse, struct async_task *task, const gcha
/* If we do have any err_msg, we failed */
if (err_msg != NULL) {
- g_simple_async_result_set_op_res_gboolean(task->res, FALSE);
- g_simple_async_result_set_error(task->res,
- SPICE_CLIENT_ERROR,
- SPICE_CLIENT_ERROR_FAILED,
- "restore-info failed due %s",
- err_msg);
+ g_task_return_new_error(task->gtask,
+ SPICE_CLIENT_ERROR,
+ SPICE_CLIENT_ERROR_FAILED,
+ "restore-info failed: %s",
+ err_msg);
/* Volume-info does not change if stream is not found */
} else if ((task->is_playback == TRUE && p->playback.info_updated == FALSE) ||
(task->is_playback == FALSE && p->record.info_updated == FALSE)) {
- g_simple_async_result_set_op_res_gboolean(task->res, FALSE);
- g_simple_async_result_set_error(task->res,
- SPICE_CLIENT_ERROR,
- SPICE_CLIENT_ERROR_FAILED,
- "Stream not found by pulse");
+ g_task_return_new_error(task->gtask,
+ SPICE_CLIENT_ERROR,
+ SPICE_CLIENT_ERROR_FAILED,
+ "Stream not found by pulse");
} else {
- g_simple_async_result_set_op_res_gboolean(task->res, TRUE);
+ g_task_return_boolean(task->gtask, TRUE);
}
-
- /* As all async calls to PulseAudio are done with glib mainloop, it is
- * safe to complete the operation synchronously here. */
- g_simple_async_result_complete(task->res);
}
static void spice_pulse_complete_async_task(struct async_task *task, const gchar *err_msg)
@@ -1157,19 +1141,13 @@ static void pulse_stream_restore_info_async(gboolean is_playback,
gpointer user_data)
{
SpicePulsePrivate *p = SPICE_PULSE(audio)->priv;
- GSimpleAsyncResult *simple;
+ GTask *gtask;
struct async_task *task = g_malloc0(sizeof(struct async_task));
pa_operation *op = NULL;
- simple = g_simple_async_result_new(G_OBJECT(audio),
- callback,
- user_data,
- pulse_stream_restore_info_async);
-#if GLIB_CHECK_VERSION(2,32,0)
- g_simple_async_result_set_check_cancellable (simple, cancellable);
-#endif
+ gtask = g_task_new(audio, cancellable, callback, user_data);
- task->res = simple;
+ task->gtask = gtask;
task->pulse = g_object_ref(audio);
task->callback = callback;
task->user_data = user_data;
@@ -1177,10 +1155,8 @@ static void pulse_stream_restore_info_async(gboolean is_playback,
task->main_channel = g_object_ref(main_channel);
task->pa_op = NULL;
- if (cancellable) {
- task->cancellable = g_object_ref(cancellable);
+ if (cancellable)
task->cancel_id = g_cancellable_connect(cancellable, G_CALLBACK(cancel_task), task, NULL);
- }
/* If Playback/Record stream is created we use pulse API to get volume-info
* from those streams directly. If the stream is not created, retrieve last
@@ -1257,13 +1233,14 @@ static void pulse_stream_restore_info_async(gboolean is_playback,
fail:
if (!op) {
- g_simple_async_report_error_in_idle(G_OBJECT(audio),
- callback,
- user_data,
- SPICE_CLIENT_ERROR,
- SPICE_CLIENT_ERROR_FAILED,
- "Volume-Info failed: %s",
- pa_strerror(pa_context_errno(p->context)));
+ g_task_report_new_error(audio,
+ callback,
+ user_data,
+ pulse_stream_restore_info_async,
+ SPICE_CLIENT_ERROR,
+ SPICE_CLIENT_ERROR_FAILED,
+ "Volume-Info failed: %s",
+ pa_strerror(pa_context_errno(p->context)));
free_async_task(task);
}
}
@@ -1279,17 +1256,16 @@ static gboolean pulse_stream_restore_info_finish(gboolean is_playback,
{
SpicePulsePrivate *p = SPICE_PULSE(audio)->priv;
struct stream *pstream = (is_playback) ? &p->playback : &p->record;
- GSimpleAsyncResult *simple = (GSimpleAsyncResult *) res;
+ GTask *task = G_TASK(res);
- g_return_val_if_fail(g_simple_async_result_is_valid(res,
- G_OBJECT(audio), pulse_stream_restore_info_async), FALSE);
+ g_return_val_if_fail(g_task_is_valid(task, G_OBJECT(audio)), FALSE);
- if (g_simple_async_result_propagate_error(simple, error)) {
+ if (g_task_had_error(task)) {
/* set out args that should have new alloc'ed memory to NULL */
if (volume != NULL) {
*volume = NULL;
}
- return FALSE;
+ return g_task_propagate_boolean(task, error);
}
if (mute != NULL) {
@@ -1310,7 +1286,7 @@ static gboolean pulse_stream_restore_info_finish(gboolean is_playback,
}
}
- return g_simple_async_result_get_op_res_gboolean(simple);
+ return g_task_propagate_boolean(task, error);
}
static void spice_pulse_get_playback_volume_info_async(SpiceAudio *audio,
commit f8e4ec428ac8d79820a59990da69bb6485e70d07
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 15:01:23 2016 +0100
spice-gstaudio: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/spice-gstaudio.c b/src/spice-gstaudio.c
index 2759c2b..a7c3c24 100644
--- a/src/spice-gstaudio.c
+++ b/src/spice-gstaudio.c
@@ -570,16 +570,9 @@ static void spice_gstaudio_get_playback_volume_info_async(SpiceAudio *audio,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *simple;
+ GTask *task = g_task_new(audio, cancellable, callback, user_data);
- simple = g_simple_async_result_new(G_OBJECT(audio),
- callback,
- user_data,
- spice_gstaudio_get_playback_volume_info_async);
- g_simple_async_result_set_check_cancellable (simple, cancellable);
-
- g_simple_async_result_set_op_res_gboolean(simple, TRUE);
- g_simple_async_result_complete_in_idle(simple);
+ g_task_return_boolean(task, TRUE);
}
static gboolean spice_gstaudio_get_playback_volume_info_finish(SpiceAudio *audio,
@@ -594,17 +587,16 @@ static gboolean spice_gstaudio_get_playback_volume_info_finish(SpiceAudio *audio
gboolean lmute;
gdouble vol;
gboolean fake_channel = FALSE;
- GSimpleAsyncResult *simple = (GSimpleAsyncResult *) res;
+ GTask *task = G_TASK(res);
- g_return_val_if_fail(g_simple_async_result_is_valid(res,
- G_OBJECT(audio), spice_gstaudio_get_playback_volume_info_async), FALSE);
+ g_return_val_if_fail(g_task_is_valid(task, audio), FALSE);
- if (g_simple_async_result_propagate_error(simple, error)) {
+ if (g_task_had_error(task)) {
/* set out args that should have new alloc'ed memory to NULL */
if (volume != NULL) {
*volume = NULL;
}
- return FALSE;
+ return g_task_propagate_boolean(task, error);
}
if (p->playback.sink == NULL || p->playback.channels == 0) {
@@ -651,7 +643,7 @@ static gboolean spice_gstaudio_get_playback_volume_info_finish(SpiceAudio *audio
}
}
- return g_simple_async_result_get_op_res_gboolean(simple);
+ return g_task_propagate_boolean(task, error);
}
static void spice_gstaudio_get_record_volume_info_async(SpiceAudio *audio,
@@ -660,16 +652,9 @@ static void spice_gstaudio_get_record_volume_info_async(SpiceAudio *audio,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *simple;
-
- simple = g_simple_async_result_new(G_OBJECT(audio),
- callback,
- user_data,
- spice_gstaudio_get_record_volume_info_async);
- g_simple_async_result_set_check_cancellable (simple, cancellable);
+ GTask *task = g_task_new(audio, cancellable, callback, user_data);
- g_simple_async_result_set_op_res_gboolean(simple, TRUE);
- g_simple_async_result_complete_in_idle(simple);
+ g_task_return_boolean(task, TRUE);
}
static gboolean spice_gstaudio_get_record_volume_info_finish(SpiceAudio *audio,
@@ -684,17 +669,16 @@ static gboolean spice_gstaudio_get_record_volume_info_finish(SpiceAudio *audio,
gboolean lmute;
gdouble vol;
gboolean fake_channel = FALSE;
- GSimpleAsyncResult *simple = (GSimpleAsyncResult *) res;
+ GTask *task = G_TASK(res);
- g_return_val_if_fail(g_simple_async_result_is_valid(res,
- G_OBJECT(audio), spice_gstaudio_get_record_volume_info_async), FALSE);
+ g_return_val_if_fail(g_task_is_valid(task, audio), FALSE);
- if (g_simple_async_result_propagate_error(simple, error)) {
+ if (g_task_had_error(task)) {
/* set out args that should have new alloc'ed memory to NULL */
if (volume != NULL) {
*volume = NULL;
}
- return FALSE;
+ return g_task_propagate_boolean(task, error);
}
if (p->record.src == NULL || p->record.channels == 0) {
@@ -741,5 +725,5 @@ static gboolean spice_gstaudio_get_record_volume_info_finish(SpiceAudio *audio,
}
}
- return g_simple_async_result_get_op_res_gboolean(simple);
+ return g_task_propagate_boolean(task, error);
}
commit 9c7a6df6065acec40c5c7798f8c732aa9070479d
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 15:00:59 2016 +0100
spice-channel: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/spice-channel.c b/src/spice-channel.c
index d8a4ed6..6cf94b4 100644
--- a/src/spice-channel.c
+++ b/src/spice-channel.c
@@ -2192,9 +2192,7 @@ static void spice_channel_flushed(SpiceChannel *channel, gboolean success)
GSList *l;
for (l = c->flushing; l != NULL; l = l->next) {
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT(l->data);
- g_simple_async_result_set_op_res_gboolean(result, success);
- g_simple_async_result_complete_in_idle(result);
+ g_task_return_boolean(G_TASK(l->data), success);
}
g_slist_free_full(c->flushing, g_object_unref);
@@ -3038,7 +3036,7 @@ static void spice_channel_send_migration_handshake(SpiceChannel *channel)
void spice_channel_flush_async(SpiceChannel *self, GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
- GSimpleAsyncResult *simple;
+ GTask *task;
SpiceChannelPrivate *c;
gboolean was_empty;
@@ -3046,26 +3044,25 @@ void spice_channel_flush_async(SpiceChannel *self, GCancellable *cancellable,
c = self->priv;
if (c->state != SPICE_CHANNEL_STATE_READY) {
- g_simple_async_report_error_in_idle(G_OBJECT(self), callback, user_data,
+ g_task_report_new_error(self, callback, user_data,
+ spice_channel_flush_async,
SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
"The channel is not ready yet");
return;
}
- simple = g_simple_async_result_new(G_OBJECT(self), callback, user_data,
- spice_channel_flush_async);
+ task = g_task_new(self, cancellable, callback, user_data);
STATIC_MUTEX_LOCK(c->xmit_queue_lock);
was_empty = g_queue_is_empty(&c->xmit_queue);
STATIC_MUTEX_UNLOCK(c->xmit_queue_lock);
if (was_empty) {
- g_simple_async_result_set_op_res_gboolean(simple, TRUE);
- g_simple_async_result_complete_in_idle(simple);
- g_object_unref(simple);
+ g_task_return_boolean(task, TRUE);
+ g_object_unref(task);
return;
}
- c->flushing = g_slist_append(c->flushing, simple);
+ c->flushing = g_slist_append(c->flushing, task);
}
/**
@@ -3083,19 +3080,16 @@ void spice_channel_flush_async(SpiceChannel *self, GCancellable *cancellable,
gboolean spice_channel_flush_finish(SpiceChannel *self, GAsyncResult *result,
GError **error)
{
- GSimpleAsyncResult *simple;
+ GTask *task;
g_return_val_if_fail(SPICE_IS_CHANNEL(self), FALSE);
g_return_val_if_fail(result != NULL, FALSE);
- simple = (GSimpleAsyncResult *)result;
+ task = G_TASK(result);
- if (g_simple_async_result_propagate_error(simple, error))
- return -1;
-
- g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(self),
- spice_channel_flush_async), FALSE);
+ g_return_val_if_fail(g_task_is_valid(task, self),
+ FALSE);
CHANNEL_DEBUG(self, "flushed finished!");
- return g_simple_async_result_get_op_res_gboolean(simple);
+ return g_task_propagate_boolean(task, error);
}
commit 0ec8c08da92be0addbbb52c519b66cf915d5f97b
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 15:00:29 2016 +0100
smartcard-manager: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/smartcard-manager.c b/src/smartcard-manager.c
index 6578328..21a4925 100644
--- a/src/smartcard-manager.c
+++ b/src/smartcard-manager.c
@@ -476,8 +476,9 @@ end:
return retval;
}
-static void smartcard_manager_init_helper(GSimpleAsyncResult *res,
- GObject *object,
+static void smartcard_manager_init_helper(GTask *task,
+ gpointer object,
+ gpointer task_data,
GCancellable *cancellable)
{
static GOnce smartcard_manager_once = G_ONCE_INIT;
@@ -491,10 +492,11 @@ static void smartcard_manager_init_helper(GSimpleAsyncResult *res,
g_once(&smartcard_manager_once,
(GThreadFunc)smartcard_manager_init,
&args);
- if (args.err != NULL) {
- g_simple_async_result_set_from_error(res, args.err);
- g_error_free(args.err);
- }
+
+ if (args.err != NULL)
+ g_task_return_error(task, args.err);
+ else
+ g_task_return_boolean(task, TRUE);
}
@@ -504,17 +506,10 @@ void spice_smartcard_manager_init_async(SpiceSession *session,
GAsyncReadyCallback callback,
gpointer opaque)
{
- GSimpleAsyncResult *res;
+ GTask *task = g_task_new(session, cancellable, callback, opaque);
- res = g_simple_async_result_new(G_OBJECT(session),
- callback,
- opaque,
- spice_smartcard_manager_init);
- g_simple_async_result_run_in_thread(res,
- smartcard_manager_init_helper,
- G_PRIORITY_DEFAULT,
- cancellable);
- g_object_unref(res);
+ g_task_run_in_thread(task, smartcard_manager_init_helper);
+ g_object_unref(task);
}
G_GNUC_INTERNAL
@@ -522,21 +517,16 @@ gboolean spice_smartcard_manager_init_finish(SpiceSession *session,
GAsyncResult *result,
GError **err)
{
- GSimpleAsyncResult *simple;
+ GTask *task = G_TASK(result);
g_return_val_if_fail(SPICE_IS_SESSION(session), FALSE);
- g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(result), FALSE);
+ g_return_val_if_fail(G_IS_TASK(task), FALSE);
SPICE_DEBUG("smartcard_manager_finish");
- simple = G_SIMPLE_ASYNC_RESULT(result);
- g_return_val_if_fail(g_simple_async_result_get_source_tag(simple) == spice_smartcard_manager_init, FALSE);
- if (g_simple_async_result_propagate_error(simple, err))
- return FALSE;
-
spice_smartcard_manager_update_monitor();
- return TRUE;
+ return g_task_propagate_boolean(task, err);
}
/**
commit f0866e141e714f92e638aa338c61cfcc1876e90e
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 15:00:12 2016 +0100
channel-usbredir: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/channel-usbredir.c b/src/channel-usbredir.c
index b37f464..d95a6c5 100644
--- a/src/channel-usbredir.c
+++ b/src/channel-usbredir.c
@@ -76,7 +76,7 @@ struct _SpiceUsbredirChannelPrivate {
int read_buf_size;
enum SpiceUsbredirChannelState state;
#ifdef USE_POLKIT
- GSimpleAsyncResult *result;
+ GTask *task;
SpiceUsbAclHelper *acl_helper;
#endif
};
@@ -297,20 +297,21 @@ static void spice_usbredir_channel_open_acl_cb(
spice_usbredir_channel_open_device(channel, &err);
}
if (err) {
- g_simple_async_result_take_error(priv->result, err);
+ g_task_return_error(priv->task, err);
libusb_unref_device(priv->device);
priv->device = NULL;
g_boxed_free(spice_usb_device_get_type(), priv->spice_device);
priv->spice_device = NULL;
priv->state = STATE_DISCONNECTED;
+ } else {
+ g_task_return_boolean(priv->task, TRUE);
}
g_clear_object(&priv->acl_helper);
g_object_set(spice_channel_get_session(SPICE_CHANNEL(channel)),
"inhibit-keyboard-grab", FALSE, NULL);
- g_simple_async_result_complete_in_idle(priv->result);
- g_clear_object(&priv->result);
+ g_clear_object(&priv->task);
}
#endif
@@ -324,7 +325,7 @@ void spice_usbredir_channel_connect_device_async(
gpointer user_data)
{
SpiceUsbredirChannelPrivate *priv = channel->priv;
- GSimpleAsyncResult *result;
+ GTask *task;
#ifndef USE_POLKIT
GError *err = NULL;
#endif
@@ -337,18 +338,17 @@ void spice_usbredir_channel_connect_device_async(
spice_usb_device_get_pid(spice_device),
spice_device, channel);
- result = g_simple_async_result_new(G_OBJECT(channel), callback, user_data,
- spice_usbredir_channel_connect_device_async);
+ task = g_task_new(channel, cancellable, callback, user_data);
if (!priv->host) {
- g_simple_async_result_set_error(result,
+ g_task_return_new_error(task,
SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
"Error libusb context not set");
goto done;
}
if (priv->state != STATE_DISCONNECTED) {
- g_simple_async_result_set_error(result,
+ g_task_return_new_error(task,
SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
"Error channel is busy");
goto done;
@@ -358,7 +358,7 @@ void spice_usbredir_channel_connect_device_async(
priv->spice_device = g_boxed_copy(spice_usb_device_get_type(),
spice_device);
#ifdef USE_POLKIT
- priv->result = result;
+ priv->task = task;
priv->state = STATE_WAITING_FOR_ACL_HELPER;
priv->acl_helper = spice_usb_acl_helper_new();
g_object_set(spice_channel_get_session(SPICE_CHANNEL(channel)),
@@ -372,17 +372,18 @@ void spice_usbredir_channel_connect_device_async(
return;
#else
if (!spice_usbredir_channel_open_device(channel, &err)) {
- g_simple_async_result_take_error(result, err);
+ g_task_return_error(task, err);
libusb_unref_device(priv->device);
priv->device = NULL;
g_boxed_free(spice_usb_device_get_type(), priv->spice_device);
priv->spice_device = NULL;
+ } else {
+ g_task_return_boolean(task, TRUE);
}
#endif
done:
- g_simple_async_result_complete_in_idle(result);
- g_object_unref(result);
+ g_object_unref(task);
}
G_GNUC_INTERNAL
@@ -391,16 +392,11 @@ gboolean spice_usbredir_channel_connect_device_finish(
GAsyncResult *res,
GError **err)
{
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT(res);
+ GTask *task = G_TASK(res);
- g_return_val_if_fail(g_simple_async_result_is_valid(res, G_OBJECT(channel),
- spice_usbredir_channel_connect_device_async),
- FALSE);
+ g_return_val_if_fail(g_task_is_valid(task, channel), FALSE);
- if (g_simple_async_result_propagate_error(result, err))
- return FALSE;
-
- return TRUE;
+ return g_task_propagate_boolean(task, err);
}
G_GNUC_INTERNAL
commit 3b130da8fc688a4968a99477513504bb43e55be9
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 14:59:30 2016 +0100
channel-port: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/channel-port.c b/src/channel-port.c
index 6e01caa..20ee2fa 100644
--- a/src/channel-port.c
+++ b/src/channel-port.c
@@ -292,7 +292,8 @@ void spice_port_write_async(SpicePortChannel *self,
c = self->priv;
if (!c->opened) {
- g_simple_async_report_error_in_idle(G_OBJECT(self), callback, user_data,
+ g_task_report_new_error(self, callback,
+ user_data, spice_port_write_async,
SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
"The port is not opened");
return;
commit a172e8f115234f797b291f474226ca1506589119
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 14:57:53 2016 +0100
channel-main: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/src/channel-main.c b/src/channel-main.c
index e5a70af..276799f 100644
--- a/src/channel-main.c
+++ b/src/channel-main.c
@@ -923,10 +923,9 @@ static gboolean flush_foreach_remove(gpointer key G_GNUC_UNUSED,
gpointer value, gpointer user_data)
{
gboolean success = GPOINTER_TO_UINT(user_data);
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT(value);
+ GTask *result = value;
+ g_task_return_boolean(result, success);
- g_simple_async_result_set_op_res_gboolean(result, success);
- g_simple_async_result_complete_in_idle(result);
return TRUE;
}
@@ -940,38 +939,31 @@ static void file_xfer_flushed(SpiceMainChannel *channel, gboolean success)
static void file_xfer_flush_async(SpiceMainChannel *channel, GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
- GSimpleAsyncResult *simple;
+ GTask *task;
SpiceMainChannelPrivate *c = channel->priv;
gboolean was_empty;
- simple = g_simple_async_result_new(G_OBJECT(channel), callback, user_data,
- file_xfer_flush_async);
+ task = g_task_new(channel, cancellable, callback, user_data);
was_empty = g_queue_is_empty(c->agent_msg_queue);
if (was_empty) {
- g_simple_async_result_set_op_res_gboolean(simple, TRUE);
- g_simple_async_result_complete_in_idle(simple);
- g_object_unref(simple);
+ g_task_return_boolean(task, TRUE);
+ g_object_unref(task);
return;
}
/* wait until the last message currently in the queue has been sent */
- g_hash_table_insert(c->flushing, g_queue_peek_tail(c->agent_msg_queue), simple);
+ g_hash_table_insert(c->flushing, g_queue_peek_tail(c->agent_msg_queue), task);
}
static gboolean file_xfer_flush_finish(SpiceMainChannel *channel, GAsyncResult *result,
GError **error)
{
- GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result;
+ GTask *task = G_TASK(result);
- g_return_val_if_fail(g_simple_async_result_is_valid(result,
- G_OBJECT(channel), file_xfer_flush_async), FALSE);
+ g_return_val_if_fail(g_task_is_valid(result, channel), FALSE);
- if (g_simple_async_result_propagate_error(simple, error)) {
- return FALSE;
- }
-
- return g_simple_async_result_get_op_res_gboolean(simple);
+ return g_task_propagate_boolean(task, error);
}
/* coroutine context */
@@ -982,16 +974,15 @@ static void agent_send_msg_queue(SpiceMainChannel *channel)
while (c->agent_tokens > 0 &&
!g_queue_is_empty(c->agent_msg_queue)) {
- GSimpleAsyncResult *simple;
+ GTask *task;
c->agent_tokens--;
out = g_queue_pop_head(c->agent_msg_queue);
spice_msg_out_send_internal(out);
- simple = g_hash_table_lookup(c->flushing, out);
- if (simple) {
+ task = g_hash_table_lookup(c->flushing, out);
+ if (task) {
/* if there's a flush task waiting for this message, finish it */
- g_simple_async_result_set_op_res_gboolean(simple, TRUE);
- g_simple_async_result_complete_in_idle(simple);
+ g_task_return_boolean(task, TRUE);
g_hash_table_remove(c->flushing, out);
}
}
@@ -1776,7 +1767,7 @@ static void file_xfer_close_cb(GObject *object,
GAsyncResult *close_res,
gpointer user_data)
{
- GSimpleAsyncResult *res;
+ GTask *task;
SpiceFileTransferTask *self;
GError *error = NULL;
@@ -1794,15 +1785,15 @@ static void file_xfer_close_cb(GObject *object,
/* Notify to user that files have been transferred or something error
happened. */
- res = g_simple_async_result_new(G_OBJECT(self->priv->channel),
- self->priv->callback,
- self->priv->user_data,
- spice_main_file_copy_async);
+ task = g_task_new(self->priv->channel,
+ self->priv->cancellable,
+ self->priv->callback,
+ self->priv->user_data);
+
if (self->priv->error) {
- g_simple_async_result_take_error(res, self->priv->error);
- g_simple_async_result_set_op_res_gboolean(res, FALSE);
+ g_task_return_error(task, self->priv->error);
} else {
- g_simple_async_result_set_op_res_gboolean(res, TRUE);
+ g_task_return_boolean(task, TRUE);
if (spice_util_get_debug()) {
gint64 now = g_get_monotonic_time();
gchar *basename = g_file_get_basename(self->priv->file);
@@ -1819,8 +1810,7 @@ static void file_xfer_close_cb(GObject *object,
g_free(transfer_speed_str);
}
}
- g_simple_async_result_complete_in_idle(res);
- g_object_unref(res);
+ g_object_unref(task);
g_object_unref(self);
}
@@ -3147,12 +3137,13 @@ void spice_main_file_copy_async(SpiceMainChannel *channel,
g_return_if_fail(sources != NULL);
if (!c->agent_connected) {
- g_simple_async_report_error_in_idle(G_OBJECT(channel),
- callback,
- user_data,
- SPICE_CLIENT_ERROR,
- SPICE_CLIENT_ERROR_FAILED,
- "The agent is not connected");
+ g_task_report_new_error(channel,
+ callback,
+ user_data,
+ spice_main_file_copy_async,
+ SPICE_CLIENT_ERROR,
+ SPICE_CLIENT_ERROR_FAILED,
+ "The agent is not connected");
return;
}
@@ -3181,19 +3172,12 @@ gboolean spice_main_file_copy_finish(SpiceMainChannel *channel,
GAsyncResult *result,
GError **error)
{
- GSimpleAsyncResult *simple;
+ GTask *task = G_TASK(result);;
g_return_val_if_fail(SPICE_IS_MAIN_CHANNEL(channel), FALSE);
- g_return_val_if_fail(g_simple_async_result_is_valid(result,
- G_OBJECT(channel), spice_main_file_copy_async), FALSE);
-
- simple = (GSimpleAsyncResult *)result;
-
- if (g_simple_async_result_propagate_error(simple, error)) {
- return FALSE;
- }
+ g_return_val_if_fail(g_task_is_valid(task, channel), FALSE);
- return g_simple_async_result_get_op_res_gboolean(simple);
+ return g_task_propagate_boolean(task, error);
}
commit 8693e7d3f7de1ff102082212fa6e35fb1a252ef7
Author: Fabiano Fidêncio <fidencio at redhat.com>
Date: Thu Jan 14 14:55:52 2016 +0100
channel-base: Use GTask instead of GSimpleAsyncResult
Instead of using GSimpleAsyncResult, use the new GTask API, which is
much more straightforward.
For using the new GTask API, let's bump GIO (part of GLib) dependency
version to 2.36, which is safe based on major distro support:
- Debian Jessie: glib-2.42
- RHEL-7.1: glib-2.40
- SLES12: glib-2.38
- Ubuntu LTS 14.04: glib-2.40
Signed-off-by: Fabiano Fidêncio <fidencio at redhat.com>
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/configure.ac b/configure.ac
index 964ee63..6983b6b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -166,7 +166,7 @@ fi
AC_CHECK_FUNCS(clearenv strtok_r)
-PKG_CHECK_MODULES(GLIB2, glib-2.0 >= 2.28)
+PKG_CHECK_MODULES(GLIB2, glib-2.0)
AC_SUBST(GLIB2_CFLAGS)
AC_SUBST(GLIB2_LIBS)
@@ -174,7 +174,7 @@ PKG_CHECK_MODULES(GOBJECT2, gobject-2.0)
AC_SUBST(GOBJECT2_CFLAGS)
AC_SUBST(GOBJECT2_LIBS)
-PKG_CHECK_MODULES(GIO, gio-2.0 >= 2.10.0 $gio_os)
+PKG_CHECK_MODULES(GIO, gio-2.0 >= 2.36 $gio_os)
AC_SUBST(GIO_CFLAGS)
AC_SUBST(GIO_LIBS)
@@ -182,7 +182,7 @@ PKG_CHECK_MODULES(CAIRO, cairo >= 1.2.0)
AC_SUBST(CAIRO_CFLAGS)
AC_SUBST(CAIRO_LIBS)
-PKG_CHECK_MODULES(GTHREAD, gthread-2.0 > 2.0.0)
+PKG_CHECK_MODULES(GTHREAD, gthread-2.0)
AC_SUBST(GTHREAD_CFLAGS)
AC_SUBST(GTHREAD_LIBS)
diff --git a/src/channel-base.c b/src/channel-base.c
index 13e4ced..de04b89 100644
--- a/src/channel-base.c
+++ b/src/channel-base.c
@@ -240,10 +240,12 @@ void spice_channel_set_handlers(SpiceChannelClass *klass,
static void
vmc_write_free_cb(uint8_t *data, void *user_data)
{
- GSimpleAsyncResult *result = user_data;
+ GTask *task = user_data;
+ gsize count = GPOINTER_TO_SIZE(g_task_get_task_data(task));
- g_simple_async_result_complete_in_idle(result);
- g_object_unref(result);
+ g_task_return_int(task, count);
+
+ g_object_unref(task);
}
G_GNUC_INTERNAL
@@ -254,15 +256,14 @@ void spice_vmc_write_async(SpiceChannel *self,
gpointer user_data)
{
SpiceMsgOut *msg;
- GSimpleAsyncResult *simple;
+ GTask *task;
- simple = g_simple_async_result_new(G_OBJECT(self), callback, user_data,
- spice_port_write_async);
- g_simple_async_result_set_op_res_gssize(simple, count);
+ task = g_task_new(self, cancellable, callback, user_data);
+ g_task_set_task_data(task, GSIZE_TO_POINTER(count), NULL);
msg = spice_msg_out_new(SPICE_CHANNEL(self), SPICE_MSGC_SPICEVMC_DATA);
spice_marshaller_add_ref_full(msg->marshaller, (uint8_t*)buffer, count,
- vmc_write_free_cb, simple);
+ vmc_write_free_cb, task);
spice_msg_out_send(msg);
}
@@ -270,17 +271,13 @@ G_GNUC_INTERNAL
gssize spice_vmc_write_finish(SpiceChannel *self,
GAsyncResult *result, GError **error)
{
- GSimpleAsyncResult *simple;
+ GTask *task;
g_return_val_if_fail(result != NULL, -1);
- simple = (GSimpleAsyncResult *)result;
-
- if (g_simple_async_result_propagate_error(simple, error))
- return -1;
+ task = G_TASK(result);
- g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(self),
- spice_port_write_async), -1);
+ g_return_val_if_fail(g_task_is_valid(task, self), -1);
- return g_simple_async_result_get_op_res_gssize(simple);
+ return g_task_propagate_int(task, error);
}
More information about the Spice-commits
mailing list