[gvfs/wip/oholy/gtask: 4/10] gdaemonfileenumerator: Port to GTask

[Ondrej Holy <oholy src gnome org>]

commit bd4dd5c16d0fdd9c9cba4af3addbed6f03ec7683
Author: Ondrej Holy <oholy redhat com>
Date:   Mon Jun 13 11:57:13 2016 +0200

    gdaemonfileenumerator: Port to GTask
    
    GSimpleAsyncResult is deprecated in favour of GTask and should be replaced.
    
    https://bugzilla.gnome.org/show_bug.cgi?id=747412

 client/gdaemonfileenumerator.c |  130 +++++++++++++---------------------------
 1 files changed, 42 insertions(+), 88 deletions(-)
---
diff --git a/client/gdaemonfileenumerator.c b/client/gdaemonfileenumerator.c
index d056359..f03a06b 100644
--- a/client/gdaemonfileenumerator.c
+++ b/client/gdaemonfileenumerator.c
@@ -58,7 +58,7 @@ struct _GDaemonFileEnumerator
   int async_requested_files;
   gulong cancelled_tag;
   guint timeout_tag;
-  GSimpleAsyncResult *async_res;
+  GTask *task;
   GMainLoop *next_files_mainloop;
   GMainContext *next_files_context;
   GSource *next_files_sync_timeout_source;
@@ -93,7 +93,8 @@ static void              g_daemon_file_enumerator_close_async (GFileEnumerator
 static gboolean          g_daemon_file_enumerator_close_finish (GFileEnumerator      *enumerator,
                                                               GAsyncResult         *result,
                                                               GError              **error);
-static void              trigger_async_done (GDaemonFileEnumerator *daemon, gboolean ok);
+static void              trigger_async_done (GDaemonFileEnumerator *daemon,
+                                             GError                *error);
 
 
 static void
@@ -190,7 +191,7 @@ handle_done (GVfsDBusEnumerator *object,
   G_LOCK (infos);
   enumerator->done = TRUE;
   if (enumerator->async_requested_files > 0)
-    trigger_async_done (enumerator, TRUE);
+    trigger_async_done (enumerator, NULL);
   next_files_sync_check (enumerator);
   G_UNLOCK (infos);
 
@@ -232,7 +233,7 @@ handle_got_info (GVfsDBusEnumerator *object,
   enumerator->infos = g_list_concat (enumerator->infos, infos);
   if (enumerator->async_requested_files > 0 &&
       g_list_length (enumerator->infos) >= enumerator->async_requested_files)
-    trigger_async_done (enumerator, TRUE);
+    trigger_async_done (enumerator, NULL);
   next_files_sync_check (enumerator);
   G_UNLOCK (infos);
 
@@ -362,46 +363,27 @@ add_metadata (GFileInfo *info,
   g_free (path);
 }
 
-static GCancellable *
-simple_async_result_get_cancellable (GSimpleAsyncResult *res)
-{
-  return g_object_get_data (G_OBJECT (res), "file-enumerator-cancellable");
-}
-
-static void
-simple_async_result_set_cancellable (GSimpleAsyncResult *res,
-                                     GCancellable       *cancellable)
-{
-  if (!cancellable)
-    return;
-
-  g_object_set_data_full (G_OBJECT (res),
-                          "file-enumerator-cancellable",
-                          g_object_ref (cancellable),
-                          g_object_unref);
-}
-
 /* Called with infos lock held */
 static void
-trigger_async_done (GDaemonFileEnumerator *daemon, gboolean ok)
+trigger_async_done (GDaemonFileEnumerator *daemon, GError *error)
 {
   GList *rest, *l;
-  
+
   if (daemon->cancelled_tag != 0)
     {
-      GCancellable *cancellable = simple_async_result_get_cancellable (daemon->async_res);
+      GCancellable *cancellable = g_task_get_cancellable (daemon->task);
 
-      /* If ok, we're a normal callback on the main thread,
+      /* If !error, we're a normal callback on the main thread,
         ensure protection against a thread cancelling and
         running the callback again.
-        If !ok then we're in a callback which may be
+        If error then we're in a callback which may be
         from another thread, but we're guaranteed that
         cancellation will only happen once. However
         we can't use g_cancellable_disconnect, as this
         deadlocks if we call it from within the signal
         handler.
       */
-      if (ok)
+      if (error == NULL)
        g_cancellable_disconnect (cancellable,
                                  daemon->cancelled_tag);
       else
@@ -419,7 +401,7 @@ trigger_async_done (GDaemonFileEnumerator *daemon, gboolean ok)
      outside the main thread which is kinda unusual for async
      ops. However, it would be nice to handle this too. */
 
-  if (ok)
+  if (error == NULL)
     {
       l = daemon->infos;
       rest = g_list_nth (l, daemon->async_requested_files);
@@ -433,13 +415,13 @@ trigger_async_done (GDaemonFileEnumerator *daemon, gboolean ok)
 
       g_list_foreach (l, (GFunc)add_metadata, daemon);
 
-      g_simple_async_result_set_op_res_gpointer (daemon->async_res,
-                                                l,
-                                                (GDestroyNotify)free_info_list);
+      g_task_return_pointer (daemon->task, l, (GDestroyNotify)free_info_list);
+    }
+  else
+    {
+      g_task_return_error (daemon->task, error);
     }
 
-  g_simple_async_result_complete_in_idle (daemon->async_res);
-  
   daemon->cancelled_tag = 0;
 
   if (daemon->timeout_tag != 0)
@@ -447,9 +429,8 @@ trigger_async_done (GDaemonFileEnumerator *daemon, gboolean ok)
   daemon->timeout_tag = 0;
   
   daemon->async_requested_files = 0;
-  
-  g_object_unref (daemon->async_res);
-  daemon->async_res = NULL;
+
+  g_clear_object (&daemon->task);
 }
 
 char  *
@@ -547,12 +528,12 @@ static void
 async_cancelled (GCancellable *cancellable,
                 GDaemonFileEnumerator *daemon)
 {
-  g_simple_async_result_set_error (daemon->async_res,
-                                  G_IO_ERROR,
-                                  G_IO_ERROR_CANCELLED,
-                                  _("Operation was cancelled"));
+  GError *error;
+
+  error = g_error_new (G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled"));
+
   G_LOCK (infos);
-  trigger_async_done (daemon, FALSE);
+  trigger_async_done (daemon, error);
   G_UNLOCK (infos);
 }
 
@@ -562,7 +543,7 @@ async_timeout (gpointer data)
   GDaemonFileEnumerator *daemon = G_DAEMON_FILE_ENUMERATOR (data);
 
   G_LOCK (infos);
-  trigger_async_done (daemon, TRUE);
+  trigger_async_done (daemon, NULL);
   G_UNLOCK (infos);
   return FALSE;
 }
@@ -576,6 +557,9 @@ g_daemon_file_enumerator_next_files_async (GFileEnumerator     *enumerator,
                                           gpointer             user_data)
 {
   GDaemonFileEnumerator *daemon = G_DAEMON_FILE_ENUMERATOR (enumerator);
+  GTask *task;
+
+  task = g_task_new (enumerator, cancellable, callback, user_data);
 
   if (daemon->sync_connection != NULL)
     {
@@ -585,26 +569,22 @@ g_daemon_file_enumerator_next_files_async (GFileEnumerator     *enumerator,
        * We could possibly pump it ourselves in this case, but i'm not sure
        * how much sense this makes, so we don't for now.
        */
-      g_simple_async_report_error_in_idle  (G_OBJECT (enumerator),
-                                           callback,
-                                           user_data,
-                                           G_IO_ERROR, G_IO_ERROR_FAILED,
-                                           "Can't do asynchronous next_files() on a file enumerator created 
synchronously");
+      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED,
+                               "Can't do asynchronous next_files() on a file enumerator created 
synchronously");
+      g_object_unref (task);
       return;
     }
-  
+
   G_LOCK (infos);
   daemon->cancelled_tag = 0;
   daemon->timeout_tag = 0;
   daemon->async_requested_files = num_files;
-  daemon->async_res = g_simple_async_result_new (G_OBJECT (enumerator), callback, user_data,
-                                                g_daemon_file_enumerator_next_files_async);
-  simple_async_result_set_cancellable (daemon->async_res, cancellable);
+  daemon->task = task;
 
   /* Maybe we already have enough info to fulfill the requeust already */
   if (daemon->done ||
       g_list_length (daemon->infos) >= daemon->async_requested_files)
-    trigger_async_done (daemon, TRUE);
+    trigger_async_done (daemon, NULL);
   else
     {
       daemon->timeout_tag = g_timeout_add (G_VFS_DBUS_TIMEOUT_MSECS,
@@ -623,23 +603,9 @@ g_daemon_file_enumerator_next_files_finish (GFileEnumerator  *enumerator,
                                            GAsyncResult     *res,
                                            GError          **error)
 {
-  GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (res);
-  GCancellable *cancellable;
-  GList *l;
+  g_return_val_if_fail (g_task_is_valid (res, enumerator), NULL);
 
-  cancellable = simple_async_result_get_cancellable (result);
-  if (g_cancellable_is_cancelled (cancellable))
-    {
-      g_set_error (error,
-                   G_IO_ERROR,
-                   G_IO_ERROR_CANCELLED,
-                   "%s", _("Operation was cancelled"));
-      return NULL;
-    }
-
-  l = g_simple_async_result_get_op_res_gpointer (result);
-  g_list_foreach (l, (GFunc)g_object_ref, NULL);
-  return g_list_copy (l);
+  return g_task_propagate_pointer (G_TASK (res), error);
 }
 
 static gboolean
@@ -662,13 +628,11 @@ g_daemon_file_enumerator_close_async (GFileEnumerator      *enumerator,
                                      GAsyncReadyCallback   callback,
                                      gpointer              user_data)
 {
-  GSimpleAsyncResult *res;
+  GTask *task;
 
-  res = g_simple_async_result_new (G_OBJECT (enumerator), callback, user_data,
-                                  g_daemon_file_enumerator_close_async);
-  simple_async_result_set_cancellable (res, cancellable);
-  g_simple_async_result_complete_in_idle (res);
-  g_object_unref (res);
+  task = g_task_new (enumerator, cancellable, callback, user_data);
+  g_task_return_boolean (task, TRUE);
+  g_object_unref (task);
 }
 
 static gboolean
@@ -676,17 +640,7 @@ g_daemon_file_enumerator_close_finish (GFileEnumerator      *enumerator,
                                       GAsyncResult         *result,
                                       GError              **error)
 {
-  GCancellable *cancellable;
-  
-  cancellable = simple_async_result_get_cancellable (G_SIMPLE_ASYNC_RESULT (result));
-  if (g_cancellable_is_cancelled (cancellable))
-    {
-      g_set_error (error,
-                   G_IO_ERROR,
-                   G_IO_ERROR_CANCELLED,
-                   "%s", _("Operation was cancelled"));
-      return FALSE;
-    }
+  g_return_val_if_fail (g_task_is_valid (result, enumerator), FALSE);
 
-  return TRUE;
+  return g_task_propagate_boolean (G_TASK (result), error);
 }