backends: Remove X11 idle-monitor backend

And use the old "native" backend for both X11 and Wayland. This will
allow us to share fixes between implementations without having to delve
into the XSync X11 extension code.

https://bugzilla.gnome.org/show_bug.cgi?id=705942

14 files changed, 151 insertions, 763 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index be3010c28..1579c8b9c 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -183,8 +183,6 @@ libmutter_@LIBMUTTER_API_VERSION@_la_SOURCES =	\
 	backends/x11/nested/meta-cursor-renderer-x11-nested.h		\
 	backends/x11/nested/meta-renderer-x11-nested.c	\
 	backends/x11/nested/meta-renderer-x11-nested.h	\
-	backends/x11/meta-idle-monitor-xsync.c		\
-	backends/x11/meta-idle-monitor-xsync.h		\
 	backends/x11/meta-input-settings-x11.c		\
 	backends/x11/meta-input-settings-x11.h		\
 	backends/x11/meta-monitor-manager-xrandr.c	\
@@ -487,8 +485,6 @@ libmutter_@LIBMUTTER_API_VERSION@_la_SOURCES +=		\
 	backends/native/meta-default-modes.h		\
 	backends/native/meta-gpu-kms.c			\
 	backends/native/meta-gpu-kms.h			\
-	backends/native/meta-idle-monitor-native.c	\
-	backends/native/meta-idle-monitor-native.h	\
 	backends/native/meta-input-settings-native.c	\
 	backends/native/meta-input-settings-native.h	\
 	backends/native/meta-monitor-manager-kms.c	\
diff --git a/src/backends/meta-backend-private.h b/src/backends/meta-backend-private.h
index 0dc6bf77a..a25275499 100644
--- a/src/backends/meta-backend-private.h
+++ b/src/backends/meta-backend-private.h
@@ -59,8 +59,6 @@ struct _MetaBackendClass
 
   void (* post_init) (MetaBackend *backend);
 
-  MetaIdleMonitor * (* create_idle_monitor) (MetaBackend *backend,
-                                             int          device_id);
   MetaMonitorManager * (* create_monitor_manager) (MetaBackend *backend,
                                                    GError     **error);
   MetaCursorRenderer * (* create_cursor_renderer) (MetaBackend *backend);
diff --git a/src/backends/meta-backend.c b/src/backends/meta-backend.c
index 4ebceb4ea..de20cddfe 100644
--- a/src/backends/meta-backend.c
+++ b/src/backends/meta-backend.c
@@ -222,7 +222,9 @@ static MetaIdleMonitor *
 meta_backend_create_idle_monitor (MetaBackend *backend,
                                   int          device_id)
 {
-  return META_BACKEND_GET_CLASS (backend)->create_idle_monitor (backend, device_id);
+  return g_object_new (META_TYPE_IDLE_MONITOR,
+                       "device-id", device_id,
+                       NULL);
 }
 
 static void
diff --git a/src/backends/meta-idle-monitor-private.h b/src/backends/meta-idle-monitor-private.h
index 7a7021559..89b80ba43 100644
--- a/src/backends/meta-idle-monitor-private.h
+++ b/src/backends/meta-idle-monitor-private.h
@@ -26,9 +26,6 @@
 #include <meta/meta-idle-monitor.h>
 #include "display-private.h"
 
-#include <X11/Xlib.h>
-#include <X11/extensions/sync.h>
-
 typedef struct
 {
   MetaIdleMonitor          *monitor;
@@ -38,6 +35,7 @@ typedef struct
   GDestroyNotify            notify;
   guint64                   timeout_msec;
   int                       idle_source_id;
+  GSource                  *timeout_source;
 } MetaIdleMonitorWatch;
 
 struct _MetaIdleMonitor
@@ -46,20 +44,15 @@ struct _MetaIdleMonitor
 
   GHashTable *watches;
   int device_id;
+  guint64 last_event_time;
 };
 
 struct _MetaIdleMonitorClass
 {
   GObjectClass parent_class;
-
-  gint64 (*get_idletime) (MetaIdleMonitor *monitor);
-  MetaIdleMonitorWatch * (*make_watch) (MetaIdleMonitor           *monitor,
-                                        guint64                    timeout_msec,
-                                        MetaIdleMonitorWatchFunc   callback,
-                                        gpointer                   user_data,
-                                        GDestroyNotify             notify);
 };
 
 void _meta_idle_monitor_watch_fire (MetaIdleMonitorWatch *watch);
+void meta_idle_monitor_reset_idletime (MetaIdleMonitor *monitor);
 
 #endif /* META_IDLE_MONITOR_PRIVATE_H */
diff --git a/src/backends/meta-idle-monitor.c b/src/backends/meta-idle-monitor.c
index 18d6155c1..3dc098f4d 100644
--- a/src/backends/meta-idle-monitor.c
+++ b/src/backends/meta-idle-monitor.c
@@ -152,8 +152,34 @@ meta_idle_monitor_class_init (MetaIdleMonitorClass *klass)
 }
 
 static void
+free_watch (gpointer data)
+{
+  MetaIdleMonitorWatch *watch = (MetaIdleMonitorWatch *) data;
+  MetaIdleMonitor *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->timeout_source != NULL)
+    g_source_destroy (watch->timeout_source);
+
+  g_object_unref (monitor);
+  g_slice_free (MetaIdleMonitorWatch, watch);
+}
+
+static void
 meta_idle_monitor_init (MetaIdleMonitor *monitor)
 {
+  monitor->watches = g_hash_table_new_full (NULL, NULL, NULL, free_watch);
+  monitor->last_event_time = g_get_monotonic_time ();
 }
 
 /**
@@ -185,6 +211,36 @@ meta_idle_monitor_get_for_device (int device_id)
   return meta_backend_get_idle_monitor (backend, device_id);
 }
 
+static guint32
+get_next_watch_serial (void)
+{
+  static guint32 serial = 0;
+
+  g_atomic_int_inc (&serial);
+
+  return serial;
+}
+
+static gboolean
+idle_monitor_dispatch_timeout (GSource     *source,
+                               GSourceFunc  callback,
+                               gpointer     user_data)
+{
+  MetaIdleMonitorWatch *watch = (MetaIdleMonitorWatch *) user_data;
+
+  _meta_idle_monitor_watch_fire (watch);
+  g_source_set_ready_time (watch->timeout_source, -1);
+
+  return TRUE;
+}
+
+static GSourceFuncs idle_monitor_source_funcs = {
+  .prepare = NULL,
+  .check = NULL,
+  .dispatch = idle_monitor_dispatch_timeout,
+  .finalize = NULL,
+};
+
 static MetaIdleMonitorWatch *
 make_watch (MetaIdleMonitor           *monitor,
             guint64                    timeout_msec,
@@ -194,11 +250,28 @@ make_watch (MetaIdleMonitor           *monitor,
 {
   MetaIdleMonitorWatch *watch;
 
-  watch = META_IDLE_MONITOR_GET_CLASS (monitor)->make_watch (monitor,
-                                                             timeout_msec,
-                                                             callback,
-                                                             user_data,
-                                                             notify);
+  watch = g_slice_new0 (MetaIdleMonitorWatch);
+
+  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)
+    {
+      GSource *source = g_source_new (&idle_monitor_source_funcs,
+                                      sizeof (GSource));
+
+      g_source_set_callback (source, NULL, watch, NULL);
+      g_source_set_ready_time (source,
+                               monitor->last_event_time + timeout_msec * 1000);
+      g_source_attach (source, NULL);
+      g_source_unref (source);
+
+      watch->timeout_source = source;
+    }
 
   g_hash_table_insert (monitor->watches,
                        GUINT_TO_POINTER (watch->id),
@@ -314,5 +387,39 @@ meta_idle_monitor_remove_watch (MetaIdleMonitor *monitor,
 gint64
 meta_idle_monitor_get_idletime (MetaIdleMonitor *monitor)
 {
-  return META_IDLE_MONITOR_GET_CLASS (monitor)->get_idletime (monitor);
+  return (g_get_monotonic_time () - monitor->last_event_time) / 1000;
+}
+
+void
+meta_idle_monitor_reset_idletime (MetaIdleMonitor *monitor)
+{
+  GList *node, *watch_ids;
+
+  monitor->last_event_time = g_get_monotonic_time ();
+
+  watch_ids = g_hash_table_get_keys (monitor->watches);
+
+  for (node = watch_ids; node != NULL; node = node->next)
+    {
+      guint watch_id = GPOINTER_TO_UINT (node->data);
+      MetaIdleMonitorWatch *watch;
+
+      watch = g_hash_table_lookup (monitor->watches,
+                                   GUINT_TO_POINTER (watch_id));
+      if (!watch)
+        continue;
+
+      if (watch->timeout_msec == 0)
+        {
+          _meta_idle_monitor_watch_fire ((MetaIdleMonitorWatch *) watch);
+        }
+      else
+        {
+          g_source_set_ready_time (watch->timeout_source,
+                                   monitor->last_event_time +
+                                   watch->timeout_msec * 1000);
+        }
+    }
+
+  g_list_free (watch_ids);
 }
diff --git a/src/backends/meta-monitor-manager.c b/src/backends/meta-monitor-manager.c
index e952e4f75..829c189ea 100644
--- a/src/backends/meta-monitor-manager.c
+++ b/src/backends/meta-monitor-manager.c
@@ -578,8 +578,6 @@ meta_monitor_manager_ensure_configured (MetaMonitorManager *manager)
                                                        &error))
         {
           g_clear_object (&config);
-          g_warning ("Failed to use linear monitor configuration: %s",
-                     error->message);
           g_clear_error (&error);
         }
       else
@@ -597,8 +595,6 @@ meta_monitor_manager_ensure_configured (MetaMonitorManager *manager)
                                                        &error))
         {
           g_clear_object (&config);
-          g_warning ("Failed to use fallback monitor configuration: %s",
-                 error->message);
           g_clear_error (&error);
         }
       else
diff --git a/src/backends/native/meta-backend-native.c b/src/backends/native/meta-backend-native.c
index e0e1cfa47..4c2342ff5 100644
--- a/src/backends/native/meta-backend-native.c
+++ b/src/backends/native/meta-backend-native.c
@@ -35,11 +35,11 @@
 #include "clutter/evdev/clutter-evdev.h"
 #include "meta-barrier-native.h"
 #include "meta-border.h"
-#include "meta-idle-monitor-native.h"
 #include "meta-monitor-manager-kms.h"
 #include "meta-cursor-renderer-native.h"
 #include "meta-launcher.h"
 #include "backends/meta-cursor-tracker-private.h"
+#include "backends/meta-idle-monitor-private.h"
 #include "backends/meta-logical-monitor.h"
 #include "backends/meta-monitor-manager-private.h"
 #include "backends/meta-pointer-constraint.h"
@@ -108,7 +108,7 @@ prepare_for_sleep_cb (GDBusConnection *connection,
   g_variant_get (parameters, "(b)", &suspending);
   if (suspending)
     return;
-  meta_idle_monitor_native_reset_idletime (meta_idle_monitor_get_core ());
+  meta_idle_monitor_reset_idletime (meta_idle_monitor_get_core ());
 }
 
 static void
@@ -145,7 +145,7 @@ lid_is_closed_changed_cb (UpClient   *client,
   if (up_client_get_lid_is_closed (client))
     return;
 
-  meta_idle_monitor_native_reset_idletime (meta_idle_monitor_get_core ());
+  meta_idle_monitor_reset_idletime (meta_idle_monitor_get_core ());
 }
 
 static void
@@ -398,15 +398,6 @@ meta_backend_native_post_init (MetaBackend *backend)
                                             meta_backend_get_monitor_manager (backend));
 }
 
-static MetaIdleMonitor *
-meta_backend_native_create_idle_monitor (MetaBackend *backend,
-                                         int          device_id)
-{
-  return g_object_new (META_TYPE_IDLE_MONITOR_NATIVE,
-                       "device-id", device_id,
-                       NULL);
-}
-
 static MetaMonitorManager *
 meta_backend_native_create_monitor_manager (MetaBackend *backend,
                                             GError     **error)
@@ -604,7 +595,6 @@ meta_backend_native_class_init (MetaBackendNativeClass *klass)
 
   backend_class->post_init = meta_backend_native_post_init;
 
-  backend_class->create_idle_monitor = meta_backend_native_create_idle_monitor;
   backend_class->create_monitor_manager = meta_backend_native_create_monitor_manager;
   backend_class->create_cursor_renderer = meta_backend_native_create_cursor_renderer;
   backend_class->create_renderer = meta_backend_native_create_renderer;
@@ -747,5 +737,5 @@ void meta_backend_native_resume (MetaBackendNative *native)
   meta_cursor_renderer_native_force_update (cursor_renderer_native);
 
   idle_monitor = meta_backend_get_idle_monitor (backend, 0);
-  meta_idle_monitor_native_reset_idletime (idle_monitor);
+  meta_idle_monitor_reset_idletime (idle_monitor);
 }
diff --git a/src/backends/native/meta-idle-monitor-native.c b/src/backends/native/meta-idle-monitor-native.c
deleted file mode 100644
index 5730ae0d2..000000000
--- a/src/backends/native/meta-idle-monitor-native.c
+++ /dev/null
@@ -1,200 +0,0 @@
-/* -*- 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 "config.h"
-
-#include "meta-idle-monitor-native.h"
-#include "meta-idle-monitor-private.h"
-
-#include <meta/util.h>
-#include "display-private.h"
-
-#include <string.h>
-
-struct _MetaIdleMonitorNative
-{
-  MetaIdleMonitor parent;
-
-  guint64 last_event_time;
-};
-
-struct _MetaIdleMonitorNativeClass
-{
-  MetaIdleMonitorClass parent_class;
-};
-
-typedef struct {
-  MetaIdleMonitorWatch base;
-
-  GSource *timeout_source;
-} MetaIdleMonitorWatchNative;
-
-G_DEFINE_TYPE (MetaIdleMonitorNative, meta_idle_monitor_native, META_TYPE_IDLE_MONITOR)
-
-static gint64
-meta_idle_monitor_native_get_idletime (MetaIdleMonitor *monitor)
-{
-  MetaIdleMonitorNative *monitor_native = META_IDLE_MONITOR_NATIVE (monitor);
-
-  return (g_get_monotonic_time () - monitor_native->last_event_time) / 1000;
-}
-
-static guint32
-get_next_watch_serial (void)
-{
-  static guint32 serial = 0;
-  g_atomic_int_inc (&serial);
-  return serial;
-}
-
-static gboolean
-native_dispatch_timeout (GSource     *source,
-                         GSourceFunc  callback,
-                         gpointer     user_data)
-{
-  MetaIdleMonitorWatchNative *watch_native = user_data;
-  MetaIdleMonitorWatch *watch = (MetaIdleMonitorWatch *) watch_native;
-
-  _meta_idle_monitor_watch_fire (watch);
-  g_source_set_ready_time (watch_native->timeout_source, -1);
-  return TRUE;
-}
-
-static GSourceFuncs native_source_funcs = {
-  NULL, /* prepare */
-  NULL, /* check */
-  native_dispatch_timeout,
-  NULL, /* finalize */
-};
-
-static void
-free_watch (gpointer data)
-{
-  MetaIdleMonitorWatchNative *watch_native = data;
-  MetaIdleMonitorWatch *watch = (MetaIdleMonitorWatch *) watch_native;
-  MetaIdleMonitor *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_native->timeout_source != NULL)
-    g_source_destroy (watch_native->timeout_source);
-
-  g_object_unref (monitor);
-  g_slice_free (MetaIdleMonitorWatchNative, watch_native);
-}
-
-static MetaIdleMonitorWatch *
-meta_idle_monitor_native_make_watch (MetaIdleMonitor           *monitor,
-                                     guint64                    timeout_msec,
-                                     MetaIdleMonitorWatchFunc   callback,
-                                     gpointer                   user_data,
-                                     GDestroyNotify             notify)
-{
-  MetaIdleMonitorWatchNative *watch_native;
-  MetaIdleMonitorWatch *watch;
-  MetaIdleMonitorNative *monitor_native = META_IDLE_MONITOR_NATIVE (monitor);
-
-  watch_native = g_slice_new0 (MetaIdleMonitorWatchNative);
-  watch = (MetaIdleMonitorWatch *) watch_native;
-
-  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)
-    {
-      GSource *source = g_source_new (&native_source_funcs, sizeof (GSource));
-
-      g_source_set_callback (source, NULL, watch, NULL);
-      g_source_set_ready_time (source, monitor_native->last_event_time + timeout_msec * 1000);
-      g_source_attach (source, NULL);
-      g_source_unref (source);
-
-      watch_native->timeout_source = source;
-    }
-
-  return watch;
-}
-
-static void
-meta_idle_monitor_native_class_init (MetaIdleMonitorNativeClass *klass)
-{
-  MetaIdleMonitorClass *idle_monitor_class = META_IDLE_MONITOR_CLASS (klass);
-
-  idle_monitor_class->get_idletime = meta_idle_monitor_native_get_idletime;
-  idle_monitor_class->make_watch = meta_idle_monitor_native_make_watch;
-}
-
-static void
-meta_idle_monitor_native_init (MetaIdleMonitorNative *monitor_native)
-{
-  MetaIdleMonitor *monitor = META_IDLE_MONITOR (monitor_native);
-
-  monitor->watches = g_hash_table_new_full (NULL, NULL, NULL, free_watch);
-  monitor_native->last_event_time = g_get_monotonic_time ();
-}
-
-void
-meta_idle_monitor_native_reset_idletime (MetaIdleMonitor *monitor)
-{
-  MetaIdleMonitorNative *monitor_native = META_IDLE_MONITOR_NATIVE (monitor);
-  GList *node, *watch_ids;
-
-  monitor_native->last_event_time = g_get_monotonic_time ();
-
-  watch_ids = g_hash_table_get_keys (monitor->watches);
-
-  for (node = watch_ids; node != NULL; node = node->next)
-    {
-      guint watch_id = GPOINTER_TO_UINT (node->data);
-      MetaIdleMonitorWatchNative *watch;
-
-      watch = g_hash_table_lookup (monitor->watches, GUINT_TO_POINTER (watch_id));
-      if (!watch)
-        continue;
-
-      if (watch->base.timeout_msec == 0)
-        {
-          _meta_idle_monitor_watch_fire ((MetaIdleMonitorWatch *) watch);
-        }
-      else
-        {
-          g_source_set_ready_time (watch->timeout_source,
-                                   monitor_native->last_event_time +
-                                   watch->base.timeout_msec * 1000);
-        }
-    }
-
-  g_list_free (watch_ids);
-}
diff --git a/src/backends/native/meta-idle-monitor-native.h b/src/backends/native/meta-idle-monitor-native.h
deleted file mode 100644
index 37745c489..000000000
--- a/src/backends/native/meta-idle-monitor-native.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* -*- 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
- */
-
-#ifndef META_IDLE_MONITOR_NATIVE_H
-#define META_IDLE_MONITOR_NATIVE_H
-
-#include <glib-object.h>
-#include <meta/meta-idle-monitor.h>
-
-#define META_TYPE_IDLE_MONITOR_NATIVE            (meta_idle_monitor_native_get_type ())
-#define META_IDLE_MONITOR_NATIVE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_IDLE_MONITOR_NATIVE, MetaIdleMonitorNative))
-#define META_IDLE_MONITOR_NATIVE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_IDLE_MONITOR_NATIVE, MetaIdleMonitorNativeClass))
-#define META_IS_IDLE_MONITOR_NATIVE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_IDLE_MONITOR_NATIVE))
-#define META_IS_IDLE_MONITOR_NATIVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_IDLE_MONITOR_NATIVE))
-#define META_IDLE_MONITOR_NATIVE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_IDLE_MONITOR_NATIVE, MetaIdleMonitorNativeClass))
-
-typedef struct _MetaIdleMonitorNative        MetaIdleMonitorNative;
-typedef struct _MetaIdleMonitorNativeClass   MetaIdleMonitorNativeClass;
-
-GType meta_idle_monitor_native_get_type (void);
-
-void meta_idle_monitor_native_reset_idletime (MetaIdleMonitor *monitor);
-
-#endif /* META_IDLE_MONITOR_NATIVE_H */
diff --git a/src/backends/native/meta-launcher.c b/src/backends/native/meta-launcher.c
index f655f0e26..8b066c9ff 100644
--- a/src/backends/native/meta-launcher.c
+++ b/src/backends/native/meta-launcher.c
@@ -44,7 +44,6 @@
 #include "backends/meta-backend-private.h"
 #include "backends/native/meta-backend-native.h"
 #include "meta-cursor-renderer-native.h"
-#include "meta-idle-monitor-native.h"
 #include "meta-renderer-native.h"
 
 struct _MetaLauncher
diff --git a/src/backends/x11/meta-backend-x11.c b/src/backends/x11/meta-backend-x11.c
index acb2b1d90..226d187c5 100644
--- a/src/backends/x11/meta-backend-x11.c
+++ b/src/backends/x11/meta-backend-x11.c
@@ -37,7 +37,6 @@
 #include <X11/Xlib-xcb.h>
 #include <xkbcommon/xkbcommon-x11.h>
 
-#include "meta-idle-monitor-xsync.h"
 #include "backends/meta-stage.h"
 #include "backends/x11/meta-clutter-backend-x11.h"
 #include "backends/x11/meta-renderer-x11.h"
@@ -84,15 +83,6 @@ G_DEFINE_TYPE_WITH_CODE (MetaBackendX11, meta_backend_x11, META_TYPE_BACKEND,
                                                 initable_iface_init));
 
 static void
-handle_alarm_notify (MetaBackend *backend,
-                     XEvent      *event)
-{
-  meta_backend_foreach_device_monitor (backend,
-                                       (GFunc) meta_idle_monitor_xsync_handle_xevent,
-                                       event);
-}
-
-static void
 meta_backend_x11_translate_device_event (MetaBackendX11 *x11,
                                          XIDeviceEvent  *device_event)
 {
@@ -274,9 +264,6 @@ handle_host_xevent (MetaBackend *backend,
   bypass_clutter = (meta_backend_x11_handle_host_xevent (x11, event) ||
                     bypass_clutter);
 
-  if (event->type == (priv->xsync_event_base + XSyncAlarmNotify))
-    handle_alarm_notify (backend, event);
-
   if (event->type == priv->xkb_event_base)
     {
       XkbEvent *xkb_ev = (XkbEvent *) event;
@@ -464,15 +451,6 @@ meta_backend_x11_create_clutter_backend (MetaBackend *backend)
   return g_object_new (META_TYPE_CLUTTER_BACKEND_X11, NULL);
 }
 
-static MetaIdleMonitor *
-meta_backend_x11_create_idle_monitor (MetaBackend *backend,
-                                      int          device_id)
-{
-  return g_object_new (META_TYPE_IDLE_MONITOR_XSYNC,
-                       "device-id", device_id,
-                       NULL);
-}
-
 static gboolean
 meta_backend_x11_grab_device (MetaBackend *backend,
                               int          device_id,
@@ -686,7 +664,6 @@ meta_backend_x11_class_init (MetaBackendX11Class *klass)
 
   backend_class->create_clutter_backend = meta_backend_x11_create_clutter_backend;
   backend_class->post_init = meta_backend_x11_post_init;
-  backend_class->create_idle_monitor = meta_backend_x11_create_idle_monitor;
   backend_class->grab_device = meta_backend_x11_grab_device;
   backend_class->ungrab_device = meta_backend_x11_ungrab_device;
   backend_class->warp_pointer = meta_backend_x11_warp_pointer;
diff --git a/src/backends/x11/meta-idle-monitor-xsync.c b/src/backends/x11/meta-idle-monitor-xsync.c
deleted file mode 100644
index de25312ad..000000000
--- a/src/backends/x11/meta-idle-monitor-xsync.c
+++ /dev/null
@@ -1,373 +0,0 @@
-/* -*- 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 "config.h"
-
-#include "meta-idle-monitor-xsync.h"
-#include "meta-idle-monitor-private.h"
-
-#include "meta-backend-x11.h"
-
-#include <string.h>
-
-struct _MetaIdleMonitorXSync
-{
-  MetaIdleMonitor parent;
-
-  GHashTable  *alarms;
-  Display     *display;
-  XSyncCounter counter;
-  XSyncAlarm   user_active_alarm;
-};
-
-struct _MetaIdleMonitorXSyncClass
-{
-  MetaIdleMonitorClass parent_class;
-};
-
-typedef struct {
-  MetaIdleMonitorWatch base;
-
-  XSyncAlarm xalarm;
-} MetaIdleMonitorWatchXSync;
-
-G_DEFINE_TYPE (MetaIdleMonitorXSync, meta_idle_monitor_xsync, META_TYPE_IDLE_MONITOR)
-
-static gint64
-_xsyncvalue_to_int64 (XSyncValue value)
-{
-  return ((guint64) XSyncValueHigh32 (value)) << 32
-    | (guint64) XSyncValueLow32 (value);
-}
-
-#define GUINT64_TO_XSYNCVALUE(value, ret) XSyncIntsToValue (ret, (value) & 0xFFFFFFFF, ((guint64)(value)) >> 32)
-
-static XSyncAlarm
-_xsync_alarm_set (MetaIdleMonitorXSync	*monitor_xsync,
-		  XSyncTestType          test_type,
-		  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_xsync->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_xsync->display, flags, &attr);
-}
-
-static void
-ensure_alarm_rescheduled (Display    *dpy,
-			  XSyncAlarm  alarm)
-{
-  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);
-}
-
-static void
-set_alarm_enabled (Display    *dpy,
-		   XSyncAlarm  alarm,
-		   gboolean    enabled)
-{
-  XSyncAlarmAttributes attr;
-  attr.events = enabled;
-  XSyncChangeAlarm (dpy, alarm, XSyncCAEvents, &attr);
-}
-
-static char *
-counter_name_for_device (int device_id)
-{
-  if (device_id > 0)
-    return g_strdup_printf ("DEVICEIDLETIME %d", device_id);
-
-  return g_strdup ("IDLETIME");
-}
-
-static XSyncCounter
-find_idletime_counter (MetaIdleMonitorXSync *monitor_xsync)
-{
-  MetaIdleMonitor *monitor = META_IDLE_MONITOR (monitor_xsync);
-  int		      i;
-  int		      ncounters;
-  XSyncSystemCounter *counters;
-  XSyncCounter        counter = None;
-  char               *counter_name;
-
-  counter_name = counter_name_for_device (monitor->device_id);
-  counters = XSyncListSystemCounters (monitor_xsync->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 void
-init_xsync (MetaIdleMonitorXSync *monitor_xsync)
-{
-  monitor_xsync->counter = find_idletime_counter (monitor_xsync);
-  /* IDLETIME counter not found? */
-  if (monitor_xsync->counter == None)
-    {
-      g_warning ("IDLETIME counter not found\n");
-      return;
-    }
-
-  monitor_xsync->user_active_alarm = _xsync_alarm_set (monitor_xsync, XSyncNegativeTransition, 1, FALSE);
-}
-
-static void
-meta_idle_monitor_xsync_dispose (GObject *object)
-{
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (object);
-
-  if (monitor_xsync->user_active_alarm != None)
-    {
-      XSyncDestroyAlarm (monitor_xsync->display, monitor_xsync->user_active_alarm);
-      monitor_xsync->user_active_alarm = None;
-    }
-
-  g_clear_pointer (&monitor_xsync->alarms, g_hash_table_destroy);
-
-  G_OBJECT_CLASS (meta_idle_monitor_xsync_parent_class)->dispose (object);
-}
-
-static void
-meta_idle_monitor_xsync_constructed (GObject *object)
-{
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (object);
-  MetaBackendX11 *backend = META_BACKEND_X11 (meta_get_backend ());
-
-  monitor_xsync->display = meta_backend_x11_get_xdisplay (backend);
-  init_xsync (monitor_xsync);
-
-  G_OBJECT_CLASS (meta_idle_monitor_xsync_parent_class)->constructed (object);
-}
-
-static gint64
-meta_idle_monitor_xsync_get_idletime (MetaIdleMonitor *monitor)
-{
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (monitor);
-  XSyncValue value;
-
-  if (!XSyncQueryCounter (monitor_xsync->display, monitor_xsync->counter, &value))
-    return -1;
-
-  return _xsyncvalue_to_int64 (value);
-}
-
-static gboolean
-fire_watch_idle (gpointer data)
-{
-  MetaIdleMonitorWatch *watch = data;
-
-  watch->idle_source_id = 0;
-  _meta_idle_monitor_watch_fire (watch);
-
-  return FALSE;
-}
-
-static guint32
-get_next_watch_serial (void)
-{
-  static guint32 serial = 0;
-  g_atomic_int_inc (&serial);
-  return serial;
-}
-
-static void
-free_watch (gpointer data)
-{
-  MetaIdleMonitorWatchXSync *watch_xsync = data;
-  MetaIdleMonitorWatch *watch = (MetaIdleMonitorWatch *) watch_xsync;
-  MetaIdleMonitor *monitor = watch->monitor;
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (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_xsync->xalarm != monitor_xsync->user_active_alarm &&
-      watch_xsync->xalarm != None)
-    {
-      XSyncDestroyAlarm (monitor_xsync->display, watch_xsync->xalarm);
-      g_hash_table_remove (monitor_xsync->alarms, (gpointer) watch_xsync->xalarm);
-    }
-
-  g_object_unref (monitor);
-  g_slice_free (MetaIdleMonitorWatchXSync, watch_xsync);
-}
-
-static MetaIdleMonitorWatch *
-meta_idle_monitor_xsync_make_watch (MetaIdleMonitor           *monitor,
-                                    guint64                    timeout_msec,
-                                    MetaIdleMonitorWatchFunc   callback,
-                                    gpointer                   user_data,
-                                    GDestroyNotify             notify)
-{
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (monitor);
-  MetaIdleMonitorWatchXSync *watch_xsync;
-  MetaIdleMonitorWatch *watch;
-
-  watch_xsync = g_slice_new0 (MetaIdleMonitorWatchXSync);
-  watch = (MetaIdleMonitorWatch *) watch_xsync;
-
-  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 (monitor_xsync->user_active_alarm != None)
-    {
-      if (timeout_msec != 0)
-        {
-          watch_xsync->xalarm = _xsync_alarm_set (monitor_xsync, XSyncPositiveTransition, timeout_msec, TRUE);
-
-          g_hash_table_add (monitor_xsync->alarms, (gpointer) watch_xsync->xalarm);
-
-          if (meta_idle_monitor_get_idletime (monitor) > (gint64)timeout_msec)
-            {
-              watch->idle_source_id = g_idle_add (fire_watch_idle, watch);
-              g_source_set_name_by_id (watch->idle_source_id, "[mutter] fire_watch_idle");
-            }
-        }
-      else
-        {
-          watch_xsync->xalarm = monitor_xsync->user_active_alarm;
-
-          set_alarm_enabled (monitor_xsync->display, monitor_xsync->user_active_alarm, TRUE);
-        }
-    }
-
-  return watch;
-}
-
-static void
-meta_idle_monitor_xsync_class_init (MetaIdleMonitorXSyncClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  MetaIdleMonitorClass *idle_monitor_class = META_IDLE_MONITOR_CLASS (klass);
-
-  object_class->dispose = meta_idle_monitor_xsync_dispose;
-  object_class->constructed = meta_idle_monitor_xsync_constructed;
-
-  idle_monitor_class->get_idletime = meta_idle_monitor_xsync_get_idletime;
-  idle_monitor_class->make_watch = meta_idle_monitor_xsync_make_watch;
-}
-
-static void
-meta_idle_monitor_xsync_init (MetaIdleMonitorXSync *monitor_xsync)
-{
-  MetaIdleMonitor *monitor = META_IDLE_MONITOR (monitor_xsync);
-
-  monitor->watches = g_hash_table_new_full (NULL, NULL, NULL, free_watch);
-  monitor_xsync->alarms = g_hash_table_new (NULL, NULL);
-}
-
-static void
-check_x11_watches (MetaIdleMonitor *monitor,
-                   XSyncAlarm       alarm)
-{
-  GList *node, *watch_ids;
-
-  /* we get the keys and do explicit look ups in case
-   * an early iteration of the loop ends up leading
-   * to watches from later iterations getting invalidated
-   */
-  watch_ids = g_hash_table_get_keys (monitor->watches);
-
-  for (node = watch_ids; node != NULL; node = node->next)
-    {
-      guint watch_id = GPOINTER_TO_UINT (node->data);
-      MetaIdleMonitorWatchXSync *watch;
-
-      watch = g_hash_table_lookup (monitor->watches, GUINT_TO_POINTER (watch_id));
-
-      if (watch && watch->xalarm == alarm)
-        _meta_idle_monitor_watch_fire ((MetaIdleMonitorWatch *) watch);
-    }
-
-  g_list_free (watch_ids);
-}
-
-void
-meta_idle_monitor_xsync_handle_xevent (MetaIdleMonitor       *monitor,
-                                       XSyncAlarmNotifyEvent *alarm_event)
-{
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (monitor);
-  XSyncAlarm alarm;
-  gboolean has_alarm;
-
-  if (alarm_event->state != XSyncAlarmActive)
-    return;
-
-  alarm = alarm_event->alarm;
-
-  has_alarm = FALSE;
-
-  if (alarm == monitor_xsync->user_active_alarm)
-    {
-      set_alarm_enabled (monitor_xsync->display,
-                         alarm,
-                         FALSE);
-      has_alarm = TRUE;
-    }
-  else if (g_hash_table_contains (monitor_xsync->alarms, (gpointer) alarm))
-    {
-      ensure_alarm_rescheduled (monitor_xsync->display,
-                                alarm);
-      has_alarm = TRUE;
-    }
-
-  if (has_alarm)
-    check_x11_watches (monitor, alarm);
-}
diff --git a/src/backends/x11/meta-idle-monitor-xsync.h b/src/backends/x11/meta-idle-monitor-xsync.h
deleted file mode 100644
index e349cfa9c..000000000
--- a/src/backends/x11/meta-idle-monitor-xsync.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/* -*- 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
- */
-
-#ifndef META_IDLE_MONITOR_XSYNC_H
-#define META_IDLE_MONITOR_XSYNC_H
-
-#include <glib-object.h>
-#include <meta/meta-idle-monitor.h>
-
-#include <X11/Xlib.h>
-#include <X11/extensions/sync.h>
-
-#define META_TYPE_IDLE_MONITOR_XSYNC            (meta_idle_monitor_xsync_get_type ())
-#define META_IDLE_MONITOR_XSYNC(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_IDLE_MONITOR_XSYNC, MetaIdleMonitorXSync))
-#define META_IDLE_MONITOR_XSYNC_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_IDLE_MONITOR_XSYNC, MetaIdleMonitorXSyncClass))
-#define META_IS_IDLE_MONITOR_XSYNC(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_IDLE_MONITOR_XSYNC))
-#define META_IS_IDLE_MONITOR_XSYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_IDLE_MONITOR_XSYNC))
-#define META_IDLE_MONITOR_XSYNC_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_IDLE_MONITOR_XSYNC, MetaIdleMonitorXSyncClass))
-
-typedef struct _MetaIdleMonitorXSync        MetaIdleMonitorXSync;
-typedef struct _MetaIdleMonitorXSyncClass   MetaIdleMonitorXSyncClass;
-
-GType meta_idle_monitor_xsync_get_type (void);
-
-void meta_idle_monitor_xsync_handle_xevent (MetaIdleMonitor       *monitor,
-                                            XSyncAlarmNotifyEvent *xevent);
-
-#endif /* META_IDLE_MONITOR_XSYNC_H */
diff --git a/src/core/events.c b/src/core/events.c
index f55e83c97..92503a168 100644
--- a/src/core/events.c
+++ b/src/core/events.c
@@ -32,9 +32,10 @@
 
 #ifdef HAVE_NATIVE_BACKEND
 #include "backends/native/meta-backend-native.h"
-#include "backends/native/meta-idle-monitor-native.h"
 #endif
 
+#include "backends/meta-idle-monitor-private.h"
+
 #ifdef HAVE_WAYLAND
 #include "wayland/meta-wayland-private.h"
 #endif
@@ -92,46 +93,38 @@ get_window_for_event (MetaDisplay        *display,
 static void
 handle_idletime_for_event (const ClutterEvent *event)
 {
-#ifdef HAVE_NATIVE_BACKEND
-  /* This is handled by XSync under X11. */
-  MetaBackend *backend = meta_get_backend ();
+  ClutterInputDevice *device, *source_device;
+  MetaIdleMonitor *core_monitor, *device_monitor;
+  int device_id;
 
-  if (META_IS_BACKEND_NATIVE (backend))
-    {
-      ClutterInputDevice *device, *source_device;
-      MetaIdleMonitor *core_monitor, *device_monitor;
-      int device_id;
-
-      device = clutter_event_get_device (event);
-      if (device == NULL)
-        return;
-
-      if (event->any.flags & CLUTTER_EVENT_FLAG_SYNTHETIC ||
-          event->type == CLUTTER_ENTER ||
-          event->type == CLUTTER_LEAVE ||
-          event->type == CLUTTER_STAGE_STATE ||
-          event->type == CLUTTER_DESTROY_NOTIFY ||
-          event->type == CLUTTER_CLIENT_MESSAGE ||
-          event->type == CLUTTER_DELETE)
-        return;
+  device = clutter_event_get_device (event);
+  if (device == NULL)
+    return;
 
-      device_id = clutter_input_device_get_device_id (device);
+  if (event->any.flags & CLUTTER_EVENT_FLAG_SYNTHETIC ||
+      event->type == CLUTTER_ENTER ||
+      event->type == CLUTTER_LEAVE ||
+      event->type == CLUTTER_STAGE_STATE ||
+      event->type == CLUTTER_DESTROY_NOTIFY ||
+      event->type == CLUTTER_CLIENT_MESSAGE ||
+      event->type == CLUTTER_DELETE)
+    return;
 
-      core_monitor = meta_idle_monitor_get_core ();
-      device_monitor = meta_idle_monitor_get_for_device (device_id);
+  device_id = clutter_input_device_get_device_id (device);
 
-      meta_idle_monitor_native_reset_idletime (core_monitor);
-      meta_idle_monitor_native_reset_idletime (device_monitor);
+  core_monitor = meta_idle_monitor_get_core ();
+  device_monitor = meta_idle_monitor_get_for_device (device_id);
 
-      source_device = clutter_event_get_source_device (event);
-      if (source_device != device)
-        {
-          device_id = clutter_input_device_get_device_id (device);
-          device_monitor = meta_idle_monitor_get_for_device (device_id);
-          meta_idle_monitor_native_reset_idletime (device_monitor);
-        }
+  meta_idle_monitor_reset_idletime (core_monitor);
+  meta_idle_monitor_reset_idletime (device_monitor);
+
+  source_device = clutter_event_get_source_device (event);
+  if (source_device != device)
+    {
+      device_id = clutter_input_device_get_device_id (device);
+      device_monitor = meta_idle_monitor_get_for_device (device_id);
+      meta_idle_monitor_reset_idletime (device_monitor);
     }
-#endif /* HAVE_NATIVE_BACKEND */
 }
 
 static gboolean