From ee771715164b157d5dbe368a7771d0018a47a27c Mon Sep 17 00:00:00 2001

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

Date: Mon, 14 May 2018 16:32:25 -0400

Subject: [PATCH 03/15] libgdm: get connection explicitly

At the moment we call gdm_client_open_connection and when it finishes,

assume client->priv->connection is implicitly initialized.

This commit makes the operation more explicit by changing

gdm_client_open_connection to gdm_client_get_connection and returning

the GDBusConnection object directly, instead of returning a boolean.

https://bugzilla.gnome.org/show_bug.cgi?id=795940

---

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

 1 file changed, 82 insertions(+), 54 deletions(-)

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

index e02e3ea57..e7b93e382 100644

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

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

@@ -366,114 +366,113 @@ on_reauthentication_channel_opened (GdmManager         *manager,

 static void

 on_got_manager_for_reauthentication (GdmClient           *client,

                                      GAsyncResult        *result,

                                      GTask               *task)

 {

         GCancellable *cancellable;

         GdmManager   *manager;

         char         *username;

         GError       *error;

         error = NULL;

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

         if (manager == NULL) {

                 g_task_return_error (task, error);

                 g_object_unref (task);

                 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);

 }

-static gboolean

-gdm_client_open_connection_sync (GdmClient      *client,

-                                 GCancellable   *cancellable,

-                                 GError        **error)

+static GDBusConnection *

+gdm_client_get_connection_sync (GdmClient      *client,

+                                GCancellable   *cancellable,

+                                GError        **error)

 {

         g_autoptr(GdmManager) manager = NULL;

         gboolean ret;

         g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);

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

-                g_object_ref (client->priv->connection);

-                return TRUE;

+                return g_object_ref (client->priv->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) {

                 goto out;

         }

         ret = gdm_manager_call_open_session_sync (manager,

                                                   &client->priv->address,

                                                   cancellable,

                                                   error);

         if (!ret) {

                 goto out;

         }

         g_debug ("GdmClient: connecting to address: %s", client->priv->address);

         client->priv->connection = g_dbus_connection_new_for_address_sync (client->priv->address,

                                                                            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,

                                                                            NULL,

                                                                            cancellable,

                                                                            error);

         if (client->priv->connection == NULL) {

                 g_clear_pointer (&client->priv->address, g_free);

                 goto out;

         }

         g_object_add_weak_pointer (G_OBJECT (client->priv->connection),

                                    (gpointer *)

                                    &client->priv->connection);

  out:

-        return client->priv->connection != NULL;

+        return client->priv->connection;

 }

 static void

 on_connected (GObject            *source_object,

               GAsyncResult       *result,

               GTask              *task)

 {

         GDBusConnection *connection;

         GError *error;

         error = NULL;

         connection = g_dbus_connection_new_for_address_finish (result, &error);

         if (!connection) {

                 g_task_return_error (task, error);

                 g_object_unref (task);

                 return;

         }

         g_task_return_pointer (task,

                                g_object_ref (connection),

                                (GDestroyNotify) g_object_unref);

         g_object_unref (task);

         g_object_unref (connection);

 }

 static void

 on_session_opened (GdmManager         *manager,

                    GAsyncResult       *result,

                    GTask              *task)

 {

@@ -503,87 +502,85 @@ on_session_opened (GdmManager         *manager,

                                            on_connected,

                                            task);

         g_object_unref (client);

 }

 static void

 on_got_manager_for_opening_connection (GdmClient           *client,

                                        GAsyncResult        *result,

                                        GTask               *task)

 {

         GCancellable *cancellable;

         GdmManager   *manager;

         GError       *error;

         error = NULL;

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

         if (manager == NULL) {

                 g_task_return_error (task, error);

                 g_object_unref (task);

                 return;

         }

         cancellable = g_task_get_cancellable (task);

         gdm_manager_call_open_session (manager,

                                        cancellable,

                                        (GAsyncReadyCallback)

                                        on_session_opened,

                                        task);

 }

-static gboolean

-gdm_client_open_connection_finish (GdmClient      *client,

-                                   GAsyncResult   *result,

-                                   GError        **error)

+static GDBusConnection *

+gdm_client_get_connection_finish (GdmClient      *client,

+                                  GAsyncResult   *result,

+                                  GError        **error)

 {

-        g_autoptr(GDBusConnection) connection = NULL;

+        GDBusConnection *connection = NULL;

         g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);

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

         if (connection == NULL) {

-                return FALSE;

+                return NULL;

         }

         if (client->priv->connection == NULL) {

-                client->priv->connection = g_steal_pointer (&connection);

+                client->priv->connection = connection;

                 g_object_add_weak_pointer (G_OBJECT (client->priv->connection),

                                            (gpointer *) &client->priv->connection);

-        } else if (client->priv->connection == connection) {

-                connection = NULL;

         }

-        return TRUE;

+        return g_object_ref (connection);

 }

 static void

-gdm_client_open_connection (GdmClient           *client,

+gdm_client_get_connection (GdmClient           *client,

                             GCancellable        *cancellable,

                             GAsyncReadyCallback  callback,

                             gpointer             user_data)

 {

         GTask *task;

         g_return_if_fail (GDM_IS_CLIENT (client));

         task = g_task_new (G_OBJECT (client),

                            cancellable,

                            callback,

                            user_data);

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

             g_task_return_pointer (task,

                                    g_object_ref (client->priv->connection),

                                    (GDestroyNotify) g_object_unref);

             g_object_unref (task);

             return;

         }

         get_manager (client,

                      cancellable,

                      (GAsyncReadyCallback)

                      on_got_manager_for_opening_connection,

                      task);

 }

 /**

  * gdm_client_open_reauthentication_channel_sync:

@@ -716,184 +713,192 @@ gdm_client_open_reauthentication_channel (GdmClient           *client,

  * gdm_client_open_reauthentication_channel().

  *

  * Returns: (transfer full):  a #GdmUserVerifier

  */

 GdmUserVerifier *

 gdm_client_open_reauthentication_channel_finish (GdmClient       *client,

                                                  GAsyncResult    *result,

                                                  GError         **error)

 {

         g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);

         return g_task_propagate_pointer (G_TASK (result), error);

 }

 /**

  * gdm_client_get_user_verifier_sync:

  * @client: a #GdmClient

  * @cancellable: a #GCancellable

  * @error: a #GError

  *

  * Gets a #GdmUserVerifier object that can be used to

  * verify a user's local account.

  *

  * Returns: (transfer full): #GdmUserVerifier or %NULL if not connected

  */

 GdmUserVerifier *

 gdm_client_get_user_verifier_sync (GdmClient     *client,

                                    GCancellable  *cancellable,

                                    GError       **error)

 {

+        g_autoptr(GDBusConnection) connection = NULL;

+

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

                 return g_object_ref (client->priv->user_verifier);

         }

-        if (!gdm_client_open_connection_sync (client, cancellable, error)) {

+        connection = gdm_client_get_connection_sync (client, cancellable, error);

+

+        if (connection == NULL) {

                 return NULL;

         }

-        client->priv->user_verifier = gdm_user_verifier_proxy_new_sync (client->priv->connection,

+        client->priv->user_verifier = gdm_user_verifier_proxy_new_sync (connection,

                                                                         G_DBUS_PROXY_FLAGS_NONE,

                                                                         NULL,

                                                                         SESSION_DBUS_PATH,

                                                                         cancellable,

                                                                         error);

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

                 g_object_add_weak_pointer (G_OBJECT (client->priv->user_verifier),

                                            (gpointer *)

                                            &client->priv->user_verifier);

+                g_object_ref (connection);

                 g_object_weak_ref (G_OBJECT (client->priv->user_verifier),

                                    (GWeakNotify)

                                    g_object_unref,

                                    client->priv->connection);

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

                         gboolean res;

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

                                                                                         g_str_equal,

                                                                                         NULL,

                                                                                         (GDestroyNotify)

                                                                                         free_interface_skeleton);

                         res = gdm_user_verifier_call_enable_extensions_sync (client->priv->user_verifier,

                                                                             (const char * const *)

                                                                              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 (client->priv->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_opened_for_user_verifier (GdmClient          *client,

-                                        GAsyncResult       *result,

-                                        GTask              *task)

+on_connection_for_user_verifier (GdmClient          *client,

+                                 GAsyncResult       *result,

+                                 GTask              *task)

 {

+        g_autoptr(GDBusConnection) connection = NULL;

         GCancellable *cancellable;

         GError       *error;

         error = NULL;

-        if (!gdm_client_open_connection_finish (client, result, &error)) {

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

+

+        if (connection == NULL) {

                 g_task_return_error (task, error);

                 g_object_unref (task);

                 return;

         }

         cancellable = g_task_get_cancellable (task);

-        gdm_user_verifier_proxy_new (client->priv->connection,

+        gdm_user_verifier_proxy_new (connection,

                                      G_DBUS_PROXY_FLAGS_NONE,

                                      NULL,

                                      SESSION_DBUS_PATH,

                                      cancellable,

                                      (GAsyncReadyCallback)

                                      on_user_verifier_proxy_created,

                                      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

  * @cancellable: a #GCancellable

  *

  * Gets a #GdmUserVerifier object that can be used to

  * verify a user's local account.

  */

 void

 gdm_client_get_user_verifier (GdmClient           *client,

                               GCancellable        *cancellable,

                               GAsyncReadyCallback  callback,

                               gpointer             user_data)

 {

         GTask *task;

         g_return_if_fail (GDM_IS_CLIENT (client));

         task = g_task_new (G_OBJECT (client),

                            cancellable,

                            callback,

                            user_data);

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

                 g_task_return_pointer (task,

                                        g_object_ref (client->priv->user_verifier),

                                        (GDestroyNotify) g_object_unref);

                 g_object_unref (task);

                 return;

         }

-        gdm_client_open_connection (client,

+        gdm_client_get_connection (client,

                                     cancellable,

                                     (GAsyncReadyCallback)

-                                    on_connection_opened_for_user_verifier,

+                                    on_connection_for_user_verifier,

                                     task);

 }

 /**

  * gdm_client_get_user_verifier_finish:

  * @client: a #GdmClient

  * @result: The #GAsyncResult from the callback

  * @error: a #GError

  *

  * Finishes an operation started with

  * gdm_client_get_user_verifier().

  *

  * Returns: (transfer full): a #GdmUserVerifier

  */

 GdmUserVerifier *

 gdm_client_get_user_verifier_finish (GdmClient       *client,

                                      GAsyncResult    *result,

                                      GError         **error)

 {

         GdmUserVerifier *user_verifier;

         g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);

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

                 return g_object_ref (client->priv->user_verifier);

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

         if (user_verifier == NULL)

                 return NULL;

@@ -948,122 +953,125 @@ query_for_timed_login_requested_signal (GdmGreeter *greeter)

                                                   NULL,

                                                   (GAsyncReadyCallback)

                                                   on_timed_login_details_got,

                                                   NULL);

 }

 static void

 on_greeter_proxy_created (GObject            *source,

                           GAsyncResult       *result,

                           GTask              *task)

 {

         GdmGreeter   *greeter;

         GError       *error = NULL;

         greeter = gdm_greeter_proxy_new_finish (result, &error);

         if (greeter == NULL) {

                 g_task_return_error (task, error);

                 g_object_unref (task);

                 return;

         }

         g_task_return_pointer (task,

                                greeter,

                                (GDestroyNotify) g_object_unref);

         g_object_unref (task);

         query_for_timed_login_requested_signal (greeter);

 }

 static void

-on_connection_opened_for_greeter (GdmClient          *client,

-                                  GAsyncResult       *result,

-                                  GTask              *task)

+on_connection_for_greeter (GdmClient          *client,

+                           GAsyncResult       *result,

+                           GTask              *task)

 {

+        g_autoptr(GDBusConnection) connection = NULL;

         GCancellable *cancellable;

         GError       *error;

         error = NULL;

-        if (!gdm_client_open_connection_finish (client, result, &error)) {

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

+

+        if (connection == NULL) {

                 g_task_return_error (task, error);

                 g_object_unref (task);

                 return;

         }

         cancellable = g_task_get_cancellable (task);

-        gdm_greeter_proxy_new (client->priv->connection,

+        gdm_greeter_proxy_new (connection,

                                G_DBUS_PROXY_FLAGS_NONE,

                                NULL,

                                SESSION_DBUS_PATH,

                                cancellable,

                                (GAsyncReadyCallback)

                                on_greeter_proxy_created,

                                task);

 }

 /**

  * gdm_client_get_greeter:

  * @client: a #GdmClient

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

  * @user_data: The data to pass to @callback

  * @cancellable: a #GCancellable

  *

  * Gets a #GdmGreeter object that can be used to

  * verify a user's local account.

  */

 void

 gdm_client_get_greeter (GdmClient           *client,

                         GCancellable        *cancellable,

                         GAsyncReadyCallback  callback,

                         gpointer             user_data)

 {

         GTask *task;

         g_return_if_fail (GDM_IS_CLIENT (client));

         task = g_task_new (G_OBJECT (client),

                            cancellable,

                            callback,

                            user_data);

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

                 g_task_return_pointer (task,

                                        g_object_ref (client->priv->greeter),

                                        (GDestroyNotify) g_object_unref);

                 g_object_unref (task);

                 return;

         }

-        gdm_client_open_connection (client,

+        gdm_client_get_connection (client,

                                     cancellable,

                                     (GAsyncReadyCallback)

-                                    on_connection_opened_for_greeter,

+                                    on_connection_for_greeter,

                                     task);

 }

 /**

  * gdm_client_get_greeter_finish:

  * @client: a #GdmClient

  * @result: The #GAsyncResult from the callback

  * @error: a #GError

  *

  * Finishes an operation started with

  * gdm_client_get_greeter().

  *

  * Returns: (transfer full): a #GdmGreeter

  */

 GdmGreeter *

 gdm_client_get_greeter_finish (GdmClient       *client,

                                GAsyncResult    *result,

                                GError         **error)

 {

         GdmGreeter *greeter;

         g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);

         if (client->priv->greeter != NULL)

                 return g_object_ref (client->priv->greeter);

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

         if (greeter == NULL)

                 return NULL;

@@ -1071,174 +1079,181 @@ gdm_client_get_greeter_finish (GdmClient       *client,

         g_object_add_weak_pointer (G_OBJECT (client->priv->greeter),

                                    (gpointer *)

                                    &client->priv->greeter);

         g_object_weak_ref (G_OBJECT (client->priv->greeter),

                            (GWeakNotify)

                            g_object_unref,

                            client->priv->connection);

         return greeter;

 }

 /**

  * gdm_client_get_greeter_sync:

  * @client: a #GdmClient

  * @cancellable: a #GCancellable

  * @error: a #GError

  *

  * Gets a #GdmGreeter object that can be used

  * to do do various login screen related tasks, such

  * as selecting a users session, and starting that

  * session.

  *

  * Returns: (transfer full): #GdmGreeter or %NULL if caller is not a greeter

  */

 GdmGreeter *

 gdm_client_get_greeter_sync (GdmClient     *client,

                              GCancellable  *cancellable,

                              GError       **error)

 {

+        g_autoptr(GDBusConnection) connection = NULL;

+

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

                 return g_object_ref (client->priv->greeter);

         }

-        if (!gdm_client_open_connection_sync (client, cancellable, error)) {

+        connection = gdm_client_get_connection_sync (client, cancellable, error);

+

+        if (connection == NULL) {

                 return NULL;

         }

-        client->priv->greeter = gdm_greeter_proxy_new_sync (client->priv->connection,

+        client->priv->greeter = gdm_greeter_proxy_new_sync (connection,

                                                             G_DBUS_PROXY_FLAGS_NONE,

                                                             NULL,

                                                             SESSION_DBUS_PATH,

                                                             cancellable,

                                                             error);

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

                 g_object_add_weak_pointer (G_OBJECT (client->priv->greeter),

                                            (gpointer *)

                                            &client->priv->greeter);

                 g_object_weak_ref (G_OBJECT (client->priv->greeter),

                                    (GWeakNotify)

                                    g_object_unref,

                                    client->priv->connection);

                 query_for_timed_login_requested_signal (client->priv->greeter);

         }

         return client->priv->greeter;

 }

 static void

 on_remote_greeter_proxy_created (GObject            *object,

                                  GAsyncResult       *result,

                                  GTask              *task)

 {

         GdmRemoteGreeter *remote_greeter;

         GError           *error = NULL;

         remote_greeter = gdm_remote_greeter_proxy_new_finish (result, &error);

         if (remote_greeter == NULL) {

                 g_task_return_error (task, error);

                 g_object_unref (task);

                 return;

         }

         g_task_return_pointer (task,

                                remote_greeter,

                                (GDestroyNotify) g_object_unref);

         g_object_unref (task);

 }

 static void

-on_connection_opened_for_remote_greeter (GdmClient          *client,

-                                         GAsyncResult       *result,

-                                         GTask              *task)

+on_connection_for_remote_greeter (GdmClient          *client,

+                                  GAsyncResult       *result,

+                                  GTask              *task)

 {

+        g_autoptr(GDBusConnection) connection = NULL;

         GCancellable *cancellable;

         GError       *error;

         error = NULL;

-        if (!gdm_client_open_connection_finish (client, result, &error)) {

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

+

+        if (connection == NULL) {

                 g_task_return_error (task, error);

                 g_object_unref (task);

                 return;

         }

         cancellable = g_task_get_cancellable (task);

-        gdm_remote_greeter_proxy_new (client->priv->connection,

+        gdm_remote_greeter_proxy_new (connection,

                                       G_DBUS_PROXY_FLAGS_NONE,

                                       NULL,

                                       SESSION_DBUS_PATH,

                                       cancellable,

                                       (GAsyncReadyCallback)

                                       on_remote_greeter_proxy_created,

                                       task);

 }

 /**

  * gdm_client_get_remote_greeter:

  * @client: a #GdmClient

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

  * @user_data: The data to pass to @callback

  * @cancellable: a #GCancellable

  *

  * Gets a #GdmRemoteGreeter object that can be used to

  * verify a user's local account.

  */

 void

 gdm_client_get_remote_greeter (GdmClient           *client,

                                GCancellable        *cancellable,

                                GAsyncReadyCallback  callback,

                                gpointer             user_data)

 {

         GTask *task;

         g_return_if_fail (GDM_IS_CLIENT (client));

         task = g_task_new (G_OBJECT (client),

                            cancellable,

                            callback,