1 files changed, 178 insertions, 83 deletions

diff --git a/src/gpm-session.c b/src/gpm-session.c
index 2960501..a3c86a5 100644
--- a/src/gpm-session.c
+++ b/src/gpm-session.c
@@ -24,8 +24,8 @@
 
 #include <string.h>
 #include <glib.h>
+#include <gio/gio.h>
 #include <glib/gi18n.h>
-#include <dbus/dbus-glib.h>
 
 #include "gpm-session.h"
 #include "gpm-common.h"
@@ -58,10 +58,10 @@ typedef enum {
 
 struct GpmSessionPrivate
 {
-	DBusGProxy		*proxy;
-	DBusGProxy		*proxy_presence;
-	DBusGProxy		*proxy_client_private;
-	DBusGProxy		*proxy_prop;
+	GDBusProxy		*proxy;
+	GDBusProxy		*proxy_presence;
+	GDBusProxy		*proxy_client_private;
+	GDBusProxy		*proxy_prop;
 	gboolean		 is_idle_old;
 	gboolean		 is_idle_inhibited_old;
 	gboolean		 is_suspend_inhibited_old;
@@ -97,7 +97,14 @@ gpm_session_logout (GpmSession *session)
 	}
 
 	/* we have to use no reply, as the SM calls into g-p-m to get the can_suspend property */
-	dbus_g_proxy_call_no_reply (session->priv->proxy, "Shutdown", G_TYPE_INVALID);
+	g_dbus_proxy_call (session->priv->proxy,
+			   "Shutdown",
+			   NULL,
+			   G_DBUS_CALL_FLAGS_NONE,
+			   -1,
+			   NULL,
+			   NULL,
+			   NULL);
 	return TRUE;
 }
 
@@ -135,9 +142,20 @@ gpm_session_get_suspend_inhibited (GpmSession *session)
  * gpm_session_presence_status_changed_cb:
  **/
 static void
-gpm_session_presence_status_changed_cb (DBusGProxy *proxy, guint status, GpmSession *session)
+gpm_session_presence_status_changed_cb (GDBusProxy *proxy,
+					gchar *sender_name,
+					gchar *signal_name,
+					GVariant *parameters,
+					GpmSession *session)
 {
+	guint status;
 	gboolean is_idle;
+
+	if (g_strcmp0 (signal_name, "StatusChanged") != 0)
+		return;
+
+	g_variant_get (parameters, "(u)", &status);
+
 	is_idle = (status == GPM_SESSION_STATUS_ENUM_IDLE);
 	if (is_idle != session->priv->is_idle_old) {
 		g_debug ("emitting idle-changed : (%i)", is_idle);
@@ -152,10 +170,12 @@ gpm_session_presence_status_changed_cb (DBusGProxy *proxy, guint status, GpmSess
 static gboolean
 gpm_session_is_idle (GpmSession *session)
 {
+	GVariant *result;
+	GVariant *status_variant;
+	guint status;
 	gboolean ret;
 	gboolean is_idle = FALSE;
 	GError *error = NULL;
-	GValue *value;
 
 	/* no mate-session */
 	if (session->priv->proxy_prop == NULL) {
@@ -163,23 +183,26 @@ gpm_session_is_idle (GpmSession *session)
 		goto out;
 	}
 
-	value = g_new0(GValue, 1);
 	/* find out if this change altered the inhibited state */
-	ret = dbus_g_proxy_call (session->priv->proxy_prop, "Get", &error,
-				 G_TYPE_STRING, GPM_SESSION_MANAGER_PRESENCE_INTERFACE,
-				 G_TYPE_STRING, "status",
-				 G_TYPE_INVALID,
-				 G_TYPE_VALUE, value,
-				 G_TYPE_INVALID);
+	result = g_dbus_proxy_call_sync (session->priv->proxy_prop,
+					 "Get",
+					 g_variant_new ("(ss)", GPM_SESSION_MANAGER_PRESENCE_INTERFACE, "status"),
+					 G_DBUS_CALL_FLAGS_NONE,
+					 -1,
+					 NULL,
+					 &error);
+	ret = (result != NULL);
 	if (!ret) {
 		g_warning ("failed to get idle status: %s", error->message);
 		g_error_free (error);
-		g_free (value);
 		is_idle = FALSE;
 		goto out;
 	}
-	is_idle = (g_value_get_uint (value) == GPM_SESSION_STATUS_ENUM_IDLE);
-	g_free (value);
+	g_variant_get (result, "(v)", &status_variant);
+	status = g_variant_get_uint32 (status_variant);
+	g_variant_unref (status_variant);
+	g_variant_unref (result);
+	is_idle = (status == GPM_SESSION_STATUS_ENUM_IDLE);
 out:
 	return is_idle;
 }
@@ -190,6 +213,7 @@ out:
 static gboolean
 gpm_session_is_idle_inhibited (GpmSession *session)
 {
+	GVariant *result;
 	gboolean ret;
 	gboolean is_inhibited = FALSE;
 	GError *error = NULL;
@@ -201,11 +225,18 @@ gpm_session_is_idle_inhibited (GpmSession *session)
 	}
 
 	/* find out if this change altered the inhibited state */
-	ret = dbus_g_proxy_call (session->priv->proxy, "IsInhibited", &error,
-				 G_TYPE_UINT, GPM_SESSION_INHIBIT_MASK_IDLE,
-				 G_TYPE_INVALID,
-				 G_TYPE_BOOLEAN, &is_inhibited,
-				 G_TYPE_INVALID);
+	result = g_dbus_proxy_call_sync (session->priv->proxy,
+					 "IsInhibited",
+					 g_variant_new ("(u)", GPM_SESSION_INHIBIT_MASK_IDLE),
+					 G_DBUS_CALL_FLAGS_NONE,
+					 -1,
+					 NULL,
+					 &error);
+	ret = (result != NULL);
+	if (result != NULL) {
+		g_variant_get (result, "(b)", &is_inhibited);
+		g_variant_unref (result);
+	}
 	if (!ret) {
 		g_warning ("failed to get inhibit status: %s", error->message);
 		g_error_free (error);
@@ -221,6 +252,7 @@ out:
 static gboolean
 gpm_session_is_suspend_inhibited (GpmSession *session)
 {
+	GVariant *result;
 	gboolean ret;
 	gboolean is_inhibited = FALSE;
 	GError *error = NULL;
@@ -232,11 +264,18 @@ gpm_session_is_suspend_inhibited (GpmSession *session)
 	}
 
 	/* find out if this change altered the inhibited state */
-	ret = dbus_g_proxy_call (session->priv->proxy, "IsInhibited", &error,
-				 G_TYPE_UINT, GPM_SESSION_INHIBIT_MASK_SUSPEND,
-				 G_TYPE_INVALID,
-				 G_TYPE_BOOLEAN, &is_inhibited,
-				 G_TYPE_INVALID);
+	result = g_dbus_proxy_call_sync (session->priv->proxy,
+					 "IsInhibited",
+					 g_variant_new ("(u)", GPM_SESSION_INHIBIT_MASK_SUSPEND),
+					 G_DBUS_CALL_FLAGS_NONE,
+					 -1,
+					 NULL,
+					 &error);
+	ret = (result != NULL);
+	if (result != NULL) {
+		g_variant_get (result, "(b)", &is_inhibited);
+		g_variant_unref (result);
+	}
 	if (!ret) {
 		g_warning ("failed to get inhibit status: %s", error->message);
 		g_error_free (error);
@@ -250,7 +289,7 @@ out:
  * gpm_session_stop_cb:
  **/
 static void
-gpm_session_stop_cb (DBusGProxy *proxy, GpmSession *session)
+gpm_session_stop_cb (GpmSession *session)
 {
 	g_debug ("emitting ::stop()");
 	g_signal_emit (session, signals [STOP], 0);
@@ -260,7 +299,7 @@ gpm_session_stop_cb (DBusGProxy *proxy, GpmSession *session)
  * gpm_session_query_end_session_cb:
  **/
 static void
-gpm_session_query_end_session_cb (DBusGProxy *proxy, guint flags, GpmSession *session)
+gpm_session_query_end_session_cb (GpmSession *session, guint flags)
 {
 	g_debug ("emitting ::query-end-session(%u)", flags);
 	g_signal_emit (session, signals [QUERY_END_SESSION], 0, flags);
@@ -270,18 +309,45 @@ gpm_session_query_end_session_cb (DBusGProxy *proxy, guint flags, GpmSession *se
  * gpm_session_end_session_cb:
  **/
 static void
-gpm_session_end_session_cb (DBusGProxy *proxy, guint flags, GpmSession *session)
+gpm_session_end_session_cb (GpmSession *session, guint flags)
 {
 	g_debug ("emitting ::end-session(%u)", flags);
 	g_signal_emit (session, signals [END_SESSION], 0, flags);
 }
 
+static void
+gpm_session_client_private_signal_cb (GDBusProxy *proxy,
+				      gchar *sender_name,
+				      gchar *signal_name,
+				      GVariant *parameters,
+				      GpmSession *session)
+{
+	guint flags;
+
+	if (g_strcmp0 (signal_name, "Stop") == 0) {
+		gpm_session_stop_cb (session);
+		return;
+	}
+
+	if (g_strcmp0 (signal_name, "QueryEndSession") == 0) {
+		g_variant_get (parameters, "(u)", &flags);
+		gpm_session_query_end_session_cb (session, flags);
+		return;
+	}
+
+	if (g_strcmp0 (signal_name, "EndSession") == 0) {
+		g_variant_get (parameters, "(u)", &flags);
+		gpm_session_end_session_cb (session, flags);
+	}
+}
+
 /**
  * gpm_session_end_session_response:
  **/
 gboolean
 gpm_session_end_session_response (GpmSession *session, gboolean is_okay, const gchar *reason)
 {
+	GVariant *result;
 	gboolean ret = FALSE;
 	GError *error = NULL;
 
@@ -295,11 +361,16 @@ gpm_session_end_session_response (GpmSession *session, gboolean is_okay, const g
 	}
 
 	/* send response */
-	ret = dbus_g_proxy_call (session->priv->proxy_client_private, "EndSessionResponse", &error,
-				 G_TYPE_BOOLEAN, is_okay,
-				 G_TYPE_STRING, reason,
-				 G_TYPE_INVALID,
-				 G_TYPE_INVALID);
+	result = g_dbus_proxy_call_sync (session->priv->proxy_client_private,
+					 "EndSessionResponse",
+					 g_variant_new ("(bs)", is_okay, reason),
+					 G_DBUS_CALL_FLAGS_NONE,
+					 -1,
+					 NULL,
+					 &error);
+	ret = (result != NULL);
+	if (result != NULL)
+		g_variant_unref (result);
 	if (!ret) {
 		g_warning ("failed to send session response: %s", error->message);
 		g_error_free (error);
@@ -315,10 +386,11 @@ out:
 gboolean
 gpm_session_register_client (GpmSession *session, const gchar *app_id, const gchar *client_startup_id)
 {
+	GVariant *result;
+	const gchar *client_id_tmp;
 	gboolean ret = FALSE;
 	gchar *client_id = NULL;
 	GError *error = NULL;
-	DBusGConnection *connection;
 
 	g_return_val_if_fail (GPM_IS_SESSION (session), FALSE);
 
@@ -329,39 +401,40 @@ gpm_session_register_client (GpmSession *session, const gchar *app_id, const gch
 	}
 
 	/* find out if this change altered the inhibited state */
-	ret = dbus_g_proxy_call (session->priv->proxy, "RegisterClient", &error,
-				 G_TYPE_STRING, app_id,
-				 G_TYPE_STRING, client_startup_id,
-				 G_TYPE_INVALID,
-				 DBUS_TYPE_G_OBJECT_PATH, &client_id,
-				 G_TYPE_INVALID);
+	result = g_dbus_proxy_call_sync (session->priv->proxy,
+					 "RegisterClient",
+					 g_variant_new ("(ss)", app_id, client_startup_id),
+					 G_DBUS_CALL_FLAGS_NONE,
+					 -1,
+					 NULL,
+					 &error);
+	ret = (result != NULL);
 	if (!ret) {
 		g_warning ("failed to register client '%s': %s", client_startup_id, error->message);
 		g_error_free (error);
 		goto out;
 	}
+	g_variant_get (result, "(&o)", &client_id_tmp);
+	client_id = g_strdup (client_id_tmp);
+	g_variant_unref (result);
 
 	/* get org.gnome.SessionManager.ClientPrivate interface */
-	connection = dbus_g_bus_get (DBUS_BUS_SESSION, NULL);
-	session->priv->proxy_client_private = dbus_g_proxy_new_for_name_owner (connection, GPM_SESSION_MANAGER_SERVICE,
-									       client_id, GPM_SESSION_MANAGER_CLIENT_PRIVATE_INTERFACE, &error);
+	session->priv->proxy_client_private = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+							     G_DBUS_PROXY_FLAGS_NONE,
+							     NULL,
+							     GPM_SESSION_MANAGER_SERVICE,
+							     client_id,
+							     GPM_SESSION_MANAGER_CLIENT_PRIVATE_INTERFACE,
+							     NULL,
+							     &error);
 	if (session->priv->proxy_client_private == NULL) {
 		g_warning ("DBUS error: %s", error->message);
 		g_error_free (error);
 		goto out;
 	}
 
-	/* get Stop */
-	dbus_g_proxy_add_signal (session->priv->proxy_client_private, "Stop", G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal (session->priv->proxy_client_private, "Stop", G_CALLBACK (gpm_session_stop_cb), session, NULL);
-
-	/* get QueryEndSession */
-	dbus_g_proxy_add_signal (session->priv->proxy_client_private, "QueryEndSession", G_TYPE_UINT, G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal (session->priv->proxy_client_private, "QueryEndSession", G_CALLBACK (gpm_session_query_end_session_cb), session, NULL);
-
-	/* get EndSession */
-	dbus_g_proxy_add_signal (session->priv->proxy_client_private, "EndSession", G_TYPE_UINT, G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal (session->priv->proxy_client_private, "EndSession", G_CALLBACK (gpm_session_end_session_cb), session, NULL);
+	g_signal_connect (session->priv->proxy_client_private, "g-signal",
+			  G_CALLBACK (gpm_session_client_private_signal_cb), session);
 
 	g_debug ("registered startup '%s' to client id '%s'", client_startup_id, client_id);
 out:
@@ -373,11 +446,19 @@ out:
  * gpm_session_inhibit_changed_cb:
  **/
 static void
-gpm_session_inhibit_changed_cb (DBusGProxy *proxy, const gchar *id, GpmSession *session)
+gpm_session_inhibit_changed_cb (GDBusProxy *proxy,
+				gchar *sender_name,
+				gchar *signal_name,
+				GVariant *parameters,
+				GpmSession *session)
 {
 	gboolean is_idle_inhibited;
 	gboolean is_suspend_inhibited;
 
+	if (g_strcmp0 (signal_name, "InhibitorAdded") != 0 &&
+	    g_strcmp0 (signal_name, "InhibitorRemoved") != 0)
+		return;
+
 	is_idle_inhibited = gpm_session_is_idle_inhibited (session);
 	is_suspend_inhibited = gpm_session_is_suspend_inhibited (session);
 	if (is_idle_inhibited != session->priv->is_idle_inhibited_old || is_suspend_inhibited != session->priv->is_suspend_inhibited_old) {
@@ -449,21 +530,26 @@ gpm_session_class_init (GpmSessionClass *klass)
 static void
 gpm_session_init (GpmSession *session)
 {
-	DBusGConnection *connection;
 	GError *error = NULL;
 
 	session->priv = gpm_session_get_instance_private (session);
 	session->priv->is_idle_old = FALSE;
 	session->priv->is_idle_inhibited_old = FALSE;
 	session->priv->is_suspend_inhibited_old = FALSE;
+	session->priv->proxy = NULL;
+	session->priv->proxy_presence = NULL;
 	session->priv->proxy_client_private = NULL;
-
-	connection = dbus_g_bus_get (DBUS_BUS_SESSION, NULL);
+	session->priv->proxy_prop = NULL;
 
 	/* get org.gnome.SessionManager interface */
-	session->priv->proxy = dbus_g_proxy_new_for_name_owner (connection, GPM_SESSION_MANAGER_SERVICE,
-								GPM_SESSION_MANAGER_PATH,
-								GPM_SESSION_MANAGER_INTERFACE, &error);
+	session->priv->proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+						      G_DBUS_PROXY_FLAGS_NONE,
+						      NULL,
+						      GPM_SESSION_MANAGER_SERVICE,
+						      GPM_SESSION_MANAGER_PATH,
+						      GPM_SESSION_MANAGER_INTERFACE,
+						      NULL,
+						      &error);
 	if (session->priv->proxy == NULL) {
 		g_warning ("DBUS error: %s", error->message);
 		g_error_free (error);
@@ -471,9 +557,15 @@ gpm_session_init (GpmSession *session)
 	}
 
 	/* get org.gnome.SessionManager.Presence interface */
-	session->priv->proxy_presence = dbus_g_proxy_new_for_name_owner (connection, GPM_SESSION_MANAGER_SERVICE,
-									 GPM_SESSION_MANAGER_PRESENCE_PATH,
-									 GPM_SESSION_MANAGER_PRESENCE_INTERFACE, &error);
+	g_clear_error (&error);
+	session->priv->proxy_presence = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+							       G_DBUS_PROXY_FLAGS_NONE,
+							       NULL,
+							       GPM_SESSION_MANAGER_SERVICE,
+							       GPM_SESSION_MANAGER_PRESENCE_PATH,
+							       GPM_SESSION_MANAGER_PRESENCE_INTERFACE,
+							       NULL,
+							       &error);
 	if (session->priv->proxy_presence == NULL) {
 		g_warning ("DBUS error: %s", error->message);
 		g_error_free (error);
@@ -481,26 +573,26 @@ gpm_session_init (GpmSession *session)
 	}
 
 	/* get properties interface */
-	session->priv->proxy_prop = dbus_g_proxy_new_for_name_owner (connection, GPM_SESSION_MANAGER_SERVICE,
-								     GPM_SESSION_MANAGER_PRESENCE_PATH,
-								     GPM_DBUS_PROPERTIES_INTERFACE, &error);
+	g_clear_error (&error);
+	session->priv->proxy_prop = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+						       G_DBUS_PROXY_FLAGS_NONE,
+						       NULL,
+						       GPM_SESSION_MANAGER_SERVICE,
+						       GPM_SESSION_MANAGER_PRESENCE_PATH,
+						       GPM_DBUS_PROPERTIES_INTERFACE,
+						       NULL,
+						       &error);
 	if (session->priv->proxy_prop == NULL) {
 		g_warning ("DBUS error: %s", error->message);
 		g_error_free (error);
 		return;
 	}
 
-	/* get StatusChanged */
-	dbus_g_proxy_add_signal (session->priv->proxy_presence, "StatusChanged", G_TYPE_UINT, G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal (session->priv->proxy_presence, "StatusChanged", G_CALLBACK (gpm_session_presence_status_changed_cb), session, NULL);
-
-	/* get InhibitorAdded */
-	dbus_g_proxy_add_signal (session->priv->proxy, "InhibitorAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal (session->priv->proxy, "InhibitorAdded", G_CALLBACK (gpm_session_inhibit_changed_cb), session, NULL);
+	g_signal_connect (session->priv->proxy_presence, "g-signal",
+			  G_CALLBACK (gpm_session_presence_status_changed_cb), session);
 
-	/* get InhibitorRemoved */
-	dbus_g_proxy_add_signal (session->priv->proxy, "InhibitorRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal (session->priv->proxy, "InhibitorRemoved", G_CALLBACK (gpm_session_inhibit_changed_cb), session, NULL);
+	g_signal_connect (session->priv->proxy, "g-signal",
+			  G_CALLBACK (gpm_session_inhibit_changed_cb), session);
 
 	/* coldplug */
 	session->priv->is_idle_inhibited_old = gpm_session_is_idle_inhibited (session);
@@ -523,11 +615,14 @@ gpm_session_finalize (GObject *object)
 	session = GPM_SESSION (object);
 	session->priv = gpm_session_get_instance_private (session);
 
-	g_object_unref (session->priv->proxy);
-	g_object_unref (session->priv->proxy_presence);
+	if (session->priv->proxy != NULL)
+		g_object_unref (session->priv->proxy);
+	if (session->priv->proxy_presence != NULL)
+		g_object_unref (session->priv->proxy_presence);
 	if (session->priv->proxy_client_private != NULL)
 		g_object_unref (session->priv->proxy_client_private);
-	g_object_unref (session->priv->proxy_prop);
+	if (session->priv->proxy_prop != NULL)
+		g_object_unref (session->priv->proxy_prop);
 
 	G_OBJECT_CLASS (gpm_session_parent_class)->finalize (object);
 }