Merge lp:~darkxst/unity-settings-daemon/lp1377847 into lp:unity-settings-daemon

[Tim Lunn]

Copy in Idle Monitor from 3.10 and hook up dbus interface

[Iain Lane (laney)]

Thanks, small nitpick in the inline comments.

Are you sure nothing is using the removed symbols? I know they've only been there for a short time.

review: Needs Fixing

[Iain Lane (laney)]

Also would you please remove the d/changelog editing? We'll upload this through CI train which will do that automatically from the commit message and I'm not sure if it'll add the bug reference with the manually edited version.

[lp:~darkxst/unity-settings-daemon/lp1377847]

4055. By Tim Lunn on 2014-10-08

drop changelog for CI

[Tim Lunn (darkxst)]

Laney, existing programs access the idle monitor through gnome-desktop (or gnome-session). gnome-shell does although its been using the new api for ages, and besides that is provided by mutter. which only leaves u-s-d (previously before roberts patches it would have called through via gnome-desktop as well), but there is little point for it to call out over dbus only to get itself.

[lp:~darkxst/unity-settings-daemon/lp1377847]

4056. By Tim Lunn on 2014-10-08

change acquired/name lost logs to g_debug

[Sebastien Bacher (seb128)]

Using this version I just had a segfault in gsd_idle_monitor_handle_xevent_all()

since the ppa doesn't have ddebs I can get a debug backtrace, but it segfaults in a call to g_hash_table_contains

what I did
- using unity, lock the screen manually
- walk away from the computer for half an hour
- come back and move the mouse to get the lock screen/unlock

It doesn't seem to happen every time with those steps though (or the time without touching the computer matters, I tried just waiting for the screen to dim/turn off when I did testing)

review: Needs Fixing

[Iain Lane (laney)]

That was the bug with the previous version, can you try building the package yourself and see if you can reproduce it using this branch? I didn't get a crash all day yesterday. At least if you do your own build you'll get a ddeb for a better backtrace.

[Sebastien Bacher (seb128)]

The build is the current version from https://launchpad.net/~ci-train-ppa-service/+archive/ubuntu/landing-026

Got the ddeb from http://ddebs.ubuntu.com/queue/utopic/

the bt is

"#0 0x206b6e61 in ?? ()
#1 0xb6d687f8 in g_hash_table_lookup_node (hash_return=<synthetic pointer>,
    key=0xe00015, hash_table=0x94b5b90)
    at /build/buildd/glib2.0-2.42.0/./glib/ghash.c:368
#2 g_hash_table_contains (hash_table=0x94b5b90, key=0xe00015)
    at /build/buildd/glib2.0-2.42.0/./glib/ghash.c:1267
#3 0xb76b01f4 in gsd_idle_monitor_handle_xevent (alarm_event=0xbfcdd9ec,
    alarm_event=0xbfcdd9ec, monitor=0x94a46a0) at gsd-idle-monitor.c:225
#4 gsd_idle_monitor_handle_xevent_all (xevent=0xbfcdd9ec)
    at gsd-idle-monitor.c:248
..."

[Iain Lane (laney)]

On Thu, Oct 09, 2014 at 09:14:57AM -0000, Sebastien Bacher wrote:
> The build is the current version from https://launchpad.net/~ci-train-ppa-service/+archive/ubuntu/landing-026
>
> Got the ddeb from http://ddebs.ubuntu.com/queue/utopic/
>
> the bt is
>
> "#0 0x206b6e61 in ?? ()
> #1 0xb6d687f8 in g_hash_table_lookup_node (hash_return=<synthetic pointer>,
> key=0xe00015, hash_table=0x94b5b90)
> at /build/buildd/glib2.0-2.42.0/./glib/ghash.c:368
> #2 g_hash_table_contains (hash_table=0x94b5b90, key=0xe00015)
> at /build/buildd/glib2.0-2.42.0/./glib/ghash.c:1267
> #3 0xb76b01f4 in gsd_idle_monitor_handle_xevent (alarm_event=0xbfcdd9ec,
> alarm_event=0xbfcdd9ec, monitor=0x94a46a0) at gsd-idle-monitor.c:225
> #4 gsd_idle_monitor_handle_xevent_all (xevent=0xbfcdd9ec)
> at gsd-idle-monitor.c:248
> ..."

It's the same as what we had before with earlier PPA versions - I think
that somehow the device monitor wasn't being disposed properly so we
were accessing some random bit of memory which was crashing inside glib.

With the current version I can't get this crash any more. Previously if
I used the mouse it was quite likely to crash while fading, but now this
never happens for me.

Have you managed to make it happen again?

--
Iain Lane [ <email address hidden> ]
Debian Developer [ <email address hidden> ]
Ubuntu Developer [ <email address hidden> ]

[Sebastien Bacher (seb128)]

no, it's a one time thing from this morning, I tried to run under valgrind as well, no error there

[Iain Lane (laney)]

On Thu, Oct 09, 2014 at 10:29:01AM -0000, Sebastien Bacher wrote:
> no, it's a one time thing from this morning, I tried to run under valgrind as well, no error there

I'll keep trying all day. Not sure what we should do, the bug this is
fixing is important but this crash might happen more often across all
users and will be hard to fix if it's very difficult to reproduce. :(

--
Iain Lane [ <email address hidden> ]
Debian Developer [ <email address hidden> ]
Ubuntu Developer [ <email address hidden> ]

[Sebastien Bacher (seb128)]

seems to trigger when going to unity-greeter (e.g try selecting another user from the indicator)

[Iain Lane (laney)]

Different problem, but I think I fixed this in https://code.launchpad.net/~laney/unity-settings-daemon/lp1377847-2/+merge/237846

hopefully... it's hard to gdb these refcounting bugs, I should learn to use refdbg. :)

[lp:~darkxst/unity-settings-daemon/lp1377847]

4057. By Tim Lunn on 2014-10-10

Move gdk_window_add_filter up a level

This only needs to be called once, not when creating each device

4058. By Tim Lunn on 2014-10-10

clear device_monitors pointer when disposing monitor

This is not happening when g_object_clear gets called, so we ended up with
a stale pointer here.

4059. By Tim Lunn on 2014-10-10

Take a ref on the GdkDevice to avoid a double free, to be safe also
take a ref on the gdk device_manager to ensure that doesnt get disposed.

4060. By Tim Lunn on 2014-10-10

fix build

[Sebastien Bacher (seb128)]

thanks for the update, triggering a silo rebuild with r4060.

The changes look fine, small nitpick, some g_object_(un)ref calls lack a space before the '('

[lp:~darkxst/unity-settings-daemon/lp1377847]

4061. By Tim Lunn on 2014-10-10

fix spacing on some ref/unref calls

[Tim Lunn (darkxst)]

fixed the spaces

[Sebastien Bacher (seb128)]

not sure why that merge request is still open but the change have been merged previous cycle

Unmerged revisions

4061. By Tim Lunn on 2014-10-10

fix spacing on some ref/unref calls

=== modified file 'debian/libunity-settings-daemon1.symbols'
--- debian/libunity-settings-daemon1.symbols	2014-08-29 10:24:00 +0000
+++ debian/libunity-settings-daemon1.symbols	2014-10-10 08:23:44 +0000
@@ -1,10 +1,12 @@
 libunity-settings-daemon.so.1 libunity-settings-daemon1 #MINVER#
  gsd_idle_monitor_add_idle_watch@Base 14.04.0
  gsd_idle_monitor_add_user_active_watch@Base 14.04.0
+ gsd_idle_monitor_get_core@Base 14.10
+ gsd_idle_monitor_get_for_device@Base 14.10
  gsd_idle_monitor_get_idletime@Base 14.04.0
  gsd_idle_monitor_get_type@Base 14.04.0
- gsd_idle_monitor_new@Base 14.04.0
- gsd_idle_monitor_new_for_device@Base 14.04.0
+ gsd_idle_monitor_handle_xevent_all@Base 14.10
+ gsd_idle_monitor_init_dbus@Base 14.10
  gsd_idle_monitor_remove_watch@Base 14.04.0
  gsd_pnp_ids_get_pnp_id@Base 14.04.0
  gsd_pnp_ids_get_type@Base 14.04.0

=== modified file 'gnome-settings-daemon/Makefile.am'
--- gnome-settings-daemon/Makefile.am	2014-08-29 10:24:00 +0000
+++ gnome-settings-daemon/Makefile.am	2014-10-10 08:23:44 +0000
@@ -33,6 +33,9 @@
 	gsd-idle-monitor.c \
 	gsd-idle-monitor.h
 
+nodist_libunity_settings_daemon_la_SOURCES =		\
+	$(dbus_idle_built_sources)
+
 libunity_settings_daemon_include_HEADERS =		\
 	gsd-pnp-ids.h \
 	gsd-rr.h \
@@ -55,6 +58,18 @@
 	-version-info 1:0:0 \
 	-export-symbols-regex \^gsd_.*
 
+BUILT_SOURCES = $(dbus_idle_built_sources)
+
+dbus_idle_built_sources = meta-dbus-idle-monitor.c meta-dbus-idle-monitor.h
+
+$(dbus_idle_built_sources) : Makefile.am idle-monitor.xml
+	$(AM_V_GEN)gdbus-codegen                                                        \
+		--interface-prefix org.gnome.Mutter                                     \
+		--c-namespace MetaDBus                                                  \
+		--generate-c-code meta-dbus-idle-monitor                                \
+		--c-generate-object-manager                                             \
+		$(srcdir)/idle-monitor.xml
+
 check_gl_texture_size_CPPFLAGS = \
 	$(CHECK_GL_TEXTURE_SIZE_CFLAGS)
 
@@ -99,7 +114,8 @@
 	unity-settings-daemon-localeexec
 
 EXTRA_DIST = \
-	unity-settings-daemon-localeexec.in
+	unity-settings-daemon-localeexec.in \
+	idle-monitor.xml
 
 unity-settings-daemon-localeexec: unity-settings-daemon-localeexec.in
 	$(AM_V_GEN) sed -e "s|\@libexecdir\@|$(libexecdir)|" -e "s|\@prefix\@|$(prefix)|"  $< > $@.tmp && mv $@.tmp $@
@@ -137,6 +153,7 @@
 	$(GNOME_DESKTOP_LIBS)		\
 	$(NULL)
 
-CLEANFILES = $(gsd_SCRIPTS)
+CLEANFILES = $(gsd_SCRIPTS)             \
+	$(dbus_idle_built_sources)
 
 # vim: ts=8

=== added file 'gnome-settings-daemon/gsd-idle-monitor-private.h'
--- gnome-settings-daemon/gsd-idle-monitor-private.h	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/gsd-idle-monitor-private.h	2014-10-10 08:23:44 +0000
@@ -0,0 +1,29 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* 
+ * Copyright 2013 Red Hat, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Adapted from gnome-session/gnome-session/gs-idle-monitor.c and
+ *         from gnome-desktop/libgnome-desktop/gnome-idle-monitor.c
+ */
+
+#include <X11/Xlib.h>
+#include <gsd-idle-monitor.h>
+
+void gsd_idle_monitor_handle_xevent_all (XEvent *xevent);
+
+
+void gsd_idle_monitor_init_dbus (gboolean replace);

=== modified file 'gnome-settings-daemon/gsd-idle-monitor.c'
--- gnome-settings-daemon/gsd-idle-monitor.c	2014-08-29 04:27:34 +0000
+++ gnome-settings-daemon/gsd-idle-monitor.c	2014-10-10 08:23:44 +0000
@@ -1,89 +1,144 @@
-/* -*- mode: C; c-file-style: "linux"; indent-tabs-mode: t -*-
- *
- * Adapted from gnome-session/gnome-session/gs-idle-monitor.c
- *
- * Copyright (C) 2012 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
- * GNU General Public License for more details.
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright 2013 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Adapted from gnome-session/gnome-session/gs-idle-monitor.c and
+ *         from gnome-desktop/libgnome-desktop/gnome-idle-monitor.c
+ */
+
+/**
+ * SECTION:idle-monitor
+ * @title: GsdIdleMonitor
+ * @short_description: Mutter idle counter (similar to X's IDLETIME)
  */
 
 #include "config.h"
 
-#include <time.h>
 #include <string.h>
-
 #include <X11/Xlib.h>
 #include <X11/extensions/sync.h>
-
-#include <glib.h>
+#include <gdk/gdk.h>
 #include <gdk/gdkx.h>
-#include <gdk/gdk.h>
 
 #include "gsd-idle-monitor.h"
-
-#define GSD_IDLE_MONITOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GSD_TYPE_IDLE_MONITOR, GsdIdleMonitorPrivate))
+#include "gsd-idle-monitor-private.h"
+#include "meta-dbus-idle-monitor.h"
 
 G_STATIC_ASSERT(sizeof(unsigned long) == sizeof(gpointer));
 
-struct _GsdIdleMonitorPrivate
-{
-	Display	    *display;
-
-	GHashTable  *watches;
-	GHashTable  *alarms;
-	int	     sync_event_base;
-	XSyncCounter counter;
-
-	XSyncAlarm   user_active_alarm;
-
-	GdkDevice   *device;
+struct _GsdIdleMonitor
+{
+  GObject parent_instance;
+
+  GHashTable  *watches;
+  GHashTable  *alarms;
+  int          device_id;
+
+  /* X11 implementation */
+  Display     *display;
+  int          sync_event_base;
+
+  XSyncCounter counter;
+  XSyncAlarm   user_active_alarm;
+};
+
+struct _GsdIdleMonitorClass
+{
+  GObjectClass parent_class;
 };
 
 typedef struct
 {
-	GsdIdleMonitor         *monitor;
-	guint			  id;
-	GsdIdleMonitorWatchFunc callback;
-	gpointer		  user_data;
-	GDestroyNotify		  notify;
-	XSyncAlarm		  xalarm;
+  GsdIdleMonitor          *monitor;
+  guint	                    id;
+  GsdIdleMonitorWatchFunc  callback;
+  gpointer		    user_data;
+  GDestroyNotify            notify;
+  guint64                   timeout_msec;
+
+  /* x11 */
+  XSyncAlarm                xalarm;
+  int                       idle_source_id;
 } GsdIdleMonitorWatch;
 
+typedef struct
+{
+        /* X11 implementation */
+        Display     *display;
+        int          sync_event_base;
+        int          sync_error_base;
+        unsigned int have_xsync : 1;
+
+}GsdXSync;
+
+static GsdXSync *xsync;
+
 enum
 {
-	PROP_0,
-	PROP_DEVICE,
-	PROP_LAST,
+  PROP_0,
+  PROP_DEVICE_ID,
+  PROP_LAST,
 };
 
 static GParamSpec *obj_props[PROP_LAST];
 
-static void gsd_idle_monitor_initable_iface_init (GInitableIface *iface);
+G_DEFINE_TYPE (GsdIdleMonitor, gsd_idle_monitor, G_TYPE_OBJECT)
 
-G_DEFINE_TYPE_WITH_CODE (GsdIdleMonitor, gsd_idle_monitor, G_TYPE_OBJECT,
-			 G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
-						gsd_idle_monitor_initable_iface_init))
+static GsdIdleMonitor  *device_monitors[256];
+static int              device_id_max;
 
 static gint64
 _xsyncvalue_to_int64 (XSyncValue value)
 {
-	return ((guint64) XSyncValueHigh32 (value)) << 32
-		| (guint64) XSyncValueLow32 (value);
-}
-
-#define GINT64_TO_XSYNCVALUE(value, ret) XSyncIntsToValue (ret, value, ((guint64)value) >> 32)
+  return ((guint64) XSyncValueHigh32 (value)) << 32
+    | (guint64) XSyncValueLow32 (value);
+}
+
+#define GUINT64_TO_XSYNCVALUE(value, ret) XSyncIntsToValue (ret, (value) & 0xFFFFFFFF, ((guint64)(value)) >> 32)
+
+static void
+fire_watch (GsdIdleMonitorWatch *watch)
+{
+  GsdIdleMonitor *monitor;
+  guint id;
+  gboolean is_user_active_watch;
+
+  monitor = watch->monitor;
+  g_object_ref (monitor);
+
+  if (watch->idle_source_id)
+    {
+      g_source_remove (watch->idle_source_id);
+      watch->idle_source_id = 0;
+    }
+
+  id = watch->id;
+  is_user_active_watch = (watch->timeout_msec == 0);
+
+  if (watch->callback)
+    watch->callback (monitor, id, watch->user_data);
+
+  if (is_user_active_watch)
+    gsd_idle_monitor_remove_watch (monitor, id);
+
+  g_object_unref (monitor);
+}
 
 static XSyncAlarm
 _xsync_alarm_set (GsdIdleMonitor	*monitor,
@@ -91,34 +146,34 @@
 		  guint64                interval,
 		  gboolean               want_events)
 {
-	XSyncAlarmAttributes attr;
-	XSyncValue	     delta;
-	guint		     flags;
-
-	flags = XSyncCACounter | XSyncCAValueType | XSyncCATestType |
-		XSyncCAValue | XSyncCADelta | XSyncCAEvents;
-
-	XSyncIntToValue (&delta, 0);
-	attr.trigger.counter = monitor->priv->counter;
-	attr.trigger.value_type = XSyncAbsolute;
-	attr.delta = delta;
-	attr.events = want_events;
-
-	GINT64_TO_XSYNCVALUE (interval, &attr.trigger.wait_value);
-	attr.trigger.test_type = test_type;
-	return XSyncCreateAlarm (monitor->priv->display, flags, &attr);
+  XSyncAlarmAttributes attr;
+  XSyncValue	     delta;
+  guint		     flags;
+
+  flags = XSyncCACounter | XSyncCAValueType | XSyncCATestType |
+    XSyncCAValue | XSyncCADelta | XSyncCAEvents;
+
+  XSyncIntToValue (&delta, 0);
+  attr.trigger.counter = monitor->counter;
+  attr.trigger.value_type = XSyncAbsolute;
+  attr.delta = delta;
+  attr.events = want_events;
+
+  GUINT64_TO_XSYNCVALUE (interval, &attr.trigger.wait_value);
+  attr.trigger.test_type = test_type;
+  return XSyncCreateAlarm (monitor->display, flags, &attr);
 }
 
 static void
 ensure_alarm_rescheduled (Display    *dpy,
 			  XSyncAlarm  alarm)
 {
-	XSyncAlarmAttributes attr;
+  XSyncAlarmAttributes attr;
 
-	/* Some versions of Xorg have an issue where alarms aren't
-	 * always rescheduled. Calling XSyncChangeAlarm, even
-	 * without any attributes, will reschedule the alarm. */
-	XSyncChangeAlarm (dpy, alarm, 0, &attr);
+  /* Some versions of Xorg have an issue where alarms aren't
+   * always rescheduled. Calling XSyncChangeAlarm, even
+   * without any attributes, will reschedule the alarm. */
+  XSyncChangeAlarm (dpy, alarm, 0, &attr);
 }
 
 static void
@@ -126,373 +181,366 @@
 		   XSyncAlarm  alarm,
 		   gboolean    enabled)
 {
-	XSyncAlarmAttributes attr;
-	attr.events = enabled;
-	XSyncChangeAlarm (dpy, alarm, XSyncCAEvents, &attr);
-}
-
-static void
-fire_watch (gpointer data,
-	    gpointer user_data)
-{
-	GsdIdleMonitorWatch *watch = data;
-	XSyncAlarm alarm = (XSyncAlarm) user_data;
-	GsdIdleMonitor *monitor;
-
-	if (watch->xalarm != alarm) {
-		return;
-	}
-
-	monitor = watch->monitor;
-	g_object_ref (monitor);
-
-	if (watch->callback) {
-		watch->callback (watch->monitor,
-				 watch->id,
-				 watch->user_data);
-	}
-
-	if (watch->xalarm == monitor->priv->user_active_alarm) {
-		gsd_idle_monitor_remove_watch (monitor, watch->id);
-	}
-
-	g_object_unref (monitor);
-}
-
-static void
-handle_alarm_notify_event (GsdIdleMonitor	    *monitor,
-			   XSyncAlarmNotifyEvent    *alarm_event)
-{
-	XSyncAlarm alarm;
-	GList *watches;
-	gboolean has_alarm;
-
-	if (alarm_event->state != XSyncAlarmActive) {
-		return;
-	}
-
-	alarm = alarm_event->alarm;
-
-	has_alarm = FALSE;
-
-	if (alarm == monitor->priv->user_active_alarm) {
-		set_alarm_enabled (monitor->priv->display,
-				   alarm,
-				   FALSE);
-		has_alarm = TRUE;
-	} else if (g_hash_table_contains (monitor->priv->alarms, (gpointer) alarm)) {
-		ensure_alarm_rescheduled (monitor->priv->display,
-					  alarm);
-		has_alarm = TRUE;
-	}
-
-	if (has_alarm) {
-		watches = g_hash_table_get_values (monitor->priv->watches);
-
-		g_list_foreach (watches,
-				fire_watch,
-				(gpointer) alarm);
-
-		g_list_free (watches);
-	}
-}
-
-static GdkFilterReturn
-xevent_filter (GdkXEvent	*xevent,
-	       GdkEvent		*event,
-	       GsdIdleMonitor *monitor)
-{
-	XEvent		      *ev;
-	XSyncAlarmNotifyEvent *alarm_event;
-
-	ev = xevent;
-	if (ev->xany.type != monitor->priv->sync_event_base + XSyncAlarmNotify) {
-		return GDK_FILTER_CONTINUE;
-	}
-
-	alarm_event = xevent;
-	handle_alarm_notify_event (monitor, alarm_event);
-
-	return GDK_FILTER_CONTINUE;
+  XSyncAlarmAttributes attr;
+  attr.events = enabled;
+  XSyncChangeAlarm (dpy, alarm, XSyncCAEvents, &attr);
+}
+
+static void
+check_x11_watch (gpointer data,
+                 gpointer user_data)
+{
+  GsdIdleMonitorWatch *watch = data;
+  XSyncAlarm alarm = (XSyncAlarm) user_data;
+
+  if (watch->xalarm != alarm)
+    return;
+
+  fire_watch (watch);
+}
+
+static void
+gsd_idle_monitor_handle_xevent (GsdIdleMonitor       *monitor,
+                                 XSyncAlarmNotifyEvent *alarm_event)
+{
+  XSyncAlarm alarm;
+  GList *watches;
+  gboolean has_alarm;
+
+
+  if (alarm_event->state != XSyncAlarmActive)
+    return;
+
+  alarm = alarm_event->alarm;
+
+  has_alarm = FALSE;
+
+  if (alarm == monitor->user_active_alarm)
+    {
+      set_alarm_enabled (monitor->display,
+                         alarm,
+                         FALSE);
+      has_alarm = TRUE;
+    }
+  else if (g_hash_table_contains (monitor->alarms, (gpointer) alarm))
+    {
+      ensure_alarm_rescheduled (monitor->display,
+                                alarm);
+      has_alarm = TRUE;
+    }
+
+  if (has_alarm)
+    {
+      watches = g_hash_table_get_values (monitor->watches);
+
+      g_list_foreach (watches, check_x11_watch, (gpointer) alarm);
+      g_list_free (watches);
+    }
+}
+
+void
+gsd_idle_monitor_handle_xevent_all (XEvent *xevent)
+{
+  int i;
+
+  for (i = 0; i <= device_id_max; i++)
+    if (device_monitors[i])
+      gsd_idle_monitor_handle_xevent (device_monitors[i], (XSyncAlarmNotifyEvent*)xevent);
 }
 
 static char *
-counter_name_for_device (GdkDevice *device)
+counter_name_for_device (int device_id)
 {
-	if (device) {
-		gint device_id = gdk_x11_device_get_id (device);
-		if (device_id > 0)
-			return g_strdup_printf ("DEVICEIDLETIME %d", device_id);
-	}
+  if (device_id > 0)
+    return g_strdup_printf ("DEVICEIDLETIME %d", device_id);
 
-	return g_strdup ("IDLETIME");
+  return g_strdup ("IDLETIME");
 }
 
 static XSyncCounter
 find_idletime_counter (GsdIdleMonitor *monitor)
 {
-	int		    i;
-	int		    ncounters;
-	XSyncSystemCounter *counters;
-	XSyncCounter        counter = None;
-	char               *counter_name;
-
-	counter_name = counter_name_for_device (monitor->priv->device);
-	counters = XSyncListSystemCounters (monitor->priv->display, &ncounters);
-	for (i = 0; i < ncounters; i++) {
-		if (counters[i].name != NULL && strcmp (counters[i].name, counter_name) == 0) {
-			counter = counters[i].counter;
-			break;
-		}
-	}
-	XSyncFreeSystemCounterList (counters);
-	g_free (counter_name);
-
-	return counter;
+  int		      i;
+  int		      ncounters;
+  XSyncSystemCounter *counters;
+  XSyncCounter        counter = None;
+  char               *counter_name;
+
+  counter_name = counter_name_for_device (monitor->device_id);
+  counters = XSyncListSystemCounters (monitor->display, &ncounters);
+  for (i = 0; i < ncounters; i++)
+    {
+      if (counters[i].name != NULL && strcmp (counters[i].name, counter_name) == 0)
+        {
+          counter = counters[i].counter;
+          break;
+        }
+    }
+  XSyncFreeSystemCounterList (counters);
+  g_free (counter_name);
+
+  return counter;
 }
 
 static guint32
 get_next_watch_serial (void)
 {
-	static guint32 serial = 0;
-	g_atomic_int_inc (&serial);
-	return serial;
+  static guint32 serial = 0;
+  g_atomic_int_inc (&serial);
+  return serial;
 }
 
 static void
 idle_monitor_watch_free (GsdIdleMonitorWatch *watch)
 {
-	GsdIdleMonitor *monitor;
-
-	if (watch == NULL) {
-		return;
-	}
-
-	monitor = watch->monitor;
-
-	if (watch->notify != NULL) {
-		watch->notify (watch->user_data);
-	}
-
-	if (watch->xalarm != monitor->priv->user_active_alarm) {
-		XSyncDestroyAlarm (monitor->priv->display, watch->xalarm);
-		g_hash_table_remove (monitor->priv->alarms, (gpointer) watch->xalarm);
-	}
-
-	g_slice_free (GsdIdleMonitorWatch, watch);
+  GsdIdleMonitor *monitor;
+
+  if (watch == NULL)
+    return;
+
+  monitor = watch->monitor;
+  g_object_ref (monitor);
+
+  if (watch->idle_source_id)
+    {
+      g_source_remove (watch->idle_source_id);
+      watch->idle_source_id = 0;
+    }
+
+  if (watch->notify != NULL)
+    watch->notify (watch->user_data);
+
+  if (watch->xalarm != monitor->user_active_alarm &&
+      watch->xalarm != None)
+    {
+      XSyncDestroyAlarm (monitor->display, watch->xalarm);
+      g_hash_table_remove (monitor->alarms, (gpointer) watch->xalarm);
+    }
+
+  g_object_unref (monitor);
+  g_slice_free (GsdIdleMonitorWatch, watch);
+}
+
+GdkFilterReturn
+xevent_filter (GdkXEvent *xevent,
+               GdkEvent *event,
+               GsdIdleMonitor *monitor)
+{
+  XEvent *ev;
+
+  ev = xevent;
+  if (ev->xany.type == xsync->sync_event_base + XSyncAlarmNotify) {
+      gsd_idle_monitor_handle_xevent_all (ev);
+  }
+  return GDK_FILTER_CONTINUE;
 }
 
 static void
 init_xsync (GsdIdleMonitor *monitor)
 {
-	int		    sync_error_base;
-	int		    res;
-	int		    major;
-	int		    minor;
-
-	res = XSyncQueryExtension (monitor->priv->display,
-				   &monitor->priv->sync_event_base,
-				   &sync_error_base);
-	if (! res) {
-		g_warning ("GsdIdleMonitor: Sync extension not present");
-		return;
-	}
-
-	res = XSyncInitialize (monitor->priv->display, &major, &minor);
-	if (! res) {
-		g_warning ("GsdIdleMonitor: Unable to initialize Sync extension");
-		return;
-	}
-
-	monitor->priv->counter = find_idletime_counter (monitor);
-	/* IDLETIME counter not found? */
-	if (monitor->priv->counter == None)
-		return;
-
-	monitor->priv->user_active_alarm = _xsync_alarm_set (monitor, XSyncNegativeTransition, 1, FALSE);
-
-	gdk_window_add_filter (NULL, (GdkFilterFunc)xevent_filter, monitor);
+
+  monitor->counter = find_idletime_counter (monitor);
+  /* IDLETIME counter not found? */
+  if (monitor->counter == None)
+    {
+      g_warning ("IDLETIME counter not found\n");
+      return;
+    }
+
+  monitor->user_active_alarm = _xsync_alarm_set (monitor, XSyncNegativeTransition, 1, FALSE);
 }
 
 static void
 gsd_idle_monitor_dispose (GObject *object)
 {
-	GsdIdleMonitor *monitor;
-
-	monitor = GSD_IDLE_MONITOR (object);
-
-	g_clear_pointer (&monitor->priv->watches, g_hash_table_destroy);
-	g_clear_pointer (&monitor->priv->alarms, g_hash_table_destroy);
-	g_clear_object (&monitor->priv->device);
-
-	if (monitor->priv->user_active_alarm != None) {
-		XSyncDestroyAlarm (monitor->priv->display, monitor->priv->user_active_alarm);
-		monitor->priv->user_active_alarm = None;
-	}
-
-	gdk_window_remove_filter (NULL, (GdkFilterFunc)xevent_filter, monitor);
-
-	G_OBJECT_CLASS (gsd_idle_monitor_parent_class)->dispose (object);
+  GsdIdleMonitor *monitor;
+
+  monitor = gsd_idle_monitor (object);
+
+  g_clear_pointer (&monitor->watches, g_hash_table_destroy);
+  g_clear_pointer (&monitor->alarms, g_hash_table_destroy);
+
+  if (monitor->user_active_alarm != None)
+    {
+      XSyncDestroyAlarm (monitor->display, monitor->user_active_alarm);
+      monitor->user_active_alarm = None;
+    }
+
+  device_monitors[monitor->device_id] = NULL;  
+
+  G_OBJECT_CLASS (gsd_idle_monitor_parent_class)->dispose (object);
 }
 
 static void
 gsd_idle_monitor_get_property (GObject    *object,
-				 guint       prop_id,
-				 GValue     *value,
-				 GParamSpec *pspec)
+                                guint       prop_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
 {
-	GsdIdleMonitor *monitor = GSD_IDLE_MONITOR (object);
-	switch (prop_id)
-	{
-	case PROP_DEVICE:
-		g_value_set_object (value, monitor->priv->device);
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-		break;
-	}
+  GsdIdleMonitor *monitor = gsd_idle_monitor (object);
+
+  switch (prop_id)
+    {
+    case PROP_DEVICE_ID:
+      g_value_set_int (value, monitor->device_id);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
 }
 
 static void
 gsd_idle_monitor_set_property (GObject      *object,
-				 guint         prop_id,
-				 const GValue *value,
-				 GParamSpec   *pspec)
+                                guint         prop_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
 {
-	GsdIdleMonitor *monitor = GSD_IDLE_MONITOR (object);
-	switch (prop_id)
-	{
-	case PROP_DEVICE:
-		monitor->priv->device = g_value_dup_object (value);
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-		break;
-	}
+  GsdIdleMonitor *monitor = gsd_idle_monitor (object);
+  switch (prop_id)
+    {
+    case PROP_DEVICE_ID:
+      monitor->device_id = g_value_get_int (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
 }
 
 static void
 gsd_idle_monitor_constructed (GObject *object)
 {
-	GsdIdleMonitor *monitor = GSD_IDLE_MONITOR (object);
-
-	monitor->priv->display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
-	init_xsync (monitor);
-}
-
-static gboolean
-gsd_idle_monitor_initable_init (GInitable     *initable,
-				  GCancellable  *cancellable,
-				  GError       **error)
-{
-	GsdIdleMonitor *monitor;
-
-	monitor = GSD_IDLE_MONITOR (initable);
-
-	if (monitor->priv->counter == None) {
-		g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
-				     "Per-device idletime is not supported");
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-static void
-gsd_idle_monitor_initable_iface_init (GInitableIface *iface)
-{
-	iface->init = gsd_idle_monitor_initable_init;
+  GsdIdleMonitor *monitor = gsd_idle_monitor (object);
+
+  monitor->display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
+  init_xsync (monitor);
 }
 
 static void
 gsd_idle_monitor_class_init (GsdIdleMonitorClass *klass)
 {
-	GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-	object_class->dispose = gsd_idle_monitor_dispose;
-	object_class->constructed = gsd_idle_monitor_constructed;
-	object_class->get_property = gsd_idle_monitor_get_property;
-	object_class->set_property = gsd_idle_monitor_set_property;
-
-	/**
-	 * GsdIdleMonitor:device:
-	 *
-	 * The device to listen to idletime on.
-	 */
-	obj_props[PROP_DEVICE] =
-		g_param_spec_object ("device",
-				     "Device",
-				     "The device to listen to idletime on",
-				     GDK_TYPE_DEVICE,
-				     G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
-	g_object_class_install_property (object_class, PROP_DEVICE, obj_props[PROP_DEVICE]);
-
-	g_type_class_add_private (klass, sizeof (GsdIdleMonitorPrivate));
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gsd_idle_monitor_dispose;
+  object_class->constructed = gsd_idle_monitor_constructed;
+  object_class->get_property = gsd_idle_monitor_get_property;
+  object_class->set_property = gsd_idle_monitor_set_property;
+
+  /**
+   * GsdIdleMonitor:device_id:
+   *
+   * The device to listen to idletime on.
+   */
+  obj_props[PROP_DEVICE_ID] =
+    g_param_spec_int ("device-id",
+                      "Device ID",
+                      "The device to listen to idletime on",
+                      0, 255, 0,
+                      G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+  g_object_class_install_property (object_class, PROP_DEVICE_ID, obj_props[PROP_DEVICE_ID]);
 }
 
 static void
 gsd_idle_monitor_init (GsdIdleMonitor *monitor)
 {
-	monitor->priv = GSD_IDLE_MONITOR_GET_PRIVATE (monitor);
-
-	monitor->priv->watches = g_hash_table_new_full (NULL,
-							NULL,
-							NULL,
-							(GDestroyNotify)idle_monitor_watch_free);
-
-	monitor->priv->alarms = g_hash_table_new (NULL, NULL);
+  monitor->watches = g_hash_table_new_full (NULL,
+                                                  NULL,
+                                                  NULL,
+                                                  (GDestroyNotify)idle_monitor_watch_free);
+
+  monitor->alarms = g_hash_table_new (NULL, NULL);
+}
+
+static void
+ensure_device_monitor (int device_id)
+{
+  if (device_monitors[device_id])
+    return;
+
+  device_monitors[device_id] = g_object_new (GSD_TYPE_IDLE_MONITOR, "device-id", device_id, NULL);
+  device_id_max = MAX (device_id_max, device_id);
 }
 
 /**
- * gsd_idle_monitor_new:
+ * gsd_idle_monitor_get_core:
  *
- * Returns: a new #GsdIdleMonitor that tracks the server-global
+ * Returns: (transfer none): the #GsdIdleMonitor that tracks the server-global
  * idletime for all devices. To track device-specific idletime,
- * use gsd_idle_monitor_new_for_device().
+ * use gsd_idle_monitor_get_for_device().
  */
 GsdIdleMonitor *
-gsd_idle_monitor_new (void)
+gsd_idle_monitor_get_core (void)
 {
-	return GSD_IDLE_MONITOR (g_initable_new (GSD_TYPE_IDLE_MONITOR, NULL, NULL, NULL));
+  ensure_device_monitor (0);
+  return device_monitors[0];
 }
 
 /**
- * gsd_idle_monitor_new_for_device:
- * @device: A #GdkDevice to get the idle time for.
+ * gsd_idle_monitor_get_for_device:
+ * @device_id: the device to get the idle time for.
  *
- * Returns: a new #GsdIdleMonitor that tracks the device-specific
- * idletime for @device. If device-specific idletime is not available,
- * %NULL is returned, and @error is set. To track server-global
- * idletime for all devices, use gsd_idle_monitor_new().
+ * Returns: (transfer none): a new #GsdIdleMonitor that tracks the
+ * device-specific idletime for @device. To track server-global idletime
+ * for all devices, use gsd_idle_monitor_get_core().
  */
 GsdIdleMonitor *
-gsd_idle_monitor_new_for_device (GdkDevice  *device)
-{
-	return GSD_IDLE_MONITOR (g_initable_new (GSD_TYPE_IDLE_MONITOR, NULL, NULL,
-						   "device", device, NULL));
+gsd_idle_monitor_get_for_device (int device_id)
+{
+  g_return_val_if_fail (device_id > 0 && device_id < 256, NULL);
+
+  ensure_device_monitor (device_id);
+  return device_monitors[device_id];
+}
+
+static gboolean
+fire_watch_idle (gpointer data)
+{
+  GsdIdleMonitorWatch *watch = data;
+
+  watch->idle_source_id = 0;
+  fire_watch (watch);
+
+  return FALSE;
 }
 
 static GsdIdleMonitorWatch *
-make_watch (GsdIdleMonitor          *monitor,
-	    XSyncAlarm                 xalarm,
-	    GsdIdleMonitorWatchFunc  callback,
+make_watch (GsdIdleMonitor           *monitor,
+            guint64                    timeout_msec,
+	    GsdIdleMonitorWatchFunc   callback,
 	    gpointer                   user_data,
 	    GDestroyNotify             notify)
 {
-	GsdIdleMonitorWatch *watch;
-
-	watch = g_slice_new0 (GsdIdleMonitorWatch);
-	watch->monitor = monitor;
-	watch->id = get_next_watch_serial ();
-	watch->callback = callback;
-	watch->user_data = user_data;
-	watch->notify = notify;
-	watch->xalarm = xalarm;
-
-	g_hash_table_insert (monitor->priv->watches,
-			     GUINT_TO_POINTER (watch->id),
-			     watch);
-	return watch;
+  GsdIdleMonitorWatch *watch;
+
+  watch = g_slice_new0 (GsdIdleMonitorWatch);
+  watch->monitor = monitor;
+  watch->id = get_next_watch_serial ();
+  watch->callback = callback;
+  watch->user_data = user_data;
+  watch->notify = notify;
+  watch->timeout_msec = timeout_msec;
+
+  if (timeout_msec != 0)
+    {
+      watch->xalarm = _xsync_alarm_set (monitor, XSyncPositiveTransition, timeout_msec, TRUE);
+
+      g_hash_table_add (monitor->alarms, (gpointer) watch->xalarm);
+
+      if (gsd_idle_monitor_get_idletime (monitor) > (gint64)timeout_msec)
+        watch->idle_source_id = g_idle_add (fire_watch_idle, watch);
+    }
+  else if (monitor->user_active_alarm != None)
+    {
+      watch->xalarm = monitor->user_active_alarm;
+
+      set_alarm_enabled (monitor->display, monitor->user_active_alarm, TRUE);
+    }
+
+  g_hash_table_insert (monitor->watches,
+                       GUINT_TO_POINTER (watch->id),
+                       watch);
+  return watch;
 }
 
 /**
@@ -519,25 +567,23 @@
  */
 guint
 gsd_idle_monitor_add_idle_watch (GsdIdleMonitor	       *monitor,
-				   guint64	                interval_msec,
-				   GsdIdleMonitorWatchFunc    callback,
-				   gpointer			user_data,
-				   GDestroyNotify		notify)
+                                  guint64	                interval_msec,
+                                  GsdIdleMonitorWatchFunc      callback,
+                                  gpointer			user_data,
+                                  GDestroyNotify		notify)
 {
-	GsdIdleMonitorWatch *watch;
-
-	g_return_val_if_fail (GSD_IS_IDLE_MONITOR (monitor), 0);
-
-	watch = make_watch (monitor,
-			    _xsync_alarm_set (monitor, XSyncPositiveTransition, interval_msec, TRUE),
-			    callback,
-			    user_data,
-			    notify);
-
-	g_hash_table_add (monitor->priv->alarms,
-			  (gpointer) watch->xalarm);
-
-	return watch->id;
+  GsdIdleMonitorWatch *watch;
+
+  g_return_val_if_fail (GSD_IS_IDLE_MONITOR (monitor), 0);
+  g_return_val_if_fail (interval_msec > 0, 0);
+
+  watch = make_watch (monitor,
+                      interval_msec,
+                      callback,
+                      user_data,
+                      notify);
+
+  return watch->id;
 }
 
 /**
@@ -558,25 +604,21 @@
  */
 guint
 gsd_idle_monitor_add_user_active_watch (GsdIdleMonitor          *monitor,
-					  GsdIdleMonitorWatchFunc  callback,
-					  gpointer		     user_data,
-					  GDestroyNotify	     notify)
+                                         GsdIdleMonitorWatchFunc  callback,
+                                         gpointer		   user_data,
+                                         GDestroyNotify	           notify)
 {
-	GsdIdleMonitorWatch *watch;
-
-	g_return_val_if_fail (GSD_IS_IDLE_MONITOR (monitor), 0);
-
-	set_alarm_enabled (monitor->priv->display,
-			   monitor->priv->user_active_alarm,
-			   TRUE);
-
-	watch = make_watch (monitor,
-			    monitor->priv->user_active_alarm,
-			    callback,
-			    user_data,
-			    notify);
-
-	return watch->id;
+  GsdIdleMonitorWatch *watch;
+
+  g_return_val_if_fail (GSD_IS_IDLE_MONITOR (monitor), 0);
+
+  watch = make_watch (monitor,
+                      0,
+                      callback,
+                      user_data,
+                      notify);
+
+  return watch->id;
 }
 
 /**
@@ -590,12 +632,15 @@
  */
 void
 gsd_idle_monitor_remove_watch (GsdIdleMonitor *monitor,
-				 guint		   id)
+                                guint	         id)
 {
-	g_return_if_fail (GSD_IS_IDLE_MONITOR (monitor));
+  g_return_if_fail (GSD_IS_IDLE_MONITOR (monitor));
 
-	g_hash_table_remove (monitor->priv->watches,
-			     GUINT_TO_POINTER (id));
+  g_object_ref (monitor);
+  g_hash_table_remove (monitor->watches,
+                       GUINT_TO_POINTER (id));
+  
+  g_object_unref (monitor);
 }
 
 /**
@@ -607,10 +652,326 @@
 gint64
 gsd_idle_monitor_get_idletime (GsdIdleMonitor *monitor)
 {
-	XSyncValue value;
-
-	if (!XSyncQueryCounter (monitor->priv->display, monitor->priv->counter, &value))
-		return -1;
-
-	return _xsyncvalue_to_int64 (value);
-}
+  XSyncValue value;
+
+  if (!XSyncQueryCounter (monitor->display, monitor->counter, &value))
+    return -1;
+
+  return _xsyncvalue_to_int64 (value);
+}
+
+static gboolean
+handle_get_idletime (MetaDBusIdleMonitor   *skeleton,
+                     GDBusMethodInvocation *invocation,
+                     GsdIdleMonitor       *monitor)
+{
+  guint64 idletime;
+
+  idletime = gsd_idle_monitor_get_idletime (monitor);
+  meta_dbus_idle_monitor_complete_get_idletime (skeleton, invocation, idletime);
+
+  return TRUE;
+}
+
+typedef struct {
+  MetaDBusIdleMonitor *dbus_monitor;
+  GsdIdleMonitor *monitor;
+  char *dbus_name;
+  guint watch_id;
+  guint name_watcher_id;
+} DBusWatch;
+
+static void
+destroy_dbus_watch (gpointer data)
+{
+  DBusWatch *watch = data;
+
+  g_object_unref (watch->dbus_monitor);
+  g_object_unref (watch->monitor);
+  g_free (watch->dbus_name);
+  g_bus_unwatch_name (watch->name_watcher_id);
+
+  g_slice_free (DBusWatch, watch);
+}
+
+static void
+dbus_idle_callback (GsdIdleMonitor *monitor,
+                    guint            watch_id,
+                    gpointer         user_data)
+{
+  DBusWatch *watch = user_data;
+  GDBusInterfaceSkeleton *skeleton = G_DBUS_INTERFACE_SKELETON (watch->dbus_monitor);
+
+  g_dbus_connection_emit_signal (g_dbus_interface_skeleton_get_connection (skeleton),
+                                 watch->dbus_name,
+                                 g_dbus_interface_skeleton_get_object_path (skeleton),
+                                 "org.gnome.Mutter.IdleMonitor",
+                                 "WatchFired",
+                                 g_variant_new ("(u)", watch_id),
+                                 NULL);
+}
+
+static void
+name_vanished_callback (GDBusConnection *connection,
+                        const char      *name,
+                        gpointer         user_data)
+{
+  DBusWatch *watch = user_data;
+
+  gsd_idle_monitor_remove_watch (watch->monitor, watch->watch_id);
+
+  if (xsync)
+    g_slice_free(GsdXSync, xsync);
+}
+
+static DBusWatch *
+make_dbus_watch (MetaDBusIdleMonitor   *skeleton,
+                 GDBusMethodInvocation *invocation,
+                 GsdIdleMonitor       *monitor)
+{
+  DBusWatch *watch;
+
+  watch = g_slice_new (DBusWatch);
+  watch->dbus_monitor = g_object_ref (skeleton);
+  watch->monitor = g_object_ref (monitor);
+  watch->dbus_name = g_strdup (g_dbus_method_invocation_get_sender (invocation));
+  watch->name_watcher_id = g_bus_watch_name_on_connection (g_dbus_method_invocation_get_connection (invocation),
+                                                           watch->dbus_name,
+                                                           G_BUS_NAME_WATCHER_FLAGS_NONE,
+                                                           NULL, /* appeared */
+                                                           name_vanished_callback,
+                                                           watch, NULL);
+
+  return watch;
+}
+
+static gboolean
+handle_add_idle_watch (MetaDBusIdleMonitor   *skeleton,
+                       GDBusMethodInvocation *invocation,
+                       guint64                interval,
+                       GsdIdleMonitor       *monitor)
+{
+  DBusWatch *watch;
+
+  watch = make_dbus_watch (skeleton, invocation, monitor);
+  watch->watch_id = gsd_idle_monitor_add_idle_watch (monitor, interval,
+                                                      dbus_idle_callback, watch, destroy_dbus_watch);
+
+  meta_dbus_idle_monitor_complete_add_idle_watch (skeleton, invocation, watch->watch_id);
+
+  return TRUE;
+}
+
+static gboolean
+handle_add_user_active_watch (MetaDBusIdleMonitor   *skeleton,
+                              GDBusMethodInvocation *invocation,
+                              GsdIdleMonitor       *monitor)
+{
+  DBusWatch *watch;
+
+  watch = make_dbus_watch (skeleton, invocation, monitor);
+  watch->watch_id = gsd_idle_monitor_add_user_active_watch (monitor,
+                                                             dbus_idle_callback, watch,
+                                                             destroy_dbus_watch);
+
+  meta_dbus_idle_monitor_complete_add_user_active_watch (skeleton, invocation, watch->watch_id);
+
+  return TRUE;
+}
+
+static gboolean
+handle_remove_watch (MetaDBusIdleMonitor   *skeleton,
+                     GDBusMethodInvocation *invocation,
+                     guint                  id,
+                     GsdIdleMonitor       *monitor)
+{
+  gsd_idle_monitor_remove_watch (monitor, id);
+  meta_dbus_idle_monitor_complete_remove_watch (skeleton, invocation);
+
+  return TRUE;
+}
+
+static void
+create_monitor_skeleton (GDBusObjectManagerServer *manager,
+                         GsdIdleMonitor          *monitor,
+                         const char               *path)
+{
+  MetaDBusIdleMonitor *skeleton;
+  MetaDBusObjectSkeleton *object;
+
+  skeleton = meta_dbus_idle_monitor_skeleton_new ();
+  g_signal_connect_object (skeleton, "handle-add-idle-watch",
+                           G_CALLBACK (handle_add_idle_watch), monitor, 0);
+  g_signal_connect_object (skeleton, "handle-add-user-active-watch",
+                           G_CALLBACK (handle_add_user_active_watch), monitor, 0);
+  g_signal_connect_object (skeleton, "handle-remove-watch",
+                           G_CALLBACK (handle_remove_watch), monitor, 0);
+  g_signal_connect_object (skeleton, "handle-get-idletime",
+                           G_CALLBACK (handle_get_idletime), monitor, 0);
+
+  object = meta_dbus_object_skeleton_new (path);
+  meta_dbus_object_skeleton_set_idle_monitor (object, skeleton);
+
+  g_dbus_object_manager_server_export (manager, G_DBUS_OBJECT_SKELETON (object));
+
+  g_object_unref (skeleton);
+  g_object_unref (object);
+}
+
+static void
+on_device_added (GdkDeviceManager         *device_manager,
+                 GdkDevice                *device,
+                 GDBusObjectManagerServer *manager)
+{
+
+  GsdIdleMonitor *monitor;
+  int device_id;
+  char *path;
+
+  g_object_ref (device);
+  device_id = gdk_x11_device_get_id (device);
+  monitor = gsd_idle_monitor_get_for_device (device_id);
+  g_object_ref (monitor);
+  path = g_strdup_printf ("/org/gnome/Mutter/IdleMonitor/Device%d", device_id);
+
+  create_monitor_skeleton (manager, monitor, path);
+  g_free (path);
+}
+
+static void
+on_device_removed (GdkDeviceManager         *device_manager,
+                   GdkDevice                *device,
+                   GDBusObjectManagerServer *manager)
+{
+  int device_id;
+  char *path;
+
+  device_id = gdk_x11_device_get_id (device);
+  path = g_strdup_printf ("/org/gnome/Mutter/IdleMonitor/Device%d", device_id);
+  g_dbus_object_manager_server_unexport (manager, path);
+  g_free (path);
+
+  g_object_unref (device_monitors[device_id]);
+  g_clear_object (&device_monitors[device_id]);
+  if (device_id == device_id_max)
+    device_id_max--;
+}
+
+static void
+on_bus_acquired (GDBusConnection *connection,
+                 const char      *name,
+                 gpointer         user_data)
+{
+  GDBusObjectManagerServer *manager;
+  GdkDeviceManager *device_manager;
+  GsdIdleMonitor *monitor;
+  GList *devices, *iter;
+  char *path;
+
+  manager = g_dbus_object_manager_server_new ("/org/gnome/Mutter/IdleMonitor");
+
+  /* We never clear the core monitor, as that's supposed to cumulate idle times from
+     all devices */
+  monitor = gsd_idle_monitor_get_core ();
+  path = g_strdup ("/org/gnome/Mutter/IdleMonitor/Core");
+  create_monitor_skeleton (manager, monitor, path);
+  g_free (path);
+
+  device_manager =  gdk_display_get_device_manager (gdk_display_get_default ());
+  g_object_ref (device_manager);
+
+  devices =  gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
+  devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
+  devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
+
+  for (iter = devices; iter; iter = iter->next)
+    on_device_added (device_manager, iter->data, manager);
+
+  g_list_free (devices);
+
+  g_signal_connect_object (device_manager, "device-added",
+                           G_CALLBACK (on_device_added), manager, 0);
+  g_signal_connect_object (device_manager, "device-removed",
+                           G_CALLBACK (on_device_removed), manager, 0);
+
+  g_dbus_object_manager_server_set_connection (manager, connection);
+
+  gdk_window_add_filter (NULL, (GdkFilterFunc)xevent_filter, monitor);
+}
+
+static void
+on_name_acquired (GDBusConnection *connection,
+                  const char      *name,
+                  gpointer         user_data)
+{
+  g_debug ("Acquired name %s\n", name);
+}
+
+static void
+on_name_lost (GDBusConnection *connection,
+              const char      *name,
+              gpointer         user_data)
+{
+  g_debug ("Lost or failed to acquire name %s\n", name);
+
+  gdk_window_remove_filter (NULL, (GdkFilterFunc)xevent_filter, NULL);
+  //mainloop_quit();
+}
+
+static void
+init_xsync_global (void)
+{
+    int major, minor;
+    xsync->display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
+    xsync->have_xsync = FALSE;
+
+    xsync->sync_error_base = 0;
+    xsync->sync_event_base = 0;
+
+    /* I don't think we really have to fill these in */
+    major = SYNC_MAJOR_VERSION;
+    minor = SYNC_MINOR_VERSION;
+
+    if (!XSyncQueryExtension (xsync->display,
+                              &xsync->sync_event_base,
+                              &xsync->sync_error_base) ||
+        !XSyncInitialize (xsync->display,
+                          &major, &minor))
+      {
+        xsync->sync_error_base = 0;
+        xsync->sync_event_base = 0;
+      }
+    else
+      {
+        xsync->have_xsync = TRUE;
+        XSyncSetPriority (xsync->display, None, 10);
+      }
+
+    g_warning ("Attempted to init Xsync, found version %d.%d error base %d event base %d\n",
+                  major, minor,
+                  xsync->sync_error_base,
+                  xsync->sync_event_base);
+}
+
+void
+gsd_idle_monitor_init_dbus (gboolean replace)
+{
+  static int dbus_name_id;
+
+  if (dbus_name_id > 0)
+    return;
+
+  xsync = g_slice_new0 (GsdXSync);
+  init_xsync_global();
+
+  dbus_name_id = g_bus_own_name (G_BUS_TYPE_SESSION,
+                                 "org.gnome.Mutter.IdleMonitor",
+                                 G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
+                                 (replace ?
+                                  G_BUS_NAME_OWNER_FLAGS_REPLACE : 0),
+                                 on_bus_acquired,
+                                 on_name_acquired,
+                                 on_name_lost,
+                                 NULL, NULL);
+}
+

=== modified file 'gnome-settings-daemon/gsd-idle-monitor.h'
--- gnome-settings-daemon/gsd-idle-monitor.h	2014-08-29 04:27:34 +0000
+++ gnome-settings-daemon/gsd-idle-monitor.h	2014-10-10 08:23:44 +0000
@@ -1,81 +1,61 @@
-/* -*- mode: C; c-file-style: "linux"; indent-tabs-mode: t -*-
- *
- * Adapted from gnome-session/gnome-session/gs-idle-monitor.h
- *
- * Copyright (C) 2012 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright 2013 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *
- * Authors: William Jon McCann <[e-mail]>
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
  */
 
-#ifndef __GSD_IDLE_MONITOR_H__
-#define __GSD_IDLE_MONITOR_H__
+#ifndef gsd_idle_monitor_H
+#define gsd_idle_monitor_H
 
 #include <glib-object.h>
-#include <gdk/gdk.h>
-
-G_BEGIN_DECLS
-
-#define GSD_TYPE_IDLE_MONITOR         (gsd_idle_monitor_get_type ())
-#define GSD_IDLE_MONITOR(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GSD_TYPE_IDLE_MONITOR, GsdIdleMonitor))
-#define GSD_IDLE_MONITOR_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), GSD_TYPE_IDLE_MONITOR, GsdIdleMonitorClass))
-#define GSD_IS_IDLE_MONITOR(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSD_TYPE_IDLE_MONITOR))
-#define GSD_IS_IDLE_MONITOR_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GSD_TYPE_IDLE_MONITOR))
-#define GSD_IDLE_MONITOR_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GSD_TYPE_IDLE_MONITOR, GsdIdleMonitorClass))
-
-typedef struct _GsdIdleMonitor GsdIdleMonitor;
-typedef struct _GsdIdleMonitorClass GsdIdleMonitorClass;
-typedef struct _GsdIdleMonitorPrivate GsdIdleMonitorPrivate;
-
-struct _GsdIdleMonitor
-{
-        GObject                  parent;
-        GsdIdleMonitorPrivate *priv;
-};
-
-struct _GsdIdleMonitorClass
-{
-        GObjectClass          parent_class;
-};
-
-typedef void (*GsdIdleMonitorWatchFunc) (GsdIdleMonitor      *monitor,
-                                           guint                  id,
-                                           gpointer               user_data);
-
-GType              gsd_idle_monitor_get_type     (void);
-
-GsdIdleMonitor * gsd_idle_monitor_new          (void);
-GsdIdleMonitor * gsd_idle_monitor_new_for_device (GdkDevice *device);
-
-guint              gsd_idle_monitor_add_idle_watch    (GsdIdleMonitor         *monitor,
-							 guint64                   interval_msec,
-							 GsdIdleMonitorWatchFunc callback,
-							 gpointer                  user_data,
-							 GDestroyNotify            notify);
-
-guint              gsd_idle_monitor_add_user_active_watch (GsdIdleMonitor          *monitor,
-							     GsdIdleMonitorWatchFunc  callback,
-							     gpointer		     user_data,
-							     GDestroyNotify	     notify);
-
-void               gsd_idle_monitor_remove_watch (GsdIdleMonitor         *monitor,
-                                                    guint                     id);
-
-gint64             gsd_idle_monitor_get_idletime (GsdIdleMonitor         *monitor);
-
-G_END_DECLS
-
-#endif /* __GSD_IDLE_MONITOR_H__ */
+
+#define GSD_TYPE_IDLE_MONITOR            (gsd_idle_monitor_get_type ())
+#define gsd_idle_monitor(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSD_TYPE_IDLE_MONITOR, GsdIdleMonitor))
+#define gsd_idle_monitor_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  GSD_TYPE_IDLE_MONITOR, GsdIdleMonitorClass))
+#define GSD_IS_IDLE_MONITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSD_TYPE_IDLE_MONITOR))
+#define GSD_IS_IDLE_MONITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  GSD_TYPE_IDLE_MONITOR))
+#define gsd_idle_monitor_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  GSD_TYPE_IDLE_MONITOR, GsdIdleMonitorClass))
+
+typedef struct _GsdIdleMonitor        GsdIdleMonitor;
+typedef struct _GsdIdleMonitorClass   GsdIdleMonitorClass;
+
+GType gsd_idle_monitor_get_type (void);
+
+typedef void (*GsdIdleMonitorWatchFunc) (GsdIdleMonitor *monitor,
+                                          guint            watch_id,
+                                          gpointer         user_data);
+
+GsdIdleMonitor *gsd_idle_monitor_get_core (void);
+GsdIdleMonitor *gsd_idle_monitor_get_for_device (int device_id);
+
+guint         gsd_idle_monitor_add_idle_watch        (GsdIdleMonitor          *monitor,
+						       guint64                   interval_msec,
+						       GsdIdleMonitorWatchFunc  callback,
+						       gpointer                  user_data,
+						       GDestroyNotify            notify);
+
+guint         gsd_idle_monitor_add_user_active_watch (GsdIdleMonitor          *monitor,
+						       GsdIdleMonitorWatchFunc  callback,
+						       gpointer                  user_data,
+						       GDestroyNotify            notify);
+
+void          gsd_idle_monitor_remove_watch          (GsdIdleMonitor          *monitor,
+						       guint                     id);
+gint64        gsd_idle_monitor_get_idletime          (GsdIdleMonitor          *monitor);
+
+#endif

=== added file 'gnome-settings-daemon/idle-monitor.xml'
--- gnome-settings-daemon/idle-monitor.xml	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/idle-monitor.xml	2014-10-10 08:23:44 +0000
@@ -0,0 +1,35 @@
+<!DOCTYPE node PUBLIC
+'-//freedesktop//DTD D-BUS Object Introspection 1.0//EN'
+'http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd'>
+<node>
+  <!--
+      org.gnome.Mutter.IdleMonitor:
+      @short_description: idle monitor interface
+
+      This interface is used by gnome-desktop to implement
+      user activity monitoring.
+  -->
+
+  <interface name="org.gnome.Mutter.IdleMonitor">
+    <method name="GetIdletime">
+      <arg name="idletime" direction="out" type="t"/>
+    </method>
+
+    <method name="AddIdleWatch">
+      <arg name="interval" direction="in" type="t" />
+      <arg name="id" direction="out" type="u" />
+    </method>
+
+    <method name="AddUserActiveWatch">
+      <arg name="id" direction="out" type="u" />
+    </method>
+
+    <method name="RemoveWatch">
+      <arg name="id" direction="in" type="u" />
+    </method>
+
+    <signal name="WatchFired">
+      <arg name="id" direction="out" type="u" />
+    </signal>
+  </interface>
+</node>

=== modified file 'gnome-settings-daemon/main.c'
--- gnome-settings-daemon/main.c	2013-11-13 01:37:21 +0000
+++ gnome-settings-daemon/main.c	2014-10-10 08:23:44 +0000
@@ -37,6 +37,7 @@
 #include "gnome-settings-plugin.h"
 #include "gnome-settings-profile.h"
 #include "gnome-settings-session.h"
+#include "gsd-idle-monitor-private.h"
 
 #define GNOME_SESSION_DBUS_NAME      "org.gnome.SessionManager"
 #define GNOME_SESSION_CLIENT_PRIVATE_DBUS_INTERFACE "org.gnome.SessionManager.ClientPrivate"
@@ -55,6 +56,8 @@
         {NULL}
 };
 
+
+
 static gboolean
 timed_exit_cb (void)
 {
@@ -444,6 +447,7 @@
                 g_setenv ("G_MESSAGES_DEBUG", "all", FALSE);
 }
 
+
 int
 main (int argc, char *argv[])
 {
@@ -454,6 +458,7 @@
         textdomain (GETTEXT_PACKAGE);
         setlocale (LC_ALL, "");
 
+
         parse_args (&argc, &argv);
 
         gnome_settings_profile_start ("opening gtk display");
@@ -472,6 +477,8 @@
         if (do_timed_exit) {
                 g_timeout_add_seconds (30, (GSourceFunc) timed_exit_cb, NULL);
         }
+     
+        gsd_idle_monitor_init_dbus (replace);
 
         gtk_main ();
 

=== modified file 'plugins/cursor/gsd-cursor-manager.c'
--- plugins/cursor/gsd-cursor-manager.c	2014-08-29 04:27:34 +0000
+++ plugins/cursor/gsd-cursor-manager.c	2014-10-10 08:23:44 +0000
@@ -129,10 +129,14 @@
                        gpointer        user_data)
 {
         GdkDevice *device;
+        int device_id;
         GsdCursorManager *manager = GSD_CURSOR_MANAGER (user_data);
+        GdkDeviceManager *device_manager;
 
         /* Oh, so you're active? */
-        g_object_get (G_OBJECT (monitor), "device", &device, NULL);
+        g_object_get (G_OBJECT (monitor), "device_id", &device_id, NULL);
+        device_manager =  gdk_display_get_device_manager (gdk_display_get_default ());
+        device = gdk_x11_device_manager_lookup (device_manager, device_id);
         g_debug ("Device %d '%s' became active", gdk_x11_device_get_id (device), gdk_device_get_name (device));
         set_cursor_visibility (manager,
                                gdk_device_get_source (device) != GDK_SOURCE_TOUCHSCREEN);
@@ -154,6 +158,7 @@
             GError          **error)
 {
         GsdIdleMonitor *monitor;
+        int device_id;
 
         if (g_hash_table_lookup (manager->priv->monitors, device) != NULL)
                 return TRUE;
@@ -165,7 +170,8 @@
                 return TRUE;
 
         /* Create IdleMonitors for each pointer device */
-        monitor = gsd_idle_monitor_new_for_device (device);
+        device_id = gdk_x11_device_get_id (device);
+        monitor = gsd_idle_monitor_get_for_device (device_id);
         if (!monitor) {
                 g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                              "Per-device idletime monitor not available");

=== modified file 'plugins/power/gsd-power-manager.c'
--- plugins/power/gsd-power-manager.c	2014-08-29 04:27:34 +0000
+++ plugins/power/gsd-power-manager.c	2014-10-10 08:23:44 +0000
@@ -3548,7 +3548,7 @@
                                                                   "use-time-for-policy");
 
         /* create IDLETIME watcher */
-        manager->priv->idle_monitor = gsd_idle_monitor_new ();
+        manager->priv->idle_monitor = gsd_idle_monitor_get_core ();
 
         /* set up the screens */
         g_signal_connect (manager->priv->rr_screen, "changed", G_CALLBACK (on_randr_event), manager);