From 1ea98ce63ec43236c7da96ffb613127a8cf8910c Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>

Date: Mon, 4 Jun 2018 19:11:25 +0200

Subject: [PATCH 12/15] libgdm: use g_autoptr to manage objects lifecycle

Using auto pointers allows to manage things in a cleaner way without having

to manually unref things before returning.

---

 libgdm/gdm-client.c | 264 +++++++++++++++++++-------------------------

 1 file changed, 111 insertions(+), 153 deletions(-)

diff --git a/libgdm/gdm-client.c b/libgdm/gdm-client.c

index 28cb72536..f9e3faee2 100644

--- a/libgdm/gdm-client.c

+++ b/libgdm/gdm-client.c

@@ -67,102 +67,97 @@ gdm_client_error_quark (void)

                 error_quark = g_quark_from_static_string ("gdm-client");

         return error_quark;

 }

 static GDBusConnection *

 gdm_client_get_open_connection (GdmClient *client)

 {

         GDBusProxy *proxy = NULL;

         if (client->priv->user_verifier != NULL) {

                 proxy = G_DBUS_PROXY (client->priv->user_verifier);

         } else if (client->priv->greeter != NULL) {

                 proxy = G_DBUS_PROXY (client->priv->greeter);

         } else if (client->priv->remote_greeter != NULL) {

                 proxy = G_DBUS_PROXY (client->priv->remote_greeter);

         } else if (client->priv->chooser != NULL) {

                 proxy = G_DBUS_PROXY (client->priv->chooser);

         }

         if (proxy != NULL) {

                 return g_dbus_proxy_get_connection (proxy);

         }

         return NULL;

 }

 static void

 on_got_manager (GObject             *object,

                 GAsyncResult        *result,

-                GTask               *task)

+                gpointer             user_data)

 {

-        GdmClient *client;

-        GError    *error;

+        g_autoptr(GTask)      task = user_data;

+        g_autoptr(GdmClient)  client = NULL;

         g_autoptr(GdmManager) manager = NULL;

+        g_autoptr(GError)     error = NULL;

         client = GDM_CLIENT (g_async_result_get_source_object (G_ASYNC_RESULT (task)));

-

-        error = NULL;

         manager = gdm_manager_proxy_new_finish (result, &error);

         if (error != NULL) {

-                g_task_return_error (task, error);

+                g_task_return_error (task, g_steal_pointer (&error));

         } else {

                 g_task_return_pointer (task,

-                                       g_object_ref (manager),

+                                       g_steal_pointer (&manager),

                                        (GDestroyNotify) g_object_unref);

         }

-

-        g_object_unref (task);

-        g_object_unref (client);

 }

 static void

 get_manager (GdmClient           *client,

              GCancellable        *cancellable,

              GAsyncReadyCallback  callback,

              gpointer             user_data)

 {

         GTask *task;

         task = g_task_new (G_OBJECT (client),

                            cancellable,

                            callback,

                            user_data);

         gdm_manager_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,

                                        G_DBUS_PROXY_FLAGS_NONE,

                                        "org.gnome.DisplayManager",

                                        "/org/gnome/DisplayManager/Manager",

                                        cancellable,

-                                       (GAsyncReadyCallback)

                                        on_got_manager,

                                        task);

 }

 typedef struct {

         GTask           *task;

         GdmUserVerifier *user_verifier;

 } UserVerifierData;

 static UserVerifierData *

 user_verifier_data_new (GTask *task, GdmUserVerifier *user_verifier)

 {

         UserVerifierData *data;

         data = g_slice_new (UserVerifierData);

         data->task = g_object_ref (task);

         data->user_verifier = g_object_ref (user_verifier);

         return data;

 }

 static void

 user_verifier_data_free (UserVerifierData *data)

 {

         g_object_unref (data->task);

         g_object_unref (data->user_verifier);

         g_slice_free (UserVerifierData, data);

 }

 static void

@@ -173,477 +168,455 @@ complete_user_verifier_proxy_operation (GdmClient          *client,

                                g_object_ref (data->user_verifier),

                                (GDestroyNotify) g_object_unref);

         user_verifier_data_free (data);

 }

 static void

 maybe_complete_user_verifier_proxy_operation (GdmClient          *client,

                                               UserVerifierData   *data)

 {

         GHashTableIter iter;

         gpointer key, value;

         if (client->priv->user_verifier_extensions != NULL) {

                 g_hash_table_iter_init (&iter, client->priv->user_verifier_extensions);

                 while (g_hash_table_iter_next (&iter, &key, &value)) {

                         if (value == NULL)

                                 return;

                 }

         }

         complete_user_verifier_proxy_operation (client, data);

 }

 static void

 on_user_verifier_choice_list_proxy_created (GObject            *source,

                                             GAsyncResult       *result,

                                             UserVerifierData   *data)

 {

         GdmClient                 *client;

         GdmUserVerifierChoiceList *choice_list;

-        GError                    *error = NULL;

+        g_autoptr(GError)          error = NULL;

         client = GDM_CLIENT (g_async_result_get_source_object (G_ASYNC_RESULT (data->task)));

         choice_list = gdm_user_verifier_choice_list_proxy_new_finish (result, &error);

         if (choice_list == NULL) {

                 g_debug ("Couldn't create UserVerifier ChoiceList proxy: %s", error->message);

-                g_clear_error (&error);

                 g_hash_table_remove (client->priv->user_verifier_extensions, gdm_user_verifier_choice_list_interface_info ()->name);

         } else {

                 g_hash_table_replace (client->priv->user_verifier_extensions, gdm_user_verifier_choice_list_interface_info ()->name, choice_list);

         }

         maybe_complete_user_verifier_proxy_operation (client, data);

 }

 static void

 on_user_verifier_extensions_enabled (GdmUserVerifier    *user_verifier,

                                      GAsyncResult       *result,

                                      UserVerifierData   *data)

 {

         GdmClient *client;

         GCancellable *cancellable;

         GDBusConnection *connection;

-        GError    *error = NULL;

+        g_autoptr(GError) error = NULL;

         size_t     i;

         client = GDM_CLIENT (g_async_result_get_source_object (G_ASYNC_RESULT (data->task)));

         cancellable = g_task_get_cancellable (data->task);

         gdm_user_verifier_call_enable_extensions_finish (user_verifier, result, &error);

         if (error != NULL) {

                 g_debug ("Couldn't enable user verifier extensions: %s",

                          error->message);

-                g_clear_error (&error);

                 complete_user_verifier_proxy_operation (client, data);

                 return;

         }

         connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (user_verifier));

         for (i = 0; client->priv->enabled_extensions[i] != NULL; i++) {

                 g_debug ("Enabled extensions[%lu] = %s", i, client->priv->enabled_extensions[i]);

                 g_hash_table_insert (client->priv->user_verifier_extensions, client->priv->enabled_extensions[i], NULL);

                 if (strcmp (client->priv->enabled_extensions[i],

                             gdm_user_verifier_choice_list_interface_info ()->name) == 0) {

                         g_hash_table_insert (client->priv->user_verifier_extensions, client->priv->enabled_extensions[i], NULL);

                         gdm_user_verifier_choice_list_proxy_new (connection,

                                                                  G_DBUS_PROXY_FLAGS_NONE,

                                                                  NULL,

                                                                  SESSION_DBUS_PATH,

                                                                  cancellable,

                                                                  (GAsyncReadyCallback)

                                                                  on_user_verifier_choice_list_proxy_created,

                                                                  data);

                 } else {

                         g_debug ("User verifier extension %s is unsupported", client->priv->enabled_extensions[i]);

                         g_hash_table_remove (client->priv->user_verifier_extensions,

                                              client->priv->enabled_extensions[i]);

                 }

         }

         if (g_hash_table_size (client->priv->user_verifier_extensions) == 0) {

                 g_debug ("No supported user verifier extensions");

                 complete_user_verifier_proxy_operation (client, data);

         }

 }

 static void

 free_interface_skeleton (GDBusInterfaceSkeleton *interface)

 {

         if (interface == NULL)

                 return;

         g_object_unref (interface);

 }

 static void

 on_user_verifier_proxy_created (GObject            *source,

                                 GAsyncResult       *result,

-                                GTask              *task)

+                                gpointer            user_data)

 {

         GdmClient       *self;

-        GdmUserVerifier *user_verifier;

         GCancellable    *cancellable = NULL;

-        GError          *error = NULL;

+        g_autoptr(GdmUserVerifier) user_verifier = NULL;

+        g_autoptr(GTask)           task = user_data;

+        g_autoptr(GError)          error = NULL;

         user_verifier = gdm_user_verifier_proxy_new_finish (result, &error);

         if (user_verifier == NULL) {

-                g_task_return_error (task, error);

-                g_object_unref (task);

+                g_task_return_error (task, g_steal_pointer (&error));

                 return;

         }

         g_debug ("UserVerifier %p created", user_verifier);

         self = GDM_CLIENT (g_async_result_get_source_object (G_ASYNC_RESULT (task)));

         if (self->priv->enabled_extensions == NULL) {

                 g_debug ("no enabled extensions");

                 g_task_return_pointer (task,

-                                       user_verifier,

+                                       g_steal_pointer (&user_verifier),

                                        (GDestroyNotify) g_object_unref);

-                g_object_unref (task);

                 return;

         }

         self->priv->user_verifier_extensions = g_hash_table_new_full (g_str_hash,

                                                                       g_str_equal,

                                                                       NULL,

                                                                       (GDestroyNotify)

                                                                       free_interface_skeleton);

         cancellable = g_task_get_cancellable (task);

         gdm_user_verifier_call_enable_extensions (user_verifier,

                                                   (const char * const *)

                                                   self->priv->enabled_extensions,

                                                   cancellable,

                                                   (GAsyncReadyCallback)

                                                   on_user_verifier_extensions_enabled,

                                                   user_verifier_data_new (task, user_verifier));

-        g_object_unref (user_verifier);

 }

 static void

 on_reauthentication_channel_connected (GObject            *source_object,

                                        GAsyncResult       *result,

-                                       GTask              *task)

+                                       gpointer            user_data)

 {

-        GDBusConnection *connection;

         GCancellable *cancellable;

-        GError       *error;

+        g_autoptr(GTask)           task = user_data;

+        g_autoptr(GDBusConnection) connection = NULL;

+        g_autoptr(GError)          error = NULL;

-        error = NULL;

         connection = g_dbus_connection_new_for_address_finish (result, &error);

         if (!connection) {

-                g_task_return_error (task, error);

-                g_object_unref (task);

+                g_task_return_error (task, g_steal_pointer (&error));

                 return;

         }

         cancellable = g_task_get_cancellable (task);

         gdm_user_verifier_proxy_new (connection,

                                      G_DBUS_PROXY_FLAGS_NONE,

                                      NULL,

                                      SESSION_DBUS_PATH,

                                      cancellable,

-                                     (GAsyncReadyCallback)

                                      on_user_verifier_proxy_created,

-                                     task);

-        g_object_unref (connection);

+                                     g_steal_pointer (&task));

 }

 static void

 on_reauthentication_channel_opened (GdmManager         *manager,

                                     GAsyncResult       *result,

-                                    GTask              *task)

+                                    gpointer            user_data)

 {

         GCancellable *cancellable;

-        char         *address;

-        GError       *error;

+        g_autoptr(GTask)  task = user_data;

+        g_autoptr(GError) error = NULL;

+        g_autofree char  *address = NULL;

-        error = NULL;

         if (!gdm_manager_call_open_reauthentication_channel_finish (manager,

                                                                     &address,

                                                                     result,

                                                                     &error)) {

-                g_task_return_error (task, error);

-                g_object_unref (task);

+                g_task_return_error (task, g_steal_pointer (&error));

                 return;

         }

         cancellable = g_task_get_cancellable (task);

         g_dbus_connection_new_for_address (address,

                                            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,

                                            NULL,

                                            cancellable,

-                                           (GAsyncReadyCallback)

                                            on_reauthentication_channel_connected,

-                                           task);

+                                           g_steal_pointer (&task));

 }

 static void

 on_got_manager_for_reauthentication (GdmClient           *client,

                                      GAsyncResult        *result,

-                                     GTask               *task)

+                                     gpointer             user_data)

 {

         GCancellable *cancellable;

-        GdmManager   *manager;

-        char         *username;

-        GError       *error;

+        const char   *username;

+        g_autoptr(GTask)      task = user_data;

+        g_autoptr(GdmManager) manager = NULL;

+        g_autoptr(GError)     error = NULL;

-        error = NULL;

         manager = g_task_propagate_pointer (G_TASK (result), &error);

         if (manager == NULL) {

-                g_task_return_error (task, error);

-                g_object_unref (task);

+                g_task_return_error (task, g_steal_pointer (&error));

                 return;

         }

         cancellable = g_task_get_cancellable (task);

         username = g_object_get_data (G_OBJECT (task), "username");

         gdm_manager_call_open_reauthentication_channel (manager,

                                                         username,

                                                         cancellable,

                                                         (GAsyncReadyCallback)

                                                         on_reauthentication_channel_opened,

-                                                        task);

-        g_object_unref (manager);

+                                                        g_steal_pointer (&task));

 }

 static GDBusConnection *

 gdm_client_get_connection_sync (GdmClient      *client,

                                 GCancellable   *cancellable,

                                 GError        **error)

 {

         g_autoptr(GdmManager) manager = NULL;

         g_autofree char *address = NULL;

         GDBusConnection *connection;

         gboolean ret;

         g_return_val_if_fail (GDM_IS_CLIENT (client), NULL);

         connection = gdm_client_get_open_connection (client);

         if (connection != NULL) {

                 return g_object_ref (connection);

         }

         manager = gdm_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,

                                                       G_DBUS_PROXY_FLAGS_NONE,

                                                       "org.gnome.DisplayManager",

                                                       "/org/gnome/DisplayManager/Manager",

                                                       cancellable,

                                                       error);

         if (manager == NULL) {

                 return NULL;

         }

         ret = gdm_manager_call_open_session_sync (manager,

                                                   &address,

                                                   cancellable,

                                                   error);

         if (!ret) {

                 return NULL;

         }

         g_debug ("GdmClient: connecting to address: %s", address);

         connection = g_dbus_connection_new_for_address_sync (address,

                                                              G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,

                                                              NULL,

                                                              cancellable,

                                                              error);

         return connection;

 }

 static void

 on_connected (GObject            *source_object,

               GAsyncResult       *result,

-              GTask              *task)

+              gpointer            user_data)

 {

-        GDBusConnection *connection;

-        GError *error;

+        g_autoptr(GTask)           task = user_data;

+        g_autoptr(GDBusConnection) connection = NULL;

+        g_autoptr(GError)          error = NULL;

-        error = NULL;

         connection = g_dbus_connection_new_for_address_finish (result, &error);

         if (!connection) {

-                g_task_return_error (task, error);

-                g_object_unref (task);

+                g_task_return_error (task, g_steal_pointer (&error));

                 return;

         }

         g_task_return_pointer (task,

-                               g_object_ref (connection),

+                               g_steal_pointer (&connection),

                                (GDestroyNotify) g_object_unref);

-        g_object_unref (task);

-        g_object_unref (connection);

 }

 static void

 on_session_opened (GdmManager         *manager,

                    GAsyncResult       *result,

-                   GTask              *task)

+                   gpointer            user_data)

 {

-        GdmClient *client;

-        g_autofree char  *address = NULL;

         GCancellable     *cancellable;

-        GError           *error;

+        g_autoptr(GTask)     task = user_data;

+        g_autoptr(GdmClient) client = NULL;

+        g_autoptr(GError)    error = NULL;

+        g_autofree char     *address = NULL;

         client = GDM_CLIENT (g_async_result_get_source_object (G_ASYNC_RESULT (task)));

-        error = NULL;

         if (!gdm_manager_call_open_session_finish (manager,

                                                    &address,

                                                    result,

                                                    &error)) {

-                g_task_return_error (task, error);

-                g_object_unref (task);

-                g_object_unref (client);

+                g_task_return_error (task, g_steal_pointer (&error));

                 return;

         }

         cancellable = g_task_get_cancellable (task);

         g_dbus_connection_new_for_address (address,

                                            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,

                                            NULL,

                                            cancellable,

-                                           (GAsyncReadyCallback)

                                            on_connected,

-                                           task);

-        g_object_unref (client);

+                                           g_steal_pointer (&task));

 }

 static void

 on_got_manager_for_opening_connection (GdmClient           *client,

                                        GAsyncResult        *result,

-                                       GTask               *task)

+                                       gpointer             user_data)

 {

         GCancellable *cancellable;

-        GdmManager   *manager;

-        GError       *error;

+        g_autoptr(GTask)      task = user_data;

+        g_autoptr(GdmManager) manager = NULL;

+        g_autoptr(GError)     error = NULL;

-        error = NULL;

         manager = g_task_propagate_pointer (G_TASK (result), &error);

         if (manager == NULL) {

-                g_task_return_error (task, error);

-                g_object_unref (task);

+                g_task_return_error (task, g_steal_pointer (&error));

                 return;

         }

         cancellable = g_task_get_cancellable (task);

         gdm_manager_call_open_session (manager,

                                        cancellable,

                                        (GAsyncReadyCallback)

                                        on_session_opened,

-                                       task);

-

-        g_object_unref (manager);

+                                       g_steal_pointer (&task));

 }

 static GDBusConnection *

 gdm_client_get_connection_finish (GdmClient      *client,

                                   GAsyncResult   *result,

                                   GError        **error)

 {

         GDBusConnection *connection;

         g_return_val_if_fail (GDM_IS_CLIENT (client), NULL);

         connection = g_task_propagate_pointer (G_TASK (result), error);

         if (connection == NULL) {

                 return NULL;

         }

         return connection;

 }

 static void

 gdm_client_get_connection (GdmClient           *client,

                             GCancellable        *cancellable,

                             GAsyncReadyCallback  callback,

                             gpointer             user_data)

 {

-        GTask *task;

+        g_autoptr(GTask) task = NULL;

         GDBusConnection *connection;

         g_return_if_fail (GDM_IS_CLIENT (client));

         task = g_task_new (G_OBJECT (client),

                            cancellable,

                            callback,

                            user_data);

         connection = gdm_client_get_open_connection (client);

         if (connection != NULL) {

             g_task_return_pointer (task,

                                    g_object_ref (connection),

                                    (GDestroyNotify) g_object_unref);

-            g_object_unref (task);

             return;

         }

         get_manager (client,

                      cancellable,

                      (GAsyncReadyCallback)

                      on_got_manager_for_opening_connection,

-                     task);

+                     g_steal_pointer (&task));

 }

 /**

  * gdm_client_open_reauthentication_channel_sync:

  * @client: a #GdmClient

  * @username: user to reauthenticate

  * @cancellable: a #GCancellable

  * @error: a #GError

  *

  * Gets a #GdmUserVerifier object that can be used to

  * reauthenticate an already logged in user. Free with

  * g_object_unref to close reauthentication channel.

  *

  * Returns: (transfer full): #GdmUserVerifier or %NULL if @username is not

  * already logged in.

  */

 GdmUserVerifier *

 gdm_client_open_reauthentication_channel_sync (GdmClient     *client,

                                                const char    *username,

                                                GCancellable  *cancellable,

                                                GError       **error)

 {

         g_autoptr(GDBusConnection) connection = NULL;

-        g_autoptr(GdmManager) manager = NULL;

+        g_autoptr(GdmManager)      manager = NULL;

         g_autofree char *address = NULL;

         GdmUserVerifier *user_verifier = NULL;

         gboolean         ret;

         g_return_val_if_fail (GDM_IS_CLIENT (client), NULL);

         manager = gdm_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,

                                                       G_DBUS_PROXY_FLAGS_NONE,

                                                       "org.gnome.DisplayManager",

                                                       "/org/gnome/DisplayManager/Manager",

                                                       cancellable,

                                                       error);

         if (manager == NULL) {

                 return NULL;

         }

         ret = gdm_manager_call_open_reauthentication_channel_sync (manager,

                                                                    username,

                                                                    &address,

                                                                    cancellable,

                                                                    error);

         if (!ret) {

                 return NULL;

         }

         g_debug ("GdmClient: connecting to address: %s", address);

         connection = g_dbus_connection_new_for_address_sync (address,

@@ -779,124 +752,120 @@ gdm_client_get_user_verifier_sync (GdmClient     *client,

                                                                              client->priv->enabled_extensions,

                                                                              cancellable,

                                                                              NULL);

                         if (res) {

                                 size_t i;

                                 for (i = 0; client->priv->enabled_extensions[i] != NULL; i++) {

                                             if (strcmp (client->priv->enabled_extensions[i],

                                                         gdm_user_verifier_choice_list_interface_info ()->name) == 0) {

                                                         GdmUserVerifierChoiceList *choice_list_interface;

                                                         choice_list_interface = gdm_user_verifier_choice_list_proxy_new_sync (connection,

                                                                                                                               G_DBUS_PROXY_FLAGS_NONE,

                                                                                                                               NULL,

                                                                                                                               SESSION_DBUS_PATH,

                                                                                                                               cancellable,

                                                                                                                               NULL);

                                                         if (choice_list_interface != NULL)

                                                                     g_hash_table_insert (client->priv->user_verifier_extensions, client->priv->enabled_extensions[i], choice_list_interface);

                                             }

                                 }

                         }

                 }

         }

         return client->priv->user_verifier;

 }

 static void

 on_connection_for_user_verifier (GdmClient          *client,

                                  GAsyncResult       *result,

-                                 GTask              *task)

+                                 gpointer            user_data)

 {

-        g_autoptr(GDBusConnection) connection = NULL;

         GCancellable *cancellable;

-        GError       *error;

+        g_autoptr(GTask)           task = user_data;

+        g_autoptr(GDBusConnection) connection = NULL;

+        g_autoptr(GError)          error = NULL;

-        error = NULL;

         connection = gdm_client_get_connection_finish (client, result, &error);

-

         if (connection == NULL) {

-                g_task_return_error (task, error);

-                g_object_unref (task);

+                g_task_return_error (task, g_steal_pointer (&error));

                 return;

         }

         cancellable = g_task_get_cancellable (task);

         gdm_user_verifier_proxy_new (connection,

                                      G_DBUS_PROXY_FLAGS_NONE,

                                      NULL,

                                      SESSION_DBUS_PATH,

                                      cancellable,

-                                     (GAsyncReadyCallback)

                                      on_user_verifier_proxy_created,

-                                     task);

+                                     g_steal_pointer (&task));

 }

 /**

  * gdm_client_get_user_verifier:

  * @client: a #GdmClient

  * @callback: a #GAsyncReadyCallback to call when the request is satisfied

  * @user_data: The data to pass to @callback