[libgdata] documents: Port from GSimpleAsyncResult to GTask

[Philip Withnall <pwithnall src gnome org>]

commit e264589f13695d55955dbe8ddb8a2743bde034d8
Author: Philip Withnall <withnall endlessm com>
Date:   Wed Aug 9 14:56:59 2017 +0100

    documents: Port from GSimpleAsyncResult to GTask
    
    Port GDataDocumentsService.
    
    Signed-off-by: Philip Withnall <withnall endlessm com>

 gdata/services/documents/gdata-documents-service.c |  196 +++++++-------------
 1 files changed, 70 insertions(+), 126 deletions(-)
---
diff --git a/gdata/services/documents/gdata-documents-service.c 
b/gdata/services/documents/gdata-documents-service.c
index 0bfdcc2..5d667e9 100644
--- a/gdata/services/documents/gdata-documents-service.c
+++ b/gdata/services/documents/gdata-documents-service.c
@@ -465,21 +465,18 @@ gdata_documents_service_get_metadata (GDataDocumentsService *self, GCancellable
 }
 
 static void
-get_metadata_thread (GSimpleAsyncResult *result, GDataDocumentsService *service, GCancellable *cancellable)
+get_metadata_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable)
 {
-       GDataDocumentsMetadata *metadata;
-       GError *error = NULL;
+       GDataDocumentsService *service = GDATA_DOCUMENTS_SERVICE (source_object);
+       g_autoptr(GDataDocumentsMetadata) metadata = NULL;
+       g_autoptr(GError) error = NULL;
 
        /* Copy the metadata and return */
        metadata = gdata_documents_service_get_metadata (service, cancellable, &error);
-       if (error != NULL) {
-               g_simple_async_result_set_from_error (result, error);
-               g_error_free (error);
-               return;
-       }
-
-       /* Return the metadata */
-       g_simple_async_result_set_op_res_gpointer (result, g_object_ref (metadata), (GDestroyNotify) 
g_object_unref);
+       if (error != NULL)
+               g_task_return_error (task, g_steal_pointer (&error));
+       else
+               g_task_return_pointer (task, g_steal_pointer (&metadata), g_object_unref);
 }
 
 /**
@@ -503,14 +500,14 @@ void
 gdata_documents_service_get_metadata_async (GDataDocumentsService *self, GCancellable *cancellable,
                                             GAsyncReadyCallback callback, gpointer user_data)
 {
-       GSimpleAsyncResult *result;
+       g_autoptr(GTask) task = NULL;
 
        g_return_if_fail (GDATA_IS_DOCUMENTS_SERVICE (self));
        g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
 
-       result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, 
gdata_documents_service_get_metadata_async);
-       g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) get_metadata_thread, 
G_PRIORITY_DEFAULT, cancellable);
-       g_object_unref (result);
+       task = g_task_new (self, cancellable, callback, user_data);
+       g_task_set_source_tag (task, gdata_documents_service_get_metadata_async);
+       g_task_run_in_thread (task, get_metadata_thread);
 }
 
 /**
@@ -528,23 +525,13 @@ gdata_documents_service_get_metadata_async (GDataDocumentsService *self, GCancel
 GDataDocumentsMetadata *
 gdata_documents_service_get_metadata_finish (GDataDocumentsService *self, GAsyncResult *async_result, GError 
**error)
 {
-       GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (async_result);
-       GDataDocumentsMetadata *metadata;
-
        g_return_val_if_fail (GDATA_IS_DOCUMENTS_SERVICE (self), NULL);
        g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), NULL);
-       g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-       g_warn_if_fail (g_simple_async_result_get_source_tag (result) == 
gdata_documents_service_get_metadata_async);
-
-       if (g_simple_async_result_propagate_error (result, error) == TRUE) {
-               return NULL;
-       }
-
-       metadata = g_simple_async_result_get_op_res_gpointer (result);
-       g_assert (GDATA_IS_DOCUMENTS_METADATA (metadata));
+       g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+       g_return_val_if_fail (g_task_is_valid (async_result, self), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (async_result, 
gdata_documents_service_get_metadata_async), NULL);
 
-       return metadata;
+       return g_task_propagate_pointer (G_TASK (async_result), error);
 }
 
 static gchar *
@@ -1098,23 +1085,19 @@ gdata_documents_service_copy_document (GDataDocumentsService *self, GDataDocumen
 }
 
 static void
-copy_document_thread (GSimpleAsyncResult *result, GDataDocumentsService *service, GCancellable *cancellable)
+copy_document_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable)
 {
-       GDataDocumentsDocument *document, *new_document;
-       GError *error = NULL;
-
-       document = g_simple_async_result_get_op_res_gpointer (result);
+       GDataDocumentsService *service = GDATA_DOCUMENTS_SERVICE (source_object);
+       GDataDocumentsDocument *document = task_data;
+       g_autoptr(GDataDocumentsDocument) new_document = NULL;
+       g_autoptr(GError) error = NULL;
 
        /* Copy the document and return */
        new_document = gdata_documents_service_copy_document (service, document, cancellable, &error);
-       if (error != NULL) {
-               g_simple_async_result_set_from_error (result, error);
-               g_error_free (error);
-               return;
-       }
-
-       /* Return the document copy */
-       g_simple_async_result_set_op_res_gpointer (result, g_object_ref (new_document), (GDestroyNotify) 
g_object_unref);
+       if (error != NULL)
+               g_task_return_error (task, g_steal_pointer (&error));
+       else
+               g_task_return_pointer (task, g_steal_pointer (&new_document), g_object_unref);
 }
 
 /**
@@ -1139,16 +1122,16 @@ void
 gdata_documents_service_copy_document_async (GDataDocumentsService *self, GDataDocumentsDocument *document, 
GCancellable *cancellable,
                                              GAsyncReadyCallback callback, gpointer user_data)
 {
-       GSimpleAsyncResult *result;
+       g_autoptr(GTask) task = NULL;
 
        g_return_if_fail (GDATA_IS_DOCUMENTS_SERVICE (self));
        g_return_if_fail (GDATA_IS_DOCUMENTS_DOCUMENT (document));
        g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
 
-       result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, 
gdata_documents_service_copy_document_async);
-       g_simple_async_result_set_op_res_gpointer (result, g_object_ref (document), (GDestroyNotify) 
g_object_unref);
-       g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) copy_document_thread, 
G_PRIORITY_DEFAULT, cancellable);
-       g_object_unref (result);
+       task = g_task_new (self, cancellable, callback, user_data);
+       g_task_set_source_tag (task, gdata_documents_service_copy_document_async);
+       g_task_set_task_data (task, g_object_ref (document), (GDestroyNotify) g_object_unref);
+       g_task_run_in_thread (task, copy_document_thread);
 }
 
 /**
@@ -1166,23 +1149,13 @@ gdata_documents_service_copy_document_async (GDataDocumentsService *self, GDataD
 GDataDocumentsDocument *
 gdata_documents_service_copy_document_finish (GDataDocumentsService *self, GAsyncResult *async_result, 
GError **error)
 {
-       GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (async_result);
-       GDataDocumentsDocument *new_document;
-
        g_return_val_if_fail (GDATA_IS_DOCUMENTS_SERVICE (self), NULL);
        g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), NULL);
-       g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-       g_warn_if_fail (g_simple_async_result_get_source_tag (result) == 
gdata_documents_service_copy_document_async);
-
-       if (g_simple_async_result_propagate_error (result, error) == TRUE) {
-               return NULL;
-       }
-
-       new_document = g_simple_async_result_get_op_res_gpointer (result);
-       g_assert (GDATA_IS_DOCUMENTS_DOCUMENT (new_document));
+       g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+       g_return_val_if_fail (g_task_is_valid (async_result, self), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (async_result, 
gdata_documents_service_copy_document_async), NULL);
 
-       return new_document;
+       return g_task_propagate_pointer (G_TASK (async_result), error);
 }
 
 /**
@@ -1301,24 +1274,19 @@ add_entry_to_folder_data_free (AddEntryToFolderData *data)
 }
 
 static void
-add_entry_to_folder_thread (GSimpleAsyncResult *result, GDataDocumentsService *service, GCancellable 
*cancellable)
+add_entry_to_folder_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable 
*cancellable)
 {
-       GDataDocumentsEntry *updated_entry;
-       AddEntryToFolderData *data;
-       GError *error = NULL;
-
-       data = g_simple_async_result_get_op_res_gpointer (result);
+       GDataDocumentsService *service = GDATA_DOCUMENTS_SERVICE (source_object);
+       g_autoptr(GDataDocumentsEntry) updated_entry = NULL;
+       AddEntryToFolderData *data = task_data;
+       g_autoptr(GError) error = NULL;
 
        /* Add the entry to the folder and return */
        updated_entry = gdata_documents_service_add_entry_to_folder (service, data->entry, data->folder, 
cancellable, &error);
-       if (error != NULL) {
-               g_simple_async_result_set_from_error (result, error);
-               g_error_free (error);
-               return;
-       }
-
-       /* Return the updated entry */
-       g_simple_async_result_set_op_res_gpointer (result, updated_entry, (GDestroyNotify) g_object_unref);
+       if (error != NULL)
+               g_task_return_error (task, g_steal_pointer (&error));
+       else
+               g_task_return_pointer (task, g_steal_pointer (&updated_entry), (GDestroyNotify) 
g_object_unref);
 }
 
 /**
@@ -1344,7 +1312,7 @@ void
 gdata_documents_service_add_entry_to_folder_async (GDataDocumentsService *self, GDataDocumentsEntry *entry, 
GDataDocumentsFolder *folder,
                                                    GCancellable *cancellable, GAsyncReadyCallback callback, 
gpointer user_data)
 {
-       GSimpleAsyncResult *result;
+       g_autoptr(GTask) task = NULL;
        AddEntryToFolderData *data;
 
        g_return_if_fail (GDATA_IS_DOCUMENTS_SERVICE (self));
@@ -1356,10 +1324,10 @@ gdata_documents_service_add_entry_to_folder_async (GDataDocumentsService *self,
        data->entry = g_object_ref (entry);
        data->folder = g_object_ref (folder);
 
-       result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, 
gdata_documents_service_add_entry_to_folder_async);
-       g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify) 
add_entry_to_folder_data_free);
-       g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) add_entry_to_folder_thread, 
G_PRIORITY_DEFAULT, cancellable);
-       g_object_unref (result);
+       task = g_task_new (self, cancellable, callback, user_data);
+       g_task_set_source_tag (task, gdata_documents_service_add_entry_to_folder_async);
+       g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) add_entry_to_folder_data_free);
+       g_task_run_in_thread (task, add_entry_to_folder_thread);
 }
 
 /**
@@ -1377,23 +1345,13 @@ gdata_documents_service_add_entry_to_folder_async (GDataDocumentsService *self,
 GDataDocumentsEntry *
 gdata_documents_service_add_entry_to_folder_finish (GDataDocumentsService *self, GAsyncResult *async_result, 
GError **error)
 {
-       GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (async_result);
-       GDataDocumentsEntry *entry;
-
        g_return_val_if_fail (GDATA_IS_DOCUMENTS_SERVICE (self), NULL);
        g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), NULL);
-       g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-       g_warn_if_fail (g_simple_async_result_get_source_tag (result) == 
gdata_documents_service_add_entry_to_folder_async);
-
-       if (g_simple_async_result_propagate_error (result, error) == TRUE)
-               return NULL;
-
-       entry = g_simple_async_result_get_op_res_gpointer (result);
-       if (entry != NULL)
-               return g_object_ref (entry);
+       g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+       g_return_val_if_fail (g_task_is_valid (async_result, self), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (async_result, 
gdata_documents_service_add_entry_to_folder_async), NULL);
 
-       g_assert_not_reached ();
+       return g_task_propagate_pointer (G_TASK (async_result), error);
 }
 
 /**
@@ -1477,23 +1435,19 @@ remove_entry_from_folder_data_free (RemoveEntryFromFolderData *data)
 }
 
 static void
-remove_entry_from_folder_thread (GSimpleAsyncResult *result, GDataDocumentsService *service, GCancellable 
*cancellable)
+remove_entry_from_folder_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable 
*cancellable)
 {
-       GDataDocumentsEntry *updated_entry;
-       RemoveEntryFromFolderData *data;
-       GError *error = NULL;
-
-       data = g_simple_async_result_get_op_res_gpointer (result);
+       GDataDocumentsService *service = GDATA_DOCUMENTS_SERVICE (source_object);
+       g_autoptr(GDataDocumentsEntry) updated_entry = NULL;
+       RemoveEntryFromFolderData *data = task_data;
+       g_autoptr(GError) error = NULL;
 
        /* Remove the entry from the folder and return */
        updated_entry = gdata_documents_service_remove_entry_from_folder (service, data->entry, data->folder, 
cancellable, &error);
-       if (error != NULL) {
-               g_simple_async_result_take_error (result, error);
-               return;
-       }
-
-       /* Return the updated entry */
-       g_simple_async_result_set_op_res_gpointer (result, updated_entry, (GDestroyNotify) g_object_unref);
+       if (error != NULL)
+               g_task_return_error (task, g_steal_pointer (&error));
+       else
+               g_task_return_pointer (task, g_steal_pointer (&updated_entry), g_object_unref);
 }
 
 /**
@@ -1519,7 +1473,7 @@ void
 gdata_documents_service_remove_entry_from_folder_async (GDataDocumentsService *self, GDataDocumentsEntry 
*entry, GDataDocumentsFolder *folder,
                                                         GCancellable *cancellable, GAsyncReadyCallback 
callback, gpointer user_data)
 {
-       GSimpleAsyncResult *result;
+       g_autoptr(GTask) task = NULL;
        RemoveEntryFromFolderData *data;
 
        g_return_if_fail (GDATA_IS_DOCUMENTS_SERVICE (self));
@@ -1531,10 +1485,10 @@ gdata_documents_service_remove_entry_from_folder_async (GDataDocumentsService *s
        data->entry = g_object_ref (entry);
        data->folder = g_object_ref (folder);
 
-       result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, 
gdata_documents_service_remove_entry_from_folder_async);
-       g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify) 
remove_entry_from_folder_data_free);
-       g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) 
remove_entry_from_folder_thread, G_PRIORITY_DEFAULT, cancellable);
-       g_object_unref (result);
+       task = g_task_new (self, cancellable, callback, user_data);
+       g_task_set_source_tag (task, gdata_documents_service_remove_entry_from_folder_async);
+       g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) 
remove_entry_from_folder_data_free);
+       g_task_run_in_thread (task, remove_entry_from_folder_thread);
 }
 
 /**
@@ -1553,23 +1507,13 @@ gdata_documents_service_remove_entry_from_folder_async (GDataDocumentsService *s
 GDataDocumentsEntry *
 gdata_documents_service_remove_entry_from_folder_finish (GDataDocumentsService *self, GAsyncResult 
*async_result, GError **error)
 {
-       GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (async_result);
-       GDataDocumentsEntry *entry;
-
        g_return_val_if_fail (GDATA_IS_DOCUMENTS_SERVICE (self), NULL);
        g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), NULL);
-       g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-       g_warn_if_fail (g_simple_async_result_get_source_tag (result) == 
gdata_documents_service_remove_entry_from_folder_async);
-
-       if (g_simple_async_result_propagate_error (result, error) == TRUE)
-               return NULL;
-
-       entry = g_simple_async_result_get_op_res_gpointer (result);
-       if (entry != NULL)
-               return g_object_ref (entry);
+       g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+       g_return_val_if_fail (g_task_is_valid (async_result, self), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (async_result, 
gdata_documents_service_remove_entry_from_folder_async), NULL);
 
-       g_assert_not_reached ();
+       return g_task_propagate_pointer (G_TASK (async_result), error);
 }
 
 /* NOTE: query may be NULL. */