[libvirt] [libvirt-glib 3/3] gobject: Port to GTask API
Christophe Fergeau
cfergeau at redhat.com
Mon Nov 2 16:30:50 UTC 2015
On Thu, Oct 29, 2015 at 08:39:08PM +0000, Zeeshan Ali (Khattak) wrote:
> Drop usage of deprecated GSimpleAsyncResult API.
> ---
> libvirt-gobject/libvirt-gobject-domain.c | 270 ++++++++++-------------
> libvirt-gobject/libvirt-gobject-input-stream.c | 76 +++----
> libvirt-gobject/libvirt-gobject-output-stream.c | 75 +++----
> libvirt-gobject/libvirt-gobject-storage-pool.c | 281 ++++++++++--------------
> libvirt-gobject/libvirt-gobject-stream.c | 46 ++--
> 5 files changed, 326 insertions(+), 422 deletions(-)
>
> diff --git a/libvirt-gobject/libvirt-gobject-domain.c b/libvirt-gobject/libvirt-gobject-domain.c
> index 34eb7ca..dda9268 100644
> --- a/libvirt-gobject/libvirt-gobject-domain.c
> +++ b/libvirt-gobject/libvirt-gobject-domain.c
> @@ -380,18 +380,19 @@ static void domain_start_data_free(DomainStartData *data)
> }
>
> static void
> -gvir_domain_start_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_domain_start_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data,
> GCancellable *cancellable G_GNUC_UNUSED)
> {
> - GVirDomain *dom = GVIR_DOMAIN(object);
> - DomainStartData *data;
> + GVirDomain *dom = GVIR_DOMAIN(source_object);
> + DomainStartData *data = (DomainStartData *) task_data;
> GError *err = NULL;
>
> - data = g_simple_async_result_get_op_res_gpointer(res);
> -
> if (!gvir_domain_start(dom, data->flags, &err))
> - g_simple_async_result_take_error(res, err);
> + g_task_return_error(task, err);
> + else
> + g_task_return_boolean(task, TRUE);
> }
>
> /**
> @@ -410,7 +411,7 @@ void gvir_domain_start_async(GVirDomain *dom,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
> DomainStartData *data;
>
> g_return_if_fail(GVIR_IS_DOMAIN(dom));
> @@ -419,16 +420,13 @@ void gvir_domain_start_async(GVirDomain *dom,
> data = g_slice_new0(DomainStartData);
> data->flags = flags;
>
> - res = g_simple_async_result_new(G_OBJECT(dom),
> - callback,
> - user_data,
> - gvir_domain_start_async);
> - g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)domain_start_data_free);
> - g_simple_async_result_run_in_thread(res,
> - gvir_domain_start_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> - g_object_unref(res);
> + task = g_task_new(G_OBJECT(dom),
> + cancellable,
> + callback,
> + user_data);
> + g_task_set_task_data(task, data, (GDestroyNotify)domain_start_data_free);
> + g_task_run_in_thread(task, gvir_domain_start_helper);
> + g_object_unref(task);
> }
>
> gboolean gvir_domain_start_finish(GVirDomain *dom,
> @@ -436,13 +434,10 @@ gboolean gvir_domain_start_finish(GVirDomain *dom,
> GError **err)
> {
> g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(dom), gvir_domain_start_async), FALSE);
> + g_return_val_if_fail(g_task_is_valid(result, dom), FALSE);
> g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
>
> - if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result), err))
> - return FALSE;
> -
> - return TRUE;
> + return g_task_propagate_boolean(G_TASK(result), err);
> }
>
> /**
> @@ -472,15 +467,18 @@ gboolean gvir_domain_resume(GVirDomain *dom,
> }
>
> static void
> -gvir_domain_resume_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_domain_resume_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data G_GNUC_UNUSED,
> GCancellable *cancellable G_GNUC_UNUSED)
> {
> - GVirDomain *dom = GVIR_DOMAIN(object);
> + GVirDomain *dom = GVIR_DOMAIN(source_object);
> GError *err = NULL;
>
> if (!gvir_domain_resume(dom, &err))
> - g_simple_async_result_take_error(res, err);
> + g_task_return_error(task, err);
> + else
> + g_task_return_boolean(task, TRUE);
> }
>
> /**
> @@ -497,20 +495,17 @@ void gvir_domain_resume_async(GVirDomain *dom,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
>
> g_return_if_fail(GVIR_IS_DOMAIN(dom));
> g_return_if_fail((cancellable == NULL) || G_IS_CANCELLABLE(cancellable));
>
> - res = g_simple_async_result_new(G_OBJECT(dom),
> - callback,
> - user_data,
> - gvir_domain_resume_async);
> - g_simple_async_result_run_in_thread(res,
> - gvir_domain_resume_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> - g_object_unref(res);
> + task = g_task_new(G_OBJECT(dom),
> + cancellable,
> + callback,
> + user_data);
> + g_task_run_in_thread(task, gvir_domain_resume_helper);
> + g_object_unref(task);
> }
>
> gboolean gvir_domain_resume_finish(GVirDomain *dom,
> @@ -518,13 +513,10 @@ gboolean gvir_domain_resume_finish(GVirDomain *dom,
> GError **err)
> {
> g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(dom), gvir_domain_resume_async), FALSE);
> + g_return_val_if_fail(g_task_is_valid(result, dom), FALSE);
> g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
>
> - if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result), err))
> - return FALSE;
> -
> - return TRUE;
> + return g_task_propagate_boolean(G_TASK(result), err);
> }
>
> /**
> @@ -555,16 +547,29 @@ gboolean gvir_domain_wakeup(GVirDomain *dom,
> return TRUE;
> }
>
> +typedef struct {
> + guint flags;
> +} DomainWakeupData;
> +
> +static void domain_wakeup_data_free(DomainWakeupData *data)
> +{
> + g_slice_free(DomainWakeupData, data);
> +}
> +
> static void
> -gvir_domain_wakeup_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_domain_wakeup_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data,
> GCancellable *cancellable G_GNUC_UNUSED)
> {
> - GVirDomain *dom = GVIR_DOMAIN(object);
> + GVirDomain *dom = GVIR_DOMAIN(source_object);
> + DomainWakeupData *data = (DomainWakeupData *) task_data;
> GError *err = NULL;
>
> - if (!gvir_domain_wakeup(dom, (guint)g_simple_async_result_get_op_res_gssize(res), &err))
> - g_simple_async_result_take_error(res, err);
> + if (!gvir_domain_wakeup(dom, data->flags, &err))
> + g_task_return_error(task, err);
> + else
> + g_task_return_boolean(task, TRUE);
> }
>
> /**
> @@ -583,21 +588,22 @@ void gvir_domain_wakeup_async(GVirDomain *dom,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
> + DomainWakeupData *data;
>
> g_return_if_fail(GVIR_IS_DOMAIN(dom));
> g_return_if_fail((cancellable == NULL) || G_IS_CANCELLABLE(cancellable));
>
> - res = g_simple_async_result_new(G_OBJECT(dom),
> - callback,
> - user_data,
> - gvir_domain_wakeup_async);
> - g_simple_async_result_set_op_res_gssize (res, (gssize)flags);
> - g_simple_async_result_run_in_thread(res,
> - gvir_domain_wakeup_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> - g_object_unref(res);
> + data = g_slice_new0(DomainWakeupData);
> + data->flags = flags;
> +
> + task = g_task_new(G_OBJECT(dom),
> + cancellable,
> + callback,
> + user_data);
> + g_task_set_task_data(task, data, (GDestroyNotify)domain_wakeup_data_free);
Maybe you can use GUINT_TO_POINTER rather than allocating memory?
> + g_task_run_in_thread(task, gvir_domain_wakeup_helper);
> + g_object_unref(task);
> }
>
> gboolean gvir_domain_wakeup_finish(GVirDomain *dom,
> @@ -605,13 +611,10 @@ gboolean gvir_domain_wakeup_finish(GVirDomain *dom,
> GError **err)
> {
> g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(dom), gvir_domain_wakeup_async), FALSE);
> + g_return_val_if_fail(g_task_is_valid(result, dom), FALSE);
> g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
>
> - if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result), err))
> - return FALSE;
> -
> - return TRUE;
> + return g_task_propagate_boolean(G_TASK(result), err);
> }
>
> /**
> @@ -785,18 +788,19 @@ static void domain_save_to_file_data_free(DomainSaveToFileData *data)
> }
>
> static void
> -gvir_domain_save_to_file_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_domain_save_to_file_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data,
> GCancellable *cancellable G_GNUC_UNUSED)
> {
> - GVirDomain *dom = GVIR_DOMAIN(object);
> - DomainSaveToFileData *data;
> + GVirDomain *dom = GVIR_DOMAIN(source_object);
> + DomainSaveToFileData *data = (DomainSaveToFileData *) task_data;
> GError *err = NULL;
>
> - data = g_simple_async_result_get_op_res_gpointer(res);
> -
> if (!gvir_domain_save_to_file(dom, data->filename, data->custom_conf, data->flags, &err))
> - g_simple_async_result_take_error(res, err);
> + g_task_return_error(task, err);
> + else
> + g_task_return_boolean(task, TRUE);
> }
>
> /**
> @@ -819,7 +823,7 @@ void gvir_domain_save_to_file_async(GVirDomain *dom,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
> DomainSaveToFileData *data;
>
> g_return_if_fail(GVIR_IS_DOMAIN(dom));
> @@ -832,19 +836,15 @@ void gvir_domain_save_to_file_async(GVirDomain *dom,
> data->custom_conf = g_object_ref(custom_conf);
> data->flags = flags;
>
> - res = g_simple_async_result_new(G_OBJECT(dom),
> - callback,
> - user_data,
> - gvir_domain_save_to_file_async);
> - g_simple_async_result_set_op_res_gpointer(res, data, (GDestroyNotify)
> - domain_save_to_file_data_free);
> -
> - g_simple_async_result_run_in_thread(res,
> - gvir_domain_save_to_file_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> -
> - g_object_unref(res);
> + task = g_task_new(G_OBJECT(dom),
> + cancellable,
> + callback,
> + user_data);
> + g_task_set_task_data(task,
> + data,
> + (GDestroyNotify) domain_save_to_file_data_free);
> + g_task_run_in_thread(task, gvir_domain_save_to_file_helper);
> + g_object_unref(task);
> }
>
> /**
> @@ -862,16 +862,10 @@ gboolean gvir_domain_save_to_file_finish(GVirDomain *dom,
> GError **err)
> {
> g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);
> - g_return_val_if_fail(g_simple_async_result_is_valid
> - (result,
> - G_OBJECT(dom),
> - gvir_domain_save_to_file_async), FALSE);
> + g_return_val_if_fail(g_task_is_valid(result, dom), FALSE);
> g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
>
> - if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result), err))
> - return FALSE;
> -
> - return TRUE;
> + return g_task_propagate_boolean(G_TASK(result), err);
> }
>
> /**
> @@ -1012,22 +1006,22 @@ GVirDomainInfo *gvir_domain_get_info(GVirDomain *dom,
> }
>
> static void
> -gvir_domain_get_info_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_domain_get_info_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data G_GNUC_UNUSED,
> GCancellable *cancellable G_GNUC_UNUSED)
> {
> - GVirDomain *dom = GVIR_DOMAIN(object);
> + GVirDomain *dom = GVIR_DOMAIN(source_object);
> GVirDomainInfo *info;
> GError *err = NULL;
>
> info = gvir_domain_get_info(dom, &err);
> if (err)
> - g_simple_async_result_take_error(res, err);
> + g_task_return_error(task, err);
> else
> - g_simple_async_result_set_op_res_gpointer
> - (res,
> - info,
> - (GDestroyNotify) gvir_domain_info_free);
> + g_task_return_pointer(task,
> + info,
> + (GDestroyNotify) gvir_domain_info_free);
> }
>
> /**
> @@ -1044,20 +1038,17 @@ void gvir_domain_get_info_async(GVirDomain *dom,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
>
> g_return_if_fail(GVIR_IS_DOMAIN(dom));
> g_return_if_fail((cancellable == NULL) || G_IS_CANCELLABLE(cancellable));
>
> - res = g_simple_async_result_new(G_OBJECT(dom),
> - callback,
> - user_data,
> - gvir_domain_get_info_async);
> - g_simple_async_result_run_in_thread(res,
> - gvir_domain_get_info_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> - g_object_unref(res);
> + task = g_task_new(G_OBJECT(dom),
> + cancellable,
> + callback,
> + user_data);
> + g_task_run_in_thread(task, gvir_domain_get_info_helper);
> + g_object_unref(task);
> }
>
> /**
> @@ -1075,22 +1066,10 @@ GVirDomainInfo *gvir_domain_get_info_finish(GVirDomain *dom,
> GAsyncResult *result,
> GError **err)
> {
> - GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT(result);
> - GVirDomainInfo *ret;
> -
> g_return_val_if_fail(GVIR_IS_DOMAIN(dom), NULL);
> - g_return_val_if_fail
> - (g_simple_async_result_is_valid(result,
> - G_OBJECT(dom),
> - gvir_domain_get_info_async),
> - NULL);
> -
> - if (g_simple_async_result_propagate_error(res, err))
> - return NULL;
> + g_return_val_if_fail(g_task_is_valid(result, dom), NULL);
>
> - ret = g_simple_async_result_get_op_res_gpointer(res);
> -
> - return gvir_domain_info_copy (ret);
> + return g_task_propagate_pointer(G_TASK(result), err);
> }
>
> /**
> @@ -1375,18 +1354,19 @@ static void domain_save_data_free(DomainSaveData *data)
> }
>
> static void
> -gvir_domain_save_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_domain_save_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data,
> GCancellable *cancellable G_GNUC_UNUSED)
> {
> - GVirDomain *dom = GVIR_DOMAIN(object);
> - DomainSaveData *data;
> + GVirDomain *dom = GVIR_DOMAIN(source_object);
> + DomainSaveData *data = (DomainSaveData *) task_data;
> GError *err = NULL;
>
> - data = g_simple_async_result_get_op_res_gpointer (res);
> -
> if (!gvir_domain_save(dom, data->flags, &err))
> - g_simple_async_result_take_error(res, err);
> + g_task_return_error(task, err);
> + else
> + g_task_return_boolean(task, TRUE);
> }
>
> /**
> @@ -1405,7 +1385,7 @@ void gvir_domain_save_async (GVirDomain *dom,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
> DomainSaveData *data;
>
> g_return_if_fail(GVIR_IS_DOMAIN(dom));
> @@ -1414,16 +1394,13 @@ void gvir_domain_save_async (GVirDomain *dom,
> data = g_slice_new0(DomainSaveData);
> data->flags = flags;
>
> - res = g_simple_async_result_new(G_OBJECT(dom),
> - callback,
> - user_data,
> - gvir_domain_save_async);
> - g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify) domain_save_data_free);
> - g_simple_async_result_run_in_thread(res,
> - gvir_domain_save_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> - g_object_unref(res);
> + task = g_task_new(G_OBJECT(dom),
> + cancellable,
> + callback,
> + user_data);
> + g_task_set_task_data(task, data, (GDestroyNotify) domain_save_data_free);
> + g_task_run_in_thread(task, gvir_domain_save_helper);
> + g_object_unref(task);
> }
>
> /**
> @@ -1441,15 +1418,10 @@ gboolean gvir_domain_save_finish (GVirDomain *dom,
> GError **err)
> {
> g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(dom),
> - gvir_domain_save_async),
> - FALSE);
> + g_return_val_if_fail(g_task_is_valid(result, dom), FALSE);
> g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
>
> - if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result), err))
> - return FALSE;
> -
> - return TRUE;
> + return g_task_propagate_boolean(G_TASK(result), err);
> }
>
> /**
> diff --git a/libvirt-gobject/libvirt-gobject-input-stream.c b/libvirt-gobject/libvirt-gobject-input-stream.c
> index ff1a70c..fe9e323 100644
> --- a/libvirt-gobject/libvirt-gobject-input-stream.c
> +++ b/libvirt-gobject/libvirt-gobject-input-stream.c
> @@ -45,8 +45,7 @@ struct _GVirInputStreamPrivate
> GVirStream *stream;
>
> /* pending operation metadata */
> - GSimpleAsyncResult *result;
> - GCancellable *cancellable;
> + GTask *task;
> gpointer buffer;
> gsize count;
> };
> @@ -103,48 +102,44 @@ gvir_input_stream_read_ready(GVirStream *stream,
> {
> GVirInputStream *input_stream = GVIR_INPUT_STREAM(opaque);
> GVirInputStreamPrivate *priv = input_stream->priv;
> - GSimpleAsyncResult *simple = priv->result;
> + GTask *task = priv->task;
> + GCancellable *cancellable = g_task_get_cancellable(task);
> GError *error = NULL;
> gssize result;
>
> + priv->task = NULL;
> +
> if (!(cond & GVIR_STREAM_IO_CONDITION_READABLE)) {
> g_warn_if_reached();
> - g_simple_async_result_set_error(simple,
> - G_IO_ERROR,
> - G_IO_ERROR_INVALID_ARGUMENT,
> - "%s",
> - "Expected stream to be readable");
> + g_task_return_new_error(task,
> + G_IO_ERROR,
> + G_IO_ERROR_INVALID_ARGUMENT,
> + "%s",
> + "Expected stream to be readable");
> goto cleanup;
> }
>
> - result = gvir_stream_receive(stream, priv->buffer, priv->count,
> - priv->cancellable, &error);
> + result = gvir_stream_receive(stream, priv->buffer, priv->count,
> + cancellable, &error);
> + if (error != NULL) {
> + if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
> + g_warn_if_reached();
> + g_task_return_new_error(task,
> + G_IO_ERROR,
> + G_IO_ERROR_INVALID_ARGUMENT,
> + "%s",
> + "Expected stream to be readable");
> + } else {
> + g_task_return_error(task, error);
> + }
>
> - if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
> - g_warn_if_reached();
> - g_simple_async_result_set_error(simple,
> - G_IO_ERROR,
> - G_IO_ERROR_INVALID_ARGUMENT,
> - "%s",
> - "Expected stream to be readable");
> goto cleanup;
> }
>
> - if (result >= 0)
> - g_simple_async_result_set_op_res_gssize(simple, result);
> -
> - if (error)
> - g_simple_async_result_take_error(simple, error);
> -
> - if (priv->cancellable) {
> - g_object_unref(priv->cancellable);
> - priv->cancellable = NULL;
> - }
> + g_task_return_int(task, result);
>
> cleanup:
> - priv->result = NULL;
> - g_simple_async_result_complete(simple);
> - g_object_unref(simple);
> + g_object_unref(task);
> return FALSE;
> }
>
> @@ -159,7 +154,7 @@ static void gvir_input_stream_read_async(GInputStream *stream,
> GVirInputStream *input_stream = GVIR_INPUT_STREAM(stream);
>
> g_return_if_fail(GVIR_IS_INPUT_STREAM(stream));
> - g_return_if_fail(input_stream->priv->result == NULL);
> + g_return_if_fail(input_stream->priv->task == NULL);
>
> gvir_stream_add_watch_full(input_stream->priv->stream,
> G_PRIORITY_DEFAULT,
> @@ -168,12 +163,8 @@ static void gvir_input_stream_read_async(GInputStream *stream,
> g_object_ref(stream),
> (GDestroyNotify)g_object_unref);
>
> - input_stream->priv->result =
> - g_simple_async_result_new(G_OBJECT(stream), callback, user_data,
> - gvir_input_stream_read_async);
> - if (cancellable)
> - g_object_ref(cancellable);
> - input_stream->priv->cancellable = cancellable;
> + input_stream->priv->task =
> + g_task_new(stream, cancellable, callback, user_data);
> input_stream->priv->buffer = buffer;
> input_stream->priv->count = count;
> }
> @@ -184,19 +175,16 @@ static gssize gvir_input_stream_read_finish(GInputStream *stream,
> GError **error G_GNUC_UNUSED)
> {
> GVirInputStream *input_stream = GVIR_INPUT_STREAM(stream);
> - GSimpleAsyncResult *simple;
> + GTask *task;
> virStreamPtr handle;
> gssize count;
>
> g_return_val_if_fail(GVIR_IS_INPUT_STREAM(stream), -1);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(stream),
> - gvir_input_stream_read_async),
> - -1);
> + g_return_val_if_fail(g_task_is_valid(result, stream), -1);
> g_object_get(input_stream->priv->stream, "handle", &handle, NULL);
>
> - simple = G_SIMPLE_ASYNC_RESULT(result);
> -
> - count = g_simple_async_result_get_op_res_gssize(simple);
> + task = G_TASK(result);
> + count = g_task_propagate_int(task, error);
You could skip the 'task' local variable as in the other _finish
implementations and just do g_task_propagate_int(G_TASK(result), error);
The 'error' argument is no longer G_GNUC_UNUSED after this change.
>
> virStreamFree(handle);
>
> diff --git a/libvirt-gobject/libvirt-gobject-output-stream.c b/libvirt-gobject/libvirt-gobject-output-stream.c
> index f39328b..5a84a23 100644
> --- a/libvirt-gobject/libvirt-gobject-output-stream.c
> +++ b/libvirt-gobject/libvirt-gobject-output-stream.c
> @@ -45,8 +45,7 @@ struct _GVirOutputStreamPrivate
> GVirStream *stream;
>
> /* pending operation metadata */
> - GSimpleAsyncResult *result;
> - GCancellable *cancellable;
> + GTask *task;
> const void * buffer;
> gsize count;
> };
> @@ -103,48 +102,45 @@ gvir_output_stream_write_ready(GVirStream *stream,
> {
> GVirOutputStream *output_stream = GVIR_OUTPUT_STREAM(opaque);
> GVirOutputStreamPrivate *priv = output_stream->priv;
> - GSimpleAsyncResult *simple = priv->result;
> + GTask *task = priv->task;
> + GCancellable *cancellable = g_task_get_cancellable(task);
> GError *error = NULL;
> gssize result;
>
> + priv->task = NULL;
> +
Any reason not to keep this in cleanup: ?
> if (!(cond & GVIR_STREAM_IO_CONDITION_WRITABLE)) {
> g_warn_if_reached();
> - g_simple_async_result_set_error(simple,
> - G_IO_ERROR,
> - G_IO_ERROR_INVALID_ARGUMENT,
> - "%s",
> - "Expected stream to be writable");
> + g_task_return_new_error(task,
> + G_IO_ERROR,
> + G_IO_ERROR_INVALID_ARGUMENT,
> + "%s",
> + "Expected stream to be readable");
> goto cleanup;
> }
>
> result = gvir_stream_send(stream, priv->buffer, priv->count,
> - priv->cancellable, &error);
> + cancellable, &error);
> +
> + if (error != NULL) {
> + if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
> + g_warn_if_reached();
> + g_task_return_new_error(task,
> + G_IO_ERROR,
> + G_IO_ERROR_INVALID_ARGUMENT,
> + "%s",
> + "Expected stream to be writable");
> + } else {
> + g_task_return_error(task, error);
> + }
>
> - if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
> - g_warn_if_reached();
> - g_simple_async_result_set_error(simple,
> - G_IO_ERROR,
> - G_IO_ERROR_INVALID_ARGUMENT,
> - "%s",
> - "Expected stream to be writable");
> goto cleanup;
> }
>
> - if (result >= 0)
> - g_simple_async_result_set_op_res_gssize(simple, result);
> -
> - if (error)
> - g_simple_async_result_take_error(simple, error);
> -
> - if (priv->cancellable) {
> - g_object_unref(priv->cancellable);
> - priv->cancellable = NULL;
> - }
> + g_task_return_int(task, result);
>
> cleanup:
> - priv->result = NULL;
> - g_simple_async_result_complete(simple);
> - g_object_unref(simple);
> + g_object_unref(task);
> return FALSE;
> }
>
> @@ -159,7 +155,7 @@ static void gvir_output_stream_write_async(GOutputStream *stream,
> GVirOutputStream *output_stream = GVIR_OUTPUT_STREAM(stream);
>
> g_return_if_fail(GVIR_IS_OUTPUT_STREAM(stream));
> - g_return_if_fail(output_stream->priv->result == NULL);
> + g_return_if_fail(output_stream->priv->task == NULL);
>
> gvir_stream_add_watch_full(output_stream->priv->stream,
> G_PRIORITY_DEFAULT,
> @@ -168,12 +164,8 @@ static void gvir_output_stream_write_async(GOutputStream *stream,
> g_object_ref(stream),
> (GDestroyNotify)g_object_unref);
>
> - output_stream->priv->result =
> - g_simple_async_result_new(G_OBJECT(stream), callback, user_data,
> - gvir_output_stream_write_async);
> - if (cancellable)
> - g_object_ref(cancellable);
> - output_stream->priv->cancellable = cancellable;
> + output_stream->priv->task =
> + g_task_new(stream, cancellable, callback, user_data);
> output_stream->priv->buffer = buffer;
> output_stream->priv->count = count;
> }
> @@ -184,19 +176,16 @@ static gssize gvir_output_stream_write_finish(GOutputStream *stream,
> GError **error G_GNUC_UNUSED)
> {
> GVirOutputStream *output_stream = GVIR_OUTPUT_STREAM(stream);
> - GSimpleAsyncResult *simple;
> + GTask *task;
> virStreamPtr handle;
> gssize count;
>
> g_return_val_if_fail(GVIR_IS_OUTPUT_STREAM(stream), -1);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(stream),
> - gvir_output_stream_write_async),
> - -1);
> + g_return_val_if_fail(g_task_is_valid(result, stream), -1);
> g_object_get(output_stream->priv->stream, "handle", &handle, NULL);
>
> - simple = G_SIMPLE_ASYNC_RESULT(result);
> -
> - count = g_simple_async_result_get_op_res_gssize(simple);
> + task = G_TASK(result);
> + count = g_task_propagate_int(task, error);
You could skip the 'task' local variable as in the other _finish
implementations and just do g_task_propagate_int(G_TASK(result), error);
The 'error' argument is no longer G_GNUC_UNUSED after this change.
>
> virStreamFree(handle);
>
> diff --git a/libvirt-gobject/libvirt-gobject-storage-pool.c b/libvirt-gobject/libvirt-gobject-storage-pool.c
> index a0dcebc..117889c 100644
> --- a/libvirt-gobject/libvirt-gobject-storage-pool.c
> +++ b/libvirt-gobject/libvirt-gobject-storage-pool.c
> @@ -439,17 +439,18 @@ cleanup:
> }
>
> static void
> -gvir_storage_pool_refresh_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_storage_pool_refresh_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data G_GNUC_UNUSED,
> GCancellable *cancellable)
> {
> - GVirStoragePool *pool = GVIR_STORAGE_POOL(object);
> + GVirStoragePool *pool = GVIR_STORAGE_POOL(source_object);
> GError *err = NULL;
>
> - if (!gvir_storage_pool_refresh(pool, cancellable, &err)) {
> - g_simple_async_result_set_from_error(res, err);
> - g_error_free(err);
> - }
> + if (!gvir_storage_pool_refresh(pool, cancellable, &err))
> + g_task_return_error(task, err);
> + else
> + g_task_return_boolean(task, TRUE);
> }
>
> /**
> @@ -464,20 +465,17 @@ void gvir_storage_pool_refresh_async(GVirStoragePool *pool,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
>
> g_return_if_fail(GVIR_IS_STORAGE_POOL(pool));
> g_return_if_fail((cancellable == NULL) || G_IS_CANCELLABLE(cancellable));
>
> - res = g_simple_async_result_new(G_OBJECT(pool),
> - callback,
> - user_data,
> - gvir_storage_pool_refresh_async);
> - g_simple_async_result_run_in_thread(res,
> - gvir_storage_pool_refresh_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> - g_object_unref(res);
> + task = g_task_new(G_OBJECT(pool),
> + cancellable,
> + callback,
> + user_data);
> + g_task_run_in_thread(task, gvir_storage_pool_refresh_helper);
> + g_object_unref(task);
> }
>
> /**
> @@ -490,15 +488,10 @@ gboolean gvir_storage_pool_refresh_finish(GVirStoragePool *pool,
> GError **err)
> {
> g_return_val_if_fail(GVIR_IS_STORAGE_POOL(pool), FALSE);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(pool),
> - gvir_storage_pool_refresh_async),
> - FALSE);
> -
> - if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result),
> - err))
> - return FALSE;
> + g_return_val_if_fail(g_task_is_valid(result, pool), FALSE);
> + g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
>
> - return TRUE;
> + return g_task_propagate_boolean(G_TASK(result), err);
> }
>
> static void gvir_storage_vol_ref(gpointer obj, gpointer ignore G_GNUC_UNUSED)
> @@ -658,24 +651,25 @@ typedef struct {
> guint flags;
> } StoragePoolBuildData;
>
> +static void storage_pool_build_data_free(StoragePoolBuildData *data)
> +{
> + g_slice_free (StoragePoolBuildData, data);
Nit: No space before parens.
> +}
> +
> static void
> -gvir_storage_pool_build_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_storage_pool_build_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data,
> GCancellable *cancellable G_GNUC_UNUSED)
> {
> - GVirStoragePool *pool = GVIR_STORAGE_POOL(object);
> - StoragePoolBuildData *data;
> + GVirStoragePool *pool = GVIR_STORAGE_POOL(source_object);
> + StoragePoolBuildData *data = (StoragePoolBuildData *) task_data;
> GError *err = NULL;
>
> - data = (StoragePoolBuildData *) g_object_get_data(G_OBJECT(res),
> - "StoragePoolBuildData");
> -
> - if (!gvir_storage_pool_build(pool, data->flags, &err)) {
> - g_simple_async_result_set_from_error(res, err);
> - g_error_free(err);
> - }
> -
> - g_slice_free (StoragePoolBuildData, data);
> + if (!gvir_storage_pool_build(pool, data->flags, &err))
> + g_task_return_error(task, err);
> + else
> + g_task_return_boolean(task, TRUE);
> }
>
> /**
> @@ -692,7 +686,7 @@ void gvir_storage_pool_build_async (GVirStoragePool *pool,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
> StoragePoolBuildData *data;
>
> g_return_if_fail(GVIR_IS_STORAGE_POOL(pool));
> @@ -701,16 +695,13 @@ void gvir_storage_pool_build_async (GVirStoragePool *pool,
> data = g_slice_new0(StoragePoolBuildData);
> data->flags = flags;
>
> - res = g_simple_async_result_new(G_OBJECT(pool),
> - callback,
> - user_data,
> - gvir_storage_pool_build_async);
> - g_object_set_data(G_OBJECT(res), "StoragePoolBuildData", data);
> - g_simple_async_result_run_in_thread(res,
> - gvir_storage_pool_build_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> - g_object_unref(res);
> + task = g_task_new(G_OBJECT(pool),
> + cancellable,
> + callback,
> + user_data);
> + g_task_set_task_data(task, data, (GDestroyNotify)storage_pool_build_data_free);
> + g_task_run_in_thread(task, gvir_storage_pool_build_helper);
> + g_object_unref(task);
> }
>
> /**
> @@ -726,16 +717,10 @@ gboolean gvir_storage_pool_build_finish(GVirStoragePool *pool,
> GError **err)
> {
> g_return_val_if_fail(GVIR_IS_STORAGE_POOL(pool), FALSE);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(pool),
> - gvir_storage_pool_build_async),
> - FALSE);
> + g_return_val_if_fail(g_task_is_valid(result, pool), FALSE);
> g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
This test that err is NULL or *err is NULL is not present in all _finish
implementations, could be a good opportunity to add it.
>
> - if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result),
> - err))
> - return FALSE;
> -
> - return TRUE;
> + return g_task_propagate_boolean(G_TASK(result), err);
> }
>
> /**
> @@ -762,17 +747,18 @@ gboolean gvir_storage_pool_undefine (GVirStoragePool *pool,
> }
>
> static void
> -gvir_storage_pool_undefine_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_storage_pool_undefine_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data G_GNUC_UNUSED,
> GCancellable *cancellable G_GNUC_UNUSED)
> {
> - GVirStoragePool *pool = GVIR_STORAGE_POOL(object);
> + GVirStoragePool *pool = GVIR_STORAGE_POOL(source_object);
> GError *err = NULL;
>
> - if (!gvir_storage_pool_undefine(pool, &err)) {
> - g_simple_async_result_set_from_error(res, err);
> - g_error_free(err);
> - }
> + if (!gvir_storage_pool_undefine(pool, &err))
> + g_task_return_error(task, err);
> + else
> + g_task_return_boolean(task, TRUE);
> }
>
> /**
> @@ -787,20 +773,17 @@ void gvir_storage_pool_undefine_async (GVirStoragePool *pool,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
>
> g_return_if_fail(GVIR_IS_STORAGE_POOL(pool));
> g_return_if_fail((cancellable == NULL) || G_IS_CANCELLABLE(cancellable));
>
> - res = g_simple_async_result_new(G_OBJECT(pool),
> - callback,
> - user_data,
> - gvir_storage_pool_undefine_async);
> - g_simple_async_result_run_in_thread(res,
> - gvir_storage_pool_undefine_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> - g_object_unref(res);
> + task = g_task_new(G_OBJECT(pool),
> + cancellable,
> + callback,
> + user_data);
> + g_task_run_in_thread(task, gvir_storage_pool_undefine_helper);
> + g_object_unref(task);
> }
>
> /**
> @@ -816,16 +799,10 @@ gboolean gvir_storage_pool_undefine_finish(GVirStoragePool *pool,
> GError **err)
> {
> g_return_val_if_fail(GVIR_IS_STORAGE_POOL(pool), FALSE);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(pool),
> - gvir_storage_pool_undefine_async),
> - FALSE);
> + g_return_val_if_fail(g_task_is_valid(result, pool), FALSE);
> g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
>
> - if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result),
> - err))
> - return FALSE;
> -
> - return TRUE;
> + return g_task_propagate_boolean(G_TASK(result), err);
> }
>
> /**
> @@ -854,23 +831,21 @@ gboolean gvir_storage_pool_start (GVirStoragePool *pool,
> }
>
> static void
> -gvir_storage_pool_start_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_storage_pool_start_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data,
> GCancellable *cancellable G_GNUC_UNUSED)
> {
> - GVirStoragePool *pool = GVIR_STORAGE_POOL(object);
> + GVirStoragePool *pool = GVIR_STORAGE_POOL(source_object);
> StoragePoolBuildData *data;
> GError *err = NULL;
>
> - data = (StoragePoolBuildData *) g_object_get_data(G_OBJECT(res),
> - "StoragePoolBuildData");
> + data = (StoragePoolBuildData *) task_data;
>
> - if (!gvir_storage_pool_start(pool, data->flags, &err)) {
> - g_simple_async_result_set_from_error(res, err);
> - g_error_free(err);
> - }
> -
> - g_slice_free (StoragePoolBuildData, data);
> + if (!gvir_storage_pool_start(pool, data->flags, &err))
> + g_task_return_error(task, err);
> + else
> + g_task_return_boolean(task, TRUE);
> }
>
> /**
> @@ -887,7 +862,7 @@ void gvir_storage_pool_start_async (GVirStoragePool *pool,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
> StoragePoolBuildData *data;
>
> g_return_if_fail(GVIR_IS_STORAGE_POOL(pool));
> @@ -896,16 +871,13 @@ void gvir_storage_pool_start_async (GVirStoragePool *pool,
> data = g_slice_new0(StoragePoolBuildData);
> data->flags = flags;
>
> - res = g_simple_async_result_new(G_OBJECT(pool),
> - callback,
> - user_data,
> - gvir_storage_pool_start_async);
> - g_object_set_data(G_OBJECT(res), "StoragePoolBuildData", data);
> - g_simple_async_result_run_in_thread(res,
> - gvir_storage_pool_start_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> - g_object_unref(res);
> + task = g_task_new(G_OBJECT(pool),
> + cancellable,
> + callback,
> + user_data);
> + g_task_set_task_data(task, data, (GDestroyNotify)storage_pool_build_data_free);
> + g_task_run_in_thread(task, gvir_storage_pool_start_helper);
> + g_object_unref(task);
> }
>
> /**
> @@ -921,16 +893,10 @@ gboolean gvir_storage_pool_start_finish(GVirStoragePool *pool,
> GError **err)
> {
> g_return_val_if_fail(GVIR_IS_STORAGE_POOL(pool), FALSE);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(pool),
> - gvir_storage_pool_start_async),
> - FALSE);
> + g_return_val_if_fail(g_task_is_valid(result, pool), FALSE);
> g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
>
> - if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result),
> - err))
> - return FALSE;
> -
> - return TRUE;
> + return g_task_propagate_boolean(G_TASK(result), err);
> }
>
> /**
> @@ -957,17 +923,18 @@ gboolean gvir_storage_pool_stop (GVirStoragePool *pool,
> }
>
> static void
> -gvir_storage_pool_stop_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_storage_pool_stop_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data G_GNUC_UNUSED,
> GCancellable *cancellable G_GNUC_UNUSED)
> {
> - GVirStoragePool *pool = GVIR_STORAGE_POOL(object);
> + GVirStoragePool *pool = GVIR_STORAGE_POOL(source_object);
> GError *err = NULL;
>
> - if (!gvir_storage_pool_stop(pool, &err)) {
> - g_simple_async_result_set_from_error(res, err);
> - g_error_free(err);
> - }
> + if (!gvir_storage_pool_stop(pool, &err))
> + g_task_return_error(task, err);
> + else
> + g_task_return_boolean(task, TRUE);
> }
>
> /**
> @@ -982,20 +949,17 @@ void gvir_storage_pool_stop_async (GVirStoragePool *pool,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
>
> g_return_if_fail(GVIR_IS_STORAGE_POOL(pool));
> g_return_if_fail((cancellable == NULL) || G_IS_CANCELLABLE(cancellable));
>
> - res = g_simple_async_result_new(G_OBJECT(pool),
> - callback,
> - user_data,
> - gvir_storage_pool_stop_async);
> - g_simple_async_result_run_in_thread(res,
> - gvir_storage_pool_stop_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> - g_object_unref(res);
> + task = g_task_new(G_OBJECT(pool),
> + cancellable,
> + callback,
> + user_data);
> + g_task_run_in_thread(task, gvir_storage_pool_stop_helper);
> + g_object_unref(task);
> }
>
> /**
> @@ -1011,16 +975,10 @@ gboolean gvir_storage_pool_stop_finish(GVirStoragePool *pool,
> GError **err)
> {
> g_return_val_if_fail(GVIR_IS_STORAGE_POOL(pool), FALSE);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(pool),
> - gvir_storage_pool_stop_async),
> - FALSE);
> + g_return_val_if_fail(g_task_is_valid(result, pool), FALSE);
> g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
>
> - if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result),
> - err))
> - return FALSE;
> -
> - return TRUE;
> + return g_task_propagate_boolean(G_TASK(result), err);
> }
>
> /**
> @@ -1100,23 +1058,21 @@ gboolean gvir_storage_pool_set_autostart(GVirStoragePool *pool,
> }
>
> static void
> -gvir_storage_pool_delete_helper(GSimpleAsyncResult *res,
> - GObject *object,
> +gvir_storage_pool_delete_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data,
> GCancellable *cancellable G_GNUC_UNUSED)
> {
> - GVirStoragePool *pool = GVIR_STORAGE_POOL(object);
> + GVirStoragePool *pool = GVIR_STORAGE_POOL(source_object);
> StoragePoolBuildData *data;
> GError *err = NULL;
>
> - data = (StoragePoolBuildData *) g_object_get_data(G_OBJECT(res),
> - "StoragePoolBuildData");
> -
> - if (!gvir_storage_pool_delete(pool, data->flags, &err)) {
> - g_simple_async_result_set_from_error(res, err);
> - g_error_free(err);
> - }
> + data = (StoragePoolBuildData *) task_data;
>
> - g_slice_free (StoragePoolBuildData, data);
> + if (!gvir_storage_pool_delete(pool, data->flags, &err))
> + g_task_return_error(task, err);
> + else
> + g_task_return_boolean(task, TRUE);
> }
>
> /**
> @@ -1133,7 +1089,7 @@ void gvir_storage_pool_delete_async (GVirStoragePool *pool,
> GAsyncReadyCallback callback,
> gpointer user_data)
> {
> - GSimpleAsyncResult *res;
> + GTask *task;
> StoragePoolBuildData *data;
>
> g_return_if_fail(GVIR_IS_STORAGE_POOL(pool));
> @@ -1142,16 +1098,13 @@ void gvir_storage_pool_delete_async (GVirStoragePool *pool,
> data = g_slice_new0(StoragePoolBuildData);
> data->flags = flags;
>
> - res = g_simple_async_result_new(G_OBJECT(pool),
> - callback,
> - user_data,
> - gvir_storage_pool_delete_async);
> - g_object_set_data(G_OBJECT(res), "StoragePoolBuildData", data);
> - g_simple_async_result_run_in_thread(res,
> - gvir_storage_pool_delete_helper,
> - G_PRIORITY_DEFAULT,
> - cancellable);
> - g_object_unref(res);
> + task = g_task_new(G_OBJECT(pool),
> + cancellable,
> + callback,
> + user_data);
> + g_task_set_task_data(task, data, (GDestroyNotify)storage_pool_build_data_free);
> + g_task_run_in_thread(task, gvir_storage_pool_delete_helper);
> + g_object_unref(task);
> }
>
> /**
> @@ -1167,16 +1120,10 @@ gboolean gvir_storage_pool_delete_finish(GVirStoragePool *pool,
> GError **err)
> {
> g_return_val_if_fail(GVIR_IS_STORAGE_POOL(pool), FALSE);
> - g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(pool),
> - gvir_storage_pool_delete_async),
> - FALSE);
> + g_return_val_if_fail(g_task_is_valid(result, pool), FALSE);
> g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
>
> - if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result),
> - err))
> - return FALSE;
> -
> - return TRUE;
> + return g_task_propagate_boolean(G_TASK(result), err);
> }
>
> G_GNUC_INTERNAL void gvir_storage_pool_delete_vol(GVirStoragePool *pool,
> diff --git a/libvirt-gobject/libvirt-gobject-stream.c b/libvirt-gobject/libvirt-gobject-stream.c
> index 46dbd9a..f8a1a8c 100644
> --- a/libvirt-gobject/libvirt-gobject-stream.c
> +++ b/libvirt-gobject/libvirt-gobject-stream.c
> @@ -129,14 +129,13 @@ static gboolean gvir_stream_close(GIOStream *io_stream,
> return (i_ret && o_ret);
> }
>
> -
> -static void gvir_stream_close_async(GIOStream *stream,
> - int io_priority G_GNUC_UNUSED,
> - GCancellable *cancellable,
> - GAsyncReadyCallback callback,
> - gpointer user_data)
> +static void
> +gvir_stream_close_helper(GTask *task,
> + gpointer source_object,
> + gpointer task_data G_GNUC_UNUSED,
> + GCancellable *cancellable)
> {
> - GSimpleAsyncResult *res;
> + GIOStream *stream = G_IO_STREAM(source_object);
> GIOStreamClass *class;
> GError *error;
>
> @@ -146,27 +145,36 @@ static void gvir_stream_close_async(GIOStream *stream,
> error = NULL;
> if (class->close_fn &&
> !class->close_fn(stream, cancellable, &error)) {
> - g_simple_async_report_take_gerror_in_idle(G_OBJECT (stream),
> - callback, user_data,
> - error);
> + g_task_return_error(task, error);
> return;
> }
>
> - res = g_simple_async_result_new(G_OBJECT (stream),
> - callback,
> - user_data,
> - gvir_stream_close_async);
> - g_simple_async_result_complete_in_idle(res);
> - g_object_unref (res);
> + g_task_return_boolean(task, TRUE);
> +}
> +
> +static void gvir_stream_close_async(GIOStream *stream,
> + int io_priority G_GNUC_UNUSED,
> + GCancellable *cancellable,
> + GAsyncReadyCallback callback,
> + gpointer user_data)
> +{
> + GTask *task;
> +
> + task = g_task_new(G_OBJECT(stream),
> + cancellable,
> + callback,
> + user_data);
> + g_task_run_in_thread(task, gvir_stream_close_helper);
> + g_object_unref(task);
> }
Was this one creating a GSimpleAsyncResult and returning immediately
without doing anything?
The helper does not seem to be doing anything more, in which case I'd
suggest not creating an intermediate helper thread, and to do something
similar to what was done before. If this is a bug and more work should
be done, I'd prefer if this was done in a separate patch.
All in all series looks good, feel free to split the
gvir_stream_close_async changes away from this patch if you want to push
the rest now (it only has minor comments).
Christophe
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://listman.redhat.com/archives/libvir-list/attachments/20151102/a3ed51f9/attachment-0001.sig>
More information about the libvir-list
mailing list