From 1a590b855f5b5d323334b49707778d4ee88ba873 Mon Sep 17 00:00:00 2001
From: Ray Strode <rstrode@redhat.com>
Date: Mon, 14 May 2018 15:57:14 -0400
Subject: [PATCH 02/15] libgdm: don't keep manager proxy around longer than we
need it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Right now we keep the manager proxy alive long after we need it.
It doesn't get cleared until one of the other proxies go away.
That is not only unnecessary but illogical and confusing.
This commit changes the manager proxy to be transient—only alive
long enough to get what we need from it.
https://bugzilla.gnome.org/show_bug.cgi?id=795940
---
libgdm/gdm-client.c | 119 ++++++++++----------------------------------
1 file changed, 26 insertions(+), 93 deletions(-)
diff --git a/libgdm/gdm-client.c b/libgdm/gdm-client.c
index 06dfe725e..e02e3ea57 100644
--- a/libgdm/gdm-client.c
+++ b/libgdm/gdm-client.c
@@ -13,150 +13,130 @@
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <glib.h>
#include <glib/gi18n.h>
#include <glib-object.h>
#include "gdm-client.h"
#include "gdm-client-glue.h"
#include "gdm-manager-glue.h"
#define GDM_CLIENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GDM_TYPE_CLIENT, GdmClientPrivate))
#define SESSION_DBUS_PATH "/org/gnome/DisplayManager/Session"
struct GdmClientPrivate
{
- GdmManager *manager;
-
GdmUserVerifier *user_verifier;
GHashTable *user_verifier_extensions;
GdmGreeter *greeter;
GdmRemoteGreeter *remote_greeter;
GdmChooser *chooser;
GDBusConnection *connection;
char *address;
char **enabled_extensions;
};
static void gdm_client_class_init (GdmClientClass *klass);
static void gdm_client_init (GdmClient *client);
static void gdm_client_finalize (GObject *object);
G_DEFINE_TYPE (GdmClient, gdm_client, G_TYPE_OBJECT);
static gpointer client_object = NULL;
GQuark
gdm_client_error_quark (void)
{
static GQuark error_quark = 0;
if (error_quark == 0)
error_quark = g_quark_from_static_string ("gdm-client");
return error_quark;
}
static void
-on_got_manager (GdmManager *manager,
+on_got_manager (GObject *object,
GAsyncResult *result,
GTask *task)
{
GdmClient *client;
- GdmManager *new_manager;
- GError *error;
+ GError *error;
+ g_autoptr(GdmManager) manager = NULL;
client = GDM_CLIENT (g_async_result_get_source_object (G_ASYNC_RESULT (task)));
error = NULL;
- new_manager = gdm_manager_proxy_new_finish (result, &error);
-
- if (client->priv->manager == NULL) {
- client->priv->manager = new_manager;
-
- } else {
- g_object_ref (client->priv->manager);
- g_object_unref (new_manager);
-
- g_clear_error (&error);
- }
+ manager = gdm_manager_proxy_new_finish (result, &error);
if (error != NULL) {
g_task_return_error (task, error);
} else {
g_task_return_pointer (task,
- g_object_ref (client->priv->manager),
+ g_object_ref (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);
- if (client->priv->manager != NULL) {
- g_task_return_pointer (task,
- g_object_ref (client->priv->manager),
- (GDestroyNotify) g_object_unref);
- g_object_unref (task);
- return;
- }
-
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)
{
@@ -377,114 +357,113 @@ on_reauthentication_channel_opened (GdmManager *manager,
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);
}
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 (client->priv->manager,
+ 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)
{
+ 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;
}
- client->priv->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);
+ 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 (client->priv->manager == NULL) {
+ if (manager == NULL) {
goto out;
}
- ret = gdm_manager_call_open_session_sync (client->priv->manager,
+ ret = gdm_manager_call_open_session_sync (manager,
&client->priv->address,
cancellable,
error);
if (!ret) {
- g_clear_object (&client->priv->manager);
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_object (&client->priv->manager);
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;
}
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),
@@ -517,61 +496,61 @@ on_session_opened (GdmManager *manager,
cancellable = g_task_get_cancellable (task);
g_dbus_connection_new_for_address (client->priv->address,
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
NULL,
cancellable,
(GAsyncReadyCallback)
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 (client->priv->manager,
+ 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)
{
g_autoptr(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;
}
if (client->priv->connection == NULL) {
client->priv->connection = g_steal_pointer (&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;
}
@@ -600,122 +579,114 @@ gdm_client_open_connection (GdmClient *client,
}
get_manager (client,
cancellable,
(GAsyncReadyCallback)
on_got_manager_for_opening_connection,
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)
{
GDBusConnection *connection;
+ g_autoptr(GdmManager) manager = NULL;
GdmUserVerifier *user_verifier = NULL;
gboolean ret;
char *address;
g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
- if (client->priv->manager == NULL) {
- client->priv->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);
+ 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 (client->priv->manager == NULL) {
- goto out;
- }
- } else {
- client->priv->manager = g_object_ref (client->priv->manager);
+ if (manager == NULL) {
+ goto out;
}
- ret = gdm_manager_call_open_reauthentication_channel_sync (client->priv->manager,
+ ret = gdm_manager_call_open_reauthentication_channel_sync (manager,
username,
&address,
cancellable,
error);
if (!ret) {
goto out;
}
g_debug ("GdmClient: connecting to address: %s", client->priv->address);
connection = g_dbus_connection_new_for_address_sync (address,
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
NULL,
cancellable,
error);
if (connection == NULL) {
g_free (address);
goto out;
}
g_free (address);
user_verifier = gdm_user_verifier_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
SESSION_DBUS_PATH,
cancellable,
error);
if (user_verifier != NULL) {
g_object_weak_ref (G_OBJECT (user_verifier),
(GWeakNotify)
g_object_unref,
connection);
-
- g_object_weak_ref (G_OBJECT (user_verifier),
- (GWeakNotify)
- g_clear_object,
- &client->priv->manager);
}
out:
return user_verifier;
}
/**
* gdm_client_open_reauthentication_channel:
* @client: a #GdmClient
* @username: user to reauthenticate
* @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
* reauthenticate an already logged in user.
*/
void
gdm_client_open_reauthentication_channel (GdmClient *client,
const char *username,
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,
@@ -764,64 +735,60 @@ gdm_client_open_reauthentication_channel_finish (GdmClient *client,
*
* 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)
{
if (client->priv->user_verifier != NULL) {
return g_object_ref (client->priv->user_verifier);
}
if (!gdm_client_open_connection_sync (client, cancellable, error)) {
return NULL;
}
client->priv->user_verifier = gdm_user_verifier_proxy_new_sync (client->priv->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_weak_ref (G_OBJECT (client->priv->user_verifier),
- (GWeakNotify)
- g_clear_object,
- &client->priv->manager);
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,
@@ -914,65 +881,60 @@ gdm_client_get_user_verifier (GdmClient *client,
*
* 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;
client->priv->user_verifier = user_verifier;
g_object_add_weak_pointer (G_OBJECT (client->priv->user_verifier),
(gpointer *)
&client->priv->user_verifier);
g_object_weak_ref (G_OBJECT (client->priv->user_verifier),
(GWeakNotify)
g_object_unref,
client->priv->connection);
- g_object_weak_ref (G_OBJECT (client->priv->user_verifier),
- (GWeakNotify)
- g_clear_object,
- &client->priv->manager);
-
return user_verifier;
}
/**
* gdm_client_get_user_verifier_choice_list:
* @client: a #GdmClient
*
* Gets a #GdmUserVerifierChoiceList object that can be used to
* verify a user's local account.
*
* Returns: (transfer none): #GdmUserVerifierChoiceList or %NULL if user
* verifier isn't yet fetched, or daemon doesn't support choice lists
*/
GdmUserVerifierChoiceList *
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);
}
@@ -1088,110 +1050,100 @@ gdm_client_get_greeter (GdmClient *client,
* 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;
client->priv->greeter = greeter;
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);
-
- g_object_weak_ref (G_OBJECT (client->priv->greeter),
- (GWeakNotify)
- g_clear_object,
- &client->priv->manager);
-
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)
{
if (client->priv->greeter != NULL) {
return g_object_ref (client->priv->greeter);
}
if (!gdm_client_open_connection_sync (client, cancellable, error)) {
return NULL;
}
client->priv->greeter = gdm_greeter_proxy_new_sync (client->priv->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_clear_object,
- &client->priv->manager);
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);
@@ -1274,108 +1226,99 @@ gdm_client_get_remote_greeter (GdmClient *client,
*
* 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;
client->priv->remote_greeter = remote_greeter;
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);
- g_object_weak_ref (G_OBJECT (client->priv->remote_greeter),
- (GWeakNotify)
- g_clear_object,
- &client->priv->manager);
-
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)
{
if (client->priv->remote_greeter != NULL) {
return g_object_ref (client->priv->remote_greeter);
}
if (!gdm_client_open_connection_sync (client, cancellable, error)) {
return NULL;
}
client->priv->remote_greeter = gdm_remote_greeter_proxy_new_sync (client->priv->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_weak_ref (G_OBJECT (client->priv->remote_greeter),
- (GWeakNotify)
- g_clear_object,
- &client->priv->manager);
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);
}
@@ -1456,109 +1399,100 @@ gdm_client_get_chooser (GdmClient *client,
*
* 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_weak_ref (G_OBJECT (client->priv->chooser),
(GWeakNotify)
g_object_unref,
client->priv->connection);
- g_object_weak_ref (G_OBJECT (client->priv->chooser),
- (GWeakNotify)
- g_clear_object,
- &client->priv->manager);
-
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)
{
if (client->priv->chooser != NULL) {
return g_object_ref (client->priv->chooser);
}
if (!gdm_client_open_connection_sync (client, cancellable, error)) {
return NULL;
}
client->priv->chooser = gdm_chooser_proxy_new_sync (client->priv->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_weak_ref (G_OBJECT (client->priv->chooser),
- (GWeakNotify)
- g_clear_object,
- &client->priv->manager);
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)
{
@@ -1574,61 +1508,60 @@ gdm_client_finalize (GObject *object)
if (client->priv->user_verifier != NULL) {
g_object_remove_weak_pointer (G_OBJECT (client->priv->user_verifier),
(gpointer *)
&client->priv->user_verifier);
}
if (client->priv->greeter != NULL) {
g_object_remove_weak_pointer (G_OBJECT (client->priv->greeter),
(gpointer *)
&client->priv->greeter);
}
if (client->priv->remote_greeter != NULL) {
g_object_remove_weak_pointer (G_OBJECT (client->priv->remote_greeter),
(gpointer *)
&client->priv->remote_greeter);
}
if (client->priv->chooser != NULL) {
g_object_remove_weak_pointer (G_OBJECT (client->priv->chooser),
(gpointer *)
&client->priv->chooser);
}
if (client->priv->connection != NULL) {
g_object_remove_weak_pointer (G_OBJECT (client->priv->connection),
(gpointer *)
&client->priv->connection);
}
- g_clear_object (&client->priv->manager);
g_clear_object (&client->priv->connection);
g_strfreev (client->priv->enabled_extensions);
g_free (client->priv->address);
G_OBJECT_CLASS (gdm_client_parent_class)->finalize (object);
}
GdmClient *
gdm_client_new (void)
{
if (client_object != NULL) {
g_object_ref (client_object);
} else {
client_object = g_object_new (GDM_TYPE_CLIENT, NULL);
g_object_add_weak_pointer (client_object,
(gpointer *) &client_object);
}
return GDM_CLIENT (client_object);
}
/**
* gdm_client_set_enabled_extensions:
* @client: a #GdmClient
* @extensions: (array zero-terminated=1) (element-type utf8): a list of extensions
*
* Enables GDM's pam extensions. Currently, only
* org.gnome.DisplayManager.UserVerifier.ChoiceList is supported.
--
2.25.1