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,
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_open_connection (client,
+ gdm_client_get_connection (client,
cancellable,
(GAsyncReadyCallback)
- on_connection_opened_for_remote_greeter,
+ on_connection_for_remote_greeter,
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), FALSE);
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;
@@ -1246,253 +1261,266 @@ gdm_client_get_remote_greeter_finish (GdmClient *client,
g_object_add_weak_pointer (G_OBJECT (client->priv->remote_greeter),
(gpointer *)
&client->priv->remote_greeter);
g_object_weak_ref (G_OBJECT (client->priv->remote_greeter),
(GWeakNotify)
g_object_unref,
client->priv->connection);
return remote_greeter;
}
/**
* gdm_client_get_remote_greeter_sync:
* @client: a #GdmClient
* @cancellable: a #GCancellable
* @error: a #GError
*
* Gets a #GdmRemoteGreeter object that can be used
* to do do various remote login screen related tasks,
* such as disconnecting.
*
* Returns: (transfer full): #GdmRemoteGreeter or %NULL if caller is not remote
*/
GdmRemoteGreeter *
gdm_client_get_remote_greeter_sync (GdmClient *client,
GCancellable *cancellable,
GError **error)
{
+ g_autoptr(GDBusConnection) connection = NULL;
+
if (client->priv->remote_greeter != NULL) {
return g_object_ref (client->priv->remote_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->remote_greeter = gdm_remote_greeter_proxy_new_sync (client->priv->connection,
+ 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);
+ g_object_ref (connection);
g_object_weak_ref (G_OBJECT (client->priv->remote_greeter),
(GWeakNotify)
g_object_unref,
client->priv->connection);
}
return client->priv->remote_greeter;
}
static void
on_chooser_proxy_created (GObject *source,
GAsyncResult *result,
GTask *task)
{
GdmChooser *chooser;
GError *error = NULL;
chooser = gdm_chooser_proxy_new_finish (result, &error);
if (chooser == NULL) {
g_task_return_error (task, error);
g_object_unref (task);
return;
}
g_task_return_pointer (task,
chooser,
(GDestroyNotify) g_object_unref);
g_object_unref (task);
}
static void
-on_connection_opened_for_chooser (GdmClient *client,
- GAsyncResult *result,
- GTask *task)
+on_connection_for_chooser (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_chooser_proxy_new (client->priv->connection,
+ gdm_chooser_proxy_new (connection,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
SESSION_DBUS_PATH,
cancellable,
(GAsyncReadyCallback)
on_chooser_proxy_created,
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_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_open_connection (client,
+ gdm_client_get_connection (client,
cancellable,
(GAsyncReadyCallback)
- on_connection_opened_for_chooser,
+ on_connection_for_chooser,
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), FALSE);
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;
g_object_add_weak_pointer (G_OBJECT (client->priv->chooser),
(gpointer *)
&client->priv->chooser);
+ g_object_ref (connection);
g_object_weak_ref (G_OBJECT (client->priv->chooser),
(GWeakNotify)
g_object_unref,
client->priv->connection);
return chooser;
}
/**
* gdm_client_get_chooser_sync:
* @client: a #GdmClient
* @cancellable: a #GCancellable
* @error: a #GError
*
* Gets a #GdmChooser object that can be used
* to do do various XDMCP chooser related tasks, such
* as selecting a host or disconnecting.
*
* Returns: (transfer full): #GdmChooser or %NULL if caller is not a chooser
*/
GdmChooser *
gdm_client_get_chooser_sync (GdmClient *client,
GCancellable *cancellable,
GError **error)
{
+ g_autoptr(GDBusConnection) connection = NULL;
if (client->priv->chooser != NULL) {
return g_object_ref (client->priv->chooser);
}
- 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->chooser = gdm_chooser_proxy_new_sync (client->priv->connection,
+ client->priv->chooser = gdm_chooser_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
SESSION_DBUS_PATH,
cancellable,
error);
if (client->priv->chooser != NULL) {
g_object_add_weak_pointer (G_OBJECT (client->priv->chooser),
(gpointer *)
&client->priv->chooser);
+ g_object_ref (connection);
g_object_weak_ref (G_OBJECT (client->priv->chooser),
(GWeakNotify)
g_object_unref,
client->priv->connection);
}
return client->priv->chooser;
}
static void
gdm_client_class_init (GdmClientClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gdm_client_finalize;
g_type_class_add_private (klass, sizeof (GdmClientPrivate));
}
static void
gdm_client_init (GdmClient *client)
{
client->priv = GDM_CLIENT_GET_PRIVATE (client);
}
static void
gdm_client_finalize (GObject *object)
{
--
2.25.1