From e625a214d531635db1e48b2dc51ed0e09ef8005b Mon Sep 17 00:00:00 2001

From: Ray Strode <rstrode@redhat.com>

Date: Tue, 14 Aug 2018 14:52:41 -0400

Subject: [PATCH 2/4] session: support new accountsservice Session and

 SessionType props

At the moment the user's session is stored in a property called

"XSession".  This is pretty weird if the user is using wayland.

AccountService now supports a more generic property "Session" and

a related "SessionType" property to replace "XSession".

This commit switches GDM over to use the new properties.

---

 daemon/gdm-session-settings.c | 61 ++++++++++++++++++++++++---

 daemon/gdm-session-settings.h |  3 ++

 daemon/gdm-session-worker.c   | 28 +++++++++++++

 daemon/gdm-session-worker.xml |  3 ++

 daemon/gdm-session.c          | 78 ++++++++++++++++++++++++++---------

 5 files changed, 148 insertions(+), 25 deletions(-)

diff --git a/daemon/gdm-session-settings.c b/daemon/gdm-session-settings.c

index 933f095bc..8463fad32 100644

--- a/daemon/gdm-session-settings.c

+++ b/daemon/gdm-session-settings.c

@@ -12,114 +12,121 @@

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

  *

  * Written by: Ray Strode <rstrode@redhat.com>

  */

 #include "config.h"

 #include "gdm-session-settings.h"

 #include <errno.h>

 #include <pwd.h>

 #include <string.h>

 #include <sys/types.h>

 #include <unistd.h>

 #include <glib.h>

 #include <glib-object.h>

 #include <glib/gi18n.h>

 #include <act/act-user-manager.h>

 struct _GdmSessionSettingsPrivate

 {

         ActUserManager *user_manager;

         ActUser *user;

         char *session_name;

+        char *session_type;

         char *language_name;

 };

 static void gdm_session_settings_finalize (GObject *object);

 static void gdm_session_settings_class_install_properties (GdmSessionSettingsClass *

                                               settings_class);

 static void gdm_session_settings_set_property (GObject      *object,

                                               guint         prop_id,

                                               const GValue *value,

                                               GParamSpec   *pspec);

 static void gdm_session_settings_get_property (GObject      *object,

                                               guint         prop_id,

                                               GValue       *value,

                                               GParamSpec   *pspec);

 enum {

         PROP_0 = 0,

         PROP_SESSION_NAME,

+        PROP_SESSION_TYPE,

         PROP_LANGUAGE_NAME,

         PROP_IS_LOADED

 };

 G_DEFINE_TYPE (GdmSessionSettings, gdm_session_settings, G_TYPE_OBJECT)

 static void

 gdm_session_settings_class_init (GdmSessionSettingsClass *settings_class)

 {

         GObjectClass *object_class;

         object_class = G_OBJECT_CLASS (settings_class);

         object_class->finalize = gdm_session_settings_finalize;

         gdm_session_settings_class_install_properties (settings_class);

         g_type_class_add_private (settings_class, sizeof (GdmSessionSettingsPrivate));

 }

 static void

 gdm_session_settings_class_install_properties (GdmSessionSettingsClass *settings_class)

 {

         GObjectClass *object_class;

         GParamSpec   *param_spec;

         object_class = G_OBJECT_CLASS (settings_class);

         object_class->set_property = gdm_session_settings_set_property;

         object_class->get_property = gdm_session_settings_get_property;

         param_spec = g_param_spec_string ("session-name", "Session Name",

                                         "The name of the session",

                                         NULL, G_PARAM_READWRITE);

         g_object_class_install_property (object_class, PROP_SESSION_NAME, param_spec);

+        param_spec = g_param_spec_string ("session-type", "Session Type",

+                                          "The type of the session",

+                                          NULL, G_PARAM_READWRITE);

+        g_object_class_install_property (object_class, PROP_SESSION_TYPE, param_spec);

+

         param_spec = g_param_spec_string ("language-name", "Language Name",

                                         "The name of the language",

                                         NULL,

                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);

         g_object_class_install_property (object_class, PROP_LANGUAGE_NAME, param_spec);

         param_spec = g_param_spec_boolean ("is-loaded", NULL, NULL,

                                            FALSE, G_PARAM_READABLE);

         g_object_class_install_property (object_class, PROP_IS_LOADED, param_spec);

 }

 static void

 gdm_session_settings_init (GdmSessionSettings *settings)

 {

         settings->priv = G_TYPE_INSTANCE_GET_PRIVATE (settings,

                                                      GDM_TYPE_SESSION_SETTINGS,

                                                      GdmSessionSettingsPrivate);

         settings->priv->user_manager = act_user_manager_get_default ();

 }

 static void

 gdm_session_settings_finalize (GObject *object)

 {

         GdmSessionSettings *settings;

         GObjectClass *parent_class;

         settings = GDM_SESSION_SETTINGS (object);

@@ -136,172 +143,212 @@ gdm_session_settings_finalize (GObject *object)

                 parent_class->finalize (object);

         }

 }

 void

 gdm_session_settings_set_language_name (GdmSessionSettings *settings,

                                         const char         *language_name)

 {

         g_return_if_fail (GDM_IS_SESSION_SETTINGS (settings));

         if (settings->priv->language_name == NULL ||

             strcmp (settings->priv->language_name, language_name) != 0) {

                 settings->priv->language_name = g_strdup (language_name);

                 g_object_notify (G_OBJECT (settings), "language-name");

         }

 }

 void

 gdm_session_settings_set_session_name (GdmSessionSettings *settings,

                                        const char         *session_name)

 {

         g_return_if_fail (GDM_IS_SESSION_SETTINGS (settings));

         if (settings->priv->session_name == NULL ||

             strcmp (settings->priv->session_name, session_name) != 0) {

                 settings->priv->session_name = g_strdup (session_name);

                 g_object_notify (G_OBJECT (settings), "session-name");

         }

 }

+void

+gdm_session_settings_set_session_type (GdmSessionSettings *settings,

+                                       const char         *session_type)

+{

+        g_return_if_fail (GDM_IS_SESSION_SETTINGS (settings));

+

+        if (settings->priv->session_type == NULL ||

+            g_strcmp0 (settings->priv->session_type, session_type) != 0) {

+                settings->priv->session_type = g_strdup (session_type);

+                g_object_notify (G_OBJECT (settings), "session-type");

+        }

+}

+

 char *

 gdm_session_settings_get_language_name (GdmSessionSettings *settings)

 {

         g_return_val_if_fail (GDM_IS_SESSION_SETTINGS (settings), NULL);

         return g_strdup (settings->priv->language_name);

 }

 char *

 gdm_session_settings_get_session_name (GdmSessionSettings *settings)

 {

         g_return_val_if_fail (GDM_IS_SESSION_SETTINGS (settings), NULL);

         return g_strdup (settings->priv->session_name);

 }

+char *

+gdm_session_settings_get_session_type (GdmSessionSettings *settings)

+{

+        g_return_val_if_fail (GDM_IS_SESSION_SETTINGS (settings), NULL);

+        return g_strdup (settings->priv->session_type);

+}

+

 static void

 gdm_session_settings_set_property (GObject      *object,

                                   guint         prop_id,

                                   const GValue *value,

                                   GParamSpec   *pspec)

 {

         GdmSessionSettings *settings;

         settings = GDM_SESSION_SETTINGS (object);

         switch (prop_id) {

                 case PROP_LANGUAGE_NAME:

                         gdm_session_settings_set_language_name (settings, g_value_get_string (value));

                 break;

                 case PROP_SESSION_NAME:

                         gdm_session_settings_set_session_name (settings, g_value_get_string (value));

                 break;

+                case PROP_SESSION_TYPE:

+                        gdm_session_settings_set_session_type (settings, g_value_get_string (value));

+                break;

+

                 default:

                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

         }

 }

 static void

 gdm_session_settings_get_property (GObject    *object,

                                   guint       prop_id,

                                   GValue     *value,

                                   GParamSpec *pspec)

 {

         GdmSessionSettings *settings;

         settings = GDM_SESSION_SETTINGS (object);

         switch (prop_id) {

                 case PROP_SESSION_NAME:

                         g_value_set_string (value, settings->priv->session_name);

                 break;

+                case PROP_SESSION_TYPE:

+                        g_value_set_string (value, settings->priv->session_type);

+                break;

+

                 case PROP_LANGUAGE_NAME:

                         g_value_set_string (value, settings->priv->language_name);

                 break;

                 case PROP_IS_LOADED:

                         g_value_set_boolean (value, gdm_session_settings_is_loaded (settings));

                 break;

                 default:

                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

     }

 }

 GdmSessionSettings *

 gdm_session_settings_new (void)

 {

         GdmSessionSettings *settings;

         settings = g_object_new (GDM_TYPE_SESSION_SETTINGS,

                                  NULL);

         return settings;

 }

 gboolean

 gdm_session_settings_is_loaded (GdmSessionSettings  *settings)

 {

         if (settings->priv->user == NULL) {

                 return FALSE;

         }

         return act_user_is_loaded (settings->priv->user);

 }

 static void

 load_settings_from_user (GdmSessionSettings *settings)

 {

         const char *session_name;

+        const char *session_type;

         const char *language_name;

         if (!act_user_is_loaded (settings->priv->user)) {

                 g_warning ("GdmSessionSettings: trying to load user settings from unloaded user");

                 return;

         }

-        session_name = act_user_get_x_session (settings->priv->user);

-        g_debug ("GdmSessionSettings: saved session is %s", session_name);

+        /* if the user doesn't have saved state, they don't have any settings worth reading */

+        if (!act_user_get_saved (settings->priv->user))

+                goto out;

+

+        session_type = act_user_get_session_type (settings->priv->user);

+        session_name = act_user_get_session (settings->priv->user);

-        if (session_name != NULL) {

+        g_debug ("GdmSessionSettings: saved session is %s (type %s)", session_name, session_type);

+

+        if (session_type != NULL && session_type[0] != '\0') {

+                gdm_session_settings_set_session_type (settings, session_type);

+        }

+

+        if (session_name != NULL && session_name[0] != '\0') {

                 gdm_session_settings_set_session_name (settings, session_name);

         }

         language_name = act_user_get_language (settings->priv->user);

         g_debug ("GdmSessionSettings: saved language is %s", language_name);

-        if (language_name != NULL) {

+        if (language_name != NULL && language_name[0] != '\0') {

                 gdm_session_settings_set_language_name (settings, language_name);

         }

+out:

         g_object_notify (G_OBJECT (settings), "is-loaded");

 }

 static void

 on_user_is_loaded_changed (ActUser            *user,

                            GParamSpec         *pspec,

                            GdmSessionSettings *settings)

 {

         if (act_user_is_loaded (settings->priv->user)) {

                 load_settings_from_user (settings);

                 g_signal_handlers_disconnect_by_func (G_OBJECT (settings->priv->user),

                                                       G_CALLBACK (on_user_is_loaded_changed),

                                                       settings);

         }

 }

 gboolean

 gdm_session_settings_load (GdmSessionSettings  *settings,

                            const char          *username)

 {

         ActUser *old_user;

         g_return_val_if_fail (settings != NULL, FALSE);

         g_return_val_if_fail (username != NULL, FALSE);

         g_return_val_if_fail (!gdm_session_settings_is_loaded (settings), FALSE);

         if (settings->priv->user != NULL) {

                 old_user = settings->priv->user;

                 g_signal_handlers_disconnect_by_func (G_OBJECT (settings->priv->user),

@@ -322,40 +369,44 @@ gdm_session_settings_load (GdmSessionSettings  *settings,

                                   G_CALLBACK (on_user_is_loaded_changed),

                                   settings);

                 return FALSE;

         }

         load_settings_from_user (settings);

         return TRUE;

 }

 gboolean

 gdm_session_settings_save (GdmSessionSettings  *settings,

                            const char          *username)

 {

         ActUser  *user;

         g_return_val_if_fail (GDM_IS_SESSION_SETTINGS (settings), FALSE);

         g_return_val_if_fail (username != NULL, FALSE);

         g_return_val_if_fail (gdm_session_settings_is_loaded (settings), FALSE);

         user = act_user_manager_get_user (settings->priv->user_manager,

                                           username);

         if (!act_user_is_loaded (user)) {

                 g_object_unref (user);

                 return FALSE;

         }

         if (settings->priv->session_name != NULL) {

-                act_user_set_x_session (user, settings->priv->session_name);

+                act_user_set_session (user, settings->priv->session_name);

+        }

+

+        if (settings->priv->session_type != NULL) {

+                act_user_set_session_type (user, settings->priv->session_type);

         }

         if (settings->priv->language_name != NULL) {

                 act_user_set_language (user, settings->priv->language_name);

         }

         g_object_unref (user);

         return TRUE;

 }

diff --git a/daemon/gdm-session-settings.h b/daemon/gdm-session-settings.h

index 20946bff1..db38ffc72 100644

--- a/daemon/gdm-session-settings.h

+++ b/daemon/gdm-session-settings.h

@@ -33,37 +33,40 @@ G_BEGIN_DECLS

 #define GDM_IS_SESSION_SETTINGS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDM_TYPE_SESSION_SETTINGS))

 #define GDM_SESSION_SETTINGS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GDM_TYPE_SESSION_SETTINGS, GdmSessionSettingsClass))

 #define GDM_SESSION_SETTINGS_ERROR (gdm_session_settings_error_quark ())

 typedef struct _GdmSessionSettings GdmSessionSettings;

 typedef struct _GdmSessionSettingsClass GdmSessionSettingsClass;

 typedef struct _GdmSessionSettingsPrivate GdmSessionSettingsPrivate;

 struct _GdmSessionSettings

 {

         GObject                   parent;

         /*< private > */

         GdmSessionSettingsPrivate *priv;

 };

 struct _GdmSessionSettingsClass

 {

         GObjectClass        parent_class;

 };

 GType               gdm_session_settings_get_type           (void);

 GdmSessionSettings *gdm_session_settings_new                (void);

 gboolean            gdm_session_settings_load               (GdmSessionSettings  *settings,

                                                              const char          *username);

 gboolean            gdm_session_settings_save               (GdmSessionSettings  *settings,

                                                              const char          *username);

 gboolean            gdm_session_settings_is_loaded          (GdmSessionSettings  *settings);

 char               *gdm_session_settings_get_language_name  (GdmSessionSettings *settings);

 char               *gdm_session_settings_get_session_name   (GdmSessionSettings *settings);

+char               *gdm_session_settings_get_session_type   (GdmSessionSettings *settings);

 void                gdm_session_settings_set_language_name  (GdmSessionSettings *settings,

                                                              const char         *language_name);

 void                gdm_session_settings_set_session_name   (GdmSessionSettings *settings,

                                                              const char         *session_name);

+void                gdm_session_settings_set_session_type   (GdmSessionSettings *settings,

+                                                             const char         *session_type);

 G_END_DECLS

 #endif /* GDM_SESSION_SETTINGS_H */

diff --git a/daemon/gdm-session-worker.c b/daemon/gdm-session-worker.c

index e79073996..ae86d28ac 100644

--- a/daemon/gdm-session-worker.c

+++ b/daemon/gdm-session-worker.c

@@ -2539,60 +2539,74 @@ gdm_session_worker_handle_set_language_name (GdmDBusWorker         *object,

         gdm_dbus_worker_complete_set_language_name (object, invocation);

         return TRUE;

 }

 static void

 on_saved_language_name_read (GdmSessionWorker *worker)

 {

         char *language_name;

         language_name = gdm_session_settings_get_language_name (worker->priv->user_settings);

         g_debug ("GdmSessionWorker: Saved language is %s", language_name);

         gdm_dbus_worker_emit_saved_language_name_read (GDM_DBUS_WORKER (worker),

                                                        language_name);

         g_free (language_name);

 }

 static void

 on_saved_session_name_read (GdmSessionWorker *worker)

 {

         char *session_name;

         session_name = gdm_session_settings_get_session_name (worker->priv->user_settings);

         g_debug ("GdmSessionWorker: Saved session is %s", session_name);

         gdm_dbus_worker_emit_saved_session_name_read (GDM_DBUS_WORKER (worker),

                                                       session_name);

         g_free (session_name);

 }

+static void

+on_saved_session_type_read (GdmSessionWorker *worker)

+{

+        char *session_type;

+

+        session_type = gdm_session_settings_get_session_type (worker->priv->user_settings);

+

+        g_debug ("GdmSessionWorker: Saved session type is %s", session_type);

+        gdm_dbus_worker_emit_saved_session_type_read (GDM_DBUS_WORKER (worker),

+                                                      session_type);

+        g_free (session_type);

+}

+

+

 static void

 do_setup (GdmSessionWorker *worker)

 {

         GError  *error;

         gboolean res;

         error = NULL;

         res = gdm_session_worker_initialize_pam (worker,

                                                  worker->priv->service,

                                                  (const char **) worker->priv->extensions,

                                                  worker->priv->username,

                                                  worker->priv->hostname,

                                                  worker->priv->display_is_local,

                                                  worker->priv->x11_display_name,

                                                  worker->priv->x11_authority_file,

                                                  worker->priv->display_device,

                                                  worker->priv->display_seat_id,

                                                  &error);

         if (res) {

                 g_dbus_method_invocation_return_value (worker->priv->pending_invocation, NULL);

         } else {

                 g_dbus_method_invocation_take_error (worker->priv->pending_invocation, error);

         }

         worker->priv->pending_invocation = NULL;

 }

 static void

 do_authenticate (GdmSessionWorker *worker)

 {

@@ -3001,158 +3015,172 @@ gdm_session_worker_handle_initialize (GdmDBusWorker         *object,

                 } else if (g_strcmp0 (key, "x11-authority-file") == 0) {

                         worker->priv->x11_authority_file = g_variant_dup_string (value, NULL);

                 } else if (g_strcmp0 (key, "console") == 0) {

                         worker->priv->display_device = g_variant_dup_string (value, NULL);

                 } else if (g_strcmp0 (key, "seat-id") == 0) {

                         worker->priv->display_seat_id = g_variant_dup_string (value, NULL);

                 } else if (g_strcmp0 (key, "hostname") == 0) {

                         worker->priv->hostname = g_variant_dup_string (value, NULL);

                 } else if (g_strcmp0 (key, "display-is-local") == 0) {

                         worker->priv->display_is_local = g_variant_get_boolean (value);

                 } else if (g_strcmp0 (key, "display-is-initial") == 0) {

                         worker->priv->display_is_initial = g_variant_get_boolean (value);

                 }

         }

         worker->priv->pending_invocation = invocation;

         if (!worker->priv->is_program_session) {

                 worker->priv->user_settings = gdm_session_settings_new ();

                 g_signal_connect_swapped (worker->priv->user_settings,

                                           "notify::language-name",

                                           G_CALLBACK (on_saved_language_name_read),

                                           worker);

                 g_signal_connect_swapped (worker->priv->user_settings,

                                           "notify::session-name",

                                           G_CALLBACK (on_saved_session_name_read),

                                           worker);

+                g_signal_connect_swapped (worker->priv->user_settings,

+                                          "notify::session-type",

+                                          G_CALLBACK (on_saved_session_type_read),

+                                          worker);

+

                 if (worker->priv->username) {

                         wait_for_settings = !gdm_session_settings_load (worker->priv->user_settings,

                                                                         worker->priv->username);

                 }

         }

         if (wait_for_settings) {

                 /* Load settings from accounts daemon before continuing

                  */

                 g_signal_connect (G_OBJECT (worker->priv->user_settings),

                                   "notify::is-loaded",

                                   G_CALLBACK (on_settings_is_loaded_changed),

                                   worker);

         } else {

                 queue_state_change (worker);

         }

         return TRUE;

 }

 static gboolean

 gdm_session_worker_handle_setup (GdmDBusWorker         *object,

                                  GDBusMethodInvocation *invocation,

                                  const char            *service,

                                  const char            *x11_display_name,

                                  const char            *x11_authority_file,

                                  const char            *console,

                                  const char            *seat_id,

                                  const char            *hostname,

                                  gboolean               display_is_local,

                                  gboolean               display_is_initial)

 {

         GdmSessionWorker *worker = GDM_SESSION_WORKER (object);

         validate_and_queue_state_change (worker, invocation, GDM_SESSION_WORKER_STATE_SETUP_COMPLETE);

         worker->priv->service = g_strdup (service);

         worker->priv->x11_display_name = g_strdup (x11_display_name);

         worker->priv->x11_authority_file = g_strdup (x11_authority_file);

         worker->priv->display_device = g_strdup (console);

         worker->priv->display_seat_id = g_strdup (seat_id);

         worker->priv->hostname = g_strdup (hostname);

         worker->priv->display_is_local = display_is_local;

         worker->priv->display_is_initial = display_is_initial;

         worker->priv->username = NULL;

         worker->priv->user_settings = gdm_session_settings_new ();

         g_signal_connect_swapped (worker->priv->user_settings,

                                   "notify::language-name",

                                   G_CALLBACK (on_saved_language_name_read),

                                   worker);

         g_signal_connect_swapped (worker->priv->user_settings,

                                   "notify::session-name",

                                   G_CALLBACK (on_saved_session_name_read),

                                   worker);

+        g_signal_connect_swapped (worker->priv->user_settings,

+                                  "notify::session-type",

+                                  G_CALLBACK (on_saved_session_type_read),

+                                  worker);

+

         return TRUE;

 }

 static gboolean

 gdm_session_worker_handle_setup_for_user (GdmDBusWorker         *object,

                                           GDBusMethodInvocation *invocation,

                                           const char            *service,

                                           const char            *username,

                                           const char            *x11_display_name,

                                           const char            *x11_authority_file,

                                           const char            *console,

                                           const char            *seat_id,

                                           const char            *hostname,

                                           gboolean               display_is_local,

                                           gboolean               display_is_initial)

 {

         GdmSessionWorker *worker = GDM_SESSION_WORKER (object);

         if (!validate_state_change (worker, invocation, GDM_SESSION_WORKER_STATE_SETUP_COMPLETE))

                 return TRUE;

         worker->priv->service = g_strdup (service);

         worker->priv->x11_display_name = g_strdup (x11_display_name);

         worker->priv->x11_authority_file = g_strdup (x11_authority_file);

         worker->priv->display_device = g_strdup (console);

         worker->priv->display_seat_id = g_strdup (seat_id);

         worker->priv->hostname = g_strdup (hostname);

         worker->priv->display_is_local = display_is_local;

         worker->priv->display_is_initial = display_is_initial;

         worker->priv->username = g_strdup (username);

         worker->priv->user_settings = gdm_session_settings_new ();

         g_signal_connect_swapped (worker->priv->user_settings,

                                   "notify::language-name",

                                   G_CALLBACK (on_saved_language_name_read),

                                   worker);

         g_signal_connect_swapped (worker->priv->user_settings,

                                   "notify::session-name",

                                   G_CALLBACK (on_saved_session_name_read),

                                   worker);

+        g_signal_connect_swapped (worker->priv->user_settings,

+                                  "notify::session-type",

+                                  G_CALLBACK (on_saved_session_type_read),

+                                  worker);

         /* Load settings from accounts daemon before continuing

          */

         worker->priv->pending_invocation = invocation;

         if (gdm_session_settings_load (worker->priv->user_settings, username)) {

                 queue_state_change (worker);

         } else {

                 g_signal_connect (G_OBJECT (worker->priv->user_settings),

                                   "notify::is-loaded",

                                   G_CALLBACK (on_settings_is_loaded_changed),

                                   worker);

         }

         return TRUE;

 }

 static gboolean

 gdm_session_worker_handle_setup_for_program (GdmDBusWorker         *object,

                                              GDBusMethodInvocation *invocation,

                                              const char            *service,

                                              const char            *username,

                                              const char            *x11_display_name,

                                              const char            *x11_authority_file,

                                              const char            *console,

                                              const char            *seat_id,

                                              const char            *hostname,

                                              gboolean               display_is_local,

                                              gboolean               display_is_initial,

                                              const char            *log_file)

 {

diff --git a/daemon/gdm-session-worker.xml b/daemon/gdm-session-worker.xml

index 4280fe095..a215779c8 100644

--- a/daemon/gdm-session-worker.xml

+++ b/daemon/gdm-session-worker.xml

@@ -51,40 +51,43 @@

     <method name="SetupForProgram">

       <arg name="service_name" direction="in" type="s"/>

       <arg name="user_name" direction="in" type="s"/>

       <arg name="x11_display_name" direction="in" type="s"/>

       <arg name="x11_authority_file" direction="in" type="s"/>

       <arg name="display_device" direction="in" type="s"/>

       <arg name="display_seat" direction="in" type="s"/>