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
* @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