From 1ea98ce63ec43236c7da96ffb613127a8cf8910c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= 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 * @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_autoptr(GTask) task = NULL; 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_get_connection (client, - cancellable, - (GAsyncReadyCallback) - on_connection_for_user_verifier, - task); + cancellable, + (GAsyncReadyCallback) + on_connection_for_user_verifier, + g_steal_pointer (&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), NULL); 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; client->priv->user_verifier = user_verifier; @@ -924,147 +893,143 @@ gdm_client_get_user_verifier_choice_list (GdmClient *client) if (client->priv->user_verifier_extensions == NULL) return NULL; return g_hash_table_lookup (client->priv->user_verifier_extensions, gdm_user_verifier_choice_list_interface_info ()->name); } static void on_timed_login_details_got (GdmGreeter *greeter, GAsyncResult *result) { gdm_greeter_call_get_timed_login_details_finish (greeter, NULL, NULL, NULL, result, NULL); } static void query_for_timed_login_requested_signal (GdmGreeter *greeter) { /* This just makes sure a timed-login-requested signal gets fired * off if appropriate. */ gdm_greeter_call_get_timed_login_details (greeter, NULL, (GAsyncReadyCallback) on_timed_login_details_got, NULL); } static void on_greeter_proxy_created (GObject *source, GAsyncResult *result, - GTask *task) + gpointer user_data) { + g_autoptr(GTask) task = user_data; + g_autoptr(GError) error = NULL; 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); + g_task_return_error (task, g_steal_pointer (&error)); 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_for_greeter (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_greeter_proxy_new (connection, G_DBUS_PROXY_FLAGS_NONE, NULL, SESSION_DBUS_PATH, cancellable, - (GAsyncReadyCallback) on_greeter_proxy_created, - task); + g_steal_pointer (&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_autoptr(GTask) task = NULL; 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_get_connection (client, - cancellable, - (GAsyncReadyCallback) - on_connection_for_greeter, - task); + cancellable, + (GAsyncReadyCallback) + on_connection_for_greeter, + g_steal_pointer (&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), NULL); 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; client->priv->greeter = greeter; @@ -1100,145 +1065,141 @@ gdm_client_get_greeter_sync (GdmClient *client, return g_object_ref (client->priv->greeter); } connection = gdm_client_get_connection_sync (client, cancellable, error); if (connection == NULL) { return NULL; } 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); 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) + gpointer user_data) { + g_autoptr(GTask) task = user_data; + g_autoptr(GError) error = NULL; 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); + g_task_return_error (task, g_steal_pointer (&error)); return; } g_task_return_pointer (task, remote_greeter, (GDestroyNotify) g_object_unref); - g_object_unref (task); } static void on_connection_for_remote_greeter (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_remote_greeter_proxy_new (connection, G_DBUS_PROXY_FLAGS_NONE, NULL, SESSION_DBUS_PATH, cancellable, - (GAsyncReadyCallback) on_remote_greeter_proxy_created, - task); + g_steal_pointer (&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_autoptr (GTask) task = NULL; g_return_if_fail (GDM_IS_CLIENT (client)); task = g_task_new (G_OBJECT (client), cancellable, callback, user_data); if (client->priv->remote_greeter != NULL) { g_task_return_pointer (task, g_object_ref (client->priv->remote_greeter), (GDestroyNotify) g_object_unref); - g_object_unref (task); return; } gdm_client_get_connection (client, - cancellable, - (GAsyncReadyCallback) - on_connection_for_remote_greeter, - task); + cancellable, + (GAsyncReadyCallback) + on_connection_for_remote_greeter, + g_steal_pointer (&task)); } /** * gdm_client_get_remote_greeter_finish: * @client: a #GdmClient * @result: The #GAsyncResult from the callback * @error: a #GError * * Finishes an operation started with * gdm_client_get_remote_greeter(). * * Returns: (transfer full): a #GdmRemoteGreeter */ GdmRemoteGreeter * gdm_client_get_remote_greeter_finish (GdmClient *client, GAsyncResult *result, GError **error) { GdmRemoteGreeter *remote_greeter; g_return_val_if_fail (GDM_IS_CLIENT (client), NULL); if (client->priv->remote_greeter != NULL) return g_object_ref (client->priv->remote_greeter); remote_greeter = g_task_propagate_pointer (G_TASK (result), error); if (remote_greeter == NULL) return NULL; client->priv->remote_greeter = remote_greeter; @@ -1271,145 +1232,142 @@ gdm_client_get_remote_greeter_sync (GdmClient *client, if (client->priv->remote_greeter != NULL) { return g_object_ref (client->priv->remote_greeter); } connection = gdm_client_get_connection_sync (client, cancellable, error); if (connection == NULL) { return NULL; } client->priv->remote_greeter = gdm_remote_greeter_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, NULL, SESSION_DBUS_PATH, cancellable, error); if (client->priv->remote_greeter != NULL) { g_object_add_weak_pointer (G_OBJECT (client->priv->remote_greeter), (gpointer *) &client->priv->remote_greeter); } return client->priv->remote_greeter; } static void on_chooser_proxy_created (GObject *source, GAsyncResult *result, - GTask *task) + gpointer user_data) { GdmChooser *chooser; - GError *error = NULL; + g_autoptr(GTask) task = user_data; + g_autoptr(GError) error = NULL; chooser = gdm_chooser_proxy_new_finish (result, &error); if (chooser == NULL) { - 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, chooser, (GDestroyNotify) g_object_unref); - g_object_unref (task); } static void on_connection_for_chooser (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_chooser_proxy_new (connection, G_DBUS_PROXY_FLAGS_NONE, NULL, SESSION_DBUS_PATH, cancellable, (GAsyncReadyCallback) on_chooser_proxy_created, - task); + g_steal_pointer (&task)); } /** * gdm_client_get_chooser: * @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 #GdmChooser object that can be used to * verify a user's local account. */ void gdm_client_get_chooser (GdmClient *client, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { - GTask *task; + g_autoptr(GTask) task = NULL; g_return_if_fail (GDM_IS_CLIENT (client)); task = g_task_new (G_OBJECT (client), cancellable, callback, user_data); if (client->priv->chooser != NULL) { g_task_return_pointer (task, g_object_ref (client->priv->chooser), (GDestroyNotify) g_object_unref); - g_object_unref (task); return; } gdm_client_get_connection (client, - cancellable, - (GAsyncReadyCallback) - on_connection_for_chooser, - task); + cancellable, + (GAsyncReadyCallback) + on_connection_for_chooser, + g_steal_pointer (&task)); } /** * gdm_client_get_chooser_finish: * @client: a #GdmClient * @result: The #GAsyncResult from the callback * @error: a #GError * * Finishes an operation started with * gdm_client_get_chooser(). * * Returns: (transfer full): a #GdmChooser */ GdmChooser * gdm_client_get_chooser_finish (GdmClient *client, GAsyncResult *result, GError **error) { GdmChooser *chooser; g_return_val_if_fail (GDM_IS_CLIENT (client), NULL); if (client->priv->chooser != NULL) return g_object_ref (client->priv->chooser); chooser = g_task_propagate_pointer (G_TASK (result), error); if (chooser == NULL) return NULL; client->priv->chooser = chooser; -- 2.25.1