MonitorXrandr: follow the right order in applying the new configuration

First disable CRTCs that should be off in the new configuration, then resize the framebuffer, then enable the new CRTCs. If we don't do that, and we're making the screen smaller, X complains with a BadMatch. https://bugzilla.gnome.org/show_bug.cgi?id=705670
MonitorXrandr: resize the framebuffer prior to setting the CRTC configuration
2013-08-17 16:57:33 +02:00 · 2013-08-17 16:57:33 +02:00 · 2013-08-17 16:57:33 +02:00 · 2013-08-17 16:57:33 +02:00 · 2013-08-17 16:57:33 +02:00 · 2013-08-17 16:57:32 +02:00
76 changed files with 2307 additions and 12774 deletions
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,5 +1,5 @@

-SUBDIRS=src protocol data po doc
+SUBDIRS=src po doc

 EXTRA_DIST = HACKING MAINTAINERS rationales.txt

--- a/autogen.sh
+++ b/autogen.sh
@@ -5,7 +5,7 @@ srcdir=`dirname $0`
 test -z "$srcdir" && srcdir=.

 PKG_NAME="mutter"
-REQUIRED_AUTOMAKE_VERSION=1.13
+REQUIRED_AUTOMAKE_VERSION=1.10

 (test -f $srcdir/configure.ac \
  && test -d $srcdir/src) || {
--- a/configure.ac
+++ b/configure.ac
@@ -15,7 +15,7 @@ AC_INIT([mutter], [mutter_version],
 AC_CONFIG_SRCDIR(src/core/display.c)
 AC_CONFIG_HEADERS(config.h)

-AM_INIT_AUTOMAKE([1.11 foreign no-dist-gzip dist-xz tar-ustar])
+AM_INIT_AUTOMAKE([1.11 no-dist-gzip dist-xz tar-ustar])
 m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])],)
 AM_MAINTAINER_MODE([enable])

@@ -76,6 +76,7 @@ MUTTER_PC_MODULES="
   $CLUTTER_PACKAGE >= 1.14.3
   cogl-1.0 >= 1.13.3
   upower-glib > 0.9.11
+   gnome-desktop-3.0
 "

 GLIB_GSETTINGS
@@ -114,32 +115,11 @@ AC_ARG_ENABLE(shape,
                 [disable mutter's use of the shaped window extension]),,
  enable_shape=auto)

-AC_ARG_ENABLE(wayland,
-  AC_HELP_STRING([--enable-wayland],
-                 [Enable support for running as a hybrid X and Wayland compositor]),,
-  enable_wayland=no)
-
-## Wayland support requires the xserver.xml protocol extension found in the weston
-## repository but since there aren't currently established conventions for
-## installing and discovering these we simply require a location to be given
-## explicitly...
-AC_ARG_WITH([wayland-protocols],
-            [AS_HELP_STRING([--with-wayland-protocols], [Location for wayland extension protocol specs])],
-            [
-            ],
-            [])
-
-AC_ARG_WITH([xwayland-path],
-            [AS_HELP_STRING([--with-xwayland-path], [Absolute path for an X Wayland server])],
-            [XWAYLAND_PATH="$withval"],
-            [XWAYLAND_PATH="$bindir/Xorg"])
-
 AM_GLIB_GNU_GETTEXT

 ## here we get the flags we'll actually use
 # GRegex requires Glib-2.14.0
 PKG_CHECK_MODULES(ALL, glib-2.0 >= 2.14.0)
-PKG_CHECK_MODULES(MUTTER_LAUNCH, libdrm libsystemd-login)

 # Unconditionally use this dir to avoid a circular dep with gnomecc
 GNOME_KEYBINDINGS_KEYSDIR="${datadir}/gnome-control-center/keybindings"
@@ -218,29 +198,6 @@ if test x$have_xcursor = xyes; then
  AC_DEFINE(HAVE_XCURSOR, , [Building with Xcursor support])
 fi

-have_wayland=no
-if test x$enable_wayland = "xyes"; then
-  WAYLAND_VERSION=0.1
-  AC_MSG_CHECKING([Wayland >= $WAYLAND_VERSION])
-  if ! $PKG_CONFIG --atleast-version $WAYLAND_VERSION wayland-server; then
-    AC_MSG_ERROR([wayland support enabled but no suitable wayland-server package found])
-  fi
-  AC_MSG_RESULT(yes)
-
-  AC_PATH_PROG([WAYLAND_SCANNER],[wayland-scanner],[no])
-  AS_IF([test "x$WAYLAND_SCANNER" = "xno"],
-        AC_MSG_ERROR([Could not find wayland-scanner in your PATH, required for parsing wayland extension protocols]))
-  AC_SUBST([WAYLAND_SCANNER])
-
-  AC_SUBST(XWAYLAND_PATH)
-
-  MUTTER_PC_MODULES="$MUTTER_PC_MODULES wayland-server libdrm"
-  AC_DEFINE(HAVE_WAYLAND, , [Building with Wayland support])
-  have_wayland=yes
-fi
-
-AM_CONDITIONAL(HAVE_WAYLAND, test x$have_wayland = "xyes")
-
 PKG_CHECK_MODULES(MUTTER, $MUTTER_PC_MODULES)

 PKG_CHECK_EXISTS([xi >= 1.6.99.1],
@@ -481,8 +438,6 @@ src/Makefile
 src/libmutter.pc
 src/mutter-plugins.pc
 src/compositor/plugins/Makefile
-protocol/Makefile
-data/Makefile
 po/Makefile.in
 ])

@@ -504,8 +459,6 @@ mutter-$VERSION
 	source code location:	  ${srcdir}
 	compiler:		  ${CC}

-	Wayland:		  ${have_wayland}
-
 	Startup notification:     ${have_startup_notification}
 	libcanberra:              ${have_libcanberra}
 	Introspection:            ${found_introspection}
--- a/data/Makefile.am
+++ b/data/Makefile.am
@@ -1,7 +0,0 @@
-defaultcursordir = $(datadir)/mutter/cursors
-
-dist_defaultcursor_DATA =
-
-if HAVE_WAYLAND
-dist_defaultcursor_DATA += left_ptr.png
-endif
--- a/data/left_ptr.png
+++ b/data/left_ptr.png
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -23,12 +23,9 @@ src/core/xprops.c
 src/mutter.desktop.in
 src/mutter-wm.desktop.in
 src/org.gnome.mutter.gschema.xml.in
-src/tools/mutter-message.c
 src/ui/frames.c
 src/ui/menu.c
 src/ui/metaaccellabel.c
 src/ui/resizepopup.c
 src/ui/theme.c
 src/ui/theme-parser.c
-src/ui/theme-viewer.c
-
--- a/protocol/Makefile.am
+++ b/protocol/Makefile.am
@@ -1 +0,0 @@
-EXTRA_DIST = xserver.xml
--- a/protocol/xserver.xml
+++ b/protocol/xserver.xml
@@ -1,18 +0,0 @@
-<protocol name="xserver">
-
-  <interface name="xserver" version="1">
-    <request name="set_window_id">
-      <arg name="surface" type="object" interface="wl_surface"/>
-      <arg name="id" type="uint"/>
-    </request>
-
-    <event name="client">
-      <arg name="fd" type="fd"/>
-    </event>
-
-    <event name="listen_socket">
-      <arg name="fd" type="fd"/>
-    </event>
-  </interface>
-
-</protocol>
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -19,7 +19,7 @@ INCLUDES=								\
 	-DMUTTER_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\"		\
 	-DMUTTER_PKGDATADIR=\"$(pkgdatadir)\"				\
 	-DMUTTER_DATADIR=\"$(datadir)\"					\
-	-DG_LOG_DOMAIN=\"mutter\"					\
+	-DG_LOG_DOMAIN=\"Mutter\"					\
 	-DSN_API_NOT_YET_FROZEN=1					\
 	-DMUTTER_MAJOR_VERSION=$(MUTTER_MAJOR_VERSION)			\
 	-DMUTTER_MINOR_VERSION=$(MUTTER_MINOR_VERSION)			\
@@ -29,25 +29,11 @@ INCLUDES=								\
 	-DMUTTER_PLUGIN_DIR=\"@MUTTER_PLUGIN_DIR@\"			\
 	-DGETTEXT_PACKAGE=\"$(GETTEXT_PACKAGE)\"

-if HAVE_WAYLAND
-INCLUDES += \
-	-I$(srcdir)/wayland						\
-	-DXWAYLAND_PATH='"@XWAYLAND_PATH@"'
-endif
-
 mutter_built_sources = \
 	$(dbus_xrandr_built_sources)	\
-	$(dbus_idle_built_sources) \
 	mutter-enum-types.h \
 	mutter-enum-types.c

-if HAVE_WAYLAND
-mutter_built_sources += \
-	wayland/xserver-protocol.c		\
-	wayland/xserver-server-protocol.h	\
-	wayland/xserver-client-protocol.h
-endif
-
 libmutter_la_SOURCES =				\
 	core/async-getprop.c			\
 	core/async-getprop.h			\
@@ -109,6 +95,8 @@ libmutter_la_SOURCES =				\
 	ui/draw-workspace.h			\
 	core/edge-resistance.c			\
 	core/edge-resistance.h			\
+	core/edid-parse.c			\
+	core/edid.h				\
 	core/errors.c				\
 	meta/errors.h				\
 	core/frame.c				\
@@ -125,14 +113,9 @@ libmutter_la_SOURCES =				\
 	core/keybindings.c			\
 	core/keybindings-private.h		\
 	core/main.c				\
-	core/meta-cursor-tracker.c		\
-	core/meta-cursor-tracker-private.h	\
-	core/meta-idle-monitor.c		\
-	core/meta-idle-monitor-private.h	\
 	core/meta-xrandr-shared.h		\
 	core/monitor.c				\
 	core/monitor-config.c			\
-	core/monitor-kms.c			\
 	core/monitor-private.h			\
 	core/monitor-xrandr.c			\
 	core/mutter-Xatomtype.h			\
@@ -183,28 +166,6 @@ libmutter_la_SOURCES =				\
 	ui/ui.c					\
 	$(mutter_built_sources)

-if HAVE_WAYLAND
-libmutter_la_SOURCES +=				\
-	wayland/meta-tty.c			\
-	wayland/meta-tty.h			\
-	wayland/meta-wayland.c			\
-	wayland/meta-wayland-private.h		\
-	wayland/meta-xwayland-private.h		\
-	wayland/meta-xwayland.c			\
-	wayland/meta-wayland-data-device.c      \
-	wayland/meta-wayland-data-device.h      \
-	wayland/meta-wayland-keyboard.c		\
-	wayland/meta-wayland-keyboard.h		\
-	wayland/meta-wayland-pointer.c		\
-	wayland/meta-wayland-pointer.h		\
-	wayland/meta-wayland-seat.c		\
-	wayland/meta-wayland-seat.h		\
-	wayland/meta-wayland-stage.h		\
-	wayland/meta-wayland-stage.c		\
-	wayland/meta-weston-launch.c		\
-	wayland/meta-weston-launch.h
-endif
-
 libmutter_la_LDFLAGS = -no-undefined
 libmutter_la_LIBADD  = $(MUTTER_LIBS)

@@ -225,8 +186,6 @@ libmutterinclude_base_headers =		\
 	meta/meta-background-actor.h		\
 	meta/meta-background-group.h		\
 	meta/meta-background.h			\
-	meta/meta-cursor-tracker.h		\
-	meta/meta-idle-monitor.h		\
 	meta/meta-plugin.h			\
 	meta/meta-shaped-texture.h		\
 	meta/meta-shadow-factory.h		\
@@ -255,19 +214,6 @@ bin_PROGRAMS=mutter
 mutter_SOURCES = core/mutter.c
 mutter_LDADD = $(MUTTER_LIBS) libmutter.la

-if HAVE_WAYLAND
-bin_PROGRAMS+=mutter-launch
-
-mutter_launch_SOURCES = wayland/weston-launch.c wayland/weston-launch.h
-
-mutter_launch_CFLAGS = $(MUTTER_LAUNCH_CFLAGS)
-mutter_launch_LDFLAGS = $(MUTTER_LAUNCH_LIBS) -lpam
-
-install-exec-hook:
-	-chown root $(DESTDIR)$(bindir)/mutter-launch
-	-chmod u+s $(DESTDIR)$(bindir)/mutter-launch
-endif
-
 if HAVE_INTROSPECTION
 include $(INTROSPECTION_MAKEFILE)

@@ -389,27 +335,8 @@ mutter-enum-types.c: stamp-mutter-enum-types.h mutter-enum-types.c.in
 dbus_xrandr_built_sources = meta-dbus-xrandr.c meta-dbus-xrandr.h

 $(dbus_xrandr_built_sources) : Makefile.am xrandr.xml
-	$(AM_V_GEN)gdbus-codegen							\
+	$(AM_V_GEN)gdbus-codegen								\
 		--interface-prefix org.gnome.Mutter					\
 		--c-namespace MetaDBus							\
 		--generate-c-code meta-dbus-xrandr					\
 		xrandr.xml
-
-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						\
-		idle-monitor.xml
-
-if HAVE_WAYLAND
-wayland/%-protocol.c : $(top_builddir)/protocol/%.xml
-	$(AM_V_GEN)$(WAYLAND_SCANNER) code < $< > $@
-wayland/%-server-protocol.h : $(top_builddir)/protocol/%.xml
-	$(AM_V_GEN)$(WAYLAND_SCANNER) server-header < $< > $@
-wayland/%-client-protocol.h : $(top_builddir)/protocol/%.xml
-	$(AM_V_GEN)$(WAYLAND_SCANNER) client-header < $< > $@
-endif
--- a/src/compositor/compositor-private.h
+++ b/src/compositor/compositor-private.h
@@ -66,6 +66,8 @@ void meta_switch_workspace_completed (MetaScreen    *screen);

 gboolean meta_begin_modal_for_plugin (MetaScreen       *screen,
                                      MetaPlugin       *plugin,
+                                      Window            grab_window,
+                                      Cursor            cursor,
                                      MetaModalOptions  options,
                                      guint32           timestamp);
 void     meta_end_modal_for_plugin   (MetaScreen       *screen,
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -84,11 +84,6 @@
 #include "meta-window-group.h"
 #include "window-private.h" /* to check window->hidden */
 #include "display-private.h" /* for meta_display_lookup_x_window() */
-#ifdef HAVE_WAYLAND
-#include "meta-wayland-private.h"
-#include "meta-wayland-pointer.h"
-#include "meta-wayland-keyboard.h"
-#endif
 #include <X11/extensions/shape.h>
 #include <X11/extensions/Xcomposite.h>

@@ -177,7 +172,7 @@ process_damage (MetaCompositor     *compositor,
  if (window_actor == NULL)
    return;

-  meta_window_actor_process_x11_damage (window_actor, event);
+  meta_window_actor_process_damage (window_actor, event);
 }

 static void
@@ -332,37 +327,29 @@ void
 meta_set_stage_input_region (MetaScreen   *screen,
                             XserverRegion region)
 {
-  /* As a wayland compositor we can simply ignore all this trickery
-   * for setting an input region on the stage for capturing events in
-   * clutter since all input comes to us first and we get to choose
-   * who else sees them.
-   */
-  if (!meta_is_wayland_compositor ())
-    {
-      MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-      MetaDisplay  *display = meta_screen_get_display (screen);
-      Display      *xdpy    = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  MetaDisplay  *display = meta_screen_get_display (screen);
+  Display      *xdpy    = meta_display_get_xdisplay (display);

-      if (info->stage && info->output)
-        {
-          do_set_stage_input_region (screen, region);
-        }
-      else 
-        {
-          /* Reset info->pending_input_region if one existed before and set the new
-           * one to use it later. */ 
-          if (info->pending_input_region)
-            {
-              XFixesDestroyRegion (xdpy, info->pending_input_region);
-              info->pending_input_region = None;
-            }
-          if (region != None)
-            {
-              info->pending_input_region = XFixesCreateRegion (xdpy, NULL, 0);
-              XFixesCopyRegion (xdpy, info->pending_input_region, region);
-            }
-        } 
+  if (info->stage && info->output)
+    {
+      do_set_stage_input_region (screen, region);
    }
+  else 
+    {
+      /* Reset info->pending_input_region if one existed before and set the new
+       * one to use it later. */ 
+      if (info->pending_input_region)
+        {
+          XFixesDestroyRegion (xdpy, info->pending_input_region);
+          info->pending_input_region = None;
+        }
+      if (region != None)
+        {
+          info->pending_input_region = XFixesCreateRegion (xdpy, NULL, 0);
+          XFixesCopyRegion (xdpy, info->pending_input_region, region);
+        }
+    } 
 }

 void
@@ -393,55 +380,56 @@ meta_focus_stage_window (MetaScreen *screen,
  if (!stage)
    return;

-  if (!meta_is_wayland_compositor ())
-    {
-      window = clutter_x11_get_stage_window (stage);
+  window = clutter_x11_get_stage_window (stage);

-      if (window == None)
-        return;
+  if (window == None)
+    return;

-      meta_display_set_input_focus_xwindow (screen->display,
-                                            screen,
-                                            META_FOCUS_STAGE,
-                                            window,
-                                            timestamp);
-    }
-  else
-    {
-      meta_display_set_input_focus_xwindow (screen->display,
-                                            screen,
-                                            META_FOCUS_STAGE,
-                                            None,
-                                            timestamp);
-    }
+  meta_display_set_input_focus_xwindow (screen->display,
+                                        screen,
+                                        window,
+                                        timestamp);
 }

 gboolean
 meta_stage_is_focused (MetaScreen *screen)
 {
  ClutterStage *stage;
+  Window window;

  stage = CLUTTER_STAGE (meta_get_stage_for_screen (screen));
  if (!stage)
    return FALSE;

-  return (screen->display->focus_type == META_FOCUS_STAGE);
+  window = clutter_x11_get_stage_window (stage);
+
+  if (window == None)
+    return FALSE;
+
+  return (screen->display->focus_xwindow == window);
 }

-static gboolean
-begin_modal_x11 (MetaScreen       *screen,
-                 MetaPlugin       *plugin,
-                 MetaModalOptions  options,
-                 guint32           timestamp)
+gboolean
+meta_begin_modal_for_plugin (MetaScreen       *screen,
+                             MetaPlugin       *plugin,
+                             Window            grab_window,
+                             Cursor            cursor,
+                             MetaModalOptions  options,
+                             guint32           timestamp)
 {
-  MetaDisplay    *display     = meta_screen_get_display (screen);
-  Display        *xdpy        = meta_display_get_xdisplay (display);
-  MetaCompScreen *info        = meta_screen_get_compositor_data (screen);
-  Window          grab_window = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));
-  Cursor          cursor      = None;
-  int             result;
-  gboolean        pointer_grabbed = FALSE;
-  gboolean        keyboard_grabbed = FALSE;
+  /* To some extent this duplicates code in meta_display_begin_grab_op(), but there
+   * are significant differences in how we handle grabs that make it difficult to
+   * merge the two.
+   */
+  MetaDisplay    *display    = meta_screen_get_display (screen);
+  Display        *xdpy       = meta_display_get_xdisplay (display);
+  MetaCompositor *compositor = display->compositor;
+  gboolean pointer_grabbed = FALSE;
+  gboolean keyboard_grabbed = FALSE;
+  int result;
+
+  if (compositor->modal_plugin != NULL || display->grab_op != META_GRAB_OP_NONE)
+    return FALSE;

  if ((options & META_MODAL_POINTER_ALREADY_GRABBED) == 0)
    {
@@ -491,79 +479,6 @@ begin_modal_x11 (MetaScreen       *screen,
      keyboard_grabbed = TRUE;
    }

-  return TRUE;
-
- fail:
-  if (pointer_grabbed)
-    XIUngrabDevice (xdpy, META_VIRTUAL_CORE_POINTER_ID, timestamp);
-  if (keyboard_grabbed)
-    XIUngrabDevice (xdpy, META_VIRTUAL_CORE_KEYBOARD_ID, timestamp);
-
-  return FALSE;
-}
-
-static gboolean
-begin_modal_wayland (MetaScreen       *screen,
-                     MetaPlugin       *plugin,
-                     MetaModalOptions  options,
-                     guint32           timestamp)
-{
-  MetaWaylandCompositor *compositor;
-  gboolean pointer_grabbed = FALSE;
-  gboolean keyboard_grabbed = FALSE;
-
-  compositor = meta_wayland_compositor_get_default ();
-
-  if ((options & META_MODAL_POINTER_ALREADY_GRABBED) == 0)
-    {
-      if (!meta_wayland_pointer_begin_modal (&compositor->seat->pointer))
-        goto fail;
-
-      pointer_grabbed = TRUE;
-    }
-  if ((options & META_MODAL_KEYBOARD_ALREADY_GRABBED) == 0)
-    {
-      if (!meta_wayland_keyboard_begin_modal (&compositor->seat->keyboard))
-        goto fail;
-
-      keyboard_grabbed = TRUE;
-    }
-
-  return TRUE;
-
- fail:
-  if (pointer_grabbed)
-    meta_wayland_pointer_end_modal (&compositor->seat->pointer);
-  if (keyboard_grabbed)
-    meta_wayland_keyboard_end_modal (&compositor->seat->keyboard);
-
-  return FALSE;
-}
-
-gboolean
-meta_begin_modal_for_plugin (MetaScreen       *screen,
-                             MetaPlugin       *plugin,
-                             MetaModalOptions  options,
-                             guint32           timestamp)
-{
-  /* To some extent this duplicates code in meta_display_begin_grab_op(), but there
-   * are significant differences in how we handle grabs that make it difficult to
-   * merge the two.
-   */
-  MetaDisplay    *display    = meta_screen_get_display (screen);
-  MetaCompositor *compositor = display->compositor;
-  gboolean ok;
-
-  if (compositor->modal_plugin != NULL || display->grab_op != META_GRAB_OP_NONE)
-    return FALSE;
-
-  if (meta_is_wayland_compositor ())
-    ok = begin_modal_wayland (screen, plugin, options, timestamp);
-  else
-    ok = begin_modal_x11 (screen, plugin, options, timestamp);
-  if (!ok)
-    return FALSE;
-
  display->grab_op = META_GRAB_OP_COMPOSITOR;
  display->grab_window = NULL;
  display->grab_screen = screen;
@@ -573,6 +488,14 @@ meta_begin_modal_for_plugin (MetaScreen       *screen,
  compositor->modal_plugin = plugin;

  return TRUE;
+
+ fail:
+  if (pointer_grabbed)
+    XIUngrabDevice (xdpy, META_VIRTUAL_CORE_POINTER_ID, timestamp);
+  if (keyboard_grabbed)
+    XIUngrabDevice (xdpy, META_VIRTUAL_CORE_KEYBOARD_ID, timestamp);
+
+  return FALSE;
 }

 void
@@ -586,18 +509,8 @@ meta_end_modal_for_plugin (MetaScreen     *screen,

  g_return_if_fail (compositor->modal_plugin == plugin);

-  if (meta_is_wayland_compositor ())
-    {
-      MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
-
-      meta_wayland_pointer_end_modal (&compositor->seat->pointer);
-      meta_wayland_keyboard_end_modal (&compositor->seat->keyboard);
-    }
-  else
-    {
-      XIUngrabDevice (xdpy, META_VIRTUAL_CORE_POINTER_ID, timestamp);
-      XIUngrabDevice (xdpy, META_VIRTUAL_CORE_KEYBOARD_ID, timestamp);
-    }
+  XIUngrabDevice (xdpy, META_VIRTUAL_CORE_POINTER_ID, timestamp);
+  XIUngrabDevice (xdpy, META_VIRTUAL_CORE_KEYBOARD_ID, timestamp);

  display->grab_op = META_GRAB_OP_NONE;
  display->grab_window = NULL;
@@ -649,11 +562,6 @@ redirect_windows (MetaCompositor *compositor,
  guint        n_retries;
  guint        max_retries;

-  /* If we're running with wayland, connected to a headless xwayland
-   * server then all the windows are implicitly redirected offscreen
-   * already and it would generate an error to try and explicitly
-   * redirect them via XCompositeRedirectSubwindows() */
-
  if (meta_get_replace_current_wm ())
    max_retries = 5;
  else
@@ -694,11 +602,8 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
  MetaCompScreen *info;
  MetaDisplay    *display       = meta_screen_get_display (screen);
  Display        *xdisplay      = meta_display_get_xdisplay (display);
-  Window          xwin          = None;
+  Window          xwin;
  gint            width, height;
-#ifdef HAVE_WAYLAND
-  MetaWaylandCompositor *wayland_compositor;
-#endif

  /* Check if the screen is already managed */
  if (meta_screen_get_compositor_data (screen))
@@ -711,14 +616,7 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
   * We have to initialize info->pending_input_region to an empty region explicitly, 
   * because None value is used to mean that the whole screen is an input region.
   */
-  if (!meta_is_wayland_compositor ())
-    info->pending_input_region = XFixesCreateRegion (xdisplay, NULL, 0);
-  else
-    {
-      /* Stage input region trickery isn't needed when we're running as a
-       * wayland compositor. */
-      info->pending_input_region = None;
-    }
+  info->pending_input_region = XFixesCreateRegion (xdisplay, NULL, 0);

  info->screen = screen;

@@ -729,58 +627,7 @@ meta_compositor_manage_screen (MetaCompositor *compositor,

  meta_screen_set_cm_selection (screen);

-  /* We will have already created a stage if running as a wayland
-   * compositor... */
-#ifdef HAVE_WAYLAND
-  if (meta_is_wayland_compositor ())
-    {
-      wayland_compositor = meta_wayland_compositor_get_default ();
-      info->stage = wayland_compositor->stage;
-
-      meta_screen_get_size (screen, &width, &height);
-      clutter_actor_set_size (info->stage, width, height);
-    }
-  else
-#endif /* HAVE_WAYLAND */
-    {
-      info->stage = clutter_stage_new ();
-
-      meta_screen_get_size (screen, &width, &height);
-      clutter_actor_realize (info->stage);
-
-      xwin = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));
-
-      XResizeWindow (xdisplay, xwin, width, height);
-
-        {
-          long event_mask;
-          unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
-          XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
-          XWindowAttributes attr;
-
-          meta_core_add_old_event_mask (xdisplay, xwin, &mask);
-
-          XISetMask (mask.mask, XI_KeyPress);
-          XISetMask (mask.mask, XI_KeyRelease);
-          XISetMask (mask.mask, XI_ButtonPress);
-          XISetMask (mask.mask, XI_ButtonRelease);
-          XISetMask (mask.mask, XI_Enter);
-          XISetMask (mask.mask, XI_Leave);
-          XISetMask (mask.mask, XI_FocusIn);
-          XISetMask (mask.mask, XI_FocusOut);
-          XISetMask (mask.mask, XI_Motion);
-          XIClearMask (mask.mask, XI_TouchBegin);
-          XIClearMask (mask.mask, XI_TouchEnd);
-          XIClearMask (mask.mask, XI_TouchUpdate);
-          XISelectEvents (xdisplay, xwin, &mask, 1);
-
-          event_mask = ExposureMask | PropertyChangeMask | StructureNotifyMask;
-          if (XGetWindowAttributes (xdisplay, xwin, &attr))
-            event_mask |= attr.your_event_mask;
-
-          XSelectInput (xdisplay, xwin, event_mask);
-        }
-    }
+  info->stage = clutter_stage_new ();

  clutter_stage_set_paint_callback (CLUTTER_STAGE (info->stage),
                                    after_stage_paint,
@@ -789,6 +636,42 @@ meta_compositor_manage_screen (MetaCompositor *compositor,

  clutter_stage_set_sync_delay (CLUTTER_STAGE (info->stage), META_SYNC_DELAY);

+  meta_screen_get_size (screen, &width, &height);
+  clutter_actor_realize (info->stage);
+
+  xwin = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));
+
+  XResizeWindow (xdisplay, xwin, width, height);
+
+  {
+    long event_mask;
+    unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
+    XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
+    XWindowAttributes attr;
+
+    meta_core_add_old_event_mask (xdisplay, xwin, &mask);
+
+    XISetMask (mask.mask, XI_KeyPress);
+    XISetMask (mask.mask, XI_KeyRelease);
+    XISetMask (mask.mask, XI_ButtonPress);
+    XISetMask (mask.mask, XI_ButtonRelease);
+    XISetMask (mask.mask, XI_Enter);
+    XISetMask (mask.mask, XI_Leave);
+    XISetMask (mask.mask, XI_FocusIn);
+    XISetMask (mask.mask, XI_FocusOut);
+    XISetMask (mask.mask, XI_Motion);
+    XIClearMask (mask.mask, XI_TouchBegin);
+    XIClearMask (mask.mask, XI_TouchEnd);
+    XIClearMask (mask.mask, XI_TouchUpdate);
+    XISelectEvents (xdisplay, xwin, &mask, 1);
+
+    event_mask = ExposureMask | PropertyChangeMask | StructureNotifyMask;
+    if (XGetWindowAttributes (xdisplay, xwin, &attr))
+      event_mask |= attr.your_event_mask;
+
+    XSelectInput (xdisplay, xwin, event_mask);
+  }
+
  info->window_group = meta_window_group_new (screen);
  info->top_window_group = meta_window_group_new (screen);

@@ -797,68 +680,53 @@ meta_compositor_manage_screen (MetaCompositor *compositor,

  info->plugin_mgr = meta_plugin_manager_new (screen);

-  if (meta_is_wayland_compositor ())
+  /*
+   * Delay the creation of the overlay window as long as we can, to avoid
+   * blanking out the screen. This means that during the plugin loading, the
+   * overlay window is not accessible; if the plugin needs to access it
+   * directly, it should hook into the "show" signal on stage, and do
+   * its stuff there.
+   */
+  info->output = get_output_window (screen);
+  XReparentWindow (xdisplay, xwin, info->output, 0, 0);
+
+ /* Make sure there isn't any left-over output shape on the 
+  * overlay window by setting the whole screen to be an
+  * output region.
+  * 
+  * Note: there doesn't seem to be any real chance of that
+  *  because the X server will destroy the overlay window
+  *  when the last client using it exits.
+  */
+  XFixesSetWindowShapeRegion (xdisplay, info->output, ShapeBounding, 0, 0, None);
+
+  do_set_stage_input_region (screen, info->pending_input_region);
+  if (info->pending_input_region != None)
    {
-      /* NB: When running as a wayland compositor we don't need an X
-       * composite overlay window, and we don't need to play any input
-       * region tricks to redirect events into clutter. */
-      info->output = None;
-    }
-  else
-    {
-      /*
-       * Delay the creation of the overlay window as long as we can, to avoid
-       * blanking out the screen. This means that during the plugin loading, the
-       * overlay window is not accessible; if the plugin needs to access it
-       * directly, it should hook into the "show" signal on stage, and do
-       * its stuff there.
-       */
-      info->output = get_output_window (screen);
-      XReparentWindow (xdisplay, xwin, info->output, 0, 0);
-
-      /* Make sure there isn't any left-over output shape on the 
-       * overlay window by setting the whole screen to be an
-       * output region.
-       * 
-       * Note: there doesn't seem to be any real chance of that
-       *  because the X server will destroy the overlay window
-       *  when the last client using it exits.
-       */
-      XFixesSetWindowShapeRegion (xdisplay, info->output, ShapeBounding, 0, 0, None);
-
-      do_set_stage_input_region (screen, info->pending_input_region);
-      if (info->pending_input_region != None)
-        {
-          XFixesDestroyRegion (xdisplay, info->pending_input_region);
-          info->pending_input_region = None;
-        }
-
-      /* Map overlay window before redirecting windows offscreen so we catch their
-       * contents until we show the stage.
-       */
-      XMapWindow (xdisplay, info->output);
-
-      redirect_windows (compositor, screen);
+      XFixesDestroyRegion (xdisplay, info->pending_input_region);
+      info->pending_input_region = None;
    }

-  clutter_actor_show (info->stage);
+  /* Map overlay window before redirecting windows offscreen so we catch their
+   * contents until we show the stage.
+   */
+  XMapWindow (xdisplay, info->output);
+
+  redirect_windows (compositor, screen);
 }

 void
 meta_compositor_unmanage_screen (MetaCompositor *compositor,
                                 MetaScreen     *screen)
 {
-  if (!meta_is_wayland_compositor ())
-    {
-      MetaDisplay    *display       = meta_screen_get_display (screen);
-      Display        *xdisplay      = meta_display_get_xdisplay (display);
-      Window          xroot         = meta_screen_get_xroot (screen);
+  MetaDisplay    *display       = meta_screen_get_display (screen);
+  Display        *xdisplay      = meta_display_get_xdisplay (display);
+  Window          xroot         = meta_screen_get_xroot (screen);

-      /* This is the most important part of cleanup - we have to do this
-       * before giving up the window manager selection or the next
-       * window manager won't be able to redirect subwindows */
-      XCompositeUnredirectSubwindows (xdisplay, xroot, CompositeRedirectManual);
-    }
+  /* This is the most important part of cleanup - we have to do this
+   * before giving up the window manager selection or the next
+   * window manager won't be able to redirect subwindows */
+  XCompositeUnredirectSubwindows (xdisplay, xroot, CompositeRedirectManual);
 }

 /*
@@ -930,18 +798,15 @@ meta_compositor_remove_window (MetaCompositor *compositor,
  if (!window_actor)
    return;

-  if (!meta_is_wayland_compositor ())
-    {
-      screen = meta_window_get_screen (window);
-      info = meta_screen_get_compositor_data (screen);
+  screen = meta_window_get_screen (window);
+  info = meta_screen_get_compositor_data (screen);

-      if (window_actor == info->unredirected_window)
-        {
-          meta_window_actor_set_redirected (window_actor, TRUE);
-          meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (info->unredirected_window)),
-                                     NULL);
-          info->unredirected_window = NULL;
-        }
+  if (window_actor == info->unredirected_window)
+    {
+      meta_window_actor_set_redirected (window_actor, TRUE);
+      meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (info->unredirected_window)),
+                                 NULL);
+      info->unredirected_window = NULL;
    }

  meta_window_actor_destroy (window_actor);
@@ -1001,8 +866,8 @@ is_grabbed_event (MetaDisplay *display,
 }

 void
-meta_compositor_window_x11_shape_changed (MetaCompositor *compositor,
-                                          MetaWindow     *window)
+meta_compositor_window_shape_changed (MetaCompositor *compositor,
+                                      MetaWindow     *window)
 {
  MetaWindowActor *window_actor;
  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
@@ -1128,8 +993,7 @@ meta_compositor_process_event (MetaCompositor *compositor,
      break;

    default:
-      if (!meta_is_wayland_compositor () &&
-          event->type == meta_display_get_damage_event_base (compositor->display) + XDamageNotify)
+      if (event->type == meta_display_get_damage_event_base (compositor->display) + XDamageNotify)
        {
          /* Core code doesn't handle damage events, so we need to extract the MetaWindow
           * ourselves
@@ -1148,7 +1012,7 @@ meta_compositor_process_event (MetaCompositor *compositor,

  /* Clutter needs to know about MapNotify events otherwise it will
     think the stage is invisible */
-  if (!meta_is_wayland_compositor () && event->type == MapNotify)
+  if (event->type == MapNotify)
    clutter_x11_handle_event (event);

  /* The above handling is basically just "observing" the events, so we return
@@ -1490,40 +1354,22 @@ meta_compositor_sync_screen_size (MetaCompositor  *compositor,
 				  guint		   width,
 				  guint		   height)
 {
+  MetaDisplay    *display = meta_screen_get_display (screen);
  MetaCompScreen *info    = meta_screen_get_compositor_data (screen);
+  Display        *xdisplay;
+  Window          xwin;

-  if (meta_is_wayland_compositor ())
-    {
-      /* FIXME: when we support a sliced stage, this is the place to do it
-         But! This is not the place to apply KMS config, here we only
-         notify Clutter/Cogl/GL that the framebuffer sizes changed.
+  DEBUG_TRACE ("meta_compositor_sync_screen_size\n");
+  g_return_if_fail (info);

-         And because for now clutter does not do sliced, we use one
-         framebuffer the size of the whole screen, and when running on
-         bare metal MetaMonitorManager will do the necessary tricks to
-         show the right portions on the right screens.
-      */
+  xdisplay = meta_display_get_xdisplay (display);
+  xwin = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));

-      clutter_actor_set_size (info->stage, width, height);
-    }
-  else
-    {
-      MetaDisplay    *display = meta_screen_get_display (screen);
-      Display        *xdisplay;
-      Window          xwin;
-
-      DEBUG_TRACE ("meta_compositor_sync_screen_size\n");
-      g_return_if_fail (info);
-
-      xdisplay = meta_display_get_xdisplay (display);
-      xwin = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));
-
-      XResizeWindow (xdisplay, xwin, width, height);
-    }
+  XResizeWindow (xdisplay, xwin, width, height);

  meta_verbose ("Changed size for stage on screen %d to %dx%d\n",
-                meta_screen_get_screen_number (screen),
-                width, height);
+		meta_screen_get_screen_number (screen),
+		width, height);
 }

 static void
@@ -1587,32 +1433,29 @@ pre_paint_windows (MetaCompScreen *info)
  if (info->windows == NULL)
    return;

-  if (!meta_is_wayland_compositor ())
+  top_window = g_list_last (info->windows)->data;
+
+  if (meta_window_actor_should_unredirect (top_window) &&
+      info->disable_unredirect_count == 0)
+    expected_unredirected_window = top_window;
+
+  if (info->unredirected_window != expected_unredirected_window)
    {
-      top_window = g_list_last (info->windows)->data;
-
-      if (meta_window_actor_should_unredirect (top_window) &&
-          info->disable_unredirect_count == 0)
-        expected_unredirected_window = top_window;
-
-      if (info->unredirected_window != expected_unredirected_window)
+      if (info->unredirected_window != NULL)
        {
-          if (info->unredirected_window != NULL)
-            {
-              meta_window_actor_set_redirected (info->unredirected_window, TRUE);
-              meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (info->unredirected_window)),
-                                         NULL);
-            }
-
-          if (expected_unredirected_window != NULL)
-            {
-              meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (top_window)),
-                                         meta_window_actor_get_meta_window (top_window));
-              meta_window_actor_set_redirected (top_window, FALSE);
-            }
-
-          info->unredirected_window = expected_unredirected_window;
+          meta_window_actor_set_redirected (info->unredirected_window, TRUE);
+          meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (info->unredirected_window)),
+                                     NULL);
        }
+
+      if (expected_unredirected_window != NULL)
+        {
+          meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (top_window)),
+                                     meta_window_actor_get_meta_window (top_window));
+          meta_window_actor_set_redirected (top_window, FALSE);
+        }
+
+      info->unredirected_window = expected_unredirected_window;
    }

  for (l = info->windows; l; l = l->next)
--- a/src/compositor/meta-background-group.c
+++ b/src/compositor/meta-background-group.c
@@ -73,13 +73,12 @@ void
 meta_background_group_set_visible_region (MetaBackgroundGroup *self,
                                          cairo_region_t      *region)
 {
-  GList *children, *l;
+  ClutterActorIter iter;
+  ClutterActor *actor;

-  children = clutter_actor_get_children (CLUTTER_ACTOR (self));
-  for (l = children; l; l = l->next)
+  clutter_actor_iter_init (&iter, CLUTTER_ACTOR (self));
+  while (clutter_actor_iter_next (&iter, &actor))
    {
-      ClutterActor *actor = l->data;
-
      if (META_IS_BACKGROUND_ACTOR (actor))
        {
          meta_background_actor_set_visible_region (META_BACKGROUND_ACTOR (actor), region);
@@ -96,7 +95,6 @@ meta_background_group_set_visible_region (MetaBackgroundGroup *self,
          cairo_region_translate (region, x, y);
        }
    }
-  g_list_free (children);
 }

 ClutterActor *
--- a/src/compositor/meta-plugin-manager.c
+++ b/src/compositor/meta-plugin-manager.c
@@ -329,18 +329,8 @@ meta_plugin_manager_xevent_filter (MetaPluginManager *plugin_mgr,
   */
  if (klass->xevent_filter)
    return klass->xevent_filter (plugin, xev);
-
-  /* When mutter is running as a wayland compositor, things like input
-   * events just come directly from clutter so it won't have disabled
-   * clutter's event retrieval and won't need to forward it events (if
-   * it did it would lead to recursion). Also when running as a
-   * wayland compositor we shouldn't be assuming that we're running
-   * with the clutter x11 backend.
-   */
-  if (meta_is_wayland_compositor ())
-    return FALSE;
-
-  return clutter_x11_handle_event (xev) != CLUTTER_X11_FILTER_CONTINUE;
+  else
+    return clutter_x11_handle_event (xev) != CLUTTER_X11_FILTER_CONTINUE;
 }

 void
--- a/src/compositor/meta-plugin.c
+++ b/src/compositor/meta-plugin.c
@@ -267,6 +267,10 @@ meta_plugin_destroy_completed (MetaPlugin      *plugin,
 /**
 * meta_plugin_begin_modal:
 * @plugin: a #MetaPlugin
+ * @grab_window: the X window to grab the keyboard and mouse on
+ * @cursor: the cursor to use for the pointer grab, or None,
+ *          to use the normal cursor for the grab window and
+ *          its descendants.
 * @options: flags that modify the behavior of the modal grab
 * @timestamp: the timestamp used for establishing grabs
 *
@@ -287,13 +291,15 @@ meta_plugin_destroy_completed (MetaPlugin      *plugin,
 */
 gboolean
 meta_plugin_begin_modal (MetaPlugin       *plugin,
+                         Window            grab_window,
+                         Cursor            cursor,
                         MetaModalOptions  options,
                         guint32           timestamp)
 {
  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

  return meta_begin_modal_for_plugin (priv->screen, plugin,
-                                      options, timestamp);
+                                      grab_window, cursor, options, timestamp);
 }

 /**
--- a/src/compositor/meta-shaped-texture.c
+++ b/src/compositor/meta-shaped-texture.c
@@ -30,14 +30,8 @@
 #include <config.h>

 #include <meta/meta-shaped-texture.h>
-#include <meta/util.h>
 #include "meta-texture-tower.h"

-#ifdef HAVE_WAYLAND
-#include "meta-wayland-private.h"
-#include <cogl/cogl-wayland-server.h>
-#endif
-
 #include <clutter/clutter.h>
 #include <cogl/cogl.h>
 #include <cogl/cogl-texture-pixmap-x11.h>
@@ -61,15 +55,6 @@ static void meta_shaped_texture_get_preferred_height (ClutterActor *self,

 static gboolean meta_shaped_texture_get_paint_volume (ClutterActor *self, ClutterPaintVolume *volume);

-typedef enum _MetaShapedTextureType
-{
-  META_SHAPED_TEXTURE_TYPE_X11_PIXMAP,
-#ifdef HAVE_WAYLAND
-  META_SHAPED_TEXTURE_TYPE_WAYLAND_SURFACE,
-#endif
-} MetaShapedTextureType;
-
-
 G_DEFINE_TYPE (MetaShapedTexture, meta_shaped_texture,
               CLUTTER_TYPE_ACTOR);

@@ -80,27 +65,13 @@ G_DEFINE_TYPE (MetaShapedTexture, meta_shaped_texture,
 struct _MetaShapedTexturePrivate
 {
  MetaTextureTower *paint_tower;
-
-  MetaShapedTextureType type;
-  union {
-    struct {
-      Pixmap pixmap;
-    } x11;
-#ifdef HAVE_WAYLAND
-    struct {
-      MetaWaylandSurface *surface;
-    } wayland;
-#endif
-  };
-
-  CoglTexture *texture;
-
+  Pixmap pixmap;
+  CoglTexturePixmapX11 *texture;
  CoglTexture *mask_texture;
  CoglPipeline *pipeline;
  CoglPipeline *pipeline_unshaped;

  cairo_region_t *clip_region;
-  cairo_region_t *input_shape_region;

  guint tex_width, tex_height;

@@ -132,10 +103,7 @@ meta_shaped_texture_init (MetaShapedTexture *self)
  priv = self->priv = META_SHAPED_TEXTURE_GET_PRIVATE (self);

  priv->paint_tower = meta_texture_tower_new ();
-
-  priv->type = META_SHAPED_TEXTURE_TYPE_X11_PIXMAP;
  priv->texture = NULL;
-
  priv->mask_texture = NULL;
  priv->create_mipmaps = TRUE;
 }
@@ -160,56 +128,6 @@ meta_shaped_texture_dispose (GObject *object)
  G_OBJECT_CLASS (meta_shaped_texture_parent_class)->dispose (object);
 }

-static void
-set_cogl_texture (MetaShapedTexture *stex,
-                  CoglTexture       *cogl_tex)
-{
-  MetaShapedTexturePrivate *priv;
-  guint width, height;
-
-  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
-
-  priv = stex->priv;
-
-  if (priv->texture)
-    cogl_object_unref (priv->texture);
-
-  priv->texture = cogl_tex;
-
-  if (priv->pipeline != NULL)
-    cogl_pipeline_set_layer_texture (priv->pipeline, 0, COGL_TEXTURE (cogl_tex));
-
-  if (priv->pipeline_unshaped != NULL)
-    cogl_pipeline_set_layer_texture (priv->pipeline_unshaped, 0, COGL_TEXTURE (cogl_tex));
-
-  if (cogl_tex != NULL)
-    {
-      width = cogl_texture_get_width (COGL_TEXTURE (cogl_tex));
-      height = cogl_texture_get_height (COGL_TEXTURE (cogl_tex));
-
-      if (width != priv->tex_width ||
-          height != priv->tex_height)
-        {
-          priv->tex_width = width;
-          priv->tex_height = height;
-
-          clutter_actor_queue_relayout (CLUTTER_ACTOR (stex));
-        }
-    }
-  else
-    {
-      /* size changed to 0 going to an invalid handle */
-      priv->tex_width = 0;
-      priv->tex_height = 0;
-      clutter_actor_queue_relayout (CLUTTER_ACTOR (stex));
-    }
-
-  /* NB: We don't queue a redraw of the actor here because we don't
-   * know how much of the buffer has changed with respect to the
-   * previous buffer. We only queue a redraw in response to surface
-   * damage. */
-}
-
 static void
 meta_shaped_texture_paint (ClutterActor *actor)
 {
@@ -367,53 +285,38 @@ meta_shaped_texture_pick (ClutterActor       *actor,
  MetaShapedTexture *stex = (MetaShapedTexture *) actor;
  MetaShapedTexturePrivate *priv = stex->priv;

-  if (!clutter_actor_should_pick_paint (actor) ||
-      (priv->clip_region && cairo_region_is_empty (priv->clip_region)))
-    return;
-
  /* If there is no region then use the regular pick */
-  if (priv->input_shape_region == NULL)
+  if (priv->mask_texture == NULL)
    CLUTTER_ACTOR_CLASS (meta_shaped_texture_parent_class)
      ->pick (actor, color);
-  else
+  else if (clutter_actor_should_pick_paint (actor))
    {
-      int n_rects;
-      float *rectangles;
-      int i;
+      CoglTexture *paint_tex;
+      ClutterActorBox alloc;
+      guint tex_width, tex_height;

-      /* Note: We don't bother trying to intersect the pick and clip regions
-       * since needing to copy the region, do the intersection, and probably
-       * increase the number of rectangles seems more likely to have a negative
-       * effect.
-       *
-       * NB: Most of the time when just using rectangles for picking then
-       * picking shouldn't involve any rendering, and minimizing the number of
-       * rectangles has more benefit than reducing the area of the pick
-       * region.
-       */
+      paint_tex = COGL_TEXTURE (priv->texture);

-      n_rects = cairo_region_num_rectangles (priv->input_shape_region);
-      rectangles = g_alloca (sizeof (float) * 4 * n_rects);
+      if (paint_tex == NULL)
+        return;

-      for (i = 0; i < n_rects; i++)
-        {
-          cairo_rectangle_int_t rect;
-          int pos = i * 4;
+      tex_width = cogl_texture_get_width (paint_tex);
+      tex_height = cogl_texture_get_height (paint_tex);

-          cairo_region_get_rectangle (priv->input_shape_region, i, &rect);
+      if (tex_width == 0 || tex_height == 0) /* no contents yet */
+        return;

-          rectangles[pos] = rect.x;
-          rectangles[pos + 1] = rect.y;
-          rectangles[pos + 2] = rect.x + rect.width;
-          rectangles[pos + 3] = rect.y + rect.height;
-        }
+      cogl_set_source_color4ub (color->red, color->green, color->blue,
+                                 color->alpha);

-      cogl_set_source_color4ub (color->red,
-                                color->green,
-                                color->blue,
-                                color->alpha);
+      clutter_actor_get_allocation_box (actor, &alloc);

-      cogl_rectangles (rectangles, n_rects);
+      /* Paint the mask rectangle in the given color */
+      cogl_set_source_texture (priv->mask_texture);
+      cogl_rectangle_with_texture_coords (0, 0,
+                                          alloc.x2 - alloc.x1,
+                                          alloc.y2 - alloc.y1,
+                                          0, 0, 1, 1);
    }
 }

@@ -462,48 +365,12 @@ meta_shaped_texture_get_paint_volume (ClutterActor *self,
  return clutter_paint_volume_set_from_allocation (volume, self);
 }

-#ifdef HAVE_WAYLAND
 ClutterActor *
-meta_shaped_texture_new_with_wayland_surface (MetaWaylandSurface *surface)
+meta_shaped_texture_new (void)
 {
-  ClutterActor *actor = g_object_new (META_TYPE_SHAPED_TEXTURE, NULL);
-  MetaShapedTexturePrivate *priv = META_SHAPED_TEXTURE (actor)->priv;
+  ClutterActor *self = g_object_new (META_TYPE_SHAPED_TEXTURE, NULL);

-  /* XXX: it could probably be better to have a "type" construct-only
-   * property or create wayland/x11 subclasses */
-  priv->type = META_SHAPED_TEXTURE_TYPE_WAYLAND_SURFACE;
-
-  meta_shaped_texture_set_wayland_surface (META_SHAPED_TEXTURE (actor),
-                                           surface);
-
-  return actor;
-}
-
-void
-meta_shaped_texture_set_wayland_surface (MetaShapedTexture *stex,
-                                         MetaWaylandSurface *surface)
-{
-  MetaShapedTexturePrivate *priv = stex->priv;
-
-  priv->wayland.surface = surface;
-
-  if (surface && surface->buffer_ref.buffer)
-    meta_shaped_texture_attach_wayland_buffer (stex,
-                                               surface->buffer_ref.buffer);
-}
-
-MetaWaylandSurface *
-meta_shaped_texture_get_wayland_surface (MetaShapedTexture *stex)
-{
-  MetaShapedTexturePrivate *priv = stex->priv;
-  return priv->wayland.surface;
-}
-#endif /* HAVE_WAYLAND */
-
-ClutterActor *
-meta_shaped_texture_new_with_xwindow (Window xwindow)
-{
-  return g_object_new (META_TYPE_SHAPED_TEXTURE, NULL);
+  return self;
 }

 void
@@ -522,7 +389,8 @@ meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex,
    {
      CoglTexture *base_texture;
      priv->create_mipmaps = create_mipmaps;
-      base_texture = create_mipmaps ? priv->texture : NULL;
+      base_texture = create_mipmaps ?
+        COGL_TEXTURE (priv->texture) : NULL;
      meta_texture_tower_set_base_texture (priv->paint_tower, base_texture);
    }
 }
@@ -548,146 +416,74 @@ meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }

-#ifdef HAVE_WAYLAND
-static void
-wayland_surface_update_area (MetaShapedTexture *stex,
-                             int                x,
-                             int                y,
-                             int                width,
-                             int                height)
-{
-  MetaShapedTexturePrivate *priv;
-  MetaWaylandBuffer *buffer;
-
-  priv = stex->priv;
-
-  g_return_if_fail (priv->type == META_SHAPED_TEXTURE_TYPE_WAYLAND_SURFACE);
-  g_return_if_fail (priv->texture != NULL);
-
-  buffer = priv->wayland.surface->buffer_ref.buffer;
-
-  if (buffer)
-    {
-      struct wl_resource *resource = buffer->resource;
-      struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get (resource);
-
-      if (shm_buffer)
-        {
-          CoglPixelFormat format;
-
-          switch (wl_shm_buffer_get_format (shm_buffer))
-            {
-#if G_BYTE_ORDER == G_BIG_ENDIAN
-            case WL_SHM_FORMAT_ARGB8888:
-              format = COGL_PIXEL_FORMAT_ARGB_8888_PRE;
-              break;
-            case WL_SHM_FORMAT_XRGB8888:
-              format = COGL_PIXEL_FORMAT_ARGB_8888;
-              break;
-#elif G_BYTE_ORDER == G_LITTLE_ENDIAN
-            case WL_SHM_FORMAT_ARGB8888:
-              format = COGL_PIXEL_FORMAT_BGRA_8888_PRE;
-              break;
-            case WL_SHM_FORMAT_XRGB8888:
-              format = COGL_PIXEL_FORMAT_BGRA_8888;
-              break;
-#endif
-            default:
-              g_warn_if_reached ();
-              format = COGL_PIXEL_FORMAT_ARGB_8888;
-            }
-
-          cogl_texture_set_region (priv->texture,
-                                   x, y,
-                                   x, y,
-                                   width, height,
-                                   width, height,
-                                   format,
-                                   wl_shm_buffer_get_stride (shm_buffer),
-                                   wl_shm_buffer_get_data (shm_buffer));
-        }
-    }
-}
-#endif /* HAVE_WAYLAND */
-
-static void
-queue_damage_redraw_with_clip (MetaShapedTexture *stex,
-                               int x,
-                               int y,
-                               int width,
-                               int height)
-{
-  ClutterActor *self = CLUTTER_ACTOR (stex);
-  MetaShapedTexturePrivate *priv;
-  ClutterActorBox allocation;
-  float scale_x;
-  float scale_y;
-  cairo_rectangle_int_t clip;
-
-  /* NB: clutter_actor_queue_redraw_with_clip expects a box in the actor's
-   * coordinate space so we need to convert from surface coordinates to
-   * actor coordinates...
-   */
-
-  /* Calling clutter_actor_get_allocation_box() is enormously expensive
-   * if the actor has an out-of-date allocation, since it triggers
-   * a full redraw. clutter_actor_queue_redraw_with_clip() would redraw
-   * the whole stage anyways in that case, so just go ahead and do
-   * it here.
-   */
-  if (!clutter_actor_has_allocation (self))
-    {
-      clutter_actor_queue_redraw (self);
-      return;
-    }
-
-  priv = stex->priv;
-
-  if (priv->tex_width == 0 || priv->tex_height == 0)
-    return;
-
-  clutter_actor_get_allocation_box (self, &allocation);
-
-  scale_x = (allocation.x2 - allocation.x1) / priv->tex_width;
-  scale_y = (allocation.y2 - allocation.y1) / priv->tex_height;
-
-  clip.x = x * scale_x;
-  clip.y = y * scale_y;
-  clip.width = width * scale_x;
-  clip.height = height * scale_y;
-  clutter_actor_queue_redraw_with_clip (self, &clip);
-}
-
 void
 meta_shaped_texture_update_area (MetaShapedTexture *stex,
-                                 int                x,
-                                 int                y,
-                                 int                width,
-                                 int                height)
+				 int                x,
+				 int                y,
+				 int                width,
+				 int                height)
 {
  MetaShapedTexturePrivate *priv;
+  const cairo_rectangle_int_t clip = { x, y, width, height };

  priv = stex->priv;

  if (priv->texture == NULL)
    return;

-  switch (priv->type)
-    {
-    case META_SHAPED_TEXTURE_TYPE_X11_PIXMAP:
-      cogl_texture_pixmap_x11_update_area (COGL_TEXTURE_PIXMAP_X11 (priv->texture),
-                                           x, y, width, height);
-      break;
-#ifdef HAVE_WAYLAND
-    case META_SHAPED_TEXTURE_TYPE_WAYLAND_SURFACE:
-      wayland_surface_update_area (stex, x, y, width, height);
-      break;
-#endif
-    }
+  cogl_texture_pixmap_x11_update_area (priv->texture,
+                                       x, y, width, height);

  meta_texture_tower_update_area (priv->paint_tower, x, y, width, height);

-  queue_damage_redraw_with_clip (stex, x, y, width, height);
+  clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (stex), &clip);
+}
+
+static void
+set_cogl_texture (MetaShapedTexture    *stex,
+                  CoglTexturePixmapX11 *cogl_tex)
+{
+  MetaShapedTexturePrivate *priv;
+  guint width, height;
+
+  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
+
+  priv = stex->priv;
+
+  if (priv->texture != NULL)
+    cogl_object_unref (priv->texture);
+
+  priv->texture = cogl_tex;
+
+  if (priv->pipeline != NULL)
+    cogl_pipeline_set_layer_texture (priv->pipeline, 0, COGL_TEXTURE (cogl_tex));
+
+  if (priv->pipeline_unshaped != NULL)
+    cogl_pipeline_set_layer_texture (priv->pipeline_unshaped, 0, COGL_TEXTURE (cogl_tex));
+
+  if (cogl_tex != NULL)
+    {
+      width = cogl_texture_get_width (COGL_TEXTURE (cogl_tex));
+      height = cogl_texture_get_height (COGL_TEXTURE (cogl_tex));
+
+      if (width != priv->tex_width ||
+          height != priv->tex_height)
+        {
+          priv->tex_width = width;
+          priv->tex_height = height;
+
+          clutter_actor_queue_relayout (CLUTTER_ACTOR (stex));
+        }
+    }
+  else
+    {
+      /* size changed to 0 going to an inavlid texture */
+      priv->tex_width = 0;
+      priv->tex_height = 0;
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (stex));
+    }
+
+  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }

 /**
@@ -705,18 +501,16 @@ meta_shaped_texture_set_pixmap (MetaShapedTexture *stex,

  priv = stex->priv;

-  if (priv->x11.pixmap == pixmap)
+  if (priv->pixmap == pixmap)
    return;

-  priv->x11.pixmap = pixmap;
+  priv->pixmap = pixmap;

  if (pixmap != None)
    {
      CoglContext *ctx =
        clutter_backend_get_cogl_context (clutter_get_default_backend ());
-      CoglTexture *texture =
-        COGL_TEXTURE (cogl_texture_pixmap_x11_new (ctx, pixmap, FALSE, NULL));
-      set_cogl_texture (stex, texture);
+      set_cogl_texture (stex, cogl_texture_pixmap_x11_new (ctx, pixmap, FALSE, NULL));
    }
  else
    set_cogl_texture (stex, NULL);
@@ -726,54 +520,6 @@ meta_shaped_texture_set_pixmap (MetaShapedTexture *stex,
                                         COGL_TEXTURE (priv->texture));
 }

-#ifdef HAVE_WAYLAND
-void
-meta_shaped_texture_attach_wayland_buffer (MetaShapedTexture  *stex,
-                                           MetaWaylandBuffer  *buffer)
-{
-  MetaShapedTexturePrivate *priv;
-
-  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
-
-  priv = stex->priv;
-
-  /* TODO: we should change this api to be something like
-   * meta_shaped_texture_notify_buffer_attach() since we now maintain
-   * a reference to the MetaWaylandSurface where we can access the
-   * buffer without it being explicitly passed as an argument.
-   */
-  g_return_if_fail (priv->wayland.surface->buffer_ref.buffer == buffer);
-
-  if (buffer)
-    {
-      CoglContext *ctx =
-        clutter_backend_get_cogl_context (clutter_get_default_backend ());
-      CoglError *catch_error = NULL;
-      CoglTexture *texture =
-        COGL_TEXTURE (cogl_wayland_texture_2d_new_from_buffer (ctx,
-                                                               buffer->resource,
-                                                               &catch_error));
-      if (!texture)
-        {
-          cogl_error_free (catch_error);
-        }
-      else
-        {
-          buffer->width = cogl_texture_get_width (texture);
-          buffer->height = cogl_texture_get_height (texture);
-        }
-
-      set_cogl_texture (stex, texture);
-    }
-  else
-    set_cogl_texture (stex, NULL);
-
-  if (priv->create_mipmaps)
-    meta_texture_tower_set_base_texture (priv->paint_tower,
-                                         COGL_TEXTURE (priv->texture));
-}
-#endif /* HAVE_WAYLAND */
-
 /**
 * meta_shaped_texture_get_texture:
 * @stex: The #MetaShapedTexture
@@ -787,41 +533,6 @@ meta_shaped_texture_get_texture (MetaShapedTexture *stex)
  return COGL_TEXTURE (stex->priv->texture);
 }

-/**
- * meta_shaped_texture_set_input_shape_region:
- * @stex: a #MetaShapedTexture
- * @shape_region: the region of the texture that should respond to
- *    input.
- *
- * Determines what region of the texture should accept input. For
- * X based windows this is defined by the ShapeInput region of the
- * window.
- */
-void
-meta_shaped_texture_set_input_shape_region (MetaShapedTexture *stex,
-                                            cairo_region_t    *shape_region)
-{
-  MetaShapedTexturePrivate *priv;
-
-  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
-
-  priv = stex->priv;
-
-  if (priv->input_shape_region != NULL)
-    {
-      cairo_region_destroy (priv->input_shape_region);
-      priv->input_shape_region = NULL;
-    }
-
-  if (shape_region != NULL)
-    {
-      cairo_region_reference (shape_region);
-      priv->input_shape_region = shape_region;
-    }
-
-  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
-}
-
 /**
 * meta_shaped_texture_set_clip_region:
 * @stex: a #MetaShapedTexture
--- a/src/compositor/meta-window-actor-private.h
+++ b/src/compositor/meta-window-actor-private.h
@@ -5,11 +5,6 @@

 #include <config.h>

-#ifdef HAVE_WAYLAND
-#include <wayland-server.h>
-#include <meta-wayland-private.h>
-#endif
-
 #include <X11/extensions/Xdamage.h>
 #include <meta/compositor-mutter.h>

@@ -29,20 +24,8 @@ void meta_window_actor_unmaximize (MetaWindowActor *self,
                                   MetaRectangle   *old_rect,
                                   MetaRectangle   *new_rect);

-void meta_window_actor_process_x11_damage (MetaWindowActor    *self,
-                                           XDamageNotifyEvent *event);
-
-#ifdef HAVE_WAYLAND
-void meta_window_actor_process_wayland_damage (MetaWindowActor *self,
-                                               int              x,
-                                               int              y,
-                                               int              width,
-                                               int              height);
-void meta_window_actor_set_wayland_surface    (MetaWindowActor    *self,
-                                               MetaWaylandSurface *surface);
-void meta_window_actor_attach_wayland_buffer  (MetaWindowActor   *self,
-                                               MetaWaylandBuffer *buffer);
-#endif
+void meta_window_actor_process_damage (MetaWindowActor    *self,
+                                       XDamageNotifyEvent *event);

 void meta_window_actor_pre_paint      (MetaWindowActor    *self);
 void meta_window_actor_post_paint     (MetaWindowActor    *self);
--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@@ -32,9 +32,6 @@
 #include "meta-window-actor-private.h"
 #include "meta-texture-rectangle.h"
 #include "region-utils.h"
-#ifdef HAVE_WAYLAND
-#include "meta-wayland-private.h"
-#endif

 enum {
  POSITION_CHANGED,
@@ -67,12 +64,14 @@ struct _MetaWindowActorPrivate
  MetaShadow       *focused_shadow;
  MetaShadow       *unfocused_shadow;

+  Pixmap            back_pixmap;
+
+  Damage            damage;
+
  guint8            opacity;

  /* A region that matches the shape of the window, including frame bounds */
  cairo_region_t   *shape_region;
-  /* If the window has an input shape, a region that matches the shape */
-  cairo_region_t   *input_shape_region;
  /* The opaque region, from _NET_WM_OPAQUE_REGION, intersected with
   * the shape region. */
  cairo_region_t   *opaque_region;
@@ -103,41 +102,31 @@ struct _MetaWindowActorPrivate
  /* List of FrameData for recent frames */
  GList            *frames;

-  Pixmap            back_pixmap; /* Not used in wayland compositor mode */
-  Damage            damage; /* Not used in wayland compositor mode */
-
  guint		    visible                : 1;
  guint		    mapped                 : 1;
  guint		    argb32                 : 1;
  guint		    disposed               : 1;
  guint             redecorating           : 1;

+  guint		    needs_damage_all       : 1;
+  guint		    received_damage        : 1;
+  guint             repaint_scheduled      : 1;
+
  /* If set, the client needs to be sent a _NET_WM_FRAME_DRAWN
   * client message using the most recent frame in ->frames */
  guint             needs_frame_drawn      : 1;
-  guint             repaint_scheduled      : 1;

+  guint		    needs_pixmap           : 1;
  guint             needs_reshape          : 1;
  guint             recompute_focused_shadow   : 1;
  guint             recompute_unfocused_shadow : 1;
+  guint		    size_changed           : 1;
+  guint             updates_frozen         : 1;

  guint		    needs_destroy	   : 1;

  guint             no_shadow              : 1;

-
-  /* 
-   * None of these are used in wayland compositor mode...
-   */
-
-  guint		    needs_damage_all       : 1;
-  guint		    received_x11_damage    : 1;
-
-  guint		    needs_pixmap           : 1;
-
-  guint		    x11_size_changed       : 1;
-  guint             updates_frozen         : 1;
-
  guint             unredirected           : 1;

  /* This is used to detect fullscreen windows that need to be unredirected */
@@ -181,7 +170,7 @@ static gboolean meta_window_actor_get_paint_volume (ClutterActor       *actor,
                                                    ClutterPaintVolume *volume);


-static void meta_window_actor_detach_x11_pixmap     (MetaWindowActor *self);
+static void     meta_window_actor_detach     (MetaWindowActor *self);
 static gboolean meta_window_actor_has_shadow (MetaWindowActor *self);

 static void meta_window_actor_handle_updates (MetaWindowActor *self);
@@ -315,21 +304,18 @@ window_decorated_notify (MetaWindow *mw,
  else
    new_xwindow = meta_window_get_xwindow (mw);

-  if (!meta_is_wayland_compositor ())
-    {
-      meta_window_actor_detach_x11_pixmap (self);
+  meta_window_actor_detach (self);

-      /*
-       * First of all, clean up any resources we are currently using and will
-       * be replacing.
-       */
-      if (priv->damage != None)
-        {
-          meta_error_trap_push (display);
-          XDamageDestroy (xdisplay, priv->damage);
-          meta_error_trap_pop (display);
-          priv->damage = None;
-        }
+  /*
+   * First of all, clean up any resources we are currently using and will
+   * be replacing.
+   */
+  if (priv->damage != None)
+    {
+      meta_error_trap_push (display);
+      XDamageDestroy (xdisplay, priv->damage);
+      meta_error_trap_pop (display);
+      priv->damage = None;
    }

  priv->xwindow = new_xwindow;
@@ -360,9 +346,8 @@ meta_window_actor_constructed (GObject *object)
  Display                *xdisplay = meta_display_get_xdisplay (display);
  XRenderPictFormat      *format;

-  if (!meta_is_wayland_compositor ())
-    priv->damage = XDamageCreate (xdisplay, xwindow,
-                                  XDamageReportBoundingBox);
+  priv->damage = XDamageCreate (xdisplay, xwindow,
+                                XDamageReportBoundingBox);

  format = XRenderFindVisualFormat (xdisplay, window->xvisual);

@@ -371,18 +356,10 @@ meta_window_actor_constructed (GObject *object)

  if (!priv->actor)
    {
-#ifdef HAVE_WAYLAND
-      if (meta_is_wayland_compositor ())
-        priv->actor = meta_shaped_texture_new_with_wayland_surface (window->surface);
-      else
-#endif
-        priv->actor = meta_shaped_texture_new_with_xwindow (xwindow);
+      priv->actor = meta_shaped_texture_new ();

      clutter_actor_add_child (CLUTTER_ACTOR (self), priv->actor);

-      if (meta_is_wayland_compositor ())
-        clutter_actor_set_reactive (priv->actor, TRUE);
-
      /*
       * Since we are holding a pointer to this actor independently of the
       * ClutterContainer internals, and provide a public API to access it,
@@ -392,10 +369,10 @@ meta_window_actor_constructed (GObject *object)
       */
      g_object_ref (priv->actor);

-      g_signal_connect (window, "notify::decorated",
-                        G_CALLBACK (window_decorated_notify), self);
-      g_signal_connect (window, "notify::appears-focused",
-                        G_CALLBACK (window_appears_focused_notify), self);
+      g_signal_connect_object (window, "notify::decorated",
+                               G_CALLBACK (window_decorated_notify), self, 0);
+      g_signal_connect_object (window, "notify::appears-focused",
+                               G_CALLBACK (window_appears_focused_notify), self, 0);
    }
  else
    {
@@ -408,10 +385,9 @@ meta_window_actor_constructed (GObject *object)

  meta_window_actor_update_opacity (self);

-  /* Start off with empty regions to maintain the invariant that
-     these regions are always set */
+  /* Start off with an empty region to maintain the invariant that
+     the shape region is always set */
  priv->shape_region = cairo_region_create();
-  priv->input_shape_region = cairo_region_create();
 }

 static void
@@ -430,18 +406,13 @@ meta_window_actor_dispose (GObject *object)
  priv->disposed = TRUE;

  screen   = priv->screen;
+  display  = meta_screen_get_display (screen);
+  xdisplay = meta_display_get_xdisplay (display);
  info     = meta_screen_get_compositor_data (screen);

-  if (!meta_is_wayland_compositor ())
-    {
-      display  = meta_screen_get_display (screen);
-      xdisplay = meta_display_get_xdisplay (display);
-
-      meta_window_actor_detach_x11_pixmap (self);
-    }
+  meta_window_actor_detach (self);

  g_clear_pointer (&priv->shape_region, cairo_region_destroy);
-  g_clear_pointer (&priv->input_shape_region, cairo_region_destroy);
  g_clear_pointer (&priv->opaque_region, cairo_region_destroy);
  g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);

@@ -450,7 +421,7 @@ meta_window_actor_dispose (GObject *object)
  g_clear_pointer (&priv->unfocused_shadow, meta_shadow_unref);
  g_clear_pointer (&priv->shadow_shape, meta_window_shape_unref);

-  if (!meta_is_wayland_compositor () && priv->damage != None)
+  if (priv->damage != None)
    {
      meta_error_trap_push (display);
      XDamageDestroy (xdisplay, priv->damage);
@@ -922,8 +893,7 @@ meta_window_actor_showing_on_its_workspace (MetaWindowActor *self)
 static void
 meta_window_actor_freeze (MetaWindowActor *self)
 {
-  if (!meta_is_wayland_compositor ())
-    self->priv->freeze_count++;
+  self->priv->freeze_count++;
 }

 static void
@@ -952,33 +922,30 @@ meta_window_actor_damage_all (MetaWindowActor *self)
 static void
 meta_window_actor_thaw (MetaWindowActor *self)
 {
-  if (!meta_is_wayland_compositor ())
+  self->priv->freeze_count--;
+
+  if (G_UNLIKELY (self->priv->freeze_count < 0))
    {
-      self->priv->freeze_count--;
-
-      if (G_UNLIKELY (self->priv->freeze_count < 0))
-        {
-          g_warning ("Error in freeze/thaw accounting.");
-          self->priv->freeze_count = 0;
-          return;
-        }
-
-      if (self->priv->freeze_count)
-        return;
-
-      /* We sometimes ignore moves and resizes on frozen windows */
-      meta_window_actor_sync_actor_geometry (self, FALSE);
-
-      /* We do this now since we might be going right back into the
-       * frozen state */
-      meta_window_actor_handle_updates (self);
-
-      /* Since we ignore damage events while a window is frozen for certain effects
-       * we may need to issue an update_area() covering the whole pixmap if we
-       * don't know what real damage has happened. */
-      if (self->priv->needs_damage_all)
-        meta_window_actor_damage_all (self);
+      g_warning ("Error in freeze/thaw accounting.");
+      self->priv->freeze_count = 0;
+      return;
    }
+
+  if (self->priv->freeze_count)
+    return;
+
+  /* We sometimes ignore moves and resizes on frozen windows */
+  meta_window_actor_sync_actor_geometry (self, FALSE);
+
+  /* We do this now since we might be going right back into the
+   * frozen state */
+  meta_window_actor_handle_updates (self);
+
+  /* Since we ignore damage events while a window is frozen for certain effects
+   * we may need to issue an update_area() covering the whole pixmap if we
+   * don't know what real damage has happened. */
+  if (self->priv->needs_damage_all)
+    meta_window_actor_damage_all (self);
 }

 void
@@ -1009,7 +976,7 @@ meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
       * send a _NET_WM_FRAME_DRAWN. We do a 1-pixel redraw to get
       * consistent timing with non-empty frames.
       */
-      if (priv->mapped && (!meta_is_wayland_compositor () || !priv->needs_pixmap))
+      if (priv->mapped && !priv->needs_pixmap)
        {
          const cairo_rectangle_int_t clip = { 0, 0, 1, 1 };
          clutter_actor_queue_redraw_with_clip (priv->actor, &clip);
@@ -1035,7 +1002,7 @@ is_frozen (MetaWindowActor *self)
 }

 static void
-meta_window_actor_queue_create_x11_pixmap (MetaWindowActor *self)
+meta_window_actor_queue_create_pixmap (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;

@@ -1139,14 +1106,11 @@ meta_window_actor_after_effects (MetaWindowActor *self)
  meta_window_actor_sync_visibility (self);
  meta_window_actor_sync_actor_geometry (self, FALSE);

-  if (!meta_is_wayland_compositor ())
-    {
-      if (!meta_window_is_mapped (priv->window))
-        meta_window_actor_detach_x11_pixmap (self);
+  if (!meta_window_is_mapped (priv->window))
+    meta_window_actor_detach (self);

-      if (priv->needs_pixmap)
-        clutter_actor_queue_redraw (priv->actor);
-    }
+  if (priv->needs_pixmap)
+    clutter_actor_queue_redraw (priv->actor);
 }

 void
@@ -1227,7 +1191,7 @@ meta_window_actor_effect_completed (MetaWindowActor *self,
 * pixmap for a new size.
 */
 static void
-meta_window_actor_detach_x11_pixmap (MetaWindowActor *self)
+meta_window_actor_detach (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv     = self->priv;
  MetaScreen            *screen   = priv->screen;
@@ -1248,7 +1212,7 @@ meta_window_actor_detach_x11_pixmap (MetaWindowActor *self)
  XFreePixmap (xdisplay, priv->back_pixmap);
  priv->back_pixmap = None;

-  meta_window_actor_queue_create_x11_pixmap (self);
+  meta_window_actor_queue_create_pixmap (self);
 }

 gboolean
@@ -1278,7 +1242,7 @@ meta_window_actor_should_unredirect (MetaWindowActor *self)
  if (meta_window_is_override_redirect (metaWindow))
    return TRUE;

-  if (!meta_is_wayland_compositor () && priv->does_full_damage)
+  if (priv->does_full_damage)
    return TRUE;

  return FALSE;
@@ -1298,7 +1262,7 @@ meta_window_actor_set_redirected (MetaWindowActor *self, gboolean state)
      meta_error_trap_push (display);
      XCompositeRedirectWindow (xdisplay, xwin, CompositeRedirectManual);
      meta_error_trap_pop (display);
-      meta_window_actor_detach_x11_pixmap (self);
+      meta_window_actor_detach (self);
      self->priv->unredirected = FALSE;
    }
  else
@@ -1320,11 +1284,6 @@ meta_window_actor_destroy (MetaWindowActor *self)

  priv = self->priv;

-#ifdef HAVE_WAYLAND
-  if (meta_is_wayland_compositor ())
-    meta_shaped_texture_set_wayland_surface (META_SHAPED_TEXTURE (priv->actor), NULL);
-#endif
-
  window = priv->window;
  window_type = meta_window_get_window_type (window);
  meta_window_set_compositor_private (window, NULL);
@@ -1376,21 +1335,15 @@ meta_window_actor_sync_actor_geometry (MetaWindowActor *self,

  meta_window_get_input_rect (priv->window, &window_rect);

-  /* When running as a display server then we instead catch size changes when
-   * new buffers are attached */
-  if (!meta_is_wayland_compositor ())
+  if (priv->last_width != window_rect.width ||
+      priv->last_height != window_rect.height)
    {
-      if (priv->last_width != window_rect.width ||
-          priv->last_height != window_rect.height)
-        {
-          priv->x11_size_changed = TRUE;
-          meta_window_actor_queue_create_x11_pixmap (self);
+      priv->size_changed = TRUE;
+      meta_window_actor_queue_create_pixmap (self);
+      meta_window_actor_update_shape (self);

-          meta_window_actor_update_shape (self);
-
-          priv->last_width = window_rect.width;
-          priv->last_height = window_rect.height;
-        }
+      priv->last_width = window_rect.width;
+      priv->last_height = window_rect.height;
    }

  if (meta_window_actor_effect_in_progress (self))
@@ -1554,27 +1507,16 @@ meta_window_actor_new (MetaWindow *window)
  MetaWindowActor        *self;
  MetaWindowActorPrivate *priv;
  MetaFrame		 *frame;
-  Window		  top_window = None;
+  Window		  top_window;
  ClutterActor           *window_group;

-  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
-    {
-      frame = meta_window_get_frame (window);
-      if (frame)
-        top_window = meta_frame_get_xwindow (frame);
-      else
-        top_window = meta_window_get_xwindow (window);
-
-      meta_verbose ("add window: Meta %p, xwin 0x%x\n", window, (guint)top_window);
-    }
-#ifdef HAVE_WAYLAND
+  frame = meta_window_get_frame (window);
+  if (frame)
+    top_window = meta_frame_get_xwindow (frame);
  else
-    {
-      meta_verbose ("add window: Meta %p, wayland surface %p\n",
-                    window, window->surface);
-      top_window = None;
-    }
-#endif
+    top_window = meta_window_get_xwindow (window);
+
+  meta_verbose ("add window: Meta %p, xwin 0x%x\n", window, (guint)top_window);

  self = g_object_new (META_TYPE_WINDOW_ACTOR,
                       "meta-window",         window,
@@ -1584,24 +1526,21 @@ meta_window_actor_new (MetaWindow *window)

  priv = self->priv;

-  if (!meta_is_wayland_compositor ())
-    {
-      priv->last_width = -1;
-      priv->last_height = -1;
+  priv->last_width = -1;
+  priv->last_height = -1;

-      priv->mapped = meta_window_toplevel_is_mapped (priv->window);
-      if (priv->mapped)
-        meta_window_actor_queue_create_x11_pixmap (self);
+  priv->mapped = meta_window_toplevel_is_mapped (priv->window);
+  if (priv->mapped)
+    meta_window_actor_queue_create_pixmap (self);

-      meta_window_actor_set_updates_frozen (self,
-                                            meta_window_updates_are_frozen (priv->window));
+  meta_window_actor_set_updates_frozen (self,
+                                        meta_window_updates_are_frozen (priv->window));

-      /* If a window doesn't start off with updates frozen, we should
-       * we should send a _NET_WM_FRAME_DRAWN immediately after the first drawn.
-       */
-      if (priv->window->extended_sync_request_counter && !priv->updates_frozen)
-        meta_window_actor_queue_frame_drawn (self, FALSE);
-    }
+  /* If a window doesn't start off with updates frozen, we should
+   * we should send a _NET_WM_FRAME_DRAWN immediately after the first drawn.
+   */
+  if (priv->window->extended_sync_request_counter && !priv->updates_frozen)
+    meta_window_actor_queue_frame_drawn (self, FALSE);

  meta_window_actor_sync_actor_geometry (self, priv->window->placed);

@@ -1636,8 +1575,7 @@ meta_window_actor_mapped (MetaWindowActor *self)

  priv->mapped = TRUE;

-  if (!meta_is_wayland_compositor ())
-    meta_window_actor_queue_create_x11_pixmap (self);
+  meta_window_actor_queue_create_pixmap (self);
 }

 void
@@ -1652,11 +1590,8 @@ meta_window_actor_unmapped (MetaWindowActor *self)
  if (meta_window_actor_effect_in_progress (self))
    return;

-  if (!meta_is_wayland_compositor ())
-    {
-      meta_window_actor_detach_x11_pixmap (self);
-      priv->needs_pixmap = FALSE;
-    }
+  meta_window_actor_detach (self);
+  priv->needs_pixmap = FALSE;
 }

 /**
@@ -1674,21 +1609,10 @@ meta_window_actor_get_obscured_region (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;

-  if (!priv->window->shaded)
-    {
-      if (meta_is_wayland_compositor ())
-        {
-          if (priv->opacity == 0xff)
-            return priv->opaque_region;
-        }
-      else
-        {
-          if (priv->back_pixmap && priv->opacity == 0xff)
-            return priv->opaque_region;
-        }
-    }
-
-  return NULL;
+  if (priv->back_pixmap && priv->opacity == 0xff && !priv->window->shaded)
+    return priv->opaque_region;
+  else
+    return NULL;
 }

 #if 0
@@ -1801,11 +1725,8 @@ meta_window_actor_reset_visible_regions (MetaWindowActor *self)
  g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);
 }

-/* When running as a wayland compositor we don't make requests for
- * replacement pixmaps when resizing windows, we will instead be
- * asked to attach replacement buffers by the clients. */
 static void
-check_needs_x11_pixmap (MetaWindowActor *self)
+check_needs_pixmap (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv     = self->priv;
  MetaScreen          *screen   = priv->screen;
@@ -1827,10 +1748,10 @@ check_needs_x11_pixmap (MetaWindowActor *self)

  compositor = meta_display_get_compositor (display);

-  if (priv->x11_size_changed)
+  if (priv->size_changed)
    {
-      meta_window_actor_detach_x11_pixmap (self);
-      priv->x11_size_changed = FALSE;
+      meta_window_actor_detach (self);
+      priv->size_changed = FALSE;
    }

  meta_error_trap_push (display);
@@ -1962,13 +1883,13 @@ check_needs_shadow (MetaWindowActor *self)
 }

 void
-meta_window_actor_process_x11_damage (MetaWindowActor    *self,
-                                      XDamageNotifyEvent *event)
+meta_window_actor_process_damage (MetaWindowActor    *self,
+                                  XDamageNotifyEvent *event)
 {
  MetaWindowActorPrivate *priv = self->priv;
  MetaCompScreen *info = meta_screen_get_compositor_data (priv->screen);

-  priv->received_x11_damage = TRUE;
+  priv->received_damage = TRUE;

  if (meta_window_is_fullscreen (priv->window) && g_list_last (info->windows)->data == self && !priv->unredirected)
    {
@@ -2022,25 +1943,6 @@ meta_window_actor_process_x11_damage (MetaWindowActor    *self,
  priv->repaint_scheduled = TRUE;
 }

-#ifdef HAVE_WAYLAND
-void
-meta_window_actor_process_wayland_damage (MetaWindowActor *self,
-                                          int x,
-                                          int y,
-                                          int width,
-                                          int height)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (!priv->mapped)
-    return;
-
-  meta_shaped_texture_update_area (META_SHAPED_TEXTURE (priv->actor),
-                                   x, y, width, height);
-  priv->repaint_scheduled = TRUE;
-}
-#endif
-
 void
 meta_window_actor_sync_visibility (MetaWindowActor *self)
 {
@@ -2180,40 +2082,39 @@ build_and_scan_frame_mask (MetaWindowActor       *self,
  g_free (mask_data);
 }

-static cairo_region_t *
-region_create_from_x_rectangles (const XRectangle *rects,
-                                 int n_rects,
-                                 int dx,
-                                 int dy)
-{
-  int i;
-  cairo_rectangle_int_t *cairo_rects = g_newa (cairo_rectangle_int_t, n_rects);
-
-  for (i = 0; i < n_rects; i ++)
-    {
-      cairo_rects[i].x = rects[i].x + dx;
-      cairo_rects[i].y = rects[i].y + dy;
-      cairo_rects[i].width = rects[i].width;
-      cairo_rects[i].height = rects[i].height;
-    }
-
-  return cairo_region_create_rectangles (cairo_rects, n_rects);
-}
-
 static void
-meta_window_actor_update_x11_shape_region (MetaWindowActor *self,
-                                           cairo_rectangle_int_t *client_area)
+check_needs_reshape (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;
+  MetaScreen *screen = priv->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  MetaFrameBorders borders;
  cairo_region_t *region = NULL;
+  cairo_rectangle_int_t client_area;
  gboolean needs_mask;

+  if (!priv->mapped)
+    return;
+
+  if (!priv->needs_reshape)
+    return;
+
  if (priv->shadow_shape != NULL)
    {
      meta_window_shape_unref (priv->shadow_shape);
      priv->shadow_shape = NULL;
    }

+  meta_frame_calc_borders (priv->window->frame, &borders);
+
+  client_area.x = borders.total.left;
+  client_area.y = borders.total.top;
+  client_area.width = priv->window->rect.width;
+  if (priv->window->shaded)
+    client_area.height = 0;
+  else
+    client_area.height = priv->window->rect.height;
+
  meta_shaped_texture_set_mask_texture (META_SHAPED_TEXTURE (priv->actor), NULL);
  g_clear_pointer (&priv->shape_region, cairo_region_destroy);
  g_clear_pointer (&priv->opaque_region, cairo_region_destroy);
@@ -2223,8 +2124,6 @@ meta_window_actor_update_x11_shape_region (MetaWindowActor *self,
    {
      /* Translate the set of XShape rectangles that we
       * get from the X server to a cairo_region. */
-      MetaScreen *screen = priv->screen;
-      MetaDisplay *display = meta_screen_get_display (screen);
      Display *xdisplay = meta_display_get_xdisplay (display);
      XRectangle *rects;
      int n_rects, ordering;
@@ -2239,10 +2138,20 @@ meta_window_actor_update_x11_shape_region (MetaWindowActor *self,

      if (rects)
        {
-          region = region_create_from_x_rectangles (rects, n_rects,
-                                                    client_area->x,
-                                                    client_area->y);
+          int i;
+          cairo_rectangle_int_t *cairo_rects = g_new (cairo_rectangle_int_t, n_rects);
+
+          for (i = 0; i < n_rects; i ++)
+            {
+              cairo_rects[i].x = rects[i].x + client_area.x;
+              cairo_rects[i].y = rects[i].y + client_area.y;
+              cairo_rects[i].width = rects[i].width;
+              cairo_rects[i].height = rects[i].height;
+            }
+
          XFree (rects);
+          region = cairo_region_create_rectangles (cairo_rects, n_rects);
+          g_free (cairo_rects);
        }
    }
 #endif
@@ -2258,14 +2167,14 @@ meta_window_actor_update_x11_shape_region (MetaWindowActor *self,
       * window would have gotten if it was unshaped. In our case,
       * this is simply the client area.
       */
-      cairo_region_intersect_rectangle (region, client_area);
+      cairo_region_intersect_rectangle (region, &client_area);
    }
  else
    {
      /* If we don't have a shape on the server, that means that
       * we have an implicit shape of one rectangle covering the
       * entire window. */
-      region = cairo_region_create_rectangle (client_area);
+      region = cairo_region_create_rectangle (&client_area);
    }

  /* The region at this point should be constrained to the
@@ -2284,7 +2193,7 @@ meta_window_actor_update_x11_shape_region (MetaWindowActor *self,
       * case, graphical glitches will occur.
       */
      priv->opaque_region = cairo_region_copy (priv->window->opaque_region);
-      cairo_region_translate (priv->opaque_region, client_area->x, client_area->y);
+      cairo_region_translate (priv->opaque_region, client_area.x, client_area.y);
      cairo_region_intersect (priv->opaque_region, region);
    }
  else if (priv->argb32)
@@ -2298,122 +2207,13 @@ meta_window_actor_update_x11_shape_region (MetaWindowActor *self,
       * and scans the mask looking for all opaque pixels,
       * adding it to region.
       */
-      build_and_scan_frame_mask (self, client_area, region);
+      build_and_scan_frame_mask (self, &client_area, region);
    }

  priv->shape_region = region;

-  meta_window_actor_invalidate_shadow (self);
-}
-
-static void
-meta_window_actor_update_x11_input_shape_region (MetaWindowActor *self,
-                                                 cairo_rectangle_int_t *client_area)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  cairo_region_t *region = NULL;
-
-  g_clear_pointer (&priv->input_shape_region, cairo_region_destroy);
-
-#ifdef HAVE_SHAPE
-  /* Note: we currently assume that mutter never sets an input region
-   * when there is a frame. */
-  if (priv->window->frame == NULL && priv->window->has_input_shape)
-    {
-      MetaScreen *screen = priv->screen;
-      MetaDisplay *display = meta_screen_get_display (screen);
-      Display *xdisplay = meta_display_get_xdisplay (display);
-      XRectangle *rects;
-      int n_rects, ordering;
-
-      /* Note we only actually query the ShapeInput shape of a window
-       * when we don't have a frame because we assume currently that
-       * mutter never sets an ShapeInput shape on a frame. */
-      meta_error_trap_push (display);
-      rects = XShapeGetRectangles (xdisplay,
-                                   priv->window->xwindow,
-                                   ShapeInput,
-                                   &n_rects,
-                                   &ordering);
-      meta_error_trap_pop (display);
-      if (rects)
-        {
-          region = region_create_from_x_rectangles (rects, n_rects,
-                                                    client_area->x,
-                                                    client_area->y);
-          XFree (rects);
-        }
-    }
-#endif /* HAVE_SHAPE */
-
-  if (region != NULL)
-    {
-      /* The X shape extension requires us to intersect the input
-       * region with the effective bounding shape to determine the
-       * effective input region.
-       */
-      if (priv->shape_region)
-        cairo_region_intersect (region, priv->shape_region);
-      else
-        cairo_region_intersect_rectangle (region, client_area);
-    }
-  else
-    {
-      /* If we don't have a shape on the server, that means that we
-       * have an implicit shape of one rectangle covering the entire
-       * window. */
-      region = cairo_region_create_rectangle (client_area);
-    }
-
-  priv->input_shape_region = region;
-
-  meta_shaped_texture_set_input_shape_region (META_SHAPED_TEXTURE (priv->actor),
-                                              priv->input_shape_region);
-}
-
-static void
-check_needs_reshape (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaFrameBorders borders;
-  cairo_rectangle_int_t client_area;
-
-  if (!priv->mapped)
-    return;
-
-  if (!priv->needs_reshape)
-    return;
-
-  meta_frame_calc_borders (priv->window->frame, &borders);
-
-  client_area.x = borders.total.left;
-  client_area.y = borders.total.top;
-  client_area.width = priv->window->rect.width;
-  if (priv->window->shaded)
-    client_area.height = 0;
-  else
-    client_area.height = priv->window->rect.height;
-
-  if (priv->window->client_type == META_WINDOW_CLIENT_TYPE_X11)
-    {
-      meta_window_actor_update_x11_shape_region (self, &client_area);
-      meta_window_actor_update_x11_input_shape_region (self, &client_area);
-    }
-  else
-    {
-      /* TODO: properly support setting an input region as specified
-       * via the wayland protocol */
-
-      g_clear_pointer (&priv->shape_region, cairo_region_destroy);
-      g_clear_pointer (&priv->opaque_region, cairo_region_destroy);
-      g_clear_pointer (&priv->input_shape_region, cairo_region_destroy);
-
-      priv->shape_region = cairo_region_create_rectangle (&client_area);
-      priv->opaque_region = cairo_region_reference (priv->shape_region);
-      priv->input_shape_region = cairo_region_reference (priv->shape_region);
-    }
-
  priv->needs_reshape = FALSE;
+  meta_window_actor_invalidate_shadow (self);
 }

 void
@@ -2429,69 +2229,6 @@ meta_window_actor_update_shape (MetaWindowActor *self)
  clutter_actor_queue_redraw (priv->actor);
 }

-#ifdef HAVE_WAYLAND
-static void
-maybe_emit_size_changed (MetaWindowActor *self,
-                         MetaWaylandBuffer *new_buffer)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  int                     width = 0, height = 0;
-
-  if (new_buffer)
-    {
-      width = new_buffer->width;
-      height = new_buffer->height;
-    }
-
-  if (priv->last_width != width || priv->last_height != height)
-    {
-      meta_window_actor_update_shape (self);
-
-      /* ::size-changed is supposed to refer to meta_window_get_outer_rect()
-       * but here we are only looking at buffer size changes.
-       *
-       * Emitting it here works pretty much OK because a new buffer size (which
-       * will correspond to the outer rect with the addition of invisible
-       * borders) also normally implies a change to the outer rect. In the rare
-       * case where a change to the window size was exactly balanced by a
-       * change to the invisible borders, we would miss emitting the signal.
-       */
-      g_signal_emit (self, signals[SIZE_CHANGED], 0);
-
-      priv->last_width = width;
-      priv->last_height = height;
-    }
-}
-
-void
-meta_window_actor_set_wayland_surface (MetaWindowActor *self,
-                                       MetaWaylandSurface *surface)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  meta_shaped_texture_set_wayland_surface (META_SHAPED_TEXTURE (priv->actor),
-                                           surface);
-  if (surface && surface->buffer_ref.buffer)
-    maybe_emit_size_changed (self, surface->buffer_ref.buffer);
-}
-
-void
-meta_window_actor_attach_wayland_buffer (MetaWindowActor *self,
-                                         MetaWaylandBuffer *buffer)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaShapedTexture *stex = META_SHAPED_TEXTURE (priv->actor);
-  CoglTexture *prev_tex = meta_shaped_texture_get_texture (stex);
-
-  meta_shaped_texture_attach_wayland_buffer (stex, buffer);
-
-  if (!prev_tex)
-    meta_window_actor_sync_actor_geometry (self, FALSE);
-
-  maybe_emit_size_changed (self, buffer);
-}
-#endif /* HAVE_WAYLAND */
-
 static void
 meta_window_actor_handle_updates (MetaWindowActor *self)
 {
@@ -2507,46 +2244,42 @@ meta_window_actor_handle_updates (MetaWindowActor *self)
      return;
    }

-  if (!meta_is_wayland_compositor ())
+  if (priv->unredirected)
    {
-      if (priv->unredirected)
-        {
-          /* Nothing to do here until/if the window gets redirected again */
-          return;
-        }
-
-      if (priv->received_x11_damage)
-        {
-          meta_error_trap_push (display);
-          XDamageSubtract (xdisplay, priv->damage, None, None);
-          meta_error_trap_pop (display);
-
-          /* We need to make sure that any X drawing that happens before the
-           * XDamageSubtract() above is visible to subsequent GL rendering;
-           * the only standardized way to do this is EXT_x11_sync_object,
-           * which isn't yet widely available. For now, we count on details
-           * of Xorg and the open source drivers, and hope for the best
-           * otherwise.
-           *
-           * Xorg and open source driver specifics:
-           *
-           * The X server makes sure to flush drawing to the kernel before
-           * sending out damage events, but since we use DamageReportBoundingBox
-           * there may be drawing between the last damage event and the
-           * XDamageSubtract() that needs to be flushed as well.
-           *
-           * Xorg always makes sure that drawing is flushed to the kernel
-           * before writing events or responses to the client, so any round trip
-           * request at this point is sufficient to flush the GLX buffers.
-           */
-          XSync (xdisplay, False);
-
-          priv->received_x11_damage = FALSE;
-        }
-
-      check_needs_x11_pixmap (self);
+      /* Nothing to do here until/if the window gets redirected again */
+      return;
    }

+  if (priv->received_damage)
+    {
+      meta_error_trap_push (display);
+      XDamageSubtract (xdisplay, priv->damage, None, None);
+      meta_error_trap_pop (display);
+
+      /* We need to make sure that any X drawing that happens before the
+       * XDamageSubtract() above is visible to subsequent GL rendering;
+       * the only standardized way to do this is EXT_x11_sync_object,
+       * which isn't yet widely available. For now, we count on details
+       * of Xorg and the open source drivers, and hope for the best
+       * otherwise.
+       *
+       * Xorg and open source driver specifics:
+       *
+       * The X server makes sure to flush drawing to the kernel before
+       * sending out damage events, but since we use DamageReportBoundingBox
+       * there may be drawing between the last damage event and the
+       * XDamageSubtract() that needs to be flushed as well.
+       *
+       * Xorg always makes sure that drawing is flushed to the kernel
+       * before writing events or responses to the client, so any round trip
+       * request at this point is sufficient to flush the GLX buffers.
+       */
+      XSync (xdisplay, False);
+
+      priv->received_damage = FALSE;
+    }
+
+  check_needs_pixmap (self);
  check_needs_reshape (self);
  check_needs_shadow (self);
 }
@@ -2725,20 +2458,16 @@ void
 meta_window_actor_set_updates_frozen (MetaWindowActor *self,
                                      gboolean         updates_frozen)
 {
-  /* On wayland we shouldn't need to ever freeze updates... */
-  if (!meta_is_wayland_compositor ())
+  MetaWindowActorPrivate *priv = self->priv;
+
+  updates_frozen = updates_frozen != FALSE;
+
+  if (priv->updates_frozen != updates_frozen)
    {
-      MetaWindowActorPrivate *priv = self->priv;
-
-      updates_frozen = updates_frozen != FALSE;
-
-      if (priv->updates_frozen != updates_frozen)
-        {
-          priv->updates_frozen = updates_frozen;
-          if (updates_frozen)
-            meta_window_actor_freeze (self);
-          else
-            meta_window_actor_thaw (self);
-        }
+      priv->updates_frozen = updates_frozen;
+      if (updates_frozen)
+        meta_window_actor_freeze (self);
+      else
+        meta_window_actor_thaw (self);
    }
 }
--- a/src/compositor/meta-window-group.c
+++ b/src/compositor/meta-window-group.c
@@ -13,7 +13,6 @@
 #include "meta-window-group.h"
 #include "meta-background-actor-private.h"
 #include "meta-background-group-private.h"
-#include "window-private.h"

 struct _MetaWindowGroupClass
 {
@@ -100,7 +99,7 @@ meta_window_group_paint (ClutterActor *actor)
  int paint_x_offset, paint_y_offset;

  MetaWindowGroup *window_group = META_WINDOW_GROUP (actor);
-  MetaCompScreen *info;
+  MetaCompScreen *info = meta_screen_get_compositor_data (window_group->screen);

  /* Normally we expect an actor to be drawn at it's position on the screen.
   * However, if we're inside the paint of a ClutterClone, that won't be the
@@ -137,17 +136,13 @@ meta_window_group_paint (ClutterActor *actor)

  visible_region = cairo_region_create_rectangle (&visible_rect);

-  if (!meta_is_wayland_compositor ())
+  if (info->unredirected_window != NULL)
    {
-      info = meta_screen_get_compositor_data (window_group->screen);
-      if (info->unredirected_window != NULL)
-        {
-          cairo_rectangle_int_t unredirected_rect;
-          MetaWindow *window = meta_window_actor_get_meta_window (info->unredirected_window);
+      cairo_rectangle_int_t unredirected_rect;
+      MetaWindow *window = meta_window_actor_get_meta_window (info->unredirected_window);

-          meta_window_get_outer_rect (window, (MetaRectangle *)&unredirected_rect);
-          cairo_region_subtract_rectangle (visible_region, &unredirected_rect);
-        }
+      meta_window_get_outer_rect (window, (MetaRectangle *)&unredirected_rect);
+      cairo_region_subtract_rectangle (visible_region, &unredirected_rect);
    }

  /* We walk the list from top to bottom (opposite of painting order),
@@ -160,8 +155,7 @@ meta_window_group_paint (ClutterActor *actor)
      if (!CLUTTER_ACTOR_IS_VISIBLE (child))
        continue;

-      if (!meta_is_wayland_compositor () &&
-          info->unredirected_window != NULL &&
+      if (info->unredirected_window != NULL &&
          child == CLUTTER_ACTOR (info->unredirected_window))
        continue;

@@ -186,8 +180,7 @@ meta_window_group_paint (ClutterActor *actor)

      if (META_IS_WINDOW_ACTOR (child))
        {
-          MetaWindow *meta_window;
-          MetaWindowActor *window_actor = child;
+          MetaWindowActor *window_actor = META_WINDOW_ACTOR (child);
          int x, y;

          if (!meta_actor_is_untransformed (CLUTTER_ACTOR (window_actor), &x, &y))
@@ -201,14 +194,7 @@ meta_window_group_paint (ClutterActor *actor)

          meta_window_actor_set_visible_region (window_actor, visible_region);

-          /* TODO: Track the opaque regions of wayland clients.
-           * Although wayland clients can report opaque window
-           * regions, for now we assume that all wayland clients are
-           * transparent... */
-          meta_window = meta_window_actor_get_meta_window (window_actor);
-
-          if (meta_window->client_type != META_WINDOW_CLIENT_TYPE_WAYLAND &&
-              clutter_actor_get_paint_opacity (CLUTTER_ACTOR (window_actor)) == 0xff)
+          if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (window_actor)) == 0xff)
            {
              cairo_region_t *obscured_region = meta_window_actor_get_obscured_region (window_actor);
              if (obscured_region)
--- a/src/compositor/plugins/default.c
+++ b/src/compositor/plugins/default.c
@@ -27,7 +27,6 @@
 #include <meta/meta-background-group.h>
 #include <meta/meta-background-actor.h>

-#include <stdlib.h>
 #include <libintl.h>
 #define _(x) dgettext (GETTEXT_PACKAGE, x)
 #define N_(x) x
--- a/src/core/core.c
+++ b/src/core/core.c
@@ -269,8 +269,6 @@ meta_core_lower_beneath_grab_window (Display *xdisplay,
  MetaDisplay *display;
  MetaScreen *screen;
  MetaWindow *grab_window;
-  MetaStackWindow stack_window;
-  MetaStackWindow stack_sibling;

  display = meta_display_for_x_display (xdisplay);
  screen = meta_display_screen_for_xwindow (display, xwindow);
@@ -283,13 +281,9 @@ meta_core_lower_beneath_grab_window (Display *xdisplay,
  changes.sibling = grab_window->frame ? grab_window->frame->xwindow
                                       : grab_window->xwindow;

-  stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
-  stack_window.x11.xwindow = xwindow;
-  stack_sibling.any.type = META_WINDOW_CLIENT_TYPE_X11;
-  stack_sibling.x11.xwindow = changes.sibling;
  meta_stack_tracker_record_lower_below (screen->stack_tracker,
-                                         &stack_window,
-                                         &stack_sibling,
+                                         xwindow,
+                                         changes.sibling,
                                         XNextRequest (screen->display->xdisplay));

  meta_error_trap_push (display);
--- a/src/core/display-private.h
+++ b/src/core/display-private.h
@@ -86,14 +86,6 @@ typedef enum {
  META_TILE_MAXIMIZED
 } MetaTileMode;

-typedef enum {
-  META_FOCUS_NONE = 0,
-  META_FOCUS_X_CLIENT = 1,
-  META_FOCUS_WAYLAND_CLIENT = 2,
-  META_FOCUS_NO_FOCUS_WINDOW = 3,
-  META_FOCUS_STAGE = 4
-} MetaFocusType;
-
 struct _MetaDisplay
 {
  GObject parent_instance;
@@ -125,7 +117,6 @@ struct _MetaDisplay
   * like the no_focus_window or the stage X window. */
  Window focus_xwindow;
  gulong focus_serial;
-  MetaFocusType focus_type;

  /* last timestamp passed to XSetInputFocus */
  guint32 last_focus_time;
@@ -476,18 +467,14 @@ gboolean meta_display_modifiers_accelerator_activate (MetaDisplay *display);
 /* In above-tab-keycode.c */
 guint meta_display_get_above_tab_keycode (MetaDisplay *display);

-gboolean meta_display_handle_event (MetaDisplay *display,
-                                    XEvent      *event);
-
 #ifdef HAVE_XI23
 gboolean meta_display_process_barrier_event (MetaDisplay    *display,
                                             XIBarrierEvent *event);
 #endif /* HAVE_XI23 */

-void meta_display_set_input_focus_xwindow (MetaDisplay   *display,
-                                           MetaScreen    *screen,
-                                           MetaFocusType  type,
-                                           Window         window,
-                                           guint32        timestamp);
+void meta_display_set_input_focus_xwindow (MetaDisplay *display,
+                                           MetaScreen  *screen,
+                                           Window       window,
+                                           guint32      timestamp);

 #endif
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -53,7 +53,6 @@
 #include <X11/Xatom.h>
 #include <X11/cursorfont.h>
 #include "mutter-enum-types.h"
-#include "meta-idle-monitor-private.h"

 #ifdef HAVE_RANDR
 #include <X11/extensions/Xrandr.h>
@@ -518,7 +517,7 @@ meta_display_open (void)

  if (meta_is_syncing ())
    XSynchronize (xdisplay, True);
-
+  
  g_assert (the_display == NULL);
  the_display = g_object_new (META_TYPE_DISPLAY, NULL);

@@ -932,24 +931,8 @@ meta_display_open (void)
  while (tmp != NULL)
    {
      MetaScreen *screen = tmp->data;
-
-      if (meta_is_wayland_compositor ())
-        {
-          /* Instead of explicitly enumerating all windows during
-           * initialization, when we run as a wayland compositor we can rely on
-           * xwayland notifying us of all top level windows so we create
-           * MetaWindows when we get those notifications.
-           *
-           * We still want a guard window so we can avoid
-           * unmapping/withdrawing minimized windows for live
-           * thumbnails...
-           */
-          if (screen->guard_window == None)
-            screen->guard_window =
-              meta_screen_create_guard_window (screen->display->xdisplay, screen);
-        }
-      else
-        meta_screen_manage_all_windows (screen);
+	
+      meta_screen_manage_all_windows (screen);

      tmp = tmp->next;
    }
@@ -1898,21 +1881,14 @@ get_input_event (MetaDisplay *display,
 }

 static void
-update_focus_window (MetaDisplay   *display,
-                     MetaFocusType  type,
-                     MetaWindow    *window,
-                     Window         xwindow,
-                     gulong         serial)
+update_focus_window (MetaDisplay *display,
+                     MetaWindow  *window,
+                     Window       xwindow,
+                     gulong       serial)
 {
-#ifdef HAVE_WAYLAND
-  MetaWaylandCompositor *compositor;
-#endif
-
  display->focus_serial = serial;

-  if (display->focus_xwindow == xwindow &&
-      display->focus_type == type &&
-      display->focus_window == window)
+  if (display->focus_xwindow == xwindow)
    return;

  if (display->focus_window)
@@ -1934,7 +1910,6 @@ update_focus_window (MetaDisplay   *display,
      meta_window_set_focused_internal (previous, FALSE);
    }

-  display->focus_type = type;
  display->focus_window = window;
  display->focus_xwindow = xwindow;

@@ -1947,21 +1922,6 @@ update_focus_window (MetaDisplay   *display,
  else
    meta_topic (META_DEBUG_FOCUS, "* Focus --> NULL with serial %lu\n", serial);

-#ifdef HAVE_WAYLAND
-  if (meta_is_wayland_compositor ())
-    {
-      compositor = meta_wayland_compositor_get_default ();
-
-      if (display->focus_type == META_FOCUS_NO_FOCUS_WINDOW ||
-          display->focus_type == META_FOCUS_STAGE)
-        meta_wayland_compositor_set_input_focus (compositor, NULL);
-      else if (window && window->surface)
-        meta_wayland_compositor_set_input_focus (compositor, window);
-      else
-        meta_topic (META_DEBUG_FOCUS, "Focus change has no effect, because there is no matching wayland surface");
-     }
-#endif
-
  g_object_notify (G_OBJECT (display), "focus-window");
  meta_display_update_active_window_hint (display);
 }
@@ -1996,18 +1956,19 @@ timestamp_too_old (MetaDisplay *display,
 }

 static void
-request_xserver_input_focus_change (MetaDisplay   *display,
-                                    MetaScreen    *screen,
-                                    MetaFocusType  type,
-                                    MetaWindow    *meta_window,
-                                    Window         xwindow,
-                                    guint32        timestamp)
+request_xserver_input_focus_change (MetaDisplay *display,
+                                    MetaScreen  *screen,
+                                    Window       xwindow,
+                                    guint32      timestamp)
 {
+  MetaWindow *meta_window;
  gulong serial;

  if (timestamp_too_old (display, &timestamp))
    return;

+  meta_window = meta_display_lookup_x_window (display, xwindow);
+
  meta_error_trap_push (display);

  /* In order for mutter to know that the focus request succeeded, we track
@@ -2034,7 +1995,6 @@ request_xserver_input_focus_change (MetaDisplay   *display,
  meta_display_ungrab (display);

  update_focus_window (display,
-                       type,
                       meta_window,
                       xwindow,
                       serial);
@@ -2055,12 +2015,9 @@ handle_window_focus_event (MetaDisplay  *display,
                           unsigned long serial)
 {
  MetaWindow *focus_window;
-  MetaFocusType type;
 #ifdef WITH_VERBOSE_MODE
  const char *window_type;

-  type = META_FOCUS_NONE;
-
  /* Note the event can be on either the window or the frame,
   * we focus the frame for shaded windows
   */
@@ -2072,26 +2029,14 @@ handle_window_focus_event (MetaDisplay  *display,
        window_type = "frame window";
      else
        window_type = "unknown client window";
-
-      if (window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
-        type = META_FOCUS_WAYLAND_CLIENT;
-      else
-        type = META_FOCUS_X_CLIENT;
    }
  else if (meta_display_xwindow_is_a_no_focus_window (display, event->event))
-    {
-      window_type = "no_focus_window";
-      type = META_FOCUS_NO_FOCUS_WINDOW;
-    }
+    window_type = "no_focus_window";
  else if (meta_display_screen_for_root (display, event->event))
    window_type = "root window";
  else
    window_type = "unknown window";

-  /* Don't change type if we don't know the new window */
-  if (type == META_FOCUS_NONE)
-    type = display->focus_type;
-
  meta_topic (META_DEBUG_FOCUS,
              "Focus %s event received on %s 0x%lx (%s) "
              "mode %s detail %s serial %lu\n",
@@ -2169,7 +2114,6 @@ handle_window_focus_event (MetaDisplay  *display,
  if (display->server_focus_serial > display->focus_serial)
    {
      update_focus_window (display,
-                           type,
                           focus_window,
                           focus_window ? focus_window->xwindow : None,
                           display->server_focus_serial);
@@ -2177,9 +2121,10 @@ handle_window_focus_event (MetaDisplay  *display,
 }

 /**
- * meta_display_handle_event:
- * @display: The MetaDisplay that events are coming from
+ * event_callback:
 * @event: The event that just happened
+ * @data: The #MetaDisplay that events are coming from, cast to a gpointer
+ *        so that it can be sent to a callback
 *
 * This is the most important function in the whole program. It is the heart,
 * it is the nexus, it is the Grand Central Station of Mutter's world.
@@ -2189,20 +2134,22 @@ handle_window_focus_event (MetaDisplay  *display,
 * busy around here. Most of this function is a ginormous switch statement
 * dealing with all the kinds of events that might turn up.
 */
-gboolean
-meta_display_handle_event (MetaDisplay *display,
-                           XEvent   *event)
+static gboolean
+event_callback (XEvent   *event,
+                gpointer  data)
 {
  MetaWindow *window;
  MetaWindow *property_for_window;
+  MetaDisplay *display;
  Window modified;
  gboolean frame_was_receiver;
  gboolean bypass_compositor;
  gboolean filter_out_event;
  XIEvent *input_event;
  MetaMonitorManager *monitor;
-  MetaScreen *screen;

+  display = data;
+  
 #ifdef WITH_VERBOSE_MODE
  if (dump_events)
    meta_spew_event (display, event);
@@ -2232,19 +2179,11 @@ meta_display_handle_event (MetaDisplay *display,
      meta_topic (META_DEBUG_FOCUS, "Earlier attempt to focus %s failed\n",
                  display->focus_window->desc);
      update_focus_window (display,
-                           META_FOCUS_NONE,
                           meta_display_lookup_x_window (display, display->server_focus_window),
                           display->server_focus_window,
                           display->server_focus_serial);
    }

-  screen = meta_display_screen_for_root (display, event->xany.window);
-  if (screen)
-    {
-      if (meta_screen_handle_xevent (screen, event))
-        return TRUE;
-    }
-
  modified = event_get_modified_window (display, event);

  input_event = get_input_event (display, event);
@@ -2317,8 +2256,6 @@ meta_display_handle_event (MetaDisplay *display,
          meta_window_update_sync_request_counter (alarm_window, new_counter_value);
          filter_out_event = TRUE; /* GTK doesn't want to see this really */
        }
-
-      meta_idle_monitor_handle_xevent_all (event);
    }
 #endif /* HAVE_XSYNC */

@@ -2356,35 +2293,8 @@ meta_display_handle_event (MetaDisplay *display,
                }

              if (display->compositor)
-                meta_compositor_window_x11_shape_changed (display->compositor,
-                                                          window);
-            }
-          else if (sev->kind == ShapeInput)
-            {
-              if (sev->shaped && !window->has_input_shape)
-                {
-                  window->has_input_shape = TRUE;                  
-                  meta_topic (META_DEBUG_SHAPES,
-                              "Window %s now has an input shape\n",
-                              window->desc);
-                }
-              else if (!sev->shaped && window->has_input_shape)
-                {
-                  window->has_input_shape = FALSE;
-                  meta_topic (META_DEBUG_SHAPES,
-                              "Window %s no longer has an input shape\n",
-                              window->desc);
-                }
-              else
-                {
-                  meta_topic (META_DEBUG_SHAPES,
-                              "Window %s input shape changed\n",
-                              window->desc);
-                }
-
-              if (display->compositor)
-                meta_compositor_window_x11_shape_changed (display->compositor,
-                                                          window);
+                meta_compositor_window_shape_changed (display->compositor,
+                                                      window);
            }
        }
      else
@@ -3215,32 +3125,6 @@ meta_display_handle_event (MetaDisplay *display,
  return filter_out_event;
 }

-static gboolean
-event_callback (XEvent  *event,
-                gpointer data)
-{
-  MetaDisplay *display = data;
-
-  /* Under Wayland we want to filter out mouse motion events so we can
-     synthesize them from the Clutter events instead. This is
-     necessary because the position in the mouse events is passed to
-     the X server relative to the position of the surface. The X
-     server then translates these back to screen coordinates based on
-     the window position. If we rely on this translatation when
-     dragging a window around then the window will jump around
-     erratically because of the lag between updating the window
-     position from the surface position. Instead we bypass the
-     translation altogether by directly using the Clutter events */
-#ifdef HAVE_WAYLAND
-  if (meta_is_wayland_compositor () &&
-      event->type == GenericEvent &&
-      event->xcookie.evtype == XI_Motion)
-    return FALSE;
-#endif
-
-  return meta_display_handle_event (display, event);
-}
-
 /* Return the window this has to do with, if any, rather
 * than the frame or root window that was selecting
 * for substructure
@@ -5892,9 +5776,6 @@ meta_display_set_input_focus_window (MetaDisplay *display,
 {
  request_xserver_input_focus_change (display,
                                      window->screen,
-                                      window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND ?
-                                      META_FOCUS_WAYLAND_CLIENT : META_FOCUS_X_CLIENT,
-                                      window,
                                      focus_frame ? window->frame->xwindow : window->xwindow,
                                      timestamp);
 }
@@ -5935,16 +5816,13 @@ meta_display_request_take_focus (MetaDisplay *display,
 }

 void
-meta_display_set_input_focus_xwindow (MetaDisplay   *display,
-                                      MetaScreen    *screen,
-                                      MetaFocusType  type,
-                                      Window         window,
-                                      guint32        timestamp)
+meta_display_set_input_focus_xwindow (MetaDisplay *display,
+                                      MetaScreen  *screen,
+                                      Window       window,
+                                      guint32      timestamp)
 {
  request_xserver_input_focus_change (display,
                                      screen,
-                                      type,
-                                      NULL,
                                      window,
                                      timestamp);
 }
@@ -5956,8 +5834,6 @@ meta_display_focus_the_no_focus_window (MetaDisplay *display,
 {
  request_xserver_input_focus_change (display,
                                      screen,
-                                      META_FOCUS_NO_FOCUS_WINDOW,
-                                      NULL,
                                      screen->no_focus_window,
                                      timestamp);
 }
--- a/src/core/edid-parse.c
+++ b/src/core/edid-parse.c
@@ -0,0 +1,540 @@
+/*
+ * Copyright 2007 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/* Author: Soren Sandmann <sandmann@redhat.com> */
+
+#include "edid.h"
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <glib.h>
+
+static int
+get_bit (int in, int bit)
+{
+    return (in & (1 << bit)) >> bit;
+}
+
+static int
+get_bits (int in, int begin, int end)
+{
+    int mask = (1 << (end - begin + 1)) - 1;
+    
+    return (in >> begin) & mask;
+}
+
+static int
+decode_header (const uchar *edid)
+{
+    if (memcmp (edid, "\x00\xff\xff\xff\xff\xff\xff\x00", 8) == 0)
+	return TRUE;
+    return FALSE;
+}
+
+static int
+decode_vendor_and_product_identification (const uchar *edid, MonitorInfo *info)
+{
+    int is_model_year;
+    
+    /* Manufacturer Code */
+    info->manufacturer_code[0]  = get_bits (edid[0x08], 2, 6);
+    info->manufacturer_code[1]  = get_bits (edid[0x08], 0, 1) << 3;
+    info->manufacturer_code[1] |= get_bits (edid[0x09], 5, 7);
+    info->manufacturer_code[2]  = get_bits (edid[0x09], 0, 4);
+    info->manufacturer_code[3]  = '\0';
+    
+    info->manufacturer_code[0] += 'A' - 1;
+    info->manufacturer_code[1] += 'A' - 1;
+    info->manufacturer_code[2] += 'A' - 1;
+
+    /* Product Code */
+    info->product_code = edid[0x0b] << 8 | edid[0x0a];
+
+    /* Serial Number */
+    info->serial_number =
+	edid[0x0c] | edid[0x0d] << 8 | edid[0x0e] << 16 | edid[0x0f] << 24;
+
+    /* Week and Year */
+    is_model_year = FALSE;
+    switch (edid[0x10])
+    {
+    case 0x00:
+	info->production_week = -1;
+	break;
+
+    case 0xff:
+	info->production_week = -1;
+	is_model_year = TRUE;
+	break;
+
+    default:
+	info->production_week = edid[0x10];
+	break;
+    }
+
+    if (is_model_year)
+    {
+	info->production_year = -1;
+	info->model_year = 1990 + edid[0x11];
+    }
+    else
+    {
+	info->production_year = 1990 + edid[0x11];
+	info->model_year = -1;
+    }
+
+    return TRUE;
+}
+
+static int
+decode_edid_version (const uchar *edid, MonitorInfo *info)
+{
+    info->major_version = edid[0x12];
+    info->minor_version = edid[0x13];
+
+    return TRUE;
+}
+
+static int
+decode_display_parameters (const uchar *edid, MonitorInfo *info)
+{
+    /* Digital vs Analog */
+    info->is_digital = get_bit (edid[0x14], 7);
+
+    if (info->is_digital)
+    {
+	int bits;
+	
+	static const int bit_depth[8] =
+	{
+	    -1, 6, 8, 10, 12, 14, 16, -1
+	};
+
+	static const Interface interfaces[6] =
+	{
+	    UNDEFINED, DVI, HDMI_A, HDMI_B, MDDI, DISPLAY_PORT
+	};
+
+	bits = get_bits (edid[0x14], 4, 6);
+	info->connector.digital.bits_per_primary = bit_depth[bits];
+
+	bits = get_bits (edid[0x14], 0, 3);
+	
+	if (bits <= 5)
+	    info->connector.digital.interface = interfaces[bits];
+	else
+	    info->connector.digital.interface = UNDEFINED;
+    }
+    else
+    {
+	int bits = get_bits (edid[0x14], 5, 6);
+	
+	static const double levels[][3] =
+	{
+	    { 0.7,   0.3,    1.0 },
+	    { 0.714, 0.286,  1.0 },
+	    { 1.0,   0.4,    1.4 },
+	    { 0.7,   0.0,    0.7 },
+	};
+
+	info->connector.analog.video_signal_level = levels[bits][0];
+	info->connector.analog.sync_signal_level = levels[bits][1];
+	info->connector.analog.total_signal_level = levels[bits][2];
+
+	info->connector.analog.blank_to_black = get_bit (edid[0x14], 4);
+
+	info->connector.analog.separate_hv_sync = get_bit (edid[0x14], 3);
+	info->connector.analog.composite_sync_on_h = get_bit (edid[0x14], 2);
+	info->connector.analog.composite_sync_on_green = get_bit (edid[0x14], 1);
+
+	info->connector.analog.serration_on_vsync = get_bit (edid[0x14], 0);
+    }
+
+    /* Screen Size / Aspect Ratio */
+    if (edid[0x15] == 0 && edid[0x16] == 0)
+    {
+	info->width_mm = -1;
+	info->height_mm = -1;
+	info->aspect_ratio = -1.0;
+    }
+    else if (edid[0x16] == 0)
+    {
+	info->width_mm = -1;
+	info->height_mm = -1; 
+	info->aspect_ratio = 100.0 / (edid[0x15] + 99);
+    }
+    else if (edid[0x15] == 0)
+    {
+	info->width_mm = -1;
+	info->height_mm = -1;
+	info->aspect_ratio = 100.0 / (edid[0x16] + 99);
+	info->aspect_ratio = 1/info->aspect_ratio; /* portrait */
+    }
+    else
+    {
+	info->width_mm = 10 * edid[0x15];
+	info->height_mm = 10 * edid[0x16];
+    }
+
+    /* Gamma */
+    if (edid[0x17] == 0xFF)
+	info->gamma = -1.0;
+    else
+	info->gamma = (edid[0x17] + 100.0) / 100.0;
+
+    /* Features */
+    info->standby = get_bit (edid[0x18], 7);
+    info->suspend = get_bit (edid[0x18], 6);
+    info->active_off = get_bit (edid[0x18], 5);
+
+    if (info->is_digital)
+    {
+	info->connector.digital.rgb444 = TRUE;
+	if (get_bit (edid[0x18], 3))
+	    info->connector.digital.ycrcb444 = 1;
+	if (get_bit (edid[0x18], 4))
+	    info->connector.digital.ycrcb422 = 1;
+    }
+    else
+    {
+	int bits = get_bits (edid[0x18], 3, 4);
+	ColorType color_type[4] =
+	{
+	    MONOCHROME, RGB, OTHER_COLOR, UNDEFINED_COLOR
+	};
+
+	info->connector.analog.color_type = color_type[bits];
+    }
+
+    info->srgb_is_standard = get_bit (edid[0x18], 2);
+
+    /* In 1.3 this is called "has preferred timing" */
+    info->preferred_timing_includes_native = get_bit (edid[0x18], 1);
+
+    /* FIXME: In 1.3 this indicates whether the monitor accepts GTF */
+    info->continuous_frequency = get_bit (edid[0x18], 0);
+    return TRUE;
+}
+
+static double
+decode_fraction (int high, int low)
+{
+    double result = 0.0;
+    int i;
+
+    high = (high << 2) | low;
+
+    for (i = 0; i < 10; ++i)
+	result += get_bit (high, i) * pow (2, i - 10);
+
+    return result;
+}
+
+static int
+decode_color_characteristics (const uchar *edid, MonitorInfo *info)
+{
+    info->red_x = decode_fraction (edid[0x1b], get_bits (edid[0x19], 6, 7));
+    info->red_y = decode_fraction (edid[0x1c], get_bits (edid[0x19], 5, 4));
+    info->green_x = decode_fraction (edid[0x1d], get_bits (edid[0x19], 2, 3));
+    info->green_y = decode_fraction (edid[0x1e], get_bits (edid[0x19], 0, 1));
+    info->blue_x = decode_fraction (edid[0x1f], get_bits (edid[0x1a], 6, 7));
+    info->blue_y = decode_fraction (edid[0x20], get_bits (edid[0x1a], 4, 5));
+    info->white_x = decode_fraction (edid[0x21], get_bits (edid[0x1a], 2, 3));
+    info->white_y = decode_fraction (edid[0x22], get_bits (edid[0x1a], 0, 1));
+
+    return TRUE;
+}
+
+static int
+decode_established_timings (const uchar *edid, MonitorInfo *info)
+{
+    static const Timing established[][8] = 
+    {
+	{
+	    { 800, 600, 60 },
+	    { 800, 600, 56 },
+	    { 640, 480, 75 },
+	    { 640, 480, 72 },
+	    { 640, 480, 67 },
+	    { 640, 480, 60 },
+	    { 720, 400, 88 },
+	    { 720, 400, 70 }
+	},
+	{
+	    { 1280, 1024, 75 },
+	    { 1024, 768, 75 },
+	    { 1024, 768, 70 },
+	    { 1024, 768, 60 },
+	    { 1024, 768, 87 },
+	    { 832, 624, 75 },
+	    { 800, 600, 75 },
+	    { 800, 600, 72 }
+	},
+	{
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 1152, 870, 75 }
+	},
+    };
+
+    int i, j, idx;
+
+    idx = 0;
+    for (i = 0; i < 3; ++i)
+    {
+	for (j = 0; j < 8; ++j)
+	{
+	    int byte = edid[0x23 + i];
+
+	    if (get_bit (byte, j) && established[i][j].frequency != 0)
+		info->established[idx++] = established[i][j];
+	}
+    }
+    return TRUE;
+}
+
+static int
+decode_standard_timings (const uchar *edid, MonitorInfo *info)
+{
+    int i;
+    
+    for (i = 0; i < 8; i++)
+    {
+	int first = edid[0x26 + 2 * i];
+	int second = edid[0x27 + 2 * i];
+
+	if (first != 0x01 && second != 0x01)
+	{
+	    int w = 8 * (first + 31);
+	    int h = 0;
+
+	    switch (get_bits (second, 6, 7))
+	    {
+	    case 0x00: h = (w / 16) * 10; break;
+	    case 0x01: h = (w / 4) * 3; break;
+	    case 0x02: h = (w / 5) * 4; break;
+	    case 0x03: h = (w / 16) * 9; break;
+	    }
+
+	    info->standard[i].width = w;
+	    info->standard[i].height = h;
+	    info->standard[i].frequency = get_bits (second, 0, 5) + 60;
+	}
+    }
+    
+    return TRUE;
+}
+
+static void
+decode_lf_string (const uchar *s, int n_chars, char *result)
+{
+    int i;
+    for (i = 0; i < n_chars; ++i)
+    {
+	if (s[i] == 0x0a)
+	{
+	    *result++ = '\0';
+	    break;
+	}
+	else if (s[i] == 0x00)
+	{
+	    /* Convert embedded 0's to spaces */
+	    *result++ = ' ';
+	}
+	else
+	{
+	    *result++ = s[i];
+	}
+    }
+}
+
+static void
+decode_display_descriptor (const uchar *desc,
+			   MonitorInfo *info)
+{
+    switch (desc[0x03])
+    {
+    case 0xFC:
+	decode_lf_string (desc + 5, 13, info->dsc_product_name);
+	break;
+    case 0xFF:
+	decode_lf_string (desc + 5, 13, info->dsc_serial_number);
+	break;
+    case 0xFE:
+	decode_lf_string (desc + 5, 13, info->dsc_string);
+	break;
+    case 0xFD:
+	/* Range Limits */
+	break;
+    case 0xFB:
+	/* Color Point */
+	break;
+    case 0xFA:
+	/* Timing Identifications */
+	break;
+    case 0xF9:
+	/* Color Management */
+	break;
+    case 0xF8:
+	/* Timing Codes */
+	break;
+    case 0xF7:
+	/* Established Timings */
+	break;
+    case 0x10:
+	break;
+    }
+}
+
+static void
+decode_detailed_timing (const uchar *timing,
+			DetailedTiming *detailed)
+{
+    int bits;
+    StereoType stereo[] =
+    {
+	NO_STEREO, NO_STEREO, FIELD_RIGHT, FIELD_LEFT,
+	TWO_WAY_RIGHT_ON_EVEN, TWO_WAY_LEFT_ON_EVEN,
+	FOUR_WAY_INTERLEAVED, SIDE_BY_SIDE
+    };
+    
+    detailed->pixel_clock = (timing[0x00] | timing[0x01] << 8) * 10000;
+    detailed->h_addr = timing[0x02] | ((timing[0x04] & 0xf0) << 4);
+    detailed->h_blank = timing[0x03] | ((timing[0x04] & 0x0f) << 8);
+    detailed->v_addr = timing[0x05] | ((timing[0x07] & 0xf0) << 4);
+    detailed->v_blank = timing[0x06] | ((timing[0x07] & 0x0f) << 8);
+    detailed->h_front_porch = timing[0x08] | get_bits (timing[0x0b], 6, 7) << 8;
+    detailed->h_sync = timing[0x09] | get_bits (timing[0x0b], 4, 5) << 8;
+    detailed->v_front_porch =
+	get_bits (timing[0x0a], 4, 7) | get_bits (timing[0x0b], 2, 3) << 4;
+    detailed->v_sync =
+	get_bits (timing[0x0a], 0, 3) | get_bits (timing[0x0b], 0, 1) << 4;
+    detailed->width_mm =  timing[0x0c] | get_bits (timing[0x0e], 4, 7) << 8;
+    detailed->height_mm = timing[0x0d] | get_bits (timing[0x0e], 0, 3) << 8;
+    detailed->right_border = timing[0x0f];
+    detailed->top_border = timing[0x10];
+
+    detailed->interlaced = get_bit (timing[0x11], 7);
+
+    /* Stereo */
+    bits = get_bits (timing[0x11], 5, 6) << 1 | get_bit (timing[0x11], 0);
+    detailed->stereo = stereo[bits];
+
+    /* Sync */
+    bits = timing[0x11];
+
+    detailed->digital_sync = get_bit (bits, 4);
+    if (detailed->digital_sync)
+    {
+	detailed->connector.digital.composite = !get_bit (bits, 3);
+
+	if (detailed->connector.digital.composite)
+	{
+	    detailed->connector.digital.serrations = get_bit (bits, 2);
+	    detailed->connector.digital.negative_vsync = FALSE;
+	}
+	else
+	{
+	    detailed->connector.digital.serrations = FALSE;
+	    detailed->connector.digital.negative_vsync = !get_bit (bits, 2);
+	}
+
+	detailed->connector.digital.negative_hsync = !get_bit (bits, 0);
+    }
+    else
+    {
+	detailed->connector.analog.bipolar = get_bit (bits, 3);
+	detailed->connector.analog.serrations = get_bit (bits, 2);
+	detailed->connector.analog.sync_on_green = !get_bit (bits, 1);
+    }
+}
+
+static int
+decode_descriptors (const uchar *edid, MonitorInfo *info)
+{
+    int i;
+    int timing_idx;
+    
+    timing_idx = 0;
+    
+    for (i = 0; i < 4; ++i)
+    {
+	int index = 0x36 + i * 18;
+
+	if (edid[index + 0] == 0x00 && edid[index + 1] == 0x00)
+	{
+	    decode_display_descriptor (edid + index, info);
+	}
+	else
+	{
+	    decode_detailed_timing (
+		edid + index, &(info->detailed_timings[timing_idx++]));
+	}
+    }
+
+    info->n_detailed_timings = timing_idx;
+
+    return TRUE;
+}
+
+static void
+decode_check_sum (const uchar *edid,
+		  MonitorInfo *info)
+{
+    int i;
+    uchar check = 0;
+
+    for (i = 0; i < 128; ++i)
+	check += edid[i];
+
+    info->checksum = check;
+}
+
+MonitorInfo *
+decode_edid (const uchar *edid)
+{
+    MonitorInfo *info = g_new0 (MonitorInfo, 1);
+
+    decode_check_sum (edid, info);
+    
+    if (decode_header (edid)
+	&& decode_vendor_and_product_identification (edid, info)
+	&& decode_edid_version (edid, info)
+	&& decode_display_parameters (edid, info)
+	&& decode_color_characteristics (edid, info)
+	&& decode_established_timings (edid, info)
+	&& decode_standard_timings (edid, info)
+	&& decode_descriptors (edid, info))
+    {
+	return info;
+    }
+    else
+    {
+	g_free (info);
+	return NULL;
+    }
+}
--- a/src/core/edid.h
+++ b/src/core/edid.h
@@ -0,0 +1,195 @@
+/* edid.h
+ *
+ * Copyright 2007, 2008, Red Hat, Inc.
+ * 
+ * This file is part of the Gnome Library.
+ * 
+ * The Gnome Library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * The Gnome Library 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
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with the Gnome Library; see the file COPYING.LIB.  If not,
+ * write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ * 
+ * Author: Soren Sandmann <sandmann@redhat.com>
+ */
+
+#ifndef EDID_H
+#define EDID_H
+
+typedef unsigned char uchar;
+typedef struct MonitorInfo MonitorInfo;
+typedef struct Timing Timing;
+typedef struct DetailedTiming DetailedTiming;
+
+typedef enum
+{
+    UNDEFINED,
+    DVI,
+    HDMI_A,
+    HDMI_B,
+    MDDI,
+    DISPLAY_PORT
+} Interface;
+
+typedef enum
+{
+    UNDEFINED_COLOR,
+    MONOCHROME,
+    RGB,
+    OTHER_COLOR
+} ColorType;
+
+typedef enum
+{
+    NO_STEREO,
+    FIELD_RIGHT,
+    FIELD_LEFT,
+    TWO_WAY_RIGHT_ON_EVEN,
+    TWO_WAY_LEFT_ON_EVEN,
+    FOUR_WAY_INTERLEAVED,
+    SIDE_BY_SIDE
+} StereoType;
+
+struct Timing
+{
+    int width;
+    int height;
+    int frequency;
+};
+
+struct DetailedTiming
+{
+    int		pixel_clock;
+    int		h_addr;
+    int		h_blank;
+    int		h_sync;
+    int		h_front_porch;
+    int		v_addr;
+    int		v_blank;
+    int		v_sync;
+    int		v_front_porch;
+    int		width_mm;
+    int		height_mm;
+    int		right_border;
+    int		top_border;
+    int		interlaced;
+    StereoType	stereo;
+
+    int		digital_sync;
+    union
+    {
+	struct
+	{
+	    int bipolar;
+	    int serrations;
+	    int sync_on_green;
+	} analog;
+
+	struct
+	{
+	    int composite;
+	    int serrations;
+	    int negative_vsync;
+	    int negative_hsync;
+	} digital;
+    } connector;
+};
+
+struct MonitorInfo
+{
+    int			checksum;
+    char		manufacturer_code[4];
+    int			product_code;
+    unsigned int	serial_number;
+    
+    int			production_week;	/* -1 if not specified */
+    int			production_year;	/* -1 if not specified */
+    int			model_year;		/* -1 if not specified */
+
+    int			major_version;
+    int			minor_version;
+
+    int			is_digital;
+    
+    union
+    {
+	struct
+	{
+	    int		bits_per_primary;
+	    Interface	interface;
+	    int		rgb444;
+	    int		ycrcb444;
+	    int		ycrcb422;
+	} digital;
+
+	struct
+	{
+	    double	video_signal_level;
+	    double	sync_signal_level;
+	    double	total_signal_level;
+
+	    int		blank_to_black;
+
+	    int		separate_hv_sync;
+	    int		composite_sync_on_h;
+	    int		composite_sync_on_green;
+	    int		serration_on_vsync;
+	    ColorType	color_type;
+	} analog;
+    } connector;
+
+    int			width_mm;		/* -1 if not specified */
+    int			height_mm;		/* -1 if not specified */
+    double		aspect_ratio;		/* -1.0 if not specififed */
+
+    double		gamma;			/* -1.0 if not specified */
+
+    int			standby;
+    int			suspend;
+    int			active_off;
+
+    int			srgb_is_standard;
+    int			preferred_timing_includes_native;
+    int			continuous_frequency;
+
+    double		red_x;
+    double		red_y;
+    double		green_x;
+    double		green_y;
+    double		blue_x;
+    double		blue_y;
+    double		white_x;
+    double		white_y;
+
+    Timing		established[24];	/* Terminated by 0x0x0 */
+    Timing		standard[8];
+    
+    int			n_detailed_timings;
+    DetailedTiming	detailed_timings[4];	/* If monitor has a preferred
+						 * mode, it is the first one
+						 * (whether it has, is
+						 * determined by the 
+						 * preferred_timing_includes
+						 * bit.
+						 */
+
+    /* Optional product description */
+    char		dsc_serial_number[14];
+    char		dsc_product_name[14];
+    char		dsc_string[14];		/* Unspecified ASCII data */
+};
+
+MonitorInfo *decode_edid (const uchar *data);
+char *make_display_name (const MonitorInfo *info);
+char *make_display_size_string (int width_mm, int height_mm);
+
+#endif
--- a/src/core/frame.c
+++ b/src/core/frame.c
@@ -47,7 +47,6 @@ meta_window_ensure_frame (MetaWindow *window)
  XSetWindowAttributes attrs;
  Visual *visual;
  gulong create_serial;
-  MetaStackWindow stack_window;
  
  if (window->frame)
    return;
@@ -106,10 +105,8 @@ meta_window_ensure_frame (MetaWindow *window)
 						frame->rect.height,
 						frame->window->screen->number,
                                                &create_serial);
-  stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
-  stack_window.x11.xwindow = frame->xwindow;
  meta_stack_tracker_record_add (window->screen->stack_tracker,
-                                 &stack_window,
+                                 frame->xwindow,
                                 create_serial);

  meta_verbose ("Frame for %s is 0x%lx\n", frame->window->desc, frame->xwindow);
@@ -141,9 +138,8 @@ meta_window_ensure_frame (MetaWindow *window)
  window->rect.x = 0;
  window->rect.y = 0;

-  stack_window.x11.xwindow = window->xwindow;
  meta_stack_tracker_record_remove (window->screen->stack_tracker,
-                                    &stack_window,
+                                    window->xwindow,
                                    XNextRequest (window->display->xdisplay));
  XReparentWindow (window->display->xdisplay,
                   window->xwindow,
@@ -178,7 +174,6 @@ meta_window_destroy_frame (MetaWindow *window)
 {
  MetaFrame *frame;
  MetaFrameBorders borders;
-  MetaStackWindow stack_window;
  
  if (window->frame == NULL)
    return;
@@ -205,10 +200,8 @@ meta_window_destroy_frame (MetaWindow *window)
                  "Incrementing unmaps_pending on %s for reparent back to root\n", window->desc);
      window->unmaps_pending += 1;
    }
-  stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
-  stack_window.x11.xwindow = window->xwindow;
  meta_stack_tracker_record_add (window->screen->stack_tracker,
-                                 &stack_window,
+                                 window->xwindow,
                                 XNextRequest (window->display->xdisplay));
  XReparentWindow (window->display->xdisplay,
                   window->xwindow,
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -53,10 +53,6 @@
 #include <X11/XKBlib.h>
 #endif

-#ifdef HAVE_WAYLAND
-#include "meta-wayland-private.h"
-#endif
-
 #define SCHEMA_COMMON_KEYBINDINGS "org.gnome.desktop.wm.keybindings"
 #define SCHEMA_MUTTER_KEYBINDINGS "org.gnome.mutter.keybindings"

@@ -1969,6 +1965,23 @@ process_overlay_key (MetaDisplay *display,
            return TRUE;
          meta_display_overlay_key_activate (display);
        }
+      else
+        {
+          /* In some rare race condition, mutter might not receive the Super_L
+           * KeyRelease event because:
+           * - the compositor might end the modal mode and call XIUngrabDevice
+           *   while the key is still down
+           * - passive grabs are only activated on KeyPress and not KeyRelease.
+           *
+           * In this case, display->overlay_key_only_pressed might be wrong.
+           * Mutter still ought to acknowledge events, otherwise the X server
+           * will not send the next events.
+           *
+           * https://bugzilla.gnome.org/show_bug.cgi?id=666101
+           */
+          XIAllowEvents (display->xdisplay, event->deviceid,
+                         XIAsyncDevice, event->time);
+        }

      return TRUE;
    }
@@ -4085,40 +4098,6 @@ handle_set_spew_mark (MetaDisplay    *display,
  meta_verbose ("-- MARK MARK MARK MARK --\n");
 }

-#ifdef HAVE_WAYLAND
-static void
-handle_switch_vt (MetaDisplay    *display,
-                  MetaScreen     *screen,
-                  MetaWindow     *window,
-                  XIDeviceEvent  *event,
-                  MetaKeyBinding *binding,
-                  gpointer        dummy)
-{
-    gint vt = binding->handler->data;
-    MetaWaylandCompositor *compositor;
-    MetaTTY *tty;
-
-    compositor = meta_wayland_compositor_get_default ();
-    tty = meta_wayland_compositor_get_tty (compositor);
-
-    if (tty)
-      {
-        GError *error;
-
-        error = NULL;
-        if (!meta_tty_activate_vt (tty, vt, &error))
-          {
-            g_warning ("Failed to switch VT: %s", error->message);
-            g_error_free (error);
-          }
-      }
-    else
-      {
-        g_debug ("Ignoring VT switch keybinding, not running as VT manager");
-      }
-}
-#endif
-
 /**
 * meta_keybindings_set_custom_handler:
 * @name: The name of the keybinding to set
@@ -4443,60 +4422,6 @@ init_builtin_key_bindings (MetaDisplay *display)
                          META_KEYBINDING_ACTION_SET_SPEW_MARK,
                          handle_set_spew_mark, 0);

-#ifdef HAVE_WAYLAND
-  if (meta_is_wayland_compositor ())
-    {
-      add_builtin_keybinding (display,
-                              "switch-to-session-1",
-                              mutter_keybindings,
-                              META_KEY_BINDING_NONE,
-                              META_KEYBINDING_ACTION_NONE,
-                              handle_switch_vt, 1);
-
-      add_builtin_keybinding (display,
-                              "switch-to-session-2",
-                              mutter_keybindings,
-                              META_KEY_BINDING_NONE,
-                              META_KEYBINDING_ACTION_NONE,
-                              handle_switch_vt, 2);
-
-      add_builtin_keybinding (display,
-                              "switch-to-session-3",
-                              mutter_keybindings,
-                              META_KEY_BINDING_NONE,
-                              META_KEYBINDING_ACTION_NONE,
-                              handle_switch_vt, 3);
-
-      add_builtin_keybinding (display,
-                              "switch-to-session-4",
-                              mutter_keybindings,
-                              META_KEY_BINDING_NONE,
-                              META_KEYBINDING_ACTION_NONE,
-                              handle_switch_vt, 4);
-
-      add_builtin_keybinding (display,
-                              "switch-to-session-5",
-                              mutter_keybindings,
-                              META_KEY_BINDING_NONE,
-                              META_KEYBINDING_ACTION_NONE,
-                              handle_switch_vt, 5);
-
-      add_builtin_keybinding (display,
-                              "switch-to-session-6",
-                              mutter_keybindings,
-                              META_KEY_BINDING_NONE,
-                              META_KEYBINDING_ACTION_NONE,
-                              handle_switch_vt, 6);
-
-      add_builtin_keybinding (display,
-                              "switch-to-session-7",
-                              mutter_keybindings,
-                              META_KEY_BINDING_NONE,
-                              META_KEYBINDING_ACTION_NONE,
-                              handle_switch_vt, 7);
-    }
-#endif
-
 #undef REVERSES_AND_REVERSED

  /************************ PER WINDOW BINDINGS ************************/
--- a/src/core/main.c
+++ b/src/core/main.c
@@ -55,12 +55,9 @@
 #include "session.h"
 #include <meta/prefs.h>
 #include <meta/compositor.h>
-#ifdef HAVE_WAYLAND
-#include "meta-wayland-private.h"
-#endif

-#include <glib-object.h>
 #include <glib-unix.h>
+#include <glib-object.h>
 #include <gdk/gdkx.h>

 #include <stdlib.h>
@@ -97,26 +94,6 @@ static GMainLoop *meta_main_loop = NULL;
 static void prefs_changed_callback (MetaPreference pref,
                                    gpointer       data);

-/**
- * log_handler:
- * @log_domain: the domain the error occurred in (we ignore this)
- * @log_level: the log level so that we can filter out less
- *             important messages
- * @message: the message to log
- * @user_data: arbitrary data (we ignore this)
- *
- * Prints log messages. If Mutter was compiled with backtrace support,
- * also prints a backtrace (see meta_print_backtrace()).
- */
-static void
-log_handler (const gchar   *log_domain,
-             GLogLevelFlags log_level,
-             const gchar   *message,
-             gpointer       user_data)
-{
-  meta_warning ("Log level %d: %s\n", log_level, message);
-}
-
 /**
 * meta_print_compilation_info:
 *
@@ -350,41 +327,13 @@ meta_finalize (void)
  if (display)
    meta_display_close (display,
                        CurrentTime); /* I doubt correct timestamps matter here */
-
-#ifdef HAVE_WAYLAND
-  if (meta_is_wayland_compositor ())
-    meta_wayland_finalize ();
-#endif
 }

 static gboolean
 on_sigterm (gpointer user_data)
 {
-  meta_quit (EXIT_SUCCESS);
-
-  return G_SOURCE_REMOVE;
-}
-
-static void
-crash_handler (int signum)
-{
-  char buffer[256];
-  MetaWaylandCompositor *compositor;
-  MetaTTY *tty;
-
-  snprintf (buffer, 256, "Fatal server error: %d\n", signum);
-  write (STDERR_FILENO, buffer, strlen (buffer));
-
-  compositor = meta_wayland_compositor_get_default ();
-  tty = meta_wayland_compositor_get_tty (compositor);
-
-  /* Passing FALSE ensures that we only do ioctls, which is
-     safe from a signal handler */
-  if (tty)
-    meta_tty_reset (tty, FALSE);
-
-  /* We can't continue with the default handling, so just exit here */
-  _exit(1);
+  meta_quit (META_EXIT_SUCCESS);
+  return FALSE;
 }

 /**
@@ -398,7 +347,7 @@ meta_init (void)
 {
  struct sigaction act;
  sigset_t empty_mask;
-  
+
  sigemptyset (&empty_mask);
  act.sa_handler = SIG_IGN;
  act.sa_mask    = empty_mask;
@@ -412,21 +361,10 @@ meta_init (void)
                g_strerror (errno));
 #endif

-  if (meta_is_wayland_compositor ())
-    {
-      act.sa_handler = crash_handler;
-
-      /* Ignore if we can't register signal handlers, worse
-         that can happen one needs the sysrq to get out of the VT */
-      sigaction (SIGABRT, &act, NULL);
-      sigaction (SIGSEGV, &act, NULL);
-      sigaction (SIGBUS, &act, NULL);
-      sigaction (SIGFPE, &act, NULL);
-      sigaction (SIGTRAP, &act, NULL);
-    }
-
  g_unix_signal_add (SIGTERM, on_sigterm, NULL);

+  meta_debug_init ();
+
  if (g_getenv ("MUTTER_VERBOSE"))
    meta_set_verbose (TRUE);
  if (g_getenv ("MUTTER_DEBUG"))
@@ -443,18 +381,9 @@ meta_init (void)
  g_irepository_prepend_search_path (MUTTER_PKGLIBDIR);
 #endif

-#ifdef HAVE_WAYLAND
-  if (meta_is_wayland_compositor ())
-    {
-      /* NB: When running as a hybrid wayland compositor we run our own headless X
-       * server so the user can't control the X display to connect too. */
-      meta_wayland_init ();
-    }
-  else
-#endif
-    meta_select_display (opt_display_name);
-
  meta_set_syncing (opt_sync || (g_getenv ("MUTTER_SYNC") != NULL));
+
+  meta_select_display (opt_display_name);
  
  if (opt_replace_wm)
    meta_set_replace_current_wm (TRUE);
@@ -466,17 +395,10 @@ meta_init (void)
  
  meta_ui_init ();

-  /* If we are running with wayland then we don't wait until we have
-   * an X connection before initializing clutter we instead initialize
-   * it earlier since we need to initialize the GL driver so the driver
-   * can register any needed wayland extensions. */
-  if (!meta_is_wayland_compositor ())
-    {
-      /*
-       * Clutter can only be initialized after the UI.
-       */
-      meta_clutter_init ();
-    }
+  /*
+   * Clutter can only be initialized after the UI.
+   */
+  meta_clutter_init ();
 }

 /**
@@ -528,63 +450,25 @@ meta_register_with_session (void)
 int
 meta_run (void)
 {
-  const gchar *log_domains[] = {
-    NULL, G_LOG_DOMAIN, "Gtk", "Gdk", "GLib",
-    "Pango", "GLib-GObject", "GThread"
-  };
-  guint i;
-
  /* Load prefs */
  meta_prefs_init ();
  meta_prefs_add_listener (prefs_changed_callback, NULL);

-  for (i=0; i<G_N_ELEMENTS(log_domains); i++)
-    g_log_set_handler (log_domains[i],
-                       G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,
-                       log_handler, NULL);
-
-  if (g_getenv ("MUTTER_G_FATAL_WARNINGS") != NULL)
-    g_log_set_always_fatal (G_LOG_LEVEL_MASK);
-  
  meta_ui_set_current_theme (meta_prefs_get_theme ());

-  /* Try to find some theme that'll work if the theme preference
-   * doesn't exist.  First try Simple (the default theme) then just
-   * try anything in the themes directory.
+  /* If the theme preference does not exists, fallback to
+   * Adwaita (the default theme), or abort if that doesn't
+   * exists.
   */
  if (!meta_ui_have_a_theme ())
-    meta_ui_set_current_theme ("Simple");
-  
+    meta_ui_set_current_theme ("Adwaita");
+
  if (!meta_ui_have_a_theme ())
-    {
-      const char *dir_entry = NULL;
-      GError *err = NULL;
-      GDir   *themes_dir = NULL;
-      
-      if (!(themes_dir = g_dir_open (MUTTER_DATADIR"/themes", 0, &err)))
-        {
-          meta_fatal (_("Failed to scan themes directory: %s\n"), err->message);
-          g_error_free (err);
-        } 
-      else 
-        {
-          while (((dir_entry = g_dir_read_name (themes_dir)) != NULL) && 
-                 (!meta_ui_have_a_theme ()))
-            {
-              meta_ui_set_current_theme (dir_entry);
-            }
-          
-          g_dir_close (themes_dir);
-        }
-    }
-  
-  if (!meta_ui_have_a_theme ())
-    meta_fatal (_("Could not find a theme! Be sure %s exists and contains the usual themes.\n"),
-                MUTTER_DATADIR"/themes");
+    meta_fatal ("Adwaita theme missing, please install the gnome-themes-standard package");

  if (!meta_display_open ())
    meta_exit (META_EXIT_ERROR);
-  
+
  g_main_loop_run (meta_main_loop);

  meta_finalize ();
--- a/src/core/meta-cursor-tracker-private.h
+++ b/src/core/meta-cursor-tracker-private.h
@@ -1,46 +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, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- *
- * Author: Giovanni Campagna <gcampagn@redhat.com>
- */
-
-#ifndef META_CURSOR_TRACKER_PRIVATE_H
-#define META_CURSOR_TRACKER_PRIVATE_H
-
-#include <meta/meta-cursor-tracker.h>
-
-gboolean meta_cursor_tracker_handle_xevent (MetaCursorTracker *tracker,
-					    XEvent            *xevent);
-
-void     meta_cursor_tracker_set_root_cursor (MetaCursorTracker *tracker,
-                                              MetaCursor         cursor);
-void     meta_cursor_tracker_revert_root     (MetaCursorTracker *tracker);
-void     meta_cursor_tracker_set_sprite      (MetaCursorTracker *tracker,
-                                              CoglTexture2D     *texture,
-                                              int                hot_x,
-                                              int                hot_y);
-
-void     meta_cursor_tracker_update_position (MetaCursorTracker *tracker,
-					      int                new_x,
-					      int                new_y);
-void     meta_cursor_tracker_paint           (MetaCursorTracker *tracker);
-void     meta_cursor_tracker_queue_redraw    (MetaCursorTracker *tracker,
-					      ClutterActor      *stage);
-#endif
--- a/src/core/meta-cursor-tracker.c
+++ b/src/core/meta-cursor-tracker.c
@@ -1,451 +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, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- *
- * Author: Giovanni Campagna <gcampagn@redhat.com>
- */
-
-/**
- * SECTION:cursor-tracker
- * @title: MetaCursorTracker
- * @short_description: Mutter cursor tracking helper
- */
-
-#include <config.h>
-#include <meta/main.h>
-#include <meta/util.h>
-#include <meta/errors.h>
-
-#include <cogl/cogl.h>
-#include <clutter/clutter.h>
-
-#include <X11/extensions/Xfixes.h>
-
-#include "meta-cursor-tracker-private.h"
-#include "screen-private.h"
-#include "meta-wayland-private.h"
-
-#define META_WAYLAND_DEFAULT_CURSOR_HOTSPOT_X 7
-#define META_WAYLAND_DEFAULT_CURSOR_HOTSPOT_Y 4
-
-struct _MetaCursorTracker {
-  GObject parent_instance;
-
-  MetaScreen *screen;
-
-  gboolean is_showing;
-
-  CoglTexture2D *sprite;
-  int hot_x, hot_y;
-
-  CoglTexture2D *root_cursor;
-  int root_hot_x, root_hot_y;
-
-  CoglTexture2D *default_cursor;
-
-  int current_x, current_y;
-  cairo_rectangle_int_t current_rect;
-  cairo_rectangle_int_t previous_rect;
-  gboolean previous_is_valid;
-
-  CoglPipeline *pipeline;
-};
-
-struct _MetaCursorTrackerClass {
-  GObjectClass parent_class;
-};
-
-G_DEFINE_TYPE (MetaCursorTracker, meta_cursor_tracker, G_TYPE_OBJECT);
-
-enum {
-    CURSOR_CHANGED,
-    LAST_SIGNAL
-};
-
-static guint signals[LAST_SIGNAL];
-
-static void
-meta_cursor_tracker_init (MetaCursorTracker *self)
-{
-  /* (JS) Best (?) that can be assumed since XFixes doesn't provide a way of
-     detecting if the system mouse cursor is showing or not.
-
-     On wayland we start with the cursor showing
-  */
-  self->is_showing = TRUE;
-}
-
-static void
-meta_cursor_tracker_finalize (GObject *object)
-{
-  MetaCursorTracker *self = META_CURSOR_TRACKER (object);
-
-  if (self->sprite)
-    cogl_object_unref (self->sprite);
-  if (self->root_cursor)
-    cogl_object_unref (self->root_cursor);
-  if (self->default_cursor)
-    cogl_object_unref (self->default_cursor);
-  if (self->pipeline)
-    cogl_object_unref (self->pipeline);
-
-  G_OBJECT_CLASS (meta_cursor_tracker_parent_class)->finalize (object);
-}
-
-static void
-meta_cursor_tracker_class_init (MetaCursorTrackerClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = meta_cursor_tracker_finalize;
-
-  signals[CURSOR_CHANGED] = g_signal_new ("cursor-changed",
-                                          G_TYPE_FROM_CLASS (klass),
-                                          G_SIGNAL_RUN_LAST,
-                                          0,
-                                          NULL, NULL, NULL,
-                                          G_TYPE_NONE, 0);
-}
-
-static MetaCursorTracker *
-make_wayland_cursor_tracker (MetaScreen *screen)
-{
-  MetaWaylandCompositor *compositor;
-  CoglContext *ctx;
-  MetaCursorTracker *self = g_object_new (META_TYPE_CURSOR_TRACKER, NULL);
-  self->screen = screen;
-
-  ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
-  self->pipeline = cogl_pipeline_new (ctx);
-
-  compositor = meta_wayland_compositor_get_default ();
-  compositor->seat->cursor_tracker = self;
-
-  return self;
-}
-
-static MetaCursorTracker *
-make_x11_cursor_tracker (MetaScreen *screen)
-{
-  MetaCursorTracker *self = g_object_new (META_TYPE_CURSOR_TRACKER, NULL);
-  self->screen = screen;
-
-  XFixesSelectCursorInput (screen->display->xdisplay,
-                           screen->xroot,
-                           XFixesDisplayCursorNotifyMask);
-
-  return self;
-}
-
-/**
- * meta_cursor_tracker_get_for_screen:
- * @screen: the #MetaScreen
- *
- * Retrieves the cursor tracker object for @screen.
- *
- * Returns: (transfer none):
- */
-MetaCursorTracker *
-meta_cursor_tracker_get_for_screen (MetaScreen *screen)
-{
-  MetaCursorTracker *self;
-
-  if (screen->cursor_tracker)
-    return screen->cursor_tracker;
-
-  if (meta_is_wayland_compositor ())
-    self = make_wayland_cursor_tracker (screen);
-  else
-    self = make_x11_cursor_tracker (screen);
-
-  screen->cursor_tracker = self;
-  return self;
-}
-
-gboolean
-meta_cursor_tracker_handle_xevent (MetaCursorTracker *tracker,
-                                   XEvent            *xevent)
-{
-  XFixesCursorNotifyEvent *notify_event;
-
-  if (meta_is_wayland_compositor ())
-    return FALSE;
-
-  if (xevent->xany.type != tracker->screen->display->xfixes_event_base + XFixesCursorNotify)
-    return FALSE;
-
-  notify_event = (XFixesCursorNotifyEvent *)xevent;
-  if (notify_event->subtype != XFixesDisplayCursorNotify)
-    return FALSE;
-
-  g_clear_pointer (&tracker->sprite, cogl_object_unref);
-  g_signal_emit (tracker, signals[CURSOR_CHANGED], 0);
-
-  return TRUE;
-}
-
-static void
-ensure_xfixes_cursor (MetaCursorTracker *tracker)
-{
-  XFixesCursorImage *cursor_image;
-  CoglTexture2D *sprite;
-  guint8 *cursor_data;
-  gboolean free_cursor_data;
-  CoglContext *ctx;
-
-  if (tracker->sprite)
-    return;
-
-  cursor_image = XFixesGetCursorImage (tracker->screen->display->xdisplay);
-  if (!cursor_image)
-    return;
-
-  /* Like all X APIs, XFixesGetCursorImage() returns arrays of 32-bit
-   * quantities as arrays of long; we need to convert on 64 bit */
-  if (sizeof(long) == 4)
-    {
-      cursor_data = (guint8 *)cursor_image->pixels;
-      free_cursor_data = FALSE;
-    }
-  else
-    {
-      int i, j;
-      guint32 *cursor_words;
-      gulong *p;
-      guint32 *q;
-
-      cursor_words = g_new (guint32, cursor_image->width * cursor_image->height);
-      cursor_data = (guint8 *)cursor_words;
-
-      p = cursor_image->pixels;
-      q = cursor_words;
-      for (j = 0; j < cursor_image->height; j++)
-        for (i = 0; i < cursor_image->width; i++)
-          *(q++) = *(p++);
-
-      free_cursor_data = TRUE;
-    }
-
-  ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
-  sprite = cogl_texture_2d_new_from_data (ctx,
-                                          cursor_image->width,
-                                          cursor_image->height,
-                                          CLUTTER_CAIRO_FORMAT_ARGB32,
-                                          COGL_PIXEL_FORMAT_ANY,
-                                          cursor_image->width * 4, /* stride */
-                                          cursor_data,
-                                          NULL);
-
-  if (free_cursor_data)
-    g_free (cursor_data);
-
-  if (sprite != NULL)
-    {
-      tracker->sprite = sprite;
-      tracker->hot_x = cursor_image->xhot;
-      tracker->hot_y = cursor_image->yhot;
-    }
-  XFree (cursor_image);
-}
-
-/**
- * meta_cursor_tracker_get_sprite:
- *
- * Returns: (transfer none):
- */
-CoglTexture *
-meta_cursor_tracker_get_sprite (MetaCursorTracker *tracker)
-{
-  g_return_val_if_fail (META_IS_CURSOR_TRACKER (tracker), NULL);
-
-  if (!meta_is_wayland_compositor ())
-    ensure_xfixes_cursor (tracker);
-
-  return COGL_TEXTURE (tracker->sprite);
-}
-
-/**
- * meta_cursor_tracker_get_hot:
- * @tracker:
- * @x: (out):
- * @y: (out):
- *
- */
-void
-meta_cursor_tracker_get_hot (MetaCursorTracker *tracker,
-                             int               *x,
-                             int               *y)
-{
-  g_return_if_fail (META_IS_CURSOR_TRACKER (tracker));
-
-  if (!meta_is_wayland_compositor ())
-    ensure_xfixes_cursor (tracker);
-
-  if (x)
-    *x = tracker->hot_x;
-  if (y)
-    *y = tracker->hot_y;
-}
-
-static void
-ensure_wayland_cursor (MetaCursorTracker *tracker)
-{
-  CoglBitmap *bitmap;
-  char *filename;
-
-  if (tracker->default_cursor)
-    return;
-
-  filename = g_build_filename (MUTTER_DATADIR,
-                               "mutter/cursors/left_ptr.png",
-                               NULL);
-
-  bitmap = cogl_bitmap_new_from_file (filename, NULL);
-  tracker->default_cursor = cogl_texture_2d_new_from_bitmap (bitmap,
-                                                             COGL_PIXEL_FORMAT_ANY,
-                                                             NULL);
-
-  cogl_object_unref (bitmap);
-  g_free (filename);
-}
-
-void
-meta_cursor_tracker_set_root_cursor (MetaCursorTracker *tracker,
-                                     MetaCursor         cursor)
-{
-  Cursor xcursor;
-  MetaDisplay *display = tracker->screen->display;
-
-  /* First create a cursor for X11 applications that don't specify their own */
-  xcursor = meta_display_create_x_cursor (display, cursor);
-
-  XDefineCursor (display->xdisplay, tracker->screen->xroot, xcursor);
-  XFlush (display->xdisplay);
-  XFreeCursor (display->xdisplay, xcursor);
-
-  /* Now update the real root cursor */
-  if (meta_is_wayland_compositor ())
-    {
-      /* FIXME! We need to load all the other cursors too */
-      ensure_wayland_cursor (tracker);
-
-      g_clear_pointer (&tracker->root_cursor, cogl_object_unref);
-      tracker->root_cursor = cogl_object_ref (tracker->default_cursor);
-      tracker->root_hot_x = META_WAYLAND_DEFAULT_CURSOR_HOTSPOT_X;
-      tracker->root_hot_y = META_WAYLAND_DEFAULT_CURSOR_HOTSPOT_Y;
-    }
-}
-
-void
-meta_cursor_tracker_revert_root (MetaCursorTracker *tracker)
-{
-  meta_cursor_tracker_set_sprite (tracker,
-                                  tracker->root_cursor,
-                                  tracker->root_hot_x,
-                                  tracker->root_hot_y);
-}
-
-void
-meta_cursor_tracker_set_sprite (MetaCursorTracker *tracker,
-                                CoglTexture2D     *sprite,
-                                int                hot_x,
-                                int                hot_y)
-{
-  g_assert (meta_is_wayland_compositor ());
-
-  g_clear_pointer (&tracker->sprite, cogl_object_unref);
-
-  if (sprite)
-    {
-      tracker->sprite = cogl_object_ref (sprite);
-      tracker->hot_x = hot_x;
-      tracker->hot_y = hot_y;
-      cogl_pipeline_set_layer_texture (tracker->pipeline, 0, COGL_TEXTURE (tracker->sprite));
-    }
-  else
-    cogl_pipeline_set_layer_texture (tracker->pipeline, 0, NULL);
-
-  g_signal_emit (tracker, signals[CURSOR_CHANGED], 0);
-
-  meta_cursor_tracker_update_position (tracker, tracker->current_x, tracker->current_y);
-}
-
-void
-meta_cursor_tracker_update_position (MetaCursorTracker *tracker,
-                                     int                new_x,
-                                     int                new_y)
-{
-  g_assert (meta_is_wayland_compositor ());
-
-  tracker->current_x = new_x;
-  tracker->current_y = new_y;
-  tracker->current_rect.x = tracker->current_x - tracker->hot_x;
-  tracker->current_rect.y = tracker->current_y - tracker->hot_y;
-
-  if (tracker->sprite)
-    {
-      tracker->current_rect.width = cogl_texture_get_width (COGL_TEXTURE (tracker->sprite));
-      tracker->current_rect.height = cogl_texture_get_height (COGL_TEXTURE (tracker->sprite));
-    }
-  else
-    {
-      tracker->current_rect.width = 0;
-      tracker->current_rect.height = 0;
-    }
-}
-
-void
-meta_cursor_tracker_paint (MetaCursorTracker *tracker)
-{
-  g_assert (meta_is_wayland_compositor ());
-
-  if (tracker->sprite == NULL)
-    return;
-
-  /* FIXME: try to use a DRM cursor when possible */
-  cogl_framebuffer_draw_rectangle (cogl_get_draw_framebuffer (),
-                                   tracker->pipeline,
-                                   tracker->current_rect.x,
-                                   tracker->current_rect.y,
-                                   tracker->current_rect.x +
-                                   tracker->current_rect.width,
-                                   tracker->current_rect.y +
-                                   tracker->current_rect.height);
-
-  tracker->previous_rect = tracker->current_rect;
-  tracker->previous_is_valid = TRUE;
-}
-
-void
-meta_cursor_tracker_queue_redraw (MetaCursorTracker *tracker,
-                                  ClutterActor      *stage)
-{
-  g_assert (meta_is_wayland_compositor ());
-
-  if (tracker->previous_is_valid)
-    {
-      clutter_actor_queue_redraw_with_clip (stage, &tracker->previous_rect);
-      tracker->previous_is_valid = FALSE;
-    }
-
-  if (tracker->sprite == NULL)
-    return;
-
-  clutter_actor_queue_redraw_with_clip (stage, &tracker->current_rect);
-}
--- a/src/core/meta-idle-monitor-private.h
+++ b/src/core/meta-idle-monitor-private.h
@@ -1,31 +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, write to the Free Software
- * 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
- */
-
-#include <meta/meta-idle-monitor.h>
-
-void meta_idle_monitor_handle_xevent_all (XEvent *xevent);
-
-void meta_idle_monitor_reset_idletime (MetaIdleMonitor *monitor);
-
-void meta_idle_monitor_init_dbus (void);
--- a/src/core/meta-idle-monitor.c
+++ b/src/core/meta-idle-monitor.c
@@ -1,932 +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, write to the Free Software
- * 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: MetaIdleMonitor
- * @short_description: Mutter idle counter (similar to X's IDLETIME)
- */
-
-#include "config.h"
-
-#include <string.h>
-#include <clutter/clutter.h>
-#include <X11/Xlib.h>
-#include <X11/extensions/sync.h>
-
-#include <meta/util.h>
-#include <meta/main.h>
-#include <meta/meta-idle-monitor.h>
-#include "display-private.h"
-#include "meta-idle-monitor-private.h"
-#include "meta-dbus-idle-monitor.h"
-
-G_STATIC_ASSERT(sizeof(unsigned long) == sizeof(gpointer));
-
-struct _MetaIdleMonitor
-{
-  GObject parent_instance;
-
-  GHashTable  *watches;
-  GHashTable  *alarms;
-  int          device_id;
-
-  /* X11 implementation */
-  Display     *display;
-  int          sync_event_base;
-  XSyncCounter counter;
-  XSyncAlarm   user_active_alarm;
-
-  /* Wayland implementation */
-  guint64      last_event_time;
-};
-
-struct _MetaIdleMonitorClass
-{
-  GObjectClass parent_class;
-};
-
-typedef struct
-{
-  MetaIdleMonitor          *monitor;
-  guint	                    id;
-  MetaIdleMonitorWatchFunc  callback;
-  gpointer		    user_data;
-  GDestroyNotify            notify;
-  guint64                   timeout_msec;
-
-  /* x11 */
-  XSyncAlarm	            xalarm;
-
-  /* wayland */
-  GSource                  *timeout_source;
-} MetaIdleMonitorWatch;
-
-enum
-{
-  PROP_0,
-  PROP_DEVICE_ID,
-  PROP_LAST,
-};
-
-static GParamSpec *obj_props[PROP_LAST];
-
-G_DEFINE_TYPE (MetaIdleMonitor, meta_idle_monitor, G_TYPE_OBJECT)
-
-static MetaIdleMonitor *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)
-
-static void
-fire_watch (MetaIdleMonitorWatch *watch)
-{
-  MetaIdleMonitor *monitor;
-
-  monitor = watch->monitor;
-  g_object_ref (monitor);
-
-  if (watch->callback)
-    {
-      watch->callback (watch->monitor,
-                       watch->id,
-                       watch->user_data);
-    }
-
-  if (watch->timeout_msec == 0)
-    meta_idle_monitor_remove_watch (watch->monitor, watch->id);
-
-  g_object_unref (monitor);
-}
-
-static XSyncAlarm
-_xsync_alarm_set (MetaIdleMonitor	*monitor,
-		  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->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->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 void
-check_x11_watch (gpointer data,
-                 gpointer user_data)
-{
-  MetaIdleMonitorWatch *watch = data;
-  XSyncAlarm alarm = (XSyncAlarm) user_data;
-
-  if (watch->xalarm != alarm)
-    return;
-
-  fire_watch (watch);
-}
-
-static void
-meta_idle_monitor_handle_xevent (MetaIdleMonitor       *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, monitor);
-      g_list_free (watches);
-    }
-}
-
-void
-meta_idle_monitor_handle_xevent_all (XEvent *xevent)
-{
-  int i;
-
-  for (i = 0; i < device_id_max; i++)
-    if (device_monitors[i])
-      meta_idle_monitor_handle_xevent (device_monitors[i], (XSyncAlarmNotifyEvent*)xevent);
-}
-
-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 (MetaIdleMonitor *monitor)
-{
-  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 void
-idle_monitor_watch_free (MetaIdleMonitorWatch *watch)
-{
-  MetaIdleMonitor *monitor;
-
-  if (watch == NULL)
-    return;
-
-  monitor = watch->monitor;
-
-  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);
-    }
-
-  if (watch->timeout_source != NULL)
-    g_source_destroy (watch->timeout_source);
-
-  g_slice_free (MetaIdleMonitorWatch, watch);
-}
-
-static void
-init_xsync (MetaIdleMonitor *monitor)
-{
-  monitor->counter = find_idletime_counter (monitor);
-  /* IDLETIME counter not found? */
-  if (monitor->counter == None)
-    return;
-
-  monitor->user_active_alarm = _xsync_alarm_set (monitor, XSyncNegativeTransition, 1, FALSE);
-}
-
-static void
-meta_idle_monitor_dispose (GObject *object)
-{
-  MetaIdleMonitor *monitor;
-
-  monitor = META_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;
-    }
-
-  G_OBJECT_CLASS (meta_idle_monitor_parent_class)->dispose (object);
-}
-
-static void
-meta_idle_monitor_get_property (GObject    *object,
-                                guint       prop_id,
-                                GValue     *value,
-                                GParamSpec *pspec)
-{
-  MetaIdleMonitor *monitor = META_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
-meta_idle_monitor_set_property (GObject      *object,
-                                guint         prop_id,
-                                const GValue *value,
-                                GParamSpec   *pspec)
-{
-  MetaIdleMonitor *monitor = META_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
-meta_idle_monitor_constructed (GObject *object)
-{
-  MetaIdleMonitor *monitor = META_IDLE_MONITOR (object);
-
-  if (!meta_is_wayland_compositor ())
-    {
-      monitor->display = meta_get_display ()->xdisplay;
-      init_xsync (monitor);
-    }
-}
-
-static void
-meta_idle_monitor_class_init (MetaIdleMonitorClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->dispose = meta_idle_monitor_dispose;
-  object_class->constructed = meta_idle_monitor_constructed;
-  object_class->get_property = meta_idle_monitor_get_property;
-  object_class->set_property = meta_idle_monitor_set_property;
-
-  /**
-   * MetaIdleMonitor: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
-meta_idle_monitor_init (MetaIdleMonitor *monitor)
-{
-  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 (META_TYPE_IDLE_MONITOR, "device-id", device_id, NULL);
-  device_id_max = MAX (device_id_max, device_id);
-}
-
-/**
- * meta_idle_monitor_get_core:
- *
- * Returns: (transfer none): the #MetaIdleMonitor that tracks the server-global
- * idletime for all devices. To track device-specific idletime,
- * use meta_idle_monitor_get_for_device().
- */
-MetaIdleMonitor *
-meta_idle_monitor_get_core (void)
-{
-  ensure_device_monitor (0);
-  return device_monitors[0];
-}
-
-/**
- * meta_idle_monitor_get_for_device:
- * @device_id: the device to get the idle time for.
- *
- * Returns: (transfer none): a new #MetaIdleMonitor that tracks the
- * device-specific idletime for @device. To track server-global idletime
- * for all devices, use meta_idle_monitor_get_core().
- */
-MetaIdleMonitor *
-meta_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
-wayland_dispatch_timeout (GSource     *source,
-                          GSourceFunc  callback,
-                          gpointer     user_data)
-{
-  MetaIdleMonitorWatch *watch = user_data;
-
-  fire_watch (watch);
-  g_source_set_ready_time (watch->timeout_source, -1);
-  return TRUE;
-}
-
-static GSourceFuncs wayland_source_funcs = {
-  NULL, /* prepare */
-  NULL, /* check */
-  wayland_dispatch_timeout,
-  NULL, /* finalize */
-};
-
-static MetaIdleMonitorWatch *
-make_watch (MetaIdleMonitor           *monitor,
-            guint64                    timeout_msec,
-	    MetaIdleMonitorWatchFunc   callback,
-	    gpointer                   user_data,
-	    GDestroyNotify             notify)
-{
-  MetaIdleMonitorWatch *watch;
-
-  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 (meta_is_wayland_compositor ())
-    {
-      if (timeout_msec != 0)
-        {
-          GSource *source = g_source_new (&wayland_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;
-        }
-    }
-  else
-    {
-      if (timeout_msec != 0)
-        {
-          watch->xalarm = _xsync_alarm_set (monitor, XSyncPositiveTransition, timeout_msec, TRUE);
-
-          g_hash_table_add (monitor->alarms, (gpointer) watch->xalarm);
-        }
-      else
-        {
-          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;
-}
-
-/**
- * meta_idle_monitor_add_idle_watch:
- * @monitor: A #MetaIdleMonitor
- * @interval_msec: The idletime interval, in milliseconds
- * @callback: (allow-none): The callback to call when the user has
- *     accumulated @interval_msec milliseconds of idle time.
- * @user_data: (allow-none): The user data to pass to the callback
- * @notify: A #GDestroyNotify
- *
- * Returns: a watch id
- *
- * Adds a watch for a specific idle time. The callback will be called
- * when the user has accumulated @interval_msec milliseconds of idle time.
- * This function will return an ID that can either be passed to
- * meta_idle_monitor_remove_watch(), or can be used to tell idle time
- * watches apart if you have more than one.
- *
- * Also note that this function will only care about positive transitions
- * (user's idle time exceeding a certain time). If you want to know about
- * when the user has become active, use
- * meta_idle_monitor_add_user_active_watch().
- */
-guint
-meta_idle_monitor_add_idle_watch (MetaIdleMonitor	       *monitor,
-                                  guint64	                interval_msec,
-                                  MetaIdleMonitorWatchFunc      callback,
-                                  gpointer			user_data,
-                                  GDestroyNotify		notify)
-{
-  MetaIdleMonitorWatch *watch;
-
-  g_return_val_if_fail (META_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;
-}
-
-/**
- * meta_idle_monitor_add_user_active_watch:
- * @monitor: A #MetaIdleMonitor
- * @callback: (allow-none): The callback to call when the user is
- *     active again.
- * @user_data: (allow-none): The user data to pass to the callback
- * @notify: A #GDestroyNotify
- *
- * Returns: a watch id
- *
- * Add a one-time watch to know when the user is active again.
- * Note that this watch is one-time and will de-activate after the
- * function is called, for efficiency purposes. It's most convenient
- * to call this when an idle watch, as added by
- * meta_idle_monitor_add_idle_watch(), has triggered.
- */
-guint
-meta_idle_monitor_add_user_active_watch (MetaIdleMonitor          *monitor,
-                                         MetaIdleMonitorWatchFunc  callback,
-                                         gpointer		   user_data,
-                                         GDestroyNotify	           notify)
-{
-  MetaIdleMonitorWatch *watch;
-
-  g_return_val_if_fail (META_IS_IDLE_MONITOR (monitor), 0);
-
-  watch = make_watch (monitor,
-                      0,
-                      callback,
-                      user_data,
-                      notify);
-
-  return watch->id;
-}
-
-/**
- * meta_idle_monitor_remove_watch:
- * @monitor: A #MetaIdleMonitor
- * @id: A watch ID
- *
- * Removes an idle time watcher, previously added by
- * meta_idle_monitor_add_idle_watch() or
- * meta_idle_monitor_add_user_active_watch().
- */
-void
-meta_idle_monitor_remove_watch (MetaIdleMonitor *monitor,
-                                guint	         id)
-{
-  g_return_if_fail (META_IS_IDLE_MONITOR (monitor));
-
-  g_hash_table_remove (monitor->watches,
-                       GUINT_TO_POINTER (id));
-}
-
-/**
- * meta_idle_monitor_get_idletime:
- * @monitor: A #MetaIdleMonitor
- *
- * Returns: The current idle time, in milliseconds, or -1 for not supported
- */
-guint64
-meta_idle_monitor_get_idletime (MetaIdleMonitor *monitor)
-{
-  XSyncValue value;
-
-  if (meta_is_wayland_compositor ())
-    {
-      return (g_get_monotonic_time () - monitor->last_event_time) / 1000;
-    }
-  else
-    {
-      if (!XSyncQueryCounter (monitor->display, monitor->counter, &value))
-        return -1;
-
-      return _xsyncvalue_to_int64 (value);
-    }
-}
-
-typedef struct {
-  MetaIdleMonitor *monitor;
-  GList *fired_watches;
-} CheckWaylandClosure;
-
-static gboolean
-check_wayland_watch (gpointer key,
-                     gpointer value,
-                     gpointer user_data)
-{
-  MetaIdleMonitorWatch *watch = value;
-  CheckWaylandClosure *closure = user_data;
-  gboolean steal;
-
-  if (watch->timeout_msec == 0)
-    {
-      closure->fired_watches = g_list_prepend (closure->fired_watches, watch);
-      steal = TRUE;
-    }
-  else
-    {
-      g_source_set_ready_time (watch->timeout_source,
-                               closure->monitor->last_event_time +
-                               watch->timeout_msec * 1000);
-      steal = FALSE;
-    }
-
-  return steal;
-}
-
-static void
-fire_wayland_watch (gpointer watch,
-                    gpointer data)
-{
-  fire_watch (watch);
-}
-
-void
-meta_idle_monitor_reset_idletime (MetaIdleMonitor *monitor)
-{
-  CheckWaylandClosure closure;
-
-  monitor->last_event_time = g_get_monotonic_time ();
-
-  closure.monitor = monitor;
-  closure.fired_watches = NULL;
-  g_hash_table_foreach_steal (monitor->watches, check_wayland_watch, &closure);
-
-  g_list_foreach (closure.fired_watches, fire_wayland_watch, NULL);
-  g_list_free (closure.fired_watches);
-}
-
-static gboolean
-handle_get_idletime (MetaDBusIdleMonitor   *skeleton,
-                     GDBusMethodInvocation *invocation,
-                     MetaIdleMonitor       *monitor)
-{
-  guint64 idletime;
-
-  idletime = meta_idle_monitor_get_idletime (monitor);
-  meta_dbus_idle_monitor_complete_get_idletime (skeleton, invocation, idletime);
-
-  return TRUE;
-}
-
-typedef struct {
-  MetaDBusIdleMonitor *dbus_monitor;
-  MetaIdleMonitor *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 (MetaIdleMonitor *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;
-
-  meta_idle_monitor_remove_watch (watch->monitor, watch->watch_id);
-}
-
-static DBusWatch *
-make_dbus_watch (MetaDBusIdleMonitor   *skeleton,
-                 GDBusMethodInvocation *invocation,
-                 MetaIdleMonitor       *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,                  
-                       MetaIdleMonitor       *monitor)
-{
-  DBusWatch *watch;
-
-  watch = make_dbus_watch (skeleton, invocation, monitor);
-  watch->watch_id = meta_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,
-                              MetaIdleMonitor       *monitor)
-{
-  DBusWatch *watch;
-
-  watch = make_dbus_watch (skeleton, invocation, monitor);
-  watch->watch_id = meta_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,
-                     MetaIdleMonitor       *monitor)
-{
-  meta_idle_monitor_remove_watch (monitor, id);
-  meta_dbus_idle_monitor_complete_remove_watch (skeleton, invocation);
-
-  return TRUE;
-}
-
-static void
-on_device_added (ClutterDeviceManager     *device_manager,
-                 ClutterInputDevice       *device,
-                 GDBusObjectManagerServer *manager)
-{
-  MetaDBusIdleMonitor *skeleton;
-  MetaIdleMonitor *monitor;
-  MetaDBusObjectSkeleton *object;
-  int device_id;
-  gboolean is_core;
-  char *path;
-
-  is_core = clutter_input_device_get_device_mode (device) == CLUTTER_INPUT_MODE_MASTER;
-
-  if (is_core)
-    {
-      monitor = meta_idle_monitor_get_core ();
-      path = g_strdup ("/org/gnome/Mutter/IdleMonitor/Core");
-    }
-  else
-    {
-      device_id = clutter_input_device_get_device_id (device);
-      monitor = meta_idle_monitor_get_for_device (device_id);
-      path = g_strdup_printf ("/org/gnome/Mutter/IdleMonitor/Device%d", device_id);
-    }
-
-  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));
-}
-
-static void
-on_bus_acquired (GDBusConnection *connection,
-                 const char      *name,
-                 gpointer         user_data)
-{
-  GDBusObjectManagerServer *manager;
-  ClutterDeviceManager *device_manager;
-  GSList *devices, *iter;
-
-  manager = g_dbus_object_manager_server_new ("/org/gnome/Mutter/IdleMonitor");
-
-  device_manager = clutter_device_manager_get_default ();
-  devices = clutter_device_manager_list_devices (device_manager);
-
-  for (iter = devices; iter; iter = iter->next)
-    on_device_added (device_manager, iter->data, manager);
-
-  g_signal_connect_object (device_manager, "device-added",
-                           G_CALLBACK (on_device_added), manager, 0);
-
-  g_dbus_object_manager_server_set_connection (manager, g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL));
-}
-
-static void
-on_name_acquired (GDBusConnection *connection,
-                  const char      *name,
-                  gpointer         user_data)
-{
-  meta_topic (META_DEBUG_DBUS, "Acquired name %s\n", name);
-}
-
-static void
-on_name_lost (GDBusConnection *connection,
-              const char      *name,
-              gpointer         user_data)
-{
-  meta_topic (META_DEBUG_DBUS, "Lost or failed to acquire name %s\n", name);
-}
-
-void
-meta_idle_monitor_init_dbus (void)
-{
-  static int dbus_name_id;
-
-  if (dbus_name_id > 0)
-    return;
-
-  dbus_name_id = g_bus_own_name (G_BUS_TYPE_SESSION,
-                                 "org.gnome.Mutter.IdleMonitor",
-                                 G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
-                                 (meta_get_replace_current_wm () ?
-                                  G_BUS_NAME_OWNER_FLAGS_REPLACE : 0),
-                                 on_bus_acquired,
-                                 on_name_acquired,
-                                 on_name_lost,
-                                 NULL, NULL);
-}
-
--- a/src/core/monitor-config.c
+++ b/src/core/monitor-config.c
@@ -952,8 +952,6 @@ meta_monitor_config_apply_stored (MetaMonitorConfig  *self,
 * or failing that, an output that is good to be a primary (LVDS or eDP,
 * which are internal monitors), or failing that, the one with the
 * best resolution
- *
- * Input assertions: there is at least one output
 */
 static MetaOutput *
 find_primary_output (MetaOutput *outputs,
@@ -963,6 +961,8 @@ find_primary_output (MetaOutput *outputs,
  MetaOutput *best;
  int best_width, best_height;

+  g_assert (n_outputs >= 1);
+
  for (i = 0; i < n_outputs; i++)
    {
      if (outputs[i].is_primary)
@@ -1029,6 +1029,9 @@ make_default_config (MetaMonitorConfig *self,
     In the latter case, search for a configuration that includes one
     less screen, then add the new one as a presentation screen
     in preferred mode.
+
+     XXX: but presentation mode is not implemented in the control-center
+     or in mutter core, so let's do extended for now.
  */
  x = 0;
  y = 0;
@@ -1054,7 +1057,7 @@ make_default_config (MetaMonitorConfig *self,
                }
              else if (j > i)
                {
-                  g_assert (output_key_equal (&ret->keys[i], &ref->keys[j - 1]));
+                  g_assert (output_key_equal (&ret->keys[j], &ref->keys[j - 1]));
                  ret->outputs[j] = ref->outputs[j - 1];
                  x = MAX (x, ref->outputs[j - 1].rect.x + ref->outputs[j - 1].rect.width);
                  y = MAX (y, ref->outputs[j - 1].rect.y + ref->outputs[j - 1].rect.height);
@@ -1069,7 +1072,7 @@ make_default_config (MetaMonitorConfig *self,
                  ret->outputs[j].refresh_rate = outputs[0].preferred_mode->refresh_rate;
                  ret->outputs[j].transform = WL_OUTPUT_TRANSFORM_NORMAL;
                  ret->outputs[j].is_primary = FALSE;
-                  ret->outputs[j].is_presentation = TRUE;
+                  ret->outputs[j].is_presentation = FALSE;
                }
            }

@@ -1543,7 +1546,7 @@ crtc_assignment_assign (CrtcAssignment            *assign,
      return TRUE;
    }
  else
-    {	
+    {
      MetaCRTCInfo *info = g_slice_new0 (MetaCRTCInfo);

      info->crtc = crtc;
@@ -1555,7 +1558,7 @@ crtc_assignment_assign (CrtcAssignment            *assign,

      g_ptr_array_add (info->outputs, output);
      g_hash_table_insert (assign->info, crtc, info);
-	    
+
      return TRUE;
    }
 }
@@ -1653,15 +1656,28 @@ real_assign_crtcs (CrtcAssignment     *assignment,
          for (j = 0; j < n_modes; j++)
 	    {
              MetaMonitorMode *mode = &modes[j];
+              int width, height;

-              if (mode->width == output_config->rect.width &&
-                  mode->height == output_config->rect.height &&
+              if (meta_monitor_transform_is_rotated (output_config->transform))
+                {
+                  width = mode->height;
+                  height = mode->width;
+                }
+              else
+                {
+                  width = mode->width;
+                  height = mode->height;
+                }
+
+              if (width == output_config->rect.width &&
+                  height == output_config->rect.height &&
                  (pass == 1 || mode->refresh_rate == output_config->refresh_rate))
 		{
-                  meta_verbose ("CRTC %ld: trying mode %dx%d@%fHz with output at %dx%d@%fHz (pass %d)\n",
+                  meta_verbose ("CRTC %ld: trying mode %dx%d@%fHz with output at %dx%d@%fHz (transform %d) (pass %d)\n",
                                crtc->crtc_id,
                                mode->width, mode->height, mode->refresh_rate,
                                output_config->rect.width, output_config->rect.height, output_config->refresh_rate,
+                                output_config->transform,
                                pass);


--- a/src/core/monitor-kms.c
+++ b/src/core/monitor-kms.c
@@ -1,767 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* 
- * Copyright (C) 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.
- *
- * Author: Giovanni Campagna <gcampagn@redhat.com>
- */
-
-#include "config.h"
-
-#include <string.h>
-#include <stdlib.h>
-#include <clutter/clutter.h>
-
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#include <xf86drm.h>
-#include <xf86drmMode.h>
-
-#include <meta/main.h>
-#include <meta/errors.h>
-#include "monitor-private.h"
-
-#define ALL_WL_TRANSFORMS ((1 << (WL_OUTPUT_TRANSFORM_FLIPPED_270 + 1)) - 1)
-
-typedef struct {
-  drmModeConnector *connector;
-
-  unsigned n_encoders;
-  drmModeEncoderPtr *encoders;
-  drmModeEncoderPtr  current_encoder;
-
-  /* bitmasks of encoder position in the resources array */
-  uint32_t encoder_mask;
-  uint32_t enc_clone_mask;
-
-  uint32_t dpms_prop_id;
-} MetaOutputKms;
-
-struct _MetaMonitorManagerKms
-{
-  MetaMonitorManager parent_instance;
-
-  int fd;
-
-  drmModeConnector **connectors;
-  unsigned int       n_connectors;
-
-  drmModeEncoder   **encoders;
-  unsigned int       n_encoders;
-
-  drmModeEncoder    *current_encoder;
-};
-
-struct _MetaMonitorManagerKmsClass
-{
-  MetaMonitorManagerClass parent_class;
-};
-
-G_DEFINE_TYPE (MetaMonitorManagerKms, meta_monitor_manager_kms, META_TYPE_MONITOR_MANAGER);
-
-static int
-compare_outputs (const void *one,
-                 const void *two)
-{
-  const MetaOutput *o_one = one, *o_two = two;
-
-  return strcmp (o_one->name, o_two->name);
-}
-
-static char *
-make_output_name (drmModeConnector *connector)
-{
-  static const char * const connector_type_names[] = {
-    "unknown", "VGA", "DVII", "DVID", "DVID", "Composite",
-    "SVIDEO", "LVDS", "Component", "9PinDIN", "DisplayPort",
-    "HDMIA", "HDMIB", "TV", "eDP"
-  };
-  const char *connector_type_name;
-
-  if (connector->connector_type >= 0 &&
-      connector->connector_type < G_N_ELEMENTS (connector_type_names))
-    connector_type_name = connector_type_names[connector->connector_type];
-  else
-    connector_type_name = "unknown";
-
-  return g_strdup_printf ("%s%d", connector_type_name, connector->connector_id);
-}
-
-static void
-meta_output_destroy_notify (MetaOutput *output)
-{
-  MetaOutputKms *output_kms;
-  unsigned i;
-
-  output_kms = output->driver_private;
-
-  for (i = 0; i < output_kms->n_encoders; i++)
-    drmModeFreeEncoder (output_kms->encoders[i]);
-
-  g_slice_free (MetaOutputKms, output_kms);
-}
-
-static void
-meta_monitor_mode_destroy_notify (MetaMonitorMode *output)
-{
-  g_slice_free (drmModeModeInfo, output->driver_private);
-}
-
-static gboolean
-drm_mode_equal (gconstpointer one,
-                gconstpointer two)
-{
-  return memcmp (one, two, sizeof (drmModeModeInfo)) == 0;
-}
-
-static guint
-drm_mode_hash (gconstpointer ptr)
-{
-  const drmModeModeInfo *mode = ptr;
-  guint hash = 0;
-
-  hash ^= mode->clock;
-  hash ^= mode->hdisplay ^ mode->hsync_start ^ mode->hsync_end;
-  hash ^= mode->vdisplay ^ mode->vsync_start ^ mode->vsync_end;
-  hash ^= mode->vrefresh;
-  hash ^= mode->flags ^ mode->type;
-
-  return hash;
-}
-
-static void
-meta_monitor_manager_kms_read_current (MetaMonitorManager *manager)
-{
-  MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (manager);
-  drmModeRes *resources;
-  GHashTable *modes;
-  GHashTableIter iter;
-  drmModeModeInfo *mode;
-  unsigned int i, j, k;
-  unsigned int n_actual_outputs;
-  int width, height;
-
-  resources = drmModeGetResources(manager_kms->fd);
-  modes = g_hash_table_new (drm_mode_hash, drm_mode_equal);
-
-  manager->max_screen_width = resources->max_width;
-  manager->max_screen_height = resources->max_height;
-
-  manager->power_save_mode = META_POWER_SAVE_ON;
-
-  manager_kms->n_connectors = resources->count_connectors;
-  manager_kms->connectors = g_new (drmModeConnector *, manager_kms->n_connectors);
-  for (i = 0; i < manager_kms->n_connectors; i++)
-    {
-      drmModeConnector *connector;
-
-      connector = drmModeGetConnector (manager_kms->fd, resources->connectors[i]);
-      manager_kms->connectors[i] = connector;
-
-      if (connector->connection == DRM_MODE_CONNECTED)
-        {
-          /* Collect all modes for this connector */
-          for (j = 0; j < (unsigned)connector->count_modes; j++)
-            g_hash_table_add (modes, &connector->modes[j]);
-        }
-    }
-
-  manager_kms->n_encoders = resources->count_encoders;
-  manager_kms->encoders = g_new (drmModeEncoder *, manager_kms->n_encoders);
-  for (i = 0; i < manager_kms->n_encoders; i++)
-    {
-      manager_kms->encoders[i] = drmModeGetEncoder (manager_kms->fd,
-                                                    resources->encoders[i]);
-    }
-
-  manager->n_modes = g_hash_table_size (modes);
-  manager->modes = g_new0 (MetaMonitorMode, manager->n_modes);
-  g_hash_table_iter_init (&iter, modes);
-  i = 0;
-  while (g_hash_table_iter_next (&iter, NULL, (gpointer)&mode))
-    {
-      MetaMonitorMode *meta_mode;
-
-      meta_mode = &manager->modes[i];
-
-      meta_mode->mode_id = i;
-      meta_mode->name = g_strndup (mode->name, DRM_DISPLAY_MODE_LEN);
-      meta_mode->width = mode->hdisplay;
-      meta_mode->height = mode->vdisplay;
-      meta_mode->refresh_rate = (1000 * mode->clock /
-                                 ((float)mode->htotal * mode->vtotal));
-
-      meta_mode->driver_private = g_slice_dup (drmModeModeInfo, mode);
-      meta_mode->driver_notify = (GDestroyNotify)meta_monitor_mode_destroy_notify;
-
-      i++;
-    }
-  g_hash_table_destroy (modes);
-
-  manager->n_crtcs = resources->count_crtcs;
-  manager->crtcs = g_new0 (MetaCRTC, manager->n_crtcs);
-  width = 0; height = 0;
-  for (i = 0; i < (unsigned)resources->count_crtcs; i++)
-    {
-      drmModeCrtc *crtc;
-      MetaCRTC *meta_crtc;
-
-      crtc = drmModeGetCrtc (manager_kms->fd, resources->crtcs[i]);
-
-      meta_crtc = &manager->crtcs[i];
-
-      meta_crtc->crtc_id = crtc->crtc_id;
-      meta_crtc->rect.x = crtc->x;
-      meta_crtc->rect.y = crtc->y;
-      meta_crtc->rect.width = crtc->width;
-      meta_crtc->rect.height = crtc->height;
-      meta_crtc->dirty = FALSE;
-
-      /* FIXME: we can handle some transforms, with a combination of
-         scaling and fitting, but it is very driver dependent */
-      meta_crtc->transform = WL_OUTPUT_TRANSFORM_NORMAL;
-      meta_crtc->all_transforms = 1 << WL_OUTPUT_TRANSFORM_NORMAL;
-
-      if (crtc->mode_valid)
-        {
-          for (j = 0; j < manager->n_modes; j++)
-            {
-              if (drm_mode_equal (&crtc->mode, manager->modes[j].driver_private))
-                {
-                  meta_crtc->current_mode = &manager->modes[j];
-                  break;
-                }
-            }
-
-          width = MAX (width, meta_crtc->rect.x + meta_crtc->rect.width);
-          height = MAX (height, meta_crtc->rect.y + meta_crtc->rect.height);
-        }
-
-      drmModeFreeCrtc (crtc);
-    }
-
-  manager->screen_width = width;
-  manager->screen_height = height;
-
-  manager->outputs = g_new0 (MetaOutput, manager_kms->n_connectors);
-  n_actual_outputs = 0;
-
-  for (i = 0; i < manager_kms->n_connectors; i++)
-    {
-      MetaOutput *meta_output;
-      MetaOutputKms *output_kms;
-      drmModeConnector *connector;
-      GArray *crtcs;
-      unsigned int crtc_mask;
-
-      connector = manager_kms->connectors[i];
-      meta_output = &manager->outputs[n_actual_outputs];
-
-      if (connector->connection == DRM_MODE_CONNECTED)
-	{
-	  meta_output->output_id = connector->connector_id;
-	  meta_output->name = make_output_name (connector);
-	  meta_output->vendor = g_strdup ("unknown");
-	  meta_output->product = g_strdup ("unknown");
-	  meta_output->serial = g_strdup ("");
-	  meta_output->width_mm = connector->mmWidth;
-	  meta_output->height_mm = connector->mmHeight;
-
-          if (connector->subpixel == DRM_MODE_SUBPIXEL_UNKNOWN)
-            meta_output->subpixel_order = COGL_SUBPIXEL_ORDER_UNKNOWN;
-          else if (connector->subpixel == DRM_MODE_SUBPIXEL_NONE)
-            meta_output->subpixel_order = COGL_SUBPIXEL_ORDER_NONE;
-          else
-            meta_output->subpixel_order = connector->subpixel;
-
-	  meta_output->n_modes = connector->count_modes;
-	  meta_output->modes = g_new0 (MetaMonitorMode *, meta_output->n_modes);
-	  for (j = 0; j < meta_output->n_modes; j++)
-	    {
-	      for (k = 0; k < manager->n_modes; k++)
-		{
-		  if (drm_mode_equal (&connector->modes[j], manager->modes[k].driver_private))
-		    {
-		      meta_output->modes[j] = &manager->modes[k];
-		      break;
-		    }
-		}
-	    }
-	  meta_output->preferred_mode = meta_output->modes[0];
-
-          meta_output->driver_private = output_kms = g_slice_new0 (MetaOutputKms);
-          meta_output->driver_notify = (GDestroyNotify)meta_output_destroy_notify;
-
-          output_kms->connector = connector;
-          output_kms->n_encoders = connector->count_encoders;
-          output_kms->encoders = g_new0 (drmModeEncoderPtr, output_kms->n_encoders);
-
-          crtc_mask = 0x7F;
-	  for (j = 0; j < output_kms->n_encoders; j++)
-	    {
-              output_kms->encoders[j] = drmModeGetEncoder (manager_kms->fd, connector->encoders[j]);
-
-              crtc_mask &= output_kms->encoders[j]->possible_crtcs;
-
-              if (output_kms->encoders[j]->encoder_id == connector->encoder_id)
-                output_kms->current_encoder = output_kms->encoders[j];
-            }
-
-          crtcs = g_array_new (FALSE, FALSE, sizeof (MetaCRTC*));
-
-          for (j = 0; j < manager->n_crtcs; j++)
-            {
-              if (crtc_mask & (1 << j))
-                {
-                  MetaCRTC *crtc = &manager->crtcs[j];
-                  g_array_append_val (crtcs, crtc);
-		}
-	    }
-          
-	  meta_output->n_possible_crtcs = crtcs->len;
-	  meta_output->possible_crtcs = (void*)g_array_free (crtcs, FALSE);
-
-          if (output_kms->current_encoder && output_kms->current_encoder->crtc_id != 0)
-            {
-              for (j = 0; j < manager->n_crtcs; j++)
-                {
-                  if (manager->crtcs[j].crtc_id == output_kms->current_encoder->crtc_id)
-                    {
-                      meta_output->crtc = &manager->crtcs[j];
-                      break;
-                    }
-                }
-            }
-          else
-            meta_output->crtc = NULL;
-
-	  meta_output->is_primary = FALSE;
-	  meta_output->is_presentation = FALSE;
-
-          for (j = 0; j < (unsigned)connector->count_props; j++)
-            {
-              drmModePropertyPtr prop;
-
-              prop = drmModeGetProperty(manager_kms->fd, connector->props[j]);
-
-              if (prop)
-                {
-                  if ((prop->flags & DRM_MODE_PROP_ENUM) &&
-                      strcmp(prop->name, "DPMS") == 0)
-                    {
-                      output_kms->dpms_prop_id = prop->prop_id;
-                      drmModeFreeProperty(prop);
-                      break;
-                    }
-
-                  drmModeFreeProperty(prop);
-		}
-            }
-
-          /* FIXME: backlight is a very driver specific thing unfortunately,
-             every DDX does its own thing, and the dumb KMS API does not include it.
-
-             For example, xf86-video-intel has a list of paths to probe in /sys/class/backlight
-             (one for each major HW maker, and then some).
-             We can't do the same because we're not root.
-             It might be best to leave backlight out of the story and rely on the setuid
-             helper in gnome-settings-daemon.
-          */
-	  meta_output->backlight_min = 0;
-          meta_output->backlight_max = 0;
-          meta_output->backlight = -1;
-
-	  n_actual_outputs++;
-	}
-    }
-
-  manager->n_outputs = n_actual_outputs;
-  manager->outputs = g_renew (MetaOutput, manager->outputs, manager->n_outputs);
-
-  /* Sort the outputs for easier handling in MetaMonitorConfig */
-  qsort (manager->outputs, manager->n_outputs, sizeof (MetaOutput), compare_outputs);
-
-  /* Now fix the clones.
-     Code mostly inspired by xf86-video-modesetting. */
-
-  /* XXX: intel hardware doesn't usually have clones, but we only have intel
-     cards, so this code was never tested! */
-  for (i = 0; i < manager->n_outputs; i++)
-    {
-      MetaOutput *meta_output;
-      MetaOutputKms *output_kms;
-
-      meta_output = &manager->outputs[i];
-      output_kms = meta_output->driver_private;
-
-      output_kms->enc_clone_mask = 0xff;
-      output_kms->encoder_mask = 0;
-
-      for (j = 0; j < output_kms->n_encoders; j++)
-	{
-	  for (k = 0; k < manager_kms->n_encoders; k++)
-	    {
-	      if (output_kms->encoders[j]->encoder_id == manager_kms->encoders[k]->encoder_id)
-		{
-                  output_kms->encoder_mask |= (1 << k);
-		  break;
-		}
-	    }
-
-          output_kms->enc_clone_mask &= output_kms->encoders[j]->possible_clones;
-	}
-    }
-
-  for (i = 0; i < manager->n_outputs; i++)
-    {
-      MetaOutput *meta_output;
-      MetaOutputKms *output_kms;
-
-      meta_output = &manager->outputs[i];
-      output_kms = meta_output->driver_private;
-
-      if (output_kms->enc_clone_mask == 0)
-        continue;
-
-      for (j = 0; j < manager->n_outputs; j++)
-        {
-          MetaOutput *meta_clone;
-          MetaOutputKms *clone_kms;
-
-          meta_clone = &manager->outputs[i];
-          clone_kms = meta_clone->driver_private;
-
-          if (meta_clone == meta_output)
-            continue;
-
-          if (clone_kms->encoder_mask == 0)
-            continue;
-
-          if (clone_kms->encoder_mask == output_kms->enc_clone_mask)
-            {
-              meta_output->n_possible_clones++;
-              meta_output->possible_clones = g_renew (MetaOutput *,
-                                                      meta_output->possible_clones,
-                                                      meta_output->n_possible_clones);
-              meta_output->possible_clones[meta_output->n_possible_clones - 1] = meta_clone;
-            }
-        }
-    }
-
-  drmModeFreeResources (resources);
-}
-
-static void
-meta_monitor_manager_kms_set_power_save_mode (MetaMonitorManager *manager,
-                                              MetaPowerSave       mode)
-{
-  MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (manager);
-  uint64_t state;
-  unsigned i;
-
-  switch (mode) {
-  case META_POWER_SAVE_ON:
-    state = DRM_MODE_DPMS_ON;
-    break;
-  case META_POWER_SAVE_STANDBY:
-    state = DRM_MODE_DPMS_STANDBY;
-    break;
-  case META_POWER_SAVE_SUSPEND:
-    state = DRM_MODE_DPMS_SUSPEND;
-    break;
-  case META_POWER_SAVE_OFF:
-    state = DRM_MODE_DPMS_SUSPEND;
-    break;
-  default:
-    return;
-  }
-
-  for (i = 0; i < manager->n_outputs; i++)
-    {
-      MetaOutput *meta_output;
-      MetaOutputKms *output_kms;
-
-      meta_output = &manager->outputs[i];
-      output_kms = meta_output->driver_private;
-
-      if (output_kms->dpms_prop_id)
-        {
-          int ok = drmModeConnectorSetProperty(manager_kms->fd, meta_output->output_id,
-                                               output_kms->dpms_prop_id, state);
-
-          if (ok < 0)
-            meta_warning ("Failed to set power save mode for output %s: %s\n",
-                          meta_output->name, strerror (errno));
-        }
-    }
-}
-
-static void
-crtc_free (CoglKmsCrtc *crtc)
-{
-  g_free (crtc->connectors);
-  g_slice_free (CoglKmsCrtc, crtc);
-}
-
-static void
-meta_monitor_manager_kms_apply_configuration (MetaMonitorManager *manager,
-                                              MetaCRTCInfo       **crtcs,
-                                              unsigned int         n_crtcs,
-                                              MetaOutputInfo     **outputs,
-                                              unsigned int         n_outputs)
-{
-  ClutterBackend *backend;
-  CoglContext *cogl_context;
-  CoglDisplay *cogl_display;
-  unsigned i;
-  GList *cogl_crtcs;
-  int width, height;
-  gboolean ok;
-  GError *error;
-
-  cogl_crtcs = NULL;
-  width = 0; height = 0;
-  for (i = 0; i < n_crtcs; i++)
-    {
-      MetaCRTCInfo *crtc_info = crtcs[i];
-      MetaCRTC *crtc = crtc_info->crtc;
-      CoglKmsCrtc *cogl_crtc;
-
-      crtc->dirty = TRUE;
-
-      cogl_crtc = g_slice_new0 (CoglKmsCrtc);
-      cogl_crtcs = g_list_prepend (cogl_crtcs, cogl_crtc);
-
-      if (crtc_info->mode == NULL)
-        {
-          cogl_crtc->id = crtc->crtc_id;
-          cogl_crtc->x = 0;
-          cogl_crtc->y = 0;
-          cogl_crtc->count = 0;
-          memset (&cogl_crtc->mode, 0, sizeof (drmModeModeInfo));
-          cogl_crtc->connectors = NULL;
-          cogl_crtc->count = 0;
-
-          crtc->rect.x = 0;
-          crtc->rect.y = 0;
-          crtc->rect.width = 0;
-          crtc->rect.height = 0;
-          crtc->current_mode = NULL;
-        }
-      else
-        {
-          MetaMonitorMode *mode;
-          uint32_t *outputs;
-          unsigned int j, n_outputs;
-
-          mode = crtc_info->mode;
-
-          cogl_crtc->id = crtc->crtc_id;
-          cogl_crtc->x = crtc_info->x;
-          cogl_crtc->y = crtc_info->y;
-          cogl_crtc->count = n_outputs = crtc_info->outputs->len;
-          cogl_crtc->connectors = outputs = g_new (uint32_t, n_outputs);
-
-          for (j = 0; j < n_outputs; j++)
-            {
-              MetaOutput *output = ((MetaOutput**)crtc_info->outputs->pdata)[j];
-
-              outputs[j] = output->output_id;
-
-              output->dirty = TRUE;
-              output->crtc = crtc;
-            }
-
-          memcpy (&cogl_crtc->mode, crtc_info->mode->driver_private,
-                  sizeof (drmModeModeInfo));
-
-          width = MAX (width, crtc_info->x + crtc_info->mode->width);
-          height = MAX (height, crtc_info->y + crtc_info->mode->height);
-
-          crtc->rect.x = crtc_info->x;
-          crtc->rect.y = crtc_info->y;
-          crtc->rect.width = mode->width;
-          crtc->rect.height = mode->height;
-          crtc->current_mode = mode;
-          crtc->transform = crtc_info->transform;
-        }
-    }
-
-  /* Disable CRTCs not mentioned in the list */
-  for (i = 0; i < manager->n_crtcs; i++)
-    {
-      MetaCRTC *crtc = &manager->crtcs[i];
-      CoglKmsCrtc *cogl_crtc;
-
-      crtc->logical_monitor = NULL;
-
-      if (crtc->dirty)
-        {
-          crtc->dirty = FALSE;
-          continue;
-        }
-
-      cogl_crtc = g_slice_new0 (CoglKmsCrtc);
-      cogl_crtcs = g_list_prepend (cogl_crtcs, cogl_crtc);
-
-      cogl_crtc->id = crtc->crtc_id;
-      cogl_crtc->x = 0;
-      cogl_crtc->y = 0;
-      cogl_crtc->count = 0;
-      memset (&cogl_crtc->mode, 0, sizeof (drmModeModeInfo));
-      cogl_crtc->connectors = NULL;
-      cogl_crtc->count = 0;
-
-      crtc->rect.x = 0;
-      crtc->rect.y = 0;
-      crtc->rect.width = 0;
-      crtc->rect.height = 0;
-      crtc->current_mode = NULL;
-    }
-
-  backend = clutter_get_default_backend ();
-  cogl_context = clutter_backend_get_cogl_context (backend);
-  cogl_display = cogl_context_get_display (cogl_context);
-
-  error = NULL;
-  ok = cogl_kms_display_set_layout (cogl_display, width, height, cogl_crtcs, &error);
-  g_list_free_full (cogl_crtcs, (GDestroyNotify) crtc_free);
-
-  if (!ok)
-    {
-      meta_warning ("Applying display configuration failed: %s\n", error->message);
-      g_error_free (error);
-      return;
-    }
-
-  for (i = 0; i < n_outputs; i++)
-    {
-      MetaOutputInfo *output_info = outputs[i];
-      MetaOutput *output = output_info->output;
-
-      output->is_primary = output_info->is_primary;
-      output->is_presentation = output_info->is_presentation;
-    }
-
-  /* Disable outputs not mentioned in the list */
-  for (i = 0; i < manager->n_outputs; i++)
-    {
-      MetaOutput *output = &manager->outputs[i];
-
-      if (output->dirty)
-        {
-          output->dirty = FALSE;
-          continue;
-        }
-
-      output->crtc = NULL;
-      output->is_primary = FALSE;
-    }
-
-  manager->screen_width = width;
-  manager->screen_height = height;
-
-  meta_monitor_manager_rebuild_derived (manager);
-}
-
-static void
-meta_monitor_manager_kms_get_crtc_gamma (MetaMonitorManager  *manager,
-                                         MetaCRTC            *crtc,
-                                         gsize               *size,
-                                         unsigned short     **red,
-                                         unsigned short     **green,
-                                         unsigned short     **blue)
-{
-  MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (manager);
-  drmModeCrtc *kms_crtc;
-
-  kms_crtc = drmModeGetCrtc (manager_kms->fd, crtc->crtc_id);
-
-  *size = kms_crtc->gamma_size;
-  *red = g_new (unsigned short, *size);
-  *green = g_new (unsigned short, *size);
-  *blue = g_new (unsigned short, *size);
-
-  drmModeCrtcGetGamma (manager_kms->fd, crtc->crtc_id, *size, *red, *green, *blue);
-
-  drmModeFreeCrtc (kms_crtc);
-}
-
-static void
-meta_monitor_manager_kms_set_crtc_gamma (MetaMonitorManager *manager,
-                                         MetaCRTC           *crtc,
-                                         gsize               size,
-                                         unsigned short     *red,
-                                         unsigned short     *green,
-                                         unsigned short     *blue)
-{
-  MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (manager);
-
-  drmModeCrtcSetGamma (manager_kms->fd, crtc->crtc_id, size, red, green, blue);
-}
-
-static void
-meta_monitor_manager_kms_init (MetaMonitorManagerKms *manager_kms)
-{
-  ClutterBackend *backend;
-  CoglContext *cogl_context;
-  CoglDisplay *cogl_display;
-  CoglRenderer *cogl_renderer;
-
-  backend = clutter_get_default_backend ();
-  cogl_context = clutter_backend_get_cogl_context (backend);
-  cogl_display = cogl_context_get_display (cogl_context);
-  cogl_renderer = cogl_display_get_renderer (cogl_display);
-
-  manager_kms->fd = cogl_kms_renderer_get_kms_fd (cogl_renderer);
-}
-
-static void
-meta_monitor_manager_kms_finalize (GObject *object)
-{
-  MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (object);
-  unsigned i;
-
-  for (i = 0; i < manager_kms->n_encoders; i++)
-    drmModeFreeEncoder (manager_kms->encoders[i]);
-  for (i = 0; i < manager_kms->n_connectors; i++)
-    drmModeFreeConnector (manager_kms->connectors[i]);
-
-  g_free (manager_kms->encoders);
-  g_free (manager_kms->connectors);
-
-  G_OBJECT_CLASS (meta_monitor_manager_kms_parent_class)->finalize (object);
-}
-
-static void
-meta_monitor_manager_kms_class_init (MetaMonitorManagerKmsClass *klass)
-{
-  MetaMonitorManagerClass *manager_class = META_MONITOR_MANAGER_CLASS (klass);
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = meta_monitor_manager_kms_finalize;
-
-  manager_class->read_current = meta_monitor_manager_kms_read_current;
-  manager_class->apply_configuration = meta_monitor_manager_kms_apply_configuration;
-  manager_class->set_power_save_mode = meta_monitor_manager_kms_set_power_save_mode;
-  manager_class->get_crtc_gamma = meta_monitor_manager_kms_get_crtc_gamma;
-  manager_class->set_crtc_gamma = meta_monitor_manager_kms_set_crtc_gamma;
-}
-
--- a/src/core/monitor-private.h
+++ b/src/core/monitor-private.h
@@ -38,6 +38,7 @@
 #define META_MONITOR_PRIVATE_H

 #include <cogl/cogl.h>
+#include <libgnome-desktop/gnome-pnp-ids.h>

 #include "display-private.h"
 #include <meta/screen.h>
@@ -115,9 +116,6 @@ struct _MetaOutput
  */
  gboolean is_primary;
  gboolean is_presentation;
-
-  gpointer driver_private;
-  GDestroyNotify driver_notify;
 };

 struct _MetaCRTC
@@ -141,14 +139,10 @@ struct _MetaMonitorMode
 {
  /* The low-level ID of this mode, used to apply back configuration */
  glong mode_id;
-  char *name;

  int width;
  int height;
  float refresh_rate;
-
-  gpointer driver_private;
-  GDestroyNotify driver_notify;
 };

 /**
@@ -171,8 +165,7 @@ struct _MetaMonitorInfo
  gboolean in_fullscreen;

  /* The primary or first output for this monitor, 0 if we can't figure out.
-     This is a XID when using XRandR, otherwise a KMS id (not implemented).
-     In any case, it can be matched to an output_id of a MetaOutput.
+     It can be matched to an output_id of a MetaOutput.

     This is used as an opaque token on reconfiguration when switching from
     clone to extened, to decide on what output the windows should go next
@@ -258,6 +251,8 @@ struct _MetaMonitorManager

  int persistent_timeout_id;
  MetaMonitorConfig *config;
+
+  GnomePnpIds *pnp_ids;
 };

 struct _MetaMonitorManagerClass
@@ -306,15 +301,6 @@ GType meta_monitor_manager_get_type (void);
 void                meta_monitor_manager_initialize (void);
 MetaMonitorManager *meta_monitor_manager_get  (void);

-void                meta_monitor_manager_init_dbus         (MetaMonitorManager *manager,
-                                                            GAsyncReadyCallback callback,
-                                                            gpointer            user_data);
-gboolean            meta_monitor_manager_init_dbus_finish  (MetaMonitorManager *manager,
-                                                            GAsyncResult       *result,
-                                                            GError            **error);
-
-void                meta_monitor_manager_rebuild_derived   (MetaMonitorManager *manager);
-
 MetaMonitorInfo    *meta_monitor_manager_get_monitor_infos (MetaMonitorManager *manager,
 							    unsigned int       *n_infos);

@@ -363,18 +349,6 @@ typedef struct _MetaMonitorManagerXrandr         MetaMonitorManagerXrandr;

 GType meta_monitor_manager_xrandr_get_type (void);

-#define META_TYPE_MONITOR_MANAGER_KMS            (meta_monitor_manager_kms_get_type ())
-#define META_MONITOR_MANAGER_KMS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_MONITOR_MANAGER_KMS, MetaMonitorManagerKms))
-#define META_MONITOR_MANAGER_KMS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_MONITOR_MANAGER_KMS, MetaMonitorManagerKmsClass))
-#define META_IS_MONITOR_MANAGER_KMS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_MONITOR_MANAGER_KMS))
-#define META_IS_MONITOR_MANAGER_KMS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_MONITOR_MANAGER_KMS))
-#define META_MONITOR_MANAGER_KMS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_MONITOR_MANAGER_KMS, MetaMonitorManagerKmsClass))
-
-typedef struct _MetaMonitorManagerKmsClass    MetaMonitorManagerKmsClass;
-typedef struct _MetaMonitorManagerKms         MetaMonitorManagerKms;
-
-GType meta_monitor_manager_kms_get_type (void);
-
 #define META_TYPE_MONITOR_CONFIG            (meta_monitor_config_get_type ())
 #define META_MONITOR_CONFIG(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_MONITOR_CONFIG, MetaMonitorConfig))
 #define META_MONITOR_CONFIG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_MONITOR_CONFIG, MetaMonitorConfigClass))
@@ -405,4 +379,12 @@ void               meta_monitor_config_restore_previous (MetaMonitorConfig  *con
 void               meta_crtc_info_free   (MetaCRTCInfo   *info);
 void               meta_output_info_free (MetaOutputInfo *info);

+/* Returns true if transform causes width and height to be inverted
+   This is true for the odd transforms in the enum */
+static inline gboolean
+meta_monitor_transform_is_rotated (enum wl_output_transform transform)
+{
+  return (transform % 2);
+}
+
 #endif
--- a/src/core/monitor-xrandr.c
+++ b/src/core/monitor-xrandr.c
@@ -29,6 +29,7 @@

 #include <string.h>
 #include <stdlib.h>
+#include <math.h>
 #include <clutter/clutter.h>

 #include <X11/Xatom.h>
@@ -39,8 +40,15 @@
 #include <meta/errors.h>
 #include "monitor-private.h"

+#include "edid.h"
+
 #define ALL_WL_TRANSFORMS ((1 << (WL_OUTPUT_TRANSFORM_FLIPPED_270 + 1)) - 1)

+/* Look for DPI_FALLBACK in:
+ * http://git.gnome.org/browse/gnome-settings-daemon/tree/plugins/xsettings/gsd-xsettings-manager.c
+ * for the reasoning */
+#define DPI_FALLBACK 96.0
+
 struct _MetaMonitorManagerXrandr
 {
  MetaMonitorManager parent_instance;
@@ -235,6 +243,74 @@ compare_outputs (const void *one,
  return strcmp (o_one->name, o_two->name);
 }

+static guint8 *
+get_edid_property (Display  *dpy,
+                   RROutput  output,
+                   Atom      atom,
+                   gsize    *len)
+{
+  unsigned char *prop;
+  int actual_format;
+  unsigned long nitems, bytes_after;
+  Atom actual_type;
+  guint8 *result;
+
+  XRRGetOutputProperty (dpy, output, atom,
+                        0, 100, False, False,
+                        AnyPropertyType,
+                        &actual_type, &actual_format,
+                        &nitems, &bytes_after, &prop);
+
+  if (actual_type == XA_INTEGER && actual_format == 8)
+    {
+      result = g_memdup (prop, nitems);
+      if (len)
+        *len = nitems;
+    }
+  else
+    {
+      result = NULL;
+    }
+
+  XFree (prop);
+    
+  return result;
+}
+
+static GBytes *
+read_output_edid (MetaMonitorManagerXrandr *manager_xrandr,
+                  XID                       output_id)
+{
+  Atom edid_atom;
+  guint8 *result;
+  gsize len;
+
+  edid_atom = XInternAtom (manager_xrandr->xdisplay, "EDID", FALSE);
+  result = get_edid_property (manager_xrandr->xdisplay, output_id, edid_atom, &len);
+
+  if (!result)
+    {
+      edid_atom = XInternAtom (manager_xrandr->xdisplay, "EDID_DATA", FALSE);
+      result = get_edid_property (manager_xrandr->xdisplay, output_id, edid_atom, &len);
+    }
+
+  if (!result)
+    {
+      edid_atom = XInternAtom (manager_xrandr->xdisplay, "XFree86_DDC_EDID1_RAWDATA", FALSE);
+      result = get_edid_property (manager_xrandr->xdisplay, output_id, edid_atom, &len);
+    }
+
+  if (result)
+    {
+      if (len > 0 && len % 128 == 0)
+        return g_bytes_new_take (result, len);
+      else
+        g_free (result);
+    }
+
+  return NULL;
+}
+
 static void
 meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
 {
@@ -364,11 +440,36 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)

      if (output->connection != RR_Disconnected)
 	{
+          GBytes *edid;
+          MonitorInfo *parsed_edid;
+
 	  meta_output->output_id = resources->outputs[i];
 	  meta_output->name = g_strdup (output->name);
-	  meta_output->vendor = g_strdup ("unknown");
-	  meta_output->product = g_strdup ("unknown");
-	  meta_output->serial = g_strdup ("");
+
+          edid = read_output_edid (manager_xrandr, meta_output->output_id);
+          if (edid)
+            {
+              gsize len;
+
+              parsed_edid = decode_edid (g_bytes_get_data (edid, &len));
+              if (parsed_edid)
+                {
+                  meta_output->vendor = g_strndup (parsed_edid->manufacturer_code, 4);
+                  meta_output->product = g_strndup (parsed_edid->dsc_product_name, 14);
+                  meta_output->serial = g_strndup (parsed_edid->dsc_serial_number, 14);
+
+                  g_free (parsed_edid);
+                }
+
+              g_bytes_unref (edid);
+            }
+
+          if (!meta_output->vendor)
+            {
+              meta_output->vendor = g_strdup ("unknown");
+              meta_output->product = g_strdup ("unknown");
+              meta_output->serial = g_strdup ("unknown");
+            }
 	  meta_output->width_mm = output->mm_width;
 	  meta_output->height_mm = output->mm_height;
 	  meta_output->subpixel_order = COGL_SUBPIXEL_ORDER_UNKNOWN;
@@ -466,73 +567,13 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
    }
 }

-static guint8 *
-get_edid_property (Display  *dpy,
-                   RROutput  output,
-                   Atom      atom,
-                   gsize    *len)
-{
-  unsigned char *prop;
-  int actual_format;
-  unsigned long nitems, bytes_after;
-  Atom actual_type;
-  guint8 *result;
-
-  XRRGetOutputProperty (dpy, output, atom,
-                        0, 100, False, False,
-                        AnyPropertyType,
-                        &actual_type, &actual_format,
-                        &nitems, &bytes_after, &prop);
-
-  if (actual_type == XA_INTEGER && actual_format == 8)
-    {
-      result = g_memdup (prop, nitems);
-      if (len)
-        *len = nitems;
-    }
-  else
-    {
-      result = NULL;
-    }
-
-  XFree (prop);
-    
-  return result;
-}
-
 static GBytes *
 meta_monitor_manager_xrandr_read_edid (MetaMonitorManager *manager,
                                       MetaOutput         *output)
 {
  MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
-  Atom edid_atom;
-  guint8 *result;
-  gsize len;

-  edid_atom = XInternAtom (manager_xrandr->xdisplay, "EDID", FALSE);
-  result = get_edid_property (manager_xrandr->xdisplay, output->output_id, edid_atom, &len);
-
-  if (!result)
-    {
-      edid_atom = XInternAtom (manager_xrandr->xdisplay, "EDID_DATA", FALSE);
-      result = get_edid_property (manager_xrandr->xdisplay, output->output_id, edid_atom, &len);
-    }
-
-  if (!result)
-    {
-      edid_atom = XInternAtom (manager_xrandr->xdisplay, "XFree86_DDC_EDID1_RAWDATA", FALSE);
-      result = get_edid_property (manager_xrandr->xdisplay, output->output_id, edid_atom, &len);
-    }
-
-  if (result)
-    {
-      if (len > 0 && len % 128 == 0)
-        return g_bytes_new_take (result, len);
-      else
-        g_free (result);
-    }
-
-  return NULL;
+  return read_output_edid (manager_xrandr, output->output_id);
 }

 static void
@@ -615,9 +656,12 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
 {
  MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
  unsigned i;
+  int width, height, width_mm, height_mm;

  meta_display_grab (meta_get_display ());

+  /* First compute the new size of the screen (framebuffer) */
+  width = 0; height = 0;
  for (i = 0; i < n_crtcs; i++)
    {
      MetaCRTCInfo *crtc_info = crtcs[i];
@@ -625,6 +669,33 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
      crtc->dirty = TRUE;

      if (crtc_info->mode == NULL)
+        continue;
+
+      if (meta_monitor_transform_is_rotated (crtc_info->transform))
+        {
+          width = MAX (width, crtc_info->x + crtc_info->mode->height);
+          height = MAX (height, crtc_info->y + crtc_info->mode->width);
+        }
+      else
+        {
+          width = MAX (width, crtc_info->x + crtc_info->mode->width);
+          height = MAX (height, crtc_info->y + crtc_info->mode->height);
+        }
+    }
+
+  /* Second disable all newly disabled CRTCs, or CRTCs that in the previous
+     configuration would be outside the new framebuffer (otherwise X complains
+     loudly when resizing)
+     CRTC will be enabled again after resizing the FB
+  */
+  for (i = 0; i < n_crtcs; i++)
+    {
+      MetaCRTCInfo *crtc_info = crtcs[i];
+      MetaCRTC *crtc = crtc_info->crtc;
+
+      if (crtc_info->mode == NULL ||
+          crtc->rect.x + crtc->rect.width > width ||
+          crtc->rect.y + crtc->rect.height > height)
        {
          XRRSetCrtcConfig (manager_xrandr->xdisplay,
                            manager_xrandr->resources,
@@ -635,7 +706,51 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
                            RR_Rotate_0,
                            NULL, 0);
        }
-      else
+    }
+
+  /* Disable CRTCs not mentioned in the list */
+  for (i = 0; i < manager->n_crtcs; i++)
+    {
+      MetaCRTC *crtc = &manager->crtcs[i];
+
+      if (crtc->dirty)
+        {
+          crtc->dirty = FALSE;
+          continue;
+        }
+      if (crtc->current_mode == NULL)
+        continue;
+
+      XRRSetCrtcConfig (manager_xrandr->xdisplay,
+                        manager_xrandr->resources,
+                        (XID)crtc->crtc_id,
+                        manager_xrandr->time,
+                        0, 0,
+                        None,
+                        RR_Rotate_0,
+                        NULL, 0);
+    }
+
+  g_assert (width > 0 && height > 0);
+  /* The 'physical size' of an X screen is meaningless if that screen
+   * can consist of many monitors. So just pick a size that make the
+   * dpi 96.
+   *
+   * Firefox and Evince apparently believe what X tells them.
+   */
+  width_mm = (width / DPI_FALLBACK) * 25.4 + 0.5;
+  height_mm = (height / DPI_FALLBACK) * 25.4 + 0.5;
+  meta_error_trap_push (meta_get_display ());
+  XRRSetScreenSize (manager_xrandr->xdisplay, DefaultRootWindow (manager_xrandr->xdisplay),
+                    width, height, width_mm, height_mm);
+  meta_error_trap_pop (meta_get_display ());
+
+  for (i = 0; i < n_crtcs; i++)
+    {
+      MetaCRTCInfo *crtc_info = crtcs[i];
+      MetaCRTC *crtc = crtc_info->crtc;
+
+      if (crtc_info->mode != NULL)
        {
          MetaMonitorMode *mode;
          XID *outputs;
@@ -663,7 +778,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,

          if (ok != Success)
            meta_warning ("Configuring CRTC %d with mode %d (%d x %d @ %f) at position %d, %d and transfrom %u failed\n",
-                          (unsigned)(crtc - manager->crtcs), (unsigned)(mode - manager->modes),
+                          (unsigned)(crtc->crtc_id), (unsigned)(mode->mode_id),
                          mode->width, mode->height, (float)mode->refresh_rate,
                          crtc_info->x, crtc_info->y, crtc_info->transform);

@@ -687,29 +802,6 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
                                      output_info->is_presentation);
    }

-  /* Disable CRTCs not mentioned in the list */
-  for (i = 0; i < manager->n_crtcs; i++)
-    {
-      MetaCRTC *crtc = &manager->crtcs[i];
-
-      if (crtc->dirty)
-        {
-          crtc->dirty = FALSE;
-          continue;
-        }
-      if (crtc->current_mode == NULL)
-        continue;
-
-      XRRSetCrtcConfig (manager_xrandr->xdisplay,
-                        manager_xrandr->resources,
-                        (XID)crtc->crtc_id,
-                        manager_xrandr->time,
-                        0, 0,
-                        None,
-                        RR_Rotate_0,
-                        NULL, 0);
-    }
-
  meta_display_ungrab (meta_get_display ());
 }

--- a/src/core/monitor.c
+++ b/src/core/monitor.c
@@ -1,4 +1,4 @@
-	/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */

 /* 
 * Copyright (C) 2001, 2002 Havoc Pennington
@@ -28,13 +28,14 @@
 #include "config.h"

 #include <string.h>
+#include <math.h>
 #include <stdlib.h>
 #include <clutter/clutter.h>

 #include <meta/main.h>
+#include <meta/util.h>
 #include <meta/errors.h>
 #include "monitor-private.h"
-#include "meta-wayland-private.h"

 #include "meta-dbus-xrandr.h"

@@ -61,8 +62,8 @@ G_DEFINE_TYPE_WITH_CODE (MetaMonitorManager, meta_monitor_manager, META_DBUS_TYP

 static void free_output_array (MetaOutput *old_outputs,
                               int         n_old_outputs);
-static void free_mode_array (MetaMonitorMode *old_modes,
-                             int              n_old_modes);
+static void invalidate_logical_config (MetaMonitorManager *manager);
+static void initialize_dbus_interface (MetaMonitorManager *manager);

 static void
 read_current_dummy (MetaMonitorManager *manager)
@@ -266,18 +267,30 @@ apply_config_dummy (MetaMonitorManager *manager,
          MetaMonitorMode *mode;
          MetaOutput *output;
          int i, n_outputs;
+          int width, height;

          mode = crtc_info->mode;

+          if (meta_monitor_transform_is_rotated (crtc_info->transform))
+            {
+              width = mode->height;
+              height = mode->width;
+            }
+          else
+            {
+              width = mode->width;
+              height = mode->height;
+            }
+
          crtc->rect.x = crtc_info->x;
          crtc->rect.y = crtc_info->y;
-          crtc->rect.width = mode->width;
-          crtc->rect.height = mode->height;
+          crtc->rect.width = width;
+          crtc->rect.height = height;
          crtc->current_mode = mode;
          crtc->transform = crtc_info->transform;

-          screen_width = MAX (screen_width, crtc_info->x + mode->width);
-          screen_height = MAX (screen_height, crtc_info->y + mode->height);
+          screen_width = MAX (screen_width, crtc_info->x + width);
+          screen_height = MAX (screen_height, crtc_info->y + height);

          n_outputs = crtc_info->outputs->len;
          for (i = 0; i < n_outputs; i++)
@@ -337,7 +350,7 @@ apply_config_dummy (MetaMonitorManager *manager,
  manager->screen_width = screen_width;
  manager->screen_height = screen_height;

-  meta_monitor_manager_rebuild_derived (manager);
+  invalidate_logical_config (manager);
 }

 static GBytes *
@@ -471,21 +484,7 @@ meta_monitor_manager_new (void)
  env = g_getenv ("META_DEBUG_MULTIMONITOR");

  if (env == NULL)
-    {
-      if (meta_is_wayland_compositor ())
-        {
-          MetaWaylandCompositor *compositor;
-
-          compositor = meta_wayland_compositor_get_default ();
-
-          if (meta_wayland_compositor_is_native (compositor))
-            type = META_TYPE_MONITOR_MANAGER_KMS;
-          else
-            type = META_TYPE_MONITOR_MANAGER;
-        }
-      else
-        type = META_TYPE_MONITOR_MANAGER_XRANDR;
-    }
+    type = META_TYPE_MONITOR_MANAGER_XRANDR;
  else if (strcmp (env, "xrandr") == 0)
    type = META_TYPE_MONITOR_MANAGER_XRANDR;
  else
@@ -520,22 +519,22 @@ meta_monitor_manager_constructed (GObject *object)
      MetaOutput *old_outputs;
      MetaCRTC *old_crtcs;
      MetaMonitorMode *old_modes;
-      unsigned int n_old_outputs, n_old_modes;
+      int n_old_outputs;

      old_outputs = manager->outputs;
      n_old_outputs = manager->n_outputs;
      old_modes = manager->modes;
-      n_old_modes = manager->n_modes;
      old_crtcs = manager->crtcs;

      read_current_config (manager);

      free_output_array (old_outputs, n_old_outputs);
-      free_mode_array (old_modes, n_old_modes);
+      g_free (old_modes);
      g_free (old_crtcs);
    }

  make_logical_config (manager);
+  initialize_dbus_interface (manager);

  manager->in_init = FALSE;
 }
@@ -575,39 +574,19 @@ free_output_array (MetaOutput *old_outputs,
      g_free (old_outputs[i].modes);
      g_free (old_outputs[i].possible_crtcs);
      g_free (old_outputs[i].possible_clones);
-
-      if (old_outputs[i].driver_notify)
-        old_outputs[i].driver_notify (&old_outputs[i]);
    }

  g_free (old_outputs);
 }

-static void
-free_mode_array (MetaMonitorMode *old_modes,
-                 int              n_old_modes)
-{
-  int i;
-
-  for (i = 0; i < n_old_modes; i++)
-    {
-      g_free (old_modes[i].name);
-
-      if (old_modes[i].driver_notify)
-        old_modes[i].driver_notify (&old_modes[i]);
-    }
-
-  g_free (old_modes);
-}
-
 static void
 meta_monitor_manager_finalize (GObject *object)
 {
  MetaMonitorManager *manager = META_MONITOR_MANAGER (object);

  free_output_array (manager->outputs, manager->n_outputs);
-  free_mode_array (manager->modes, manager->n_modes);
  g_free (manager->monitor_infos);
+  g_free (manager->modes);
  g_free (manager->crtcs);

  G_OBJECT_CLASS (meta_monitor_manager_parent_class)->finalize (object);
@@ -677,9 +656,9 @@ meta_monitor_manager_class_init (MetaMonitorManagerClass *klass)
  object_class->finalize = meta_monitor_manager_finalize;

  klass->read_current = read_current_dummy;
-  klass->read_edid = read_edid_dummy;
-  klass->get_edid_file = get_edid_file_dummy;
  klass->apply_configuration = apply_config_dummy;
+  klass->get_edid_file = get_edid_file_dummy;
+  klass->read_edid = read_edid_dummy;

  signals[MONITORS_CHANGED] =
    g_signal_new ("monitors-changed",
@@ -724,16 +703,41 @@ diagonal_to_str (double d)
 }

 static char *
-make_display_name (MetaOutput *output)
+make_display_name (MetaMonitorManager *manager,
+                   MetaOutput         *output)
 {
+  if (g_str_has_prefix (output->name, "LVDS") ||
+      g_str_has_prefix (output->name, "eDP"))
+    return g_strdup (_("Built-in display"));
+
  if (output->width_mm != -1 && output->height_mm != -1)
    {
      double d = sqrt (output->width_mm * output->width_mm +
                       output->height_mm * output->height_mm);
      char *inches = diagonal_to_str (d / 25.4);
+      char *vendor_name;
      char *ret;

-      ret = g_strdup_printf ("%s %s", output->vendor, inches);
+      if (g_strcmp0 (output->vendor, "unknown") != 0)
+        {
+          if (!manager->pnp_ids)
+            manager->pnp_ids = gnome_pnp_ids_new ();
+
+          vendor_name = gnome_pnp_ids_get_pnp_id (manager->pnp_ids,
+                                                  output->vendor);
+
+          ret = g_strdup_printf ("%s %s", vendor_name, inches);
+
+          g_free (vendor_name);
+        }
+      else
+        {
+          /* TRANSLATORS: this is a monitor name (in case we don't know
+             the vendor), it's Unknown followed by a size in inches,
+             like 'Unknown 15"'
+          */
+          ret = g_strdup_printf (_("Unknown %s"), inches);
+        }

      g_free (inches);
      return ret;
@@ -810,7 +814,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
      g_variant_builder_add (&properties, "{sv}", "serial",
                             g_variant_new_string (output->serial));
      g_variant_builder_add (&properties, "{sv}", "display-name",
-                             g_variant_new_take_string (make_display_name (output)));
+                             g_variant_new_take_string (make_display_name (manager, output)));
      g_variant_builder_add (&properties, "{sv}", "backlight",
                             g_variant_new_int32 (output->backlight));
      g_variant_builder_add (&properties, "{sv}", "primary",
@@ -978,7 +982,7 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto
      crtc_info = g_slice_new (MetaCRTCInfo);
      crtc_info->outputs = g_ptr_array_new ();

-      if (crtc_id < 0 || crtc_id >= manager->n_crtcs)
+      if (crtc_id >= manager->n_crtcs)
        {
          g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
                                                 G_DBUS_ERROR_INVALID_ARGS,
@@ -1000,10 +1004,23 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto

      if (mode)
        {
+          int width, height;
+
+          if (meta_monitor_transform_is_rotated (transform))
+            {
+              width = mode->height;
+              height = mode->width;
+            }
+          else
+            {
+              width = mode->width;
+              height = mode->height;
+            }
+
          if (x < 0 ||
-              x + mode->width > manager->max_screen_width ||
+              x + width > manager->max_screen_width ||
              y < 0 ||
-              y + mode->height > manager->max_screen_height)
+              y + height > manager->max_screen_height)
            {
              g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
                                                     G_DBUS_ERROR_INVALID_ARGS,
@@ -1011,8 +1028,8 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto
              return TRUE;
            }

-          new_screen_width = MAX (new_screen_width, x + mode->width);
-          new_screen_height = MAX (new_screen_height, y + mode->height);
+          new_screen_width = MAX (new_screen_width, x + width);
+          new_screen_height = MAX (new_screen_height, y + height);
          crtc_info->x = x;
          crtc_info->y = y;
        }
@@ -1023,7 +1040,8 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto
        }

      if (transform < WL_OUTPUT_TRANSFORM_NORMAL ||
-          transform > WL_OUTPUT_TRANSFORM_FLIPPED_270)
+          transform > WL_OUTPUT_TRANSFORM_FLIPPED_270 ||
+          ((crtc->all_transforms & (1 << transform)) == 0))
        {
          g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
                                                 G_DBUS_ERROR_INVALID_ARGS,
@@ -1037,7 +1055,7 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto
        {
          MetaOutput *output;

-          if (output_id < 0 || output_id >= manager->n_outputs)
+          if (output_id >= manager->n_outputs)
            {
              g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
                                                     G_DBUS_ERROR_INVALID_ARGS,
@@ -1094,7 +1112,7 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto
      MetaOutputInfo *output_info;
      gboolean primary, presentation;

-      if (output_id < 0 || output_id >= manager->n_outputs)
+      if (output_id >= manager->n_outputs)
        {
          g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
                                                 G_DBUS_ERROR_INVALID_ARGS,
@@ -1187,7 +1205,7 @@ meta_monitor_manager_handle_change_backlight  (MetaDBusDisplayConfig *skeleton,
      return TRUE;
    }

-  if (output_id < 0 || output_id >= manager->n_outputs)
+  if (output_id >= manager->n_outputs)
    {
      g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
                                             G_DBUS_ERROR_INVALID_ARGS,
@@ -1243,7 +1261,7 @@ meta_monitor_manager_handle_get_crtc_gamma  (MetaDBusDisplayConfig *skeleton,
      return TRUE;
    }

-  if (crtc_id < 0 || crtc_id >= manager->n_crtcs)
+  if (crtc_id >= manager->n_crtcs)
    {
      g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
                                             G_DBUS_ERROR_INVALID_ARGS,
@@ -1305,7 +1323,7 @@ meta_monitor_manager_handle_set_crtc_gamma  (MetaDBusDisplayConfig *skeleton,
      return TRUE;
    }

-  if (crtc_id < 0 || crtc_id >= manager->n_crtcs)
+  if (crtc_id >= manager->n_crtcs)
    {
      g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
                                             G_DBUS_ERROR_INVALID_ARGS,
@@ -1351,8 +1369,7 @@ on_bus_acquired (GDBusConnection *connection,
                 const char      *name,
                 gpointer         user_data)
 {
-  GTask *task = user_data;
-  MetaMonitorManager *manager = g_task_get_task_data (task);
+  MetaMonitorManager *manager = user_data;

  g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (manager),
                                    connection,
@@ -1365,11 +1382,7 @@ on_name_acquired (GDBusConnection *connection,
                  const char      *name,
                  gpointer         user_data)
 {
-  GTask *task = user_data;
-
  meta_topic (META_DEBUG_DBUS, "Acquired name %s\n", name);
-
-  g_task_return_boolean (task, TRUE);
 }

 static void
@@ -1380,14 +1393,9 @@ on_name_lost (GDBusConnection *connection,
  meta_topic (META_DEBUG_DBUS, "Lost or failed to acquire name %s\n", name);
 }

-void
-meta_monitor_manager_init_dbus (MetaMonitorManager   *manager,
-                                GAsyncReadyCallback   callback,
-                                gpointer              user_data)
+static void
+initialize_dbus_interface (MetaMonitorManager *manager)
 {
-  GTask *task = g_task_new (manager, NULL, callback, user_data);
-  g_task_set_task_data (task, g_object_ref (manager), g_object_unref);
-
  manager->dbus_name_id = g_bus_own_name (G_BUS_TYPE_SESSION,
                                          "org.gnome.Mutter.DisplayConfig",
                                          G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
@@ -1396,32 +1404,24 @@ meta_monitor_manager_init_dbus (MetaMonitorManager   *manager,
                                          on_bus_acquired,
                                          on_name_acquired,
                                          on_name_lost,
-                                          task,
+                                          g_object_ref (manager),
                                          g_object_unref);
 }

-gboolean
-meta_monitor_manager_init_dbus_finish (MetaMonitorManager  *manager,
-                                       GAsyncResult        *result,
-                                       GError             **error)
-{
-  return g_task_propagate_boolean (G_TASK (result), error);
-}
-
-static MetaMonitorManager *global_manager;
+static MetaMonitorManager *global_monitor_manager;

 void
 meta_monitor_manager_initialize (void)
 {
-  global_manager = meta_monitor_manager_new ();
+  global_monitor_manager = meta_monitor_manager_new ();
 }

 MetaMonitorManager *
 meta_monitor_manager_get (void)
 {
-  g_assert (global_manager != NULL);
+  g_assert (global_monitor_manager != NULL);

-  return global_manager;
+  return global_monitor_manager;
 }

 MetaMonitorInfo *
@@ -1481,8 +1481,8 @@ meta_monitor_manager_get_screen_limits (MetaMonitorManager *manager,
  *height = manager->max_screen_height;
 }

-void
-meta_monitor_manager_rebuild_derived (MetaMonitorManager *manager)
+static void
+invalidate_logical_config (MetaMonitorManager *manager)
 {
  MetaMonitorInfo *old_monitor_infos;

@@ -1506,7 +1506,7 @@ meta_monitor_manager_handle_xevent (MetaMonitorManager *manager,
  MetaOutput *old_outputs;
  MetaCRTC *old_crtcs;
  MetaMonitorMode *old_modes;
-  unsigned int n_old_outputs, n_old_modes;
+  int n_old_outputs;
  gboolean changed;

  klass = META_MONITOR_MANAGER_GET_CLASS (manager);
@@ -1522,7 +1522,6 @@ meta_monitor_manager_handle_xevent (MetaMonitorManager *manager,
  old_outputs = manager->outputs;
  n_old_outputs = manager->n_outputs;
  old_modes = manager->modes;
-  n_old_modes = manager->n_modes;
  old_crtcs = manager->crtcs;

  read_current_config (manager);
@@ -1537,7 +1536,7 @@ meta_monitor_manager_handle_xevent (MetaMonitorManager *manager,
  */
  if (meta_monitor_config_match_current (manager->config, manager))
    {
-      meta_monitor_manager_rebuild_derived (manager);
+      invalidate_logical_config (manager);
    }
  else
    {
@@ -1546,7 +1545,7 @@ meta_monitor_manager_handle_xevent (MetaMonitorManager *manager,
    }

  free_output_array (old_outputs, n_old_outputs);
-  free_mode_array (old_modes, n_old_modes);
+  g_free (old_modes);
  g_free (old_crtcs);

  return TRUE;
--- a/src/core/mutter.c
+++ b/src/core/mutter.c
@@ -46,15 +46,8 @@ print_version (const gchar    *option_name,
 }

 static gchar *plugin = "default";
-static gboolean opt_nested = FALSE;

 GOptionEntry mutter_options[] = {
-  {
-    "nested", 0, 0, G_OPTION_ARG_NONE,
-    &opt_nested,
-    N_("Run nested as an application for testing"),
-    NULL,
-  },
  {
    "version", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
    print_version,
@@ -84,8 +77,6 @@ main (int argc, char **argv)
      exit (1);
    }

-  meta_set_is_wayland_compositor (opt_nested);
-
  if (plugin)
    meta_plugin_manager_load (plugin);

--- a/src/core/screen-private.h
+++ b/src/core/screen-private.h
@@ -83,7 +83,6 @@ struct _MetaScreen
  MetaStack *stack;
  MetaStackTracker *stack_tracker;

-  MetaCursorTracker *cursor_tracker;
  MetaCursor current_cursor;

  Window flash_window;
@@ -245,14 +244,9 @@ void     meta_screen_workspace_switched (MetaScreen         *screen,

 void meta_screen_set_active_workspace_hint (MetaScreen *screen);

-Window   meta_screen_create_guard_window (Display *xdisplay, MetaScreen *screen);
-
 int meta_screen_xinerama_index_to_monitor_index (MetaScreen *screen,
                                                 int         index);
 int meta_screen_monitor_index_to_xinerama_index (MetaScreen *screen,
                                                 int         index);

-gboolean meta_screen_handle_xevent (MetaScreen *screen,
-                                    XEvent     *xevent);
-
 #endif
--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -45,11 +45,6 @@
 #include <meta/compositor.h>
 #include "mutter-enum-types.h"
 #include "core.h"
-#ifdef HAVE_WAYLAND
-#include "meta-wayland-private.h"
-#endif
-#include "meta-cursor-tracker-private.h"
-#include "meta-idle-monitor-private.h"

 #include <X11/extensions/Xinerama.h>

@@ -450,13 +445,12 @@ reload_monitor_infos (MetaScreen *screen)
 * should effectively be forwarded to events on the background actor,
 * providing that the scene graph is set up correctly.
 */
-Window
-meta_screen_create_guard_window (Display *xdisplay, MetaScreen *screen)
+static Window
+create_guard_window (Display *xdisplay, MetaScreen *screen)
 {
  XSetWindowAttributes attributes;
  Window guard_window;
  gulong create_serial;
-  MetaStackWindow stack_window;
  
  attributes.event_mask = NoEventMask;
  attributes.override_redirect = True;
@@ -489,14 +483,12 @@ meta_screen_create_guard_window (Display *xdisplay, MetaScreen *screen)
    XISelectEvents (xdisplay, guard_window, &mask, 1);
  }

-  stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
-  stack_window.x11.xwindow = guard_window;
  meta_stack_tracker_record_add (screen->stack_tracker,
-                                 &stack_window,
+                                 guard_window,
                                 create_serial);

  meta_stack_tracker_record_lower (screen->stack_tracker,
-                                   &stack_window,
+                                   guard_window,
                                   XNextRequest (xdisplay));
  XLowerWindow (xdisplay, guard_window);
  XMapWindow (xdisplay, guard_window);
@@ -678,10 +670,7 @@ meta_screen_new (MetaDisplay *display,
  screen->xroot = xroot;
  screen->rect.x = screen->rect.y = 0;
  
-#ifdef HAVE_WAYLAND
-  if (!meta_is_wayland_compositor ())
-#endif
-    meta_monitor_manager_initialize ();
+  meta_monitor_manager_initialize ();

  manager = meta_monitor_manager_get ();
  g_signal_connect (manager, "monitors-changed",
@@ -691,12 +680,6 @@ meta_screen_new (MetaDisplay *display,
                                        &screen->rect.width,
                                        &screen->rect.height);

-#ifdef HAVE_WAYLAND
-  if (!meta_is_wayland_compositor ())
-#endif
-    meta_monitor_manager_init_dbus (manager, NULL, NULL);
-  meta_idle_monitor_init_dbus ();
-
  screen->current_cursor = -1; /* invalid/unset */
  screen->default_xvisual = DefaultVisualOfScreen (screen->xscreen);
  screen->default_depth = DefaultDepthOfScreen (screen->xscreen);
@@ -723,7 +706,6 @@ meta_screen_new (MetaDisplay *display,

  reload_monitor_infos (screen);
  
-  meta_cursor_tracker_get_for_screen (screen);  
  meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);

  /* Handle creating a no_focus_window for this screen */  
@@ -948,8 +930,8 @@ meta_screen_manage_all_windows (MetaScreen *screen)
  meta_display_grab (screen->display);

  if (screen->guard_window == None)
-    screen->guard_window =
-      meta_screen_create_guard_window (screen->display->xdisplay, screen);
+    screen->guard_window = create_guard_window (screen->display->xdisplay,
+                                                screen);

  windows = list_windows (screen);

@@ -1479,18 +1461,29 @@ void
 meta_screen_set_cursor (MetaScreen *screen,
                        MetaCursor  cursor)
 {
+  Cursor xcursor;
+
  if (cursor == screen->current_cursor)
    return;

  screen->current_cursor = cursor;
-  meta_cursor_tracker_set_root_cursor (screen->cursor_tracker, cursor);
+  
+  xcursor = meta_display_create_x_cursor (screen->display, cursor);
+  XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
+  XFlush (screen->display->xdisplay);
+  XFreeCursor (screen->display->xdisplay, xcursor);
 }

 void
 meta_screen_update_cursor (MetaScreen *screen)
 {
-  meta_cursor_tracker_set_root_cursor (screen->cursor_tracker,
-                                       screen->current_cursor);
+  Cursor xcursor;
+
+  xcursor = meta_display_create_x_cursor (screen->display, 
+					  screen->current_cursor);
+  XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
+  XFlush (screen->display->xdisplay);
+  XFreeCursor (screen->display->xdisplay, xcursor);
 }

 void
@@ -1753,15 +1746,12 @@ meta_screen_tile_preview_update_timeout (gpointer data)
    {
      Window xwindow;
      gulong create_serial;
-      MetaStackWindow stack_window;

      screen->tile_preview = meta_tile_preview_new (screen->number);
      xwindow = meta_tile_preview_get_xwindow (screen->tile_preview,
                                               &create_serial);
-      stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
-      stack_window.x11.xwindow = xwindow;
      meta_stack_tracker_record_add (screen->stack_tracker,
-                                     &stack_window,
+                                     xwindow,
                                     create_serial);
    }

@@ -2884,9 +2874,10 @@ on_monitors_changed (MetaMonitorManager *manager,
                       &changes);
    }

-  meta_compositor_sync_screen_size (screen->display->compositor,
-                                    screen,
-                                    screen->rect.width, screen->rect.height);
+  if (screen->display->compositor)
+    meta_compositor_sync_screen_size (screen->display->compositor,
+				      screen,
+                                      screen->rect.width, screen->rect.height);

  /* Queue a resize on all the windows */
  meta_screen_foreach_window (screen, meta_screen_resize_func, 0);
@@ -3697,13 +3688,3 @@ meta_screen_get_monitor_in_fullscreen (MetaScreen  *screen,
  /* We use -1 as a flag to mean "not known yet" for notification purposes */
  return screen->monitor_infos[monitor].in_fullscreen == TRUE;
 }
-
-gboolean
-meta_screen_handle_xevent (MetaScreen *screen,
-                           XEvent     *xevent)
-{
-  if (meta_cursor_tracker_handle_xevent (screen->cursor_tracker, xevent))
-    return TRUE;
-
-  return FALSE;
-}
--- a/src/core/stack-tracker.c
+++ b/src/core/stack-tracker.c
--- a/src/core/stack-tracker.h
+++ b/src/core/stack-tracker.h
@@ -37,55 +37,36 @@
 #define META_STACK_TRACKER_H

 #include <meta/screen.h>
-#include <meta/window.h>

 typedef struct _MetaStackTracker MetaStackTracker;

-typedef union _MetaStackWindow
-{
-  struct {
-    MetaWindowClientType type;
-  } any;
-  struct {
-    MetaWindowClientType type;
-    Window xwindow;
-  } x11;
-  struct {
-    MetaWindowClientType type;
-    MetaWindow *meta_window;
-  } wayland;
-} MetaStackWindow;
-
-gboolean meta_stack_window_equal (const MetaStackWindow *a,
-                                  const MetaStackWindow *b);
-
 MetaStackTracker *meta_stack_tracker_new  (MetaScreen       *screen);
 void              meta_stack_tracker_free (MetaStackTracker *tracker);

 /* These functions are called when we make an X call that changes the
 * stacking order; this allows MetaStackTracker to predict stacking
 * order before it receives events back from the X server */
-void meta_stack_tracker_record_add             (MetaStackTracker      *tracker,
-                                                const MetaStackWindow *window,
-                                                gulong                 serial);
-void meta_stack_tracker_record_remove          (MetaStackTracker      *tracker,
-                                                const MetaStackWindow *window,
-                                                gulong                 serial);
-void meta_stack_tracker_record_restack_windows (MetaStackTracker      *tracker,
-                                                const MetaStackWindow *windows,
-						int                    n_windows,
-                                                gulong                 serial);
-void meta_stack_tracker_record_raise_above     (MetaStackTracker      *tracker,
-                                                const MetaStackWindow *window,
-                                                const MetaStackWindow *sibling,
-                                                gulong                 serial);
-void meta_stack_tracker_record_lower_below    (MetaStackTracker       *tracker,
-                                               const MetaStackWindow  *window,
-                                               const MetaStackWindow  *sibling,
-                                               gulong                  serial);
-void meta_stack_tracker_record_lower           (MetaStackTracker      *tracker,
-                                                const MetaStackWindow *window,
-                                                gulong                 serial);
+void meta_stack_tracker_record_add             (MetaStackTracker *tracker,
+						Window            window,
+                                                gulong            serial);
+void meta_stack_tracker_record_remove          (MetaStackTracker *tracker,
+						Window            window,
+                                                gulong            serial);
+void meta_stack_tracker_record_restack_windows (MetaStackTracker *tracker,
+						Window           *windows,
+						int               n_windows,
+                                                gulong            serial);
+void meta_stack_tracker_record_raise_above     (MetaStackTracker *tracker,
+						Window            window,
+						Window            sibling,
+                                                gulong            serial);
+void meta_stack_tracker_record_lower_below    (MetaStackTracker *tracker,
+						Window            window,
+						Window            sibling,
+                                                gulong            serial);
+void meta_stack_tracker_record_lower           (MetaStackTracker *tracker,
+						Window            window,
+                                                gulong            serial);

 /* These functions are used to update the stack when we get events
 * reflecting changes to the stacking order */
@@ -98,9 +79,9 @@ void meta_stack_tracker_reparent_event  (MetaStackTracker    *tracker,
 void meta_stack_tracker_configure_event (MetaStackTracker    *tracker,
 					 XConfigureEvent     *event);

-void meta_stack_tracker_get_stack  (MetaStackTracker      *tracker,
-                                    MetaStackWindow      **windows,
-                                    int                   *n_entries);
+void meta_stack_tracker_get_stack  (MetaStackTracker  *tracker,
+                                    Window           **windows,
+                                    int               *n_windows);

 void meta_stack_tracker_sync_stack       (MetaStackTracker *tracker);
 void meta_stack_tracker_queue_sync_stack (MetaStackTracker *tracker);
--- a/src/core/stack.c
+++ b/src/core/stack.c
@@ -52,7 +52,7 @@

 #define WINDOW_IN_STACK(w) (w->stack_position >= 0)

-static void stack_sync_to_xserver (MetaStack *stack);
+static void stack_sync_to_server (MetaStack *stack);
 static void meta_window_set_stack_position_no_sync (MetaWindow *window,
                                                    int         position);
 static void stack_do_window_deletions (MetaStack *stack);
@@ -71,14 +71,14 @@ meta_stack_new (MetaScreen *screen)
  stack = g_new (MetaStack, 1);

  stack->screen = screen;
-  stack->xwindows = g_array_new (FALSE, FALSE, sizeof (Window));
+  stack->windows = g_array_new (FALSE, FALSE, sizeof (Window));

  stack->sorted = NULL;
  stack->added = NULL;
  stack->removed = NULL;

  stack->freeze_count = 0;
-  stack->last_all_root_children_stacked = NULL;
+  stack->last_root_children_stacked = NULL;

  stack->n_positions = 0;

@@ -89,34 +89,17 @@ meta_stack_new (MetaScreen *screen)
  return stack;
 }

-static void
-free_last_all_root_children_stacked_cache (MetaStack *stack)
-{
-  unsigned int i;
-
-  for (i = 0; i < stack->last_all_root_children_stacked->len; i++)
-    {
-      MetaStackWindow *window = &g_array_index (stack->last_all_root_children_stacked, MetaStackWindow, i);
-      if (window->any.type == META_WINDOW_CLIENT_TYPE_WAYLAND)
-        g_object_remove_weak_pointer (G_OBJECT (window->wayland.meta_window),
-                                      (gpointer *)&window->wayland.meta_window);
-    }
-
-  g_array_free (stack->last_all_root_children_stacked, TRUE);
-  stack->last_all_root_children_stacked = NULL;
-}
-
 void
 meta_stack_free (MetaStack *stack)
 {
-  g_array_free (stack->xwindows, TRUE);
+  g_array_free (stack->windows, TRUE);

  g_list_free (stack->sorted);
  g_list_free (stack->added);
  g_list_free (stack->removed);

-  if (stack->last_all_root_children_stacked)
-    free_last_all_root_children_stacked_cache (stack);
+  if (stack->last_root_children_stacked)
+    g_array_free (stack->last_root_children_stacked, TRUE);
  
  g_free (stack);
 }
@@ -138,7 +121,7 @@ meta_stack_add (MetaStack  *stack,
              "Window %s has stack_position initialized to %d\n",
              window->desc, window->stack_position);
  
-  stack_sync_to_xserver (stack);
+  stack_sync_to_server (stack);
  meta_stack_update_window_tile_matches (stack, window->screen->active_workspace);
 }

@@ -174,7 +157,7 @@ meta_stack_remove (MetaStack  *stack,
    stack->removed = g_list_prepend (stack->removed,
                                     GUINT_TO_POINTER (window->frame->xwindow));
  
-  stack_sync_to_xserver (stack);
+  stack_sync_to_server (stack);
  meta_stack_update_window_tile_matches (stack, window->screen->active_workspace);
 }

@@ -184,7 +167,7 @@ meta_stack_update_layer (MetaStack  *stack,
 {
  stack->need_relayer = TRUE;
  
-  stack_sync_to_xserver (stack);
+  stack_sync_to_server (stack);
  meta_stack_update_window_tile_matches (stack, window->screen->active_workspace);
 }

@@ -194,7 +177,7 @@ meta_stack_update_transient (MetaStack  *stack,
 {
  stack->need_constrain = TRUE;
  
-  stack_sync_to_xserver (stack);
+  stack_sync_to_server (stack);
  meta_stack_update_window_tile_matches (stack, window->screen->active_workspace);
 }

@@ -223,7 +206,7 @@ meta_stack_raise (MetaStack  *stack,

  meta_window_set_stack_position_no_sync (window, max_stack_position);

-  stack_sync_to_xserver (stack);
+  stack_sync_to_server (stack);
  meta_stack_update_window_tile_matches (stack, window->screen->active_workspace);
 }

@@ -251,7 +234,7 @@ meta_stack_lower (MetaStack  *stack,

  meta_window_set_stack_position_no_sync (window, min_stack_position);
  
-  stack_sync_to_xserver (stack);
+  stack_sync_to_server (stack);
  meta_stack_update_window_tile_matches (stack, window->screen->active_workspace);
 }

@@ -267,7 +250,7 @@ meta_stack_thaw (MetaStack *stack)
  g_return_if_fail (stack->freeze_count > 0);
  
  stack->freeze_count -= 1;
-  stack_sync_to_xserver (stack);
+  stack_sync_to_server (stack);
  meta_stack_update_window_tile_matches (stack, NULL);
 }

@@ -846,7 +829,7 @@ stack_do_window_deletions (MetaStack *stack)
      /* We go from the end figuring removals are more
       * likely to be recent.
       */
-      i = stack->xwindows->len;
+      i = stack->windows->len;
      while (i > 0)
        {
          --i;
@@ -857,9 +840,9 @@ stack_do_window_deletions (MetaStack *stack)
           * both the window->xwindow and window->frame->xwindow
           * in the removal list.
           */
-          if (xwindow == g_array_index (stack->xwindows, Window, i))
+          if (xwindow == g_array_index (stack->windows, Window, i))
            {
-              g_array_remove_index (stack->xwindows, i);
+              g_array_remove_index (stack->windows, i);
              goto next;
            }
        }
@@ -888,10 +871,10 @@ stack_do_window_additions (MetaStack *stack)
                  "Adding %d windows to sorted list\n",
                  n_added);
      
-      old_size = stack->xwindows->len;
-      g_array_set_size (stack->xwindows, old_size + n_added);
+      old_size = stack->windows->len;
+      g_array_set_size (stack->windows, old_size + n_added);
      
-      end = &g_array_index (stack->xwindows, Window, old_size);
+      end = &g_array_index (stack->windows, Window, old_size);

      /* stack->added has the most recent additions at the
       * front of the list, so we need to reverse it
@@ -1046,102 +1029,6 @@ stack_ensure_sorted (MetaStack *stack)
  stack_do_resort (stack);
 }

-static MetaStackWindow *
-find_top_most_managed_window (MetaScreen *screen,
-                              const MetaStackWindow *ignore)
-{
-  MetaStackTracker *stack_tracker = screen->stack_tracker;
-  MetaStackWindow *windows;
-  int n_windows;
-  int i;
-
-  meta_stack_tracker_get_stack (stack_tracker,
-                                &windows, &n_windows);
-
-  /* Children are in order from bottom to top. We want to
-   * find the topmost managed child, then configure
-   * our window to be above it.
-   */
-  for (i = n_windows -1; i >= 0; i--)
-    {
-      MetaStackWindow *other_window = &windows[i];
-
-      if (other_window->any.type == ignore->any.type &&
-          ((other_window->any.type == META_WINDOW_CLIENT_TYPE_X11 &&
-            other_window->x11.xwindow == ignore->x11.xwindow) ||
-           other_window->wayland.meta_window == ignore->wayland.meta_window))
-        {
-          /* Do nothing. This means we're already the topmost managed
-           * window, but it DOES NOT mean we are already just above
-           * the topmost managed window. This is important because if
-           * an override redirect window is up, and we map a new
-           * managed window, the new window is probably above the old
-           * popup by default, and we want to push it below that
-           * popup. So keep looking for a sibling managed window
-           * to be moved below.
-           */
-        }
-      else
-        {
-          if (other_window->any.type == META_WINDOW_CLIENT_TYPE_X11)
-            {
-              MetaWindow *other = meta_display_lookup_x_window (screen->display,
-                                                                other_window->x11.xwindow);
-
-              if (other != NULL && !other->override_redirect)
-                return other_window;
-            }
-          else
-            {
-              /* All wayland windows are currently considered "managed"
-               * TODO: consider wayland pop-up windows like override
-               * redirect windows here. */
-              return other_window;
-            }
-        }
-    }
-
-  return NULL;
-}
-
-/* When moving an X window we sometimes need an X based sibling.
- *
- * If the given sibling is X based this function returns it back
- * otherwise it searches downwards looking for the nearest X window.
- *
- * If no X based sibling could be found return NULL. */
-static MetaStackWindow *
-find_x11_sibling_downwards (MetaScreen *screen,
-                            MetaStackWindow *sibling)
-{
-  MetaStackTracker *stack_tracker = screen->stack_tracker;
-  MetaStackWindow *windows;
-  int n_windows;
-  int i;
-
-  if (sibling->any.type == META_WINDOW_CLIENT_TYPE_X11)
-    return sibling;
-
-  meta_stack_tracker_get_stack (stack_tracker,
-                                &windows, &n_windows);
-
-  /* NB: Children are in order from bottom to top and we
-   * want to search downwards for the nearest X window.
-   */
-
-  for (i = n_windows - 1; i >= 0; i--)
-    if (meta_stack_window_equal (&windows[i], sibling))
-      break;
-
-  for (; i >= 0; i--)
-    {
-      if (windows[i].any.type == META_WINDOW_CLIENT_TYPE_X11)
-        return &windows[i];
-    }
-
-  return NULL;
-}
-
 /**
 * raise_window_relative_to_managed_windows:
 *
@@ -1166,74 +1053,84 @@ find_x11_sibling_downwards (MetaScreen *screen,
 */
 static void
 raise_window_relative_to_managed_windows (MetaScreen *screen,
-                                          const MetaStackWindow *window)
+                                          Window      xwindow)
 {
-  gulong serial = 0;
-  MetaStackWindow *sibling;

-  sibling = find_top_most_managed_window (screen, window);
-  if (!sibling)
+  Window *children;
+  int n_children;
+  int i;
+
+  meta_stack_tracker_get_stack (screen->stack_tracker,
+                                &children, &n_children);
+
+  /* Children are in order from bottom to top. We want to
+   * find the topmost managed child, then configure
+   * our window to be above it.
+   */
+  i = n_children - 1;
+  while (i >= 0)
    {
-      if (window->any.type == META_WINDOW_CLIENT_TYPE_X11)
+      if (children[i] == xwindow)
        {
-          serial = XNextRequest (screen->display->xdisplay);
-          meta_error_trap_push (screen->display);
-          XLowerWindow (screen->display->xdisplay,
-                        window->x11.xwindow);
-          meta_error_trap_pop (screen->display);
-        }
-
-      /* No sibling to use, just lower ourselves to the bottom
-       * to be sure we're below any override redirect windows.
+          /* Do nothing. This means we're already the topmost managed
+           * window, but it DOES NOT mean we are already just above
+           * the topmost managed window. This is important because if
+           * an override redirect window is up, and we map a new
+           * managed window, the new window is probably above the old
+           * popup by default, and we want to push it below that
+           * popup. So keep looking for a sibling managed window
+           * to be moved below.
           */
-      meta_stack_tracker_record_lower (screen->stack_tracker,
-                                       window,
-                                       serial);
-      return;
        }
+      else
+        {
+          MetaWindow *other = meta_display_lookup_x_window (screen->display,
+                                                            children[i]);
+          if (other != NULL && !other->override_redirect)
+            {
+              XWindowChanges changes;

-  /* window is the topmost managed child */
+              /* children[i] is the topmost managed child */
              meta_topic (META_DEBUG_STACK,
                          "Moving 0x%lx above topmost managed child window 0x%lx\n",
-              window->any.type == META_WINDOW_CLIENT_TYPE_X11 ? window->x11.xwindow: 0,
-              sibling->any.type == META_WINDOW_CLIENT_TYPE_X11 ? sibling->x11.xwindow: 0);
+                          xwindow, children[i]);

-  if (window->any.type == META_WINDOW_CLIENT_TYPE_X11)
-    {
-      XWindowChanges changes;
-      MetaStackWindow *x11_sibling = find_x11_sibling_downwards (screen, sibling);
-      serial = XNextRequest (screen->display->xdisplay);
-
-      if (x11_sibling)
-        {
-          changes.sibling = x11_sibling->x11.xwindow;
+              changes.sibling = children[i];
              changes.stack_mode = Above;

              meta_error_trap_push (screen->display);
+              meta_stack_tracker_record_raise_above (screen->stack_tracker,
+                                                     xwindow,
+                                                     children[i],
+                                                     XNextRequest (screen->display->xdisplay));
              XConfigureWindow (screen->display->xdisplay,
-                            window->x11.xwindow,
+                                xwindow,
                                CWSibling | CWStackMode,
                                &changes);
              meta_error_trap_pop (screen->display);
+
+              break;
+            }
        }
-      else
+
+      --i;
+    }
+
+  if (i < 0)
    {
      /* No sibling to use, just lower ourselves to the bottom
       * to be sure we're below any override redirect windows.
       */
      meta_error_trap_push (screen->display);
+      meta_stack_tracker_record_lower (screen->stack_tracker,
+                                       xwindow,
+                                       XNextRequest (screen->display->xdisplay));
      XLowerWindow (screen->display->xdisplay,
-                        window->x11.xwindow);
+                    xwindow);
      meta_error_trap_pop (screen->display);
    }
 }

-  meta_stack_tracker_record_raise_above (screen->stack_tracker,
-                                         window,
-                                         sibling,
-                                         serial);
-}
-
 /**
 * stack_sync_to_server:
 *
@@ -1248,16 +1145,13 @@ raise_window_relative_to_managed_windows (MetaScreen *screen,
 * job of computing the minimal set of stacking requests needed.
 */
 static void
-stack_sync_to_xserver (MetaStack *stack)
+stack_sync_to_server (MetaStack *stack)
 {
-  GArray *x11_stacked;
-  GArray *x11_root_children_stacked;
-  GArray *all_root_children_stacked; /* wayland OR x11 */
+  GArray *stacked;
+  GArray *root_children_stacked;
  GList *tmp;
-  GArray *x11_hidden;
-  GArray *x11_hidden_stack_windows;
+  GArray *all_hidden;
  int n_override_redirect = 0;
-  MetaStackWindow guard_stack_window;
  
  /* Bail out if frozen */
  if (stack->freeze_count > 0)
@@ -1272,17 +1166,13 @@ stack_sync_to_xserver (MetaStack *stack)
   * _NET hints, and "root_children_stacked" is in top-to-bottom
   * order for XRestackWindows()
   */
-  x11_stacked = g_array_new (FALSE, FALSE, sizeof (Window));
-
-  all_root_children_stacked = g_array_new (FALSE, FALSE, sizeof (MetaStackWindow));
-  x11_root_children_stacked = g_array_new (FALSE, FALSE, sizeof (Window));
-
-  x11_hidden_stack_windows = g_array_new (FALSE, FALSE, sizeof (MetaStackWindow));
-  x11_hidden = g_array_new (FALSE, FALSE, sizeof (Window));
+  stacked = g_array_new (FALSE, FALSE, sizeof (Window));
+  root_children_stacked = g_array_new (FALSE, FALSE, sizeof (Window));
+  all_hidden = g_array_new (FALSE, FALSE, sizeof (Window));

  /* The screen guard window sits above all hidden windows and acts as
   * a barrier to input reaching these windows. */
-  g_array_append_val (x11_hidden, stack->screen->guard_window);
+  g_array_append_val (all_hidden, stack->screen->guard_window);

  meta_topic (META_DEBUG_STACK, "Top to bottom: ");
  meta_push_no_msg_prefix ();
@@ -1291,9 +1181,6 @@ stack_sync_to_xserver (MetaStack *stack)
    {
      MetaWindow *w = tmp->data;
      Window top_level_window;
-      MetaStackWindow stack_window;
-
-      stack_window.any.type = w->client_type;
      
      meta_topic (META_DEBUG_STACK, "%u:%d - %s ",
 		  w->layer, w->stack_position, w->desc);
@@ -1302,93 +1189,60 @@ stack_sync_to_xserver (MetaStack *stack)
      if (w->override_redirect)
 	n_override_redirect++;
      else
-	g_array_prepend_val (x11_stacked, w->xwindow);
+	g_array_prepend_val (stacked, w->xwindow);
      
      if (w->frame)
 	top_level_window = w->frame->xwindow;
      else
 	top_level_window = w->xwindow;

-      if (w->client_type == META_WINDOW_CLIENT_TYPE_X11)
-        stack_window.x11.xwindow = top_level_window;
-      else
-        stack_window.wayland.meta_window = w;
-
      /* We don't restack hidden windows along with the rest, though they are
       * reflected in the _NET hints. Hidden windows all get pushed below
       * the screens fullscreen guard_window. */
      if (w->hidden)
 	{
-          if (w->client_type == META_WINDOW_CLIENT_TYPE_X11)
-            {
-              MetaStackWindow stack_window;
-
-              stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
-              stack_window.x11.xwindow = top_level_window;
-
-              g_array_append_val (x11_hidden_stack_windows, stack_window);
-              g_array_append_val (x11_hidden, top_level_window);
-            }
+	  g_array_append_val (all_hidden, top_level_window);
 	  continue;
 	}

-      g_array_append_val (all_root_children_stacked, stack_window);
-
      /* build XRestackWindows() array from top to bottom */
-      if (w->client_type == META_WINDOW_CLIENT_TYPE_X11)
-        g_array_append_val (x11_root_children_stacked, top_level_window);
-      else
-        {
-          MetaStackWindow *new;
-
-          /* So we can determine later if a cached stack window is
-           * stale because the corresponding window has been freed we
-           * associate a weak pointer with the new window. */
-          new = &g_array_index (all_root_children_stacked, MetaStackWindow, all_root_children_stacked->len - 1);
-          g_object_add_weak_pointer (G_OBJECT (new->wayland.meta_window),
-                                     (gpointer *)&new->wayland.meta_window);
-        }
+      g_array_append_val (root_children_stacked, top_level_window);
    }

  meta_topic (META_DEBUG_STACK, "\n");
  meta_pop_no_msg_prefix ();

-  /* All X windows should be in some stacking order */
-  if (x11_stacked->len != stack->xwindows->len - n_override_redirect)
+  /* All windows should be in some stacking order */
+  if (stacked->len != stack->windows->len - n_override_redirect)
    meta_bug ("%u windows stacked, %u windows exist in stack\n",
-              x11_stacked->len, stack->xwindows->len);
+              stacked->len, stack->windows->len);
  
  /* Sync to server */

  meta_topic (META_DEBUG_STACK, "Restacking %u windows\n",
-              all_root_children_stacked->len);
+              root_children_stacked->len);
  
  meta_error_trap_push (stack->screen->display);

-  if (stack->last_all_root_children_stacked == NULL)
+  if (stack->last_root_children_stacked == NULL)
    {
      /* Just impose our stack, we don't know the previous state.
       * This involves a ton of circulate requests and may flicker.
       */
      meta_topic (META_DEBUG_STACK, "Don't know last stack state, restacking everything\n");

-      if (all_root_children_stacked->len > 1)
+      if (root_children_stacked->len > 0)
        {
-          gulong serial = 0;
-          if (x11_root_children_stacked->len > 1)
-            {
-              serial = XNextRequest (stack->screen->display->xdisplay);
-          XRestackWindows (stack->screen->display->xdisplay,
-                               (Window *) x11_root_children_stacked->data,
-                               x11_root_children_stacked->len);
-            }
          meta_stack_tracker_record_restack_windows (stack->screen->stack_tracker,
-                                                     (MetaStackWindow *) all_root_children_stacked->data,
-                                                     all_root_children_stacked->len,
-                                                     serial);
+                                                     (Window *) root_children_stacked->data,
+                                                     root_children_stacked->len,
+                                                     XNextRequest (stack->screen->display->xdisplay));
+          XRestackWindows (stack->screen->display->xdisplay,
+                           (Window *) root_children_stacked->data,
+                           root_children_stacked->len);
        }
    }
-  else if (all_root_children_stacked->len > 0)
+  else if (root_children_stacked->len > 0)
    {
      /* Try to do minimal window moves to get the stack in order */
      /* A point of note: these arrays include frames not client windows,
@@ -1396,34 +1250,28 @@ stack_sync_to_xserver (MetaStack *stack)
       * was saved, then we may have inefficiency, but I don't think things
       * break...
       */
-      const MetaStackWindow *old_stack = (MetaStackWindow *) stack->last_all_root_children_stacked->data;
-      const MetaStackWindow *new_stack = (MetaStackWindow *) all_root_children_stacked->data;
-      const int old_len = stack->last_all_root_children_stacked->len;
-      const int new_len = all_root_children_stacked->len;
-      const MetaStackWindow *oldp = old_stack;
-      const MetaStackWindow *newp = new_stack;
-      const MetaStackWindow *old_end = old_stack + old_len;
-      const MetaStackWindow *new_end = new_stack + new_len;
-      Window last_xwindow = None;
-      const MetaStackWindow *last_window = NULL;
-
+      const Window *old_stack = (Window *) stack->last_root_children_stacked->data;
+      const Window *new_stack = (Window *) root_children_stacked->data;
+      const int old_len = stack->last_root_children_stacked->len;
+      const int new_len = root_children_stacked->len;
+      const Window *oldp = old_stack;
+      const Window *newp = new_stack;
+      const Window *old_end = old_stack + old_len;
+      const Window *new_end = new_stack + new_len;
+      Window last_window = None;
+      
      while (oldp != old_end &&
             newp != new_end)
        {
-          if (meta_stack_window_equal (oldp, newp))
+          if (*oldp == *newp)
            {
              /* Stacks are the same here, move on */
              ++oldp;
-              if (newp->any.type == META_WINDOW_CLIENT_TYPE_X11)
-                last_xwindow = newp->x11.xwindow;
-              last_window = newp;
+              last_window = *newp;
              ++newp;
            }
-          else if ((oldp->any.type == META_WINDOW_CLIENT_TYPE_X11 &&
-                    meta_display_lookup_x_window (stack->screen->display,
-                                                  oldp->x11.xwindow) == NULL) ||
-                   (oldp->any.type == META_WINDOW_CLIENT_TYPE_WAYLAND &&
-                    oldp->wayland.meta_window == NULL))
+          else if (meta_display_lookup_x_window (stack->screen->display,
+                                                 *oldp) == NULL)
            {
              /* *oldp is no longer known to us (probably destroyed),
               * so we can just skip it
@@ -1432,161 +1280,75 @@ stack_sync_to_xserver (MetaStack *stack)
            }
          else
            {
-              /* Move *newp below the last_window */
-              if (!last_window)
+              /* Move *newp below last_window */
+              if (last_window == None)
                {
-                  meta_topic (META_DEBUG_STACK, "Using window 0x%lx as topmost (but leaving it in-place)\n",
-                              newp->x11.xwindow);
+                  meta_topic (META_DEBUG_STACK, "Using window 0x%lx as topmost (but leaving it in-place)\n", *newp);

-                  raise_window_relative_to_managed_windows (stack->screen, newp);
-                }
-              else if (newp->any.type == META_WINDOW_CLIENT_TYPE_X11 &&
-                       last_xwindow == None)
-                {
-                  /* In this case we have an X window that we need to
-                   * put below a wayland window and this is the
-                   * topmost X window. */
-                  
-                  /* In X terms (because this is the topmost X window)
-                   * we want to
-                   * raise_window_relative_to_managed_windows() to
-                   * ensure the X window is below override-redirect
-                   * pop-up windows.
-                   *
-                   * In Wayland terms we just want to ensure
-                   * newp is lowered below last_window (which
-                   * notably doesn't require an X request because we
-                   * know last_window isn't an X window).
-                   */
-
-                  raise_window_relative_to_managed_windows (stack->screen, newp);
-
-                  meta_stack_tracker_record_lower_below (stack->screen->stack_tracker,
-                                                         newp, last_window,
-                                                         0); /* no x request serial */
+                  raise_window_relative_to_managed_windows (stack->screen,
+                                                            *newp);
                }
              else
                {
-                  gulong serial = 0;
-
-                  /* This means that if last_xwindow is dead, but not
+                  /* This means that if last_window is dead, but not
                   * *newp, then we fail to restack *newp; but on
-                   * unmanaging last_xwindow, we'll fix it up.
+                   * unmanaging last_window, we'll fix it up.
                   */
                  
-                  meta_topic (META_DEBUG_STACK, "Placing window 0x%lx below 0x%lx\n",
-                              newp->any.type == META_WINDOW_CLIENT_TYPE_X11 ? newp->x11.xwindow : 0,
-                              last_xwindow);
-
-                  if (newp->any.type == META_WINDOW_CLIENT_TYPE_X11)
-                    {
                  XWindowChanges changes;
-                      serial = XNextRequest (stack->screen->display->xdisplay);

-                      changes.sibling = last_xwindow;
+                  changes.sibling = last_window;
                  changes.stack_mode = Below;

+                  meta_topic (META_DEBUG_STACK, "Placing window 0x%lx below 0x%lx\n",
+                              *newp, last_window);
+
+                  meta_stack_tracker_record_lower_below (stack->screen->stack_tracker,
+                                                         *newp, last_window,
+                                                         XNextRequest (stack->screen->display->xdisplay));
                  XConfigureWindow (stack->screen->display->xdisplay,
-                                        newp->x11.xwindow,
+                                    *newp,
                                    CWSibling | CWStackMode,
                                    &changes);
                }

-                  meta_stack_tracker_record_lower_below (stack->screen->stack_tracker,
-                                                         newp, last_window,
-                                                         serial);
-                }
-
-              if (newp->any.type == META_WINDOW_CLIENT_TYPE_X11)
-                last_xwindow = newp->x11.xwindow;
-              last_window = newp;
+              last_window = *newp;
              ++newp;
            }
        }

      if (newp != new_end)
        {
-          const MetaStackWindow *x_ref;
-          unsigned long serial = 0;
-
          /* Restack remaining windows */
          meta_topic (META_DEBUG_STACK, "Restacking remaining %d windows\n",
                        (int) (new_end - newp));
-
-          /* rewind until we find the last stacked X window that we can use
-           * as a reference point for re-stacking remaining X windows */
-          if (newp != new_stack)
-            for (x_ref = newp - 1;
-                 x_ref->any.type != META_WINDOW_CLIENT_TYPE_X11 && x_ref > new_stack;
-                 x_ref--)
-              ;
-          else
-            x_ref = new_stack;
-
-          /* If we didn't find an X window looking backwards then walk forwards
-           * through the remaining windows to find the first remaining X window
-           * instead. */
-          if (x_ref->any.type != META_WINDOW_CLIENT_TYPE_X11)
-            {
-              for (x_ref = newp;
-                   x_ref->any.type != META_WINDOW_CLIENT_TYPE_X11 && x_ref > new_stack;
-                   x_ref++)
-                ;
-            }
-
-          /* If there are any X windows remaining unstacked then restack them */
-          if (x_ref->any.type == META_WINDOW_CLIENT_TYPE_X11)
-            {
-              int i;
-
-              for (i = x11_root_children_stacked->len - 1; i; i--)
-                {
-                  Window *reference = &g_array_index (x11_root_children_stacked, Window, i);
-
-                  if (*reference == x_ref->x11.xwindow)
-                    {
-                      int n = x11_root_children_stacked->len - i;
-
-                      /* There's no point restacking if there's only one X window */
-                      if (n == 1)
-                        break;
-
-                      serial = XNextRequest (stack->screen->display->xdisplay);
-                      XRestackWindows (stack->screen->display->xdisplay,
-                                       reference, n);
-                      break;
-                    }
-                }
-            }
-
          /* We need to include an already-stacked window
           * in the restack call, so we get in the proper position
           * with respect to it.
           */
          if (newp != new_stack)
-            newp = MIN (newp - 1, x_ref);
+            --newp;
          meta_stack_tracker_record_restack_windows (stack->screen->stack_tracker,
-                                                     newp, new_end - newp,
-                                                     serial);
+                                                     (Window *) newp, new_end - newp,
+                                                     XNextRequest (stack->screen->display->xdisplay));
+          XRestackWindows (stack->screen->display->xdisplay,
+                           (Window *) newp, new_end - newp);
        }
    }

-  /* Push hidden X windows to the bottom of the stack under the guard window */
-  guard_stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
-  guard_stack_window.x11.xwindow = stack->screen->guard_window;
+  /* Push hidden windows to the bottom of the stack under the guard window */
  meta_stack_tracker_record_lower (stack->screen->stack_tracker,
-                                   &guard_stack_window,
+                                   stack->screen->guard_window,
                                   XNextRequest (stack->screen->display->xdisplay));
  XLowerWindow (stack->screen->display->xdisplay, stack->screen->guard_window);
  meta_stack_tracker_record_restack_windows (stack->screen->stack_tracker,
-                                             (MetaStackWindow *)x11_hidden_stack_windows->data,
-                                             x11_hidden_stack_windows->len,
+                                             (Window *)all_hidden->data,
+                                             all_hidden->len,
                                             XNextRequest (stack->screen->display->xdisplay));
  XRestackWindows (stack->screen->display->xdisplay,
-		   (Window *)x11_hidden->data,
-		   x11_hidden->len);
-  g_array_free (x11_hidden, TRUE);
-  g_array_free (x11_hidden_stack_windows, TRUE);
+		   (Window *)all_hidden->data,
+		   all_hidden->len);
+  g_array_free (all_hidden, TRUE);

  meta_error_trap_pop (stack->screen->display);
  /* on error, a window was destroyed; it should eventually
@@ -1601,23 +1363,21 @@ stack_sync_to_xserver (MetaStack *stack)
                   stack->screen->display->atom__NET_CLIENT_LIST,
                   XA_WINDOW,
                   32, PropModeReplace,
-                   (unsigned char *)stack->xwindows->data,
-                   stack->xwindows->len);
+                   (unsigned char *)stack->windows->data,
+                   stack->windows->len);
  XChangeProperty (stack->screen->display->xdisplay,
                   stack->screen->xroot,
                   stack->screen->display->atom__NET_CLIENT_LIST_STACKING,
                   XA_WINDOW,
                   32, PropModeReplace,
-                   (unsigned char *)x11_stacked->data,
-                   x11_stacked->len);
+                   (unsigned char *)stacked->data,
+                   stacked->len);

-  g_array_free (x11_stacked, TRUE);
+  g_array_free (stacked, TRUE);

-  if (stack->last_all_root_children_stacked)
-    free_last_all_root_children_stacked_cache (stack);
-  stack->last_all_root_children_stacked = all_root_children_stacked;
-
-  g_array_free (x11_root_children_stacked, TRUE);
+  if (stack->last_root_children_stacked)
+    g_array_free (stack->last_root_children_stacked, TRUE);
+  stack->last_root_children_stacked = root_children_stacked;

  /* That was scary... */
 }
@@ -1978,7 +1738,7 @@ meta_stack_set_positions (MetaStack *stack,
  meta_topic (META_DEBUG_STACK,
              "Reset the stack positions of (nearly) all windows\n");

-  stack_sync_to_xserver (stack);
+  stack_sync_to_server (stack);
  meta_stack_update_window_tile_matches (stack, NULL);
 }

@@ -2041,7 +1801,7 @@ meta_window_set_stack_position (MetaWindow *window,
                                int         position)
 {
  meta_window_set_stack_position_no_sync (window, position);
-  stack_sync_to_xserver (window->screen->stack);
+  stack_sync_to_server (window->screen->stack);
  meta_stack_update_window_tile_matches (window->screen->stack,
                                         window->screen->active_workspace);
 }
--- a/src/core/stack.h
+++ b/src/core/stack.h
@@ -60,7 +60,7 @@ struct _MetaStack
   * A sequence of all the Windows (X handles, not MetaWindows) of the windows
   * we manage, sorted in order.  Suitable to be passed into _NET_CLIENT_LIST.
   */
-  GArray *xwindows;
+  GArray *windows;

  /** The MetaWindows of the windows we manage, sorted in order. */
  GList *sorted;
@@ -99,7 +99,7 @@ struct _MetaStack
   * The last-known stack of all windows, bottom to top.  We cache it here
   * so that subsequent times we'll be able to do incremental moves.
   */
-  GArray *last_all_root_children_stacked;
+  GArray *last_root_children_stacked;

  /**
   * Number of stack positions; same as the length of added, but
--- a/src/core/util.c
+++ b/src/core/util.c
@@ -55,7 +55,6 @@ static gint verbose_topics = 0;
 static gboolean is_debugging = FALSE;
 static gboolean replace_current = FALSE;
 static int no_prefix = 0;
-static gboolean is_wayland_compositor = FALSE;

 #ifdef WITH_VERBOSE_MODE
 static FILE* logfile = NULL;
@@ -195,18 +194,6 @@ meta_set_replace_current_wm (gboolean setting)
  replace_current = setting;
 }

-gboolean
-meta_is_wayland_compositor (void)
-{
-  return is_wayland_compositor;
-}
-
-void
-meta_set_is_wayland_compositor (gboolean value)
-{
-  is_wayland_compositor = value;
-}
-
 char *
 meta_g_utf8_strndup (const gchar *src,
                     gsize        n)
@@ -404,91 +391,100 @@ meta_topic_real (MetaDebugTopic topic,
 }
 #endif /* WITH_VERBOSE_MODE */

+#ifdef WITH_VERBOSE_MODE
+static void
+logfile_log_handler (const gchar *log_domain,
+                     GLogLevelFlags log_level,
+                     const gchar *message,
+                     gpointer user_data)
+{
+  switch (log_level & G_LOG_LEVEL_MASK) {
+  case G_LOG_LEVEL_ERROR:
+    utf8_fputs ("ERROR: ", logfile);
+    break;
+
+  case G_LOG_LEVEL_CRITICAL:
+    utf8_fputs ("CRITICAL: ", logfile);
+    break;
+
+  case G_LOG_LEVEL_WARNING:
+    utf8_fputs ("WARNING: ", logfile);
+    break;
+
+  default:
+    /* the other levels don't go through
+       g_log, they go directly to the log file */
+    ;
+  }
+
+  utf8_fputs (message, logfile);
+}
+
+void
+meta_debug_init (void)
+{
+  ensure_logfile ();
+
+  if (logfile)
+    g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_MASK,
+                       logfile_log_handler, NULL);
+}
+#else
+void
+meta_debug_init (void)
+{
+}
+#endif
+
 void
 meta_bug (const char *format, ...)
 {
+  char *stripped;
  va_list args;
-  gchar *str;
-  FILE *out;

  g_return_if_fail (format != NULL);
-  
+
+  stripped = g_strstrip (g_strdup (format));
+
  va_start (args, format);
-  str = g_strdup_vprintf (format, args);
+  g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, stripped, args);
  va_end (args);

-#ifdef WITH_VERBOSE_MODE
-  out = logfile ? logfile : stderr;
-#else
-  out = stderr;
-#endif
-
-  if (no_prefix == 0)
-    utf8_fputs (_("Bug in window manager: "), out);
-  utf8_fputs (str, out);
-
-  fflush (out);
-  
-  g_free (str);
-  
-  /* stop us in a debugger */
-  abort ();
+  g_free (stripped);
 }

 void
 meta_warning (const char *format, ...)
 {
+  char *stripped;
  va_list args;
-  gchar *str;
-  FILE *out;
-  
+
  g_return_if_fail (format != NULL);
-  
+
+  stripped = g_strstrip (g_strdup (format));
+
  va_start (args, format);
-  str = g_strdup_vprintf (format, args);
+  g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, stripped, args);
  va_end (args);

-#ifdef WITH_VERBOSE_MODE
-  out = logfile ? logfile : stderr;
-#else
-  out = stderr;
-#endif
-
-  if (no_prefix == 0)
-    utf8_fputs (_("Window manager warning: "), out);
-  utf8_fputs (str, out);
-
-  fflush (out);
-  
-  g_free (str);
+  g_free (stripped);
 }

 void
 meta_fatal (const char *format, ...)
 {
+  char *stripped;
  va_list args;
-  gchar *str;
-  FILE *out;
-  
+
  g_return_if_fail (format != NULL);
-  
+
+  stripped = g_strstrip (g_strdup (format));
+
  va_start (args, format);
-  str = g_strdup_vprintf (format, args);
+  g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, stripped, args);
  va_end (args);

-#ifdef WITH_VERBOSE_MODE
-  out = logfile ? logfile : stderr;
-#else
-  out = stderr;
-#endif
-
-  if (no_prefix == 0)
-    utf8_fputs (_("Window manager error: "), out);
-  utf8_fputs (str, out);
-
-  fflush (out);
-  
-  g_free (str);
+  g_free (stripped);

  meta_exit (META_EXIT_ERROR);
 }
@@ -510,7 +506,6 @@ meta_pop_no_msg_prefix (void)
 void
 meta_exit (MetaExitCode code)
 {
-  
  exit (code);
 }

--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -44,17 +44,6 @@
 #include <X11/Xutil.h>
 #include <cairo.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
-#ifdef HAVE_WAYLAND
-#include "meta-wayland-private.h"
-#endif
-
-/* XXX: We should find a nicer approach to deal with the
- * circular dependency we have with the current headers
- * (meta-wayland-private.h which typedefs MetaWaylandSurface
- *  also includes window-private.h) */
-#ifndef HAVE_META_WAYLAND_SURFACE_TYPE
-typedef struct _MetaWaylandSurface MetaWaylandSurface;
-#endif

 typedef struct _MetaWindowQueue MetaWindowQueue;

@@ -80,7 +69,6 @@ typedef enum {
  _NET_WM_BYPASS_COMPOSITOR_HINT_OFF = 2,
 } MetaBypassCompositorHintValue;

-
 struct _MetaWindow
 {
  GObject parent_instance;
@@ -89,10 +77,6 @@ struct _MetaWindow
  MetaScreen *screen;
  const MetaMonitorInfo *monitor;
  MetaWorkspace *workspace;
-  MetaWindowClientType client_type;
-#ifdef HAVE_WAYLAND
-  MetaWaylandSurface *surface;
-#endif
  Window xwindow;
  /* may be NULL! not all windows get decorated */
  MetaFrame *frame;
@@ -341,10 +325,8 @@ struct _MetaWindow
  guint using_net_wm_icon_name         : 1; /* vs. plain wm_icon_name */
  guint using_net_wm_visible_icon_name : 1; /* tracked so we can clear it */

-  /* has a bounding shape mask */
+  /* has a shape mask */
  guint has_shape : 1;
-  /* has an input shape mask */
-  guint has_input_shape : 1;

  /* icon props have changed */
  guint need_reread_icon : 1;
@@ -508,10 +490,6 @@ MetaWindow* meta_window_new_with_attrs     (MetaDisplay       *display,
                                            gboolean           must_be_viewable,
                                            MetaCompEffect     effect,
                                            XWindowAttributes *attrs);
-MetaWindow *meta_window_new_for_wayland    (MetaDisplay        *display,
-                                            int                 width,
-                                            int                 height,
-                                            MetaWaylandSurface *surface);
 void        meta_window_unmanage           (MetaWindow  *window,
                                            guint32      timestamp);
 void        meta_window_calc_showing       (MetaWindow  *window);
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -62,10 +62,6 @@

 #include <X11/extensions/Xcomposite.h>

-#ifdef HAVE_WAYLAND
-#include "meta-wayland-private.h"
-#endif
-
 /* Windows that unmaximize to a size bigger than that fraction of the workarea
 * will be scaled down to that size (while maintaining aspect ratio).
 * Windows that cover an area greater then this size are automaximized on map.
@@ -717,10 +713,10 @@ meta_window_new (MetaDisplay *display,
 * Returns TRUE if window has been filtered out and should be ignored.
 */
 static gboolean
-maybe_filter_xwindow (MetaDisplay       *display,
-                      Window             xwindow,
-                      gboolean           must_be_viewable,
-                      XWindowAttributes *attrs)
+maybe_filter_window (MetaDisplay       *display,
+                     Window             xwindow,
+                     gboolean           must_be_viewable,
+                     XWindowAttributes *attrs)
 {
  static char **filter_wm_classes = NULL;
  static gboolean initialized = FALSE;
@@ -816,25 +812,80 @@ meta_window_should_attach_to_parent (MetaWindow *window)
    }
 }

-static MetaWindow*
-meta_window_new_shared (MetaDisplay         *display,
-                        MetaScreen          *screen,
-                        MetaWindowClientType client_type,
-                        MetaWaylandSurface  *surface,
-                        Window               xwindow,
-                        gboolean             must_be_viewable,
-                        gulong               existing_wm_state,
-                        gboolean             has_shape,
-                        gboolean             has_input_shape,
-                        MetaCompEffect       effect,
-                        XWindowAttributes   *attrs)
+MetaWindow*
+meta_window_new_with_attrs (MetaDisplay       *display,
+                            Window             xwindow,
+                            gboolean           must_be_viewable,
+                            MetaCompEffect     effect,
+                            XWindowAttributes *attrs)
 {
  MetaWindow *window;
+  GSList *tmp;
  MetaWorkspace *space;
+  gulong existing_wm_state;
+  gulong event_mask;
  MetaMoveResizeFlags flags;
+  gboolean has_shape;
+  MetaScreen *screen;

  g_assert (attrs != NULL);

+  meta_verbose ("Attempting to manage 0x%lx\n", xwindow);
+
+  if (meta_display_xwindow_is_a_no_focus_window (display, xwindow))
+    {
+      meta_verbose ("Not managing no_focus_window 0x%lx\n",
+                    xwindow);
+      return NULL;
+    }
+
+  screen = NULL;
+  for (tmp = display->screens; tmp != NULL; tmp = tmp->next)
+    {
+      MetaScreen *scr = tmp->data;
+
+      if (scr->xroot == attrs->root)
+        {
+          screen = tmp->data;
+          break;
+        }
+    }
+
+  g_assert (screen);
+
+  /* A black list of override redirect windows that we don't need to manage: */
+  if (attrs->override_redirect &&
+      (xwindow == screen->no_focus_window ||
+       xwindow == screen->flash_window ||
+       xwindow == screen->wm_sn_selection_window ||
+       attrs->class == InputOnly ||
+       /* any windows created via meta_create_offscreen_window: */
+       (attrs->x == -100 && attrs->y == -100
+	&& attrs->width == 1 && attrs->height == 1) ||
+       xwindow == screen->wm_cm_selection_window ||
+       xwindow == screen->guard_window ||
+       (display->compositor &&
+        xwindow == XCompositeGetOverlayWindow (display->xdisplay,
+					       screen->xroot)
+       )
+      )
+     ) {
+    meta_verbose ("Not managing our own windows\n");
+    return NULL;
+  }
+
+  if (maybe_filter_window (display, xwindow, must_be_viewable, attrs))
+    {
+      meta_verbose ("Not managing filtered window\n");
+      return NULL;
+    }
+
+  /* Grab server */
+  meta_display_grab (display);
+  meta_error_trap_push (display); /* Push a trap over all of window
+                                   * creation, to reduce XSync() calls
+                                   */
+
  meta_verbose ("must_be_viewable = %d attrs->map_state = %d (%s)\n",
                must_be_viewable,
                attrs->map_state,
@@ -846,16 +897,126 @@ meta_window_new_shared (MetaDisplay         *display,
                "IsUnviewable" :
                "(unknown)");

+  existing_wm_state = WithdrawnState;
+  if (must_be_viewable && attrs->map_state != IsViewable)
+    {
+      /* Only manage if WM_STATE is IconicState or NormalState */
+      gulong state;
+
+      /* WM_STATE isn't a cardinal, it's type WM_STATE, but is an int */
+      if (!(meta_prop_get_cardinal_with_atom_type (display, xwindow,
+                                                   display->atom_WM_STATE,
+                                                   display->atom_WM_STATE,
+                                                   &state) &&
+            (state == IconicState || state == NormalState)))
+        {
+          meta_verbose ("Deciding not to manage unmapped or unviewable window 0x%lx\n", xwindow);
+          meta_error_trap_pop (display);
+          meta_display_ungrab (display);
+          return NULL;
+        }
+
+      existing_wm_state = state;
+      meta_verbose ("WM_STATE of %lx = %s\n", xwindow,
+                    wm_state_to_string (existing_wm_state));
+    }
+
+  meta_error_trap_push_with_return (display);
+
+  /*
+   * XAddToSaveSet can only be called on windows created by a different client.
+   * with Mutter we want to be able to create manageable windows from within
+   * the process (such as a dummy desktop window), so we do not want this
+   * call failing to prevent the window from being managed -- wrap it in its
+   * own error trap (we use the _with_return() version here to ensure that
+   * XSync() is done on the pop, otherwise the error will not get caught).
+   */
+  meta_error_trap_push_with_return (display);
+  XAddToSaveSet (display->xdisplay, xwindow);
+  meta_error_trap_pop_with_return (display);
+
+  event_mask = PropertyChangeMask | ColormapChangeMask;
+  if (attrs->override_redirect)
+    event_mask |= StructureNotifyMask;
+
+  /* If the window is from this client (a menu, say) we need to augment
+   * the event mask, not replace it. For windows from other clients,
+   * attrs->your_event_mask will be empty at this point.
+   */
+  XSelectInput (display->xdisplay, xwindow, attrs->your_event_mask | event_mask);
+
+  {
+    unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
+    XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
+
+    meta_core_add_old_event_mask (display->xdisplay, xwindow, &mask);
+
+    XISetMask (mask.mask, XI_Enter);
+    XISetMask (mask.mask, XI_Leave);
+    XISetMask (mask.mask, XI_FocusIn);
+    XISetMask (mask.mask, XI_FocusOut);
+
+    XISelectEvents (display->xdisplay, xwindow, &mask, 1);
+  }
+
+  has_shape = FALSE;
+#ifdef HAVE_SHAPE
+  if (META_DISPLAY_HAS_SHAPE (display))
+    {
+      int x_bounding, y_bounding, x_clip, y_clip;
+      unsigned w_bounding, h_bounding, w_clip, h_clip;
+      int bounding_shaped, clip_shaped;
+
+      XShapeSelectInput (display->xdisplay, xwindow, ShapeNotifyMask);
+
+      XShapeQueryExtents (display->xdisplay, xwindow,
+                          &bounding_shaped, &x_bounding, &y_bounding,
+                          &w_bounding, &h_bounding,
+                          &clip_shaped, &x_clip, &y_clip,
+                          &w_clip, &h_clip);
+
+      has_shape = bounding_shaped != FALSE;
+
+      meta_topic (META_DEBUG_SHAPES,
+                  "Window has_shape = %d extents %d,%d %u x %u\n",
+                  has_shape, x_bounding, y_bounding,
+                  w_bounding, h_bounding);
+    }
+#endif
+
+  /* Get rid of any borders */
+  if (attrs->border_width != 0)
+    XSetWindowBorderWidth (display->xdisplay, xwindow, 0);
+
+  /* Get rid of weird gravities */
+  if (attrs->win_gravity != NorthWestGravity)
+    {
+      XSetWindowAttributes set_attrs;
+
+      set_attrs.win_gravity = NorthWestGravity;
+
+      XChangeWindowAttributes (display->xdisplay,
+                               xwindow,
+                               CWWinGravity,
+                               &set_attrs);
+    }
+
+  if (meta_error_trap_pop_with_return (display) != Success)
+    {
+      meta_verbose ("Window 0x%lx disappeared just as we tried to manage it\n",
+                    xwindow);
+      meta_error_trap_pop (display);
+      meta_display_ungrab (display);
+      return NULL;
+    }
+
+
  window = g_object_new (META_TYPE_WINDOW, NULL);

  window->constructing = TRUE;

  window->dialog_pid = -1;

-  window->client_type = client_type;
-#ifdef HAVE_WAYLAND
-  window->surface = surface;
-#endif
  window->xwindow = xwindow;

  /* this is in window->screen->display, but that's too annoying to
@@ -881,7 +1042,6 @@ meta_window_new_shared (MetaDisplay         *display,
  meta_stack_freeze (window->screen->stack);

  window->has_shape = has_shape;
-  window->has_input_shape = has_input_shape;

  window->rect.x = attrs->x;
  window->rect.y = attrs->y;
@@ -982,11 +1142,7 @@ meta_window_new_shared (MetaDisplay         *display,
  window->mwm_has_move_func = TRUE;
  window->mwm_has_resize_func = TRUE;

-  if (client_type == META_WINDOW_CLIENT_TYPE_X11)
-    window->decorated = TRUE;
-  else
-    window->decorated = FALSE;
-
+  window->decorated = TRUE;
  window->has_close_func = TRUE;
  window->has_minimize_func = TRUE;
  window->has_maximize_func = TRUE;
@@ -1045,26 +1201,23 @@ meta_window_new_shared (MetaDisplay         *display,

  window->tile_match = NULL;

+  if (window->override_redirect)
+    {
+      window->decorated = FALSE;
+      window->always_sticky = TRUE;
+      window->has_close_func = FALSE;
+      window->has_shade_func = FALSE;
+      window->has_move_func = FALSE;
+      window->has_resize_func = FALSE;
+    }
+
+  meta_display_register_x_window (display, &window->xwindow, window);
+
  /* Assign this #MetaWindow a sequence number which can be used
   * for sorting.
   */
  window->stable_sequence = ++display->window_sequence_counter;

-  if (client_type == META_WINDOW_CLIENT_TYPE_X11)
-    {
-      if (window->override_redirect)
-        {
-          window->decorated = FALSE;
-          window->always_sticky = TRUE;
-          window->has_close_func = FALSE;
-          window->has_shade_func = FALSE;
-          window->has_move_func = FALSE;
-          window->has_resize_func = FALSE;
-        }
-
-      meta_display_register_x_window (display, &window->xwindow, window);
-    }
-
  /* assign the window to its group, or create a new group if needed
   */
  window->group = NULL;
@@ -1073,8 +1226,7 @@ meta_window_new_shared (MetaDisplay         *display,

  meta_window_load_initial_properties (window);

-  if (!window->override_redirect &&
-      client_type == META_WINDOW_CLIENT_TYPE_X11)
+  if (!window->override_redirect)
    {
      update_sm_hints (window); /* must come after transient_for */

@@ -1148,16 +1300,6 @@ meta_window_new_shared (MetaDisplay         *display,
  if (window->decorated)
    meta_window_ensure_frame (window);

-  if (window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
-    {
-      MetaStackWindow stack_window;
-      stack_window.any.type = META_WINDOW_CLIENT_TYPE_WAYLAND;
-      stack_window.wayland.meta_window = window;
-      meta_stack_tracker_record_add (window->screen->stack_tracker,
-                                     &stack_window,
-                                     0);
-    }
-
  meta_window_grab_keys (window);
  if (window->type != META_WINDOW_DOCK && !window->override_redirect)
    {
@@ -1358,14 +1500,11 @@ meta_window_new_shared (MetaDisplay         *display,
      !window->initially_iconic)
    unminimize_window_and_all_transient_parents (window);

+  meta_error_trap_pop (display); /* pop the XSync()-reducing trap */
+  meta_display_ungrab (display);
+
  window->constructing = FALSE;

-  return window;
-}
-
-static void
-display_notify_window (MetaDisplay *display, MetaWindow *window)
-{
  meta_display_notify_window_created (display, window);

  if (window->wm_state_demands_attention)
@@ -1373,309 +1512,6 @@ display_notify_window (MetaDisplay *display, MetaWindow *window)

  if (window->wm_hints_urgent)
    g_signal_emit_by_name (window->display, "window-marked-urgent", window);
-}
-
-#ifdef HAVE_WAYLAND
-MetaWindow *
-meta_window_new_for_wayland (MetaDisplay        *display,
-                             int                 width,
-                             int                 height,
-                             MetaWaylandSurface *surface)
-{
-  XWindowAttributes attrs;
-  MetaScreen *scr = display->screens->data;
-  MetaWindow *window;
-
-  attrs.x = 0;
-  attrs.y = 0;
-  attrs.width = width;
-  attrs.height = height;
-  attrs.border_width = 0;
-  attrs.depth = 24;
-  attrs.visual = NULL;
-  attrs.root = scr->xroot;
-  attrs.class = InputOutput;
-  attrs.bit_gravity = NorthWestGravity;
-  attrs.win_gravity = NorthWestGravity;
-  attrs.backing_store = 0;
-  attrs.backing_planes = ~0;
-  attrs.backing_pixel = 0;
-  attrs.save_under = 0;
-  attrs.colormap = 0;
-  attrs.map_installed = 1;
-  attrs.map_state = IsUnmapped;
-  attrs.all_event_masks = ~0;
-  attrs.your_event_mask = 0;
-  attrs.do_not_propagate_mask = 0;
-  attrs.override_redirect = 0;
-  attrs.screen = scr->xscreen;
-
-  /* XXX: Note: In the Wayland case we currently still grab the
-   * xserver and trap X errors while creating a MetaWindow because we
-   * will still be making various redundant X requests (passing a
-   * window xid of None) until we thoroughly audit all the code to
-   * make sure it knows about non X based clients...
-   */
-
-  /* Grab server */
-  meta_display_grab (display);
-  meta_error_trap_push (display); /* Push a trap over all of window
-                                   * creation, to reduce XSync() calls
-                                   */
-
-  window = meta_window_new_shared (display,
-                                   scr,
-                                   META_WINDOW_CLIENT_TYPE_WAYLAND,
-                                   surface,
-                                   None,
-                                   TRUE,
-                                   WithdrawnState,
-                                   FALSE, /* has shape */
-                                   FALSE, /* has input shape */
-                                   META_COMP_EFFECT_NONE,
-                                   &attrs);
-
-  meta_error_trap_pop (display); /* pop the XSync()-reducing trap */
-  meta_display_ungrab (display);
-
-  /* XXX: Maybe this could be called in meta_window_new_shared() but
-   * before splitting the X11 specific code out it came after the
-   * meta_display_ungrab() and we wanted to minimize the risk of
-   * breaking something.
-   */
-  display_notify_window (window->display, window);
-
-  return window;
-}
-#endif
-
-MetaWindow*
-meta_window_new_with_attrs (MetaDisplay       *display,
-                            Window             xwindow,
-                            gboolean           must_be_viewable,
-                            MetaCompEffect     effect,
-                            XWindowAttributes *attrs)
-{
-  MetaScreen *screen = NULL;
-  GSList *tmp;
-  gulong existing_wm_state;
-  MetaWindow *window;
-  gulong event_mask;
-  gboolean has_shape = FALSE;
-  gboolean has_input_shape = FALSE;
-
-  meta_verbose ("Attempting to manage 0x%lx\n", xwindow);
-
-  if (meta_display_xwindow_is_a_no_focus_window (display, xwindow))
-    {
-      meta_verbose ("Not managing no_focus_window 0x%lx\n",
-                    xwindow);
-      return NULL;
-    }
-
-  for (tmp = display->screens; tmp != NULL; tmp = tmp->next)
-    {
-      MetaScreen *scr = tmp->data;
-
-      if (scr->xroot == attrs->root)
-        {
-          screen = tmp->data;
-          break;
-        }
-    }
-
-  g_assert (screen);
-
-  /* A black list of override redirect windows that we don't need to manage: */
-  if (attrs->override_redirect &&
-      (xwindow == screen->no_focus_window ||
-       xwindow == screen->flash_window ||
-       xwindow == screen->wm_sn_selection_window ||
-       attrs->class == InputOnly ||
-       /* any windows created via meta_create_offscreen_window: */
-       (attrs->x == -100 && attrs->y == -100
-	&& attrs->width == 1 && attrs->height == 1) ||
-       xwindow == screen->wm_cm_selection_window ||
-       xwindow == screen->guard_window ||
-       (display->compositor &&
-        xwindow == XCompositeGetOverlayWindow (display->xdisplay,
-					       screen->xroot)
-       )
-      )
-     ) {
-    meta_verbose ("Not managing our own windows\n");
-    return NULL;
-  }
-
-  if (maybe_filter_xwindow (display, xwindow, must_be_viewable, attrs))
-    {
-      meta_verbose ("Not managing filtered window\n");
-      return NULL;
-    }
-
-  /* Grab server */
-  meta_display_grab (display);
-  meta_error_trap_push (display); /* Push a trap over all of window
-                                   * creation, to reduce XSync() calls
-                                   */
-
-  existing_wm_state = WithdrawnState;
-  if (must_be_viewable && attrs->map_state != IsViewable)
-    {
-      /* Only manage if WM_STATE is IconicState or NormalState */
-      gulong state;
-
-      /* WM_STATE isn't a cardinal, it's type WM_STATE, but is an int */
-      if (!(meta_prop_get_cardinal_with_atom_type (display, xwindow,
-                                                   display->atom_WM_STATE,
-                                                   display->atom_WM_STATE,
-                                                   &state) &&
-            (state == IconicState || state == NormalState)))
-        {
-          meta_verbose ("Deciding not to manage unmapped or unviewable window 0x%lx\n", xwindow);
-          meta_error_trap_pop (display);
-          meta_display_ungrab (display);
-          return NULL;
-        }
-
-      existing_wm_state = state;
-      meta_verbose ("WM_STATE of %lx = %s\n", xwindow,
-                    wm_state_to_string (existing_wm_state));
-    }
-
-  meta_error_trap_push_with_return (display);
-
-  /*
-   * XAddToSaveSet can only be called on windows created by a different
-   * client.  with Mutter we want to be able to create manageable windows
-   * from within the process (such as a dummy desktop window), so we do not
-   * want this call failing to prevent the window from being managed -- wrap
-   * it in its own error trap (we use the _with_return() version here to
-   * ensure that XSync() is done on the pop, otherwise the error will not
-   * get caught).
-   */
-  meta_error_trap_push_with_return (display);
-  XAddToSaveSet (display->xdisplay, xwindow);
-  meta_error_trap_pop_with_return (display);
-
-  event_mask = PropertyChangeMask | ColormapChangeMask;
-  if (attrs->override_redirect)
-    event_mask |= StructureNotifyMask;
-
-  /* If the window is from this client (a menu, say) we need to augment
-   * the event mask, not replace it. For windows from other clients,
-   * attrs->your_event_mask will be empty at this point.
-   */
-  XSelectInput (display->xdisplay, xwindow, attrs->your_event_mask | event_mask);
-
-    {
-      unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
-      XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
-
-      meta_core_add_old_event_mask (display->xdisplay, xwindow, &mask);
-
-      XISetMask (mask.mask, XI_Enter);
-      XISetMask (mask.mask, XI_Leave);
-      XISetMask (mask.mask, XI_FocusIn);
-      XISetMask (mask.mask, XI_FocusOut);
-
-      XISelectEvents (display->xdisplay, xwindow, &mask, 1);
-    }
-
-#ifdef HAVE_SHAPE
-  if (META_DISPLAY_HAS_SHAPE (display))
-    {
-      int x_bounding, y_bounding, x_clip, y_clip;
-      unsigned w_bounding, h_bounding, w_clip, h_clip;
-      int bounding_shaped, clip_shaped;
-      XRectangle *input_rectangles;
-      int n_rects, ordering;
-
-      XShapeSelectInput (display->xdisplay, xwindow, ShapeNotifyMask);
-
-      XShapeQueryExtents (display->xdisplay, xwindow,
-                          &bounding_shaped, &x_bounding, &y_bounding,
-                          &w_bounding, &h_bounding,
-                          &clip_shaped, &x_clip, &y_clip,
-                          &w_clip, &h_clip);
-
-      has_shape = bounding_shaped != FALSE;
-
-      /* XXX: The x shape extension doesn't provide a way to only test if an
-       * input shape has been specified, so we have to query and throw away the
-       * rectangles. */
-      meta_error_trap_push (display);
-      input_rectangles = XShapeGetRectangles (display->xdisplay, xwindow,
-                                              ShapeInput, &n_rects, &ordering);
-      meta_error_trap_pop (display);
-      if (input_rectangles)
-        {
-          if (n_rects > 1 ||
-              (n_rects == 1 &&
-               (input_rectangles[0].x != x_bounding ||
-                input_rectangles[1].y != y_bounding ||
-                input_rectangles[2].width != w_bounding ||
-                input_rectangles[3].height != h_bounding)))
-            {
-              has_input_shape = TRUE;
-            }
-          XFree (input_rectangles);
-        }
-
-      meta_topic (META_DEBUG_SHAPES,
-                  "Window has_shape = %d extents %d,%d %u x %u\n",
-                  has_shape, x_bounding, y_bounding,
-                  w_bounding, h_bounding);
-    }
-#endif
-
-  /* Get rid of any borders */
-  if (attrs->border_width != 0)
-    XSetWindowBorderWidth (display->xdisplay, xwindow, 0);
-
-  /* Get rid of weird gravities */
-  if (attrs->win_gravity != NorthWestGravity)
-    {
-      XSetWindowAttributes set_attrs;
-
-      set_attrs.win_gravity = NorthWestGravity;
-
-      XChangeWindowAttributes (display->xdisplay,
-                               xwindow,
-                               CWWinGravity,
-                               &set_attrs);
-    }
-
-  if (meta_error_trap_pop_with_return (display) != Success)
-    {
-      meta_verbose ("Window 0x%lx disappeared just as we tried to manage it\n",
-                    xwindow);
-      meta_error_trap_pop (display);
-      meta_display_ungrab (display);
-      return NULL;
-    }
-
-  window = meta_window_new_shared (display,
-                                   screen,
-                                   META_WINDOW_CLIENT_TYPE_X11,
-                                   NULL,
-                                   xwindow,
-                                   must_be_viewable,
-                                   existing_wm_state,
-                                   has_shape,
-                                   has_input_shape,
-                                   effect,
-                                   attrs);
-
-  meta_error_trap_pop (display); /* pop the XSync()-reducing trap */
-  meta_display_ungrab (display);
-
-  /* XXX: Maybe this could be called in meta_window_new_shared() but
-   * before splitting the X11 specific code out it came after the
-   * meta_display_ungrab() and we wanted to minimize the risk of
-   * breaking something.
-   */
-  display_notify_window (display, window);

  return window;
 }
@@ -1846,16 +1682,6 @@ meta_window_unmanage (MetaWindow  *window,

  meta_verbose ("Unmanaging 0x%lx\n", window->xwindow);

-  if (window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
-    {
-      MetaStackWindow stack_window;
-      stack_window.any.type = META_WINDOW_CLIENT_TYPE_WAYLAND;
-      stack_window.wayland.meta_window = window;
-      meta_stack_tracker_record_remove (window->screen->stack_tracker,
-                                        &stack_window,
-                                        0);
-    }
-
  if (window->display->compositor)
    {
      if (window->visible_to_compositor)
@@ -2062,56 +1888,49 @@ meta_window_unmanage (MetaWindow  *window,
  meta_display_ungrab_window_buttons (window->display, window->xwindow);
  meta_display_ungrab_focus_window_button (window->display, window);

-  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
+  meta_display_unregister_x_window (window->display, window->xwindow);
+
+
+  meta_error_trap_push (window->display);
+
+  /* Put back anything we messed up */
+  if (window->border_width != 0)
+    XSetWindowBorderWidth (window->display->xdisplay,
+                           window->xwindow,
+                           window->border_width);
+
+  /* No save set */
+  XRemoveFromSaveSet (window->display->xdisplay,
+                      window->xwindow);
+
+  /* Even though the window is now unmanaged, we can't unselect events. This
+   * window might be a window from this process, like a GdkMenu, in
+   * which case it will have pointer events and so forth selected
+   * for it by GDK. There's no way to disentangle those events from the events
+   * we've selected. Even for a window from a different X client,
+   * GDK could also have selected events for it for IPC purposes, so we
+   * can't unselect in that case either.
+   *
+   * Similarly, we can't unselected for events on window->user_time_window.
+   * It might be our own GDK focus window, or it might be a window that a
+   * different client is using for multiple different things:
+   * _NET_WM_USER_TIME_WINDOW and IPC, perhaps.
+   */
+
+  if (window->user_time_window != None)
    {
-      meta_display_unregister_x_window (window->display, window->xwindow);
-
-      meta_error_trap_push (window->display);
-
-      /* Put back anything we messed up */
-      if (window->border_width != 0)
-        XSetWindowBorderWidth (window->display->xdisplay,
-                               window->xwindow,
-                               window->border_width);
-
-      /* No save set */
-      XRemoveFromSaveSet (window->display->xdisplay,
-                          window->xwindow);
-
-      /* Even though the window is now unmanaged, we can't unselect events. This
-       * window might be a window from this process, like a GdkMenu, in
-       * which case it will have pointer events and so forth selected
-       * for it by GDK. There's no way to disentangle those events from the events
-       * we've selected. Even for a window from a different X client,
-       * GDK could also have selected events for it for IPC purposes, so we
-       * can't unselect in that case either.
-       *
-       * Similarly, we can't unselected for events on window->user_time_window.
-       * It might be our own GDK focus window, or it might be a window that a
-       * different client is using for multiple different things:
-       * _NET_WM_USER_TIME_WINDOW and IPC, perhaps.
-       */
-
-      if (window->user_time_window != None)
-        {
-          meta_display_unregister_x_window (window->display,
-                                            window->user_time_window);
-          window->user_time_window = None;
-        }
-
-#ifdef HAVE_SHAPE
-      if (META_DISPLAY_HAS_SHAPE (window->display))
-        XShapeSelectInput (window->display->xdisplay, window->xwindow, NoEventMask);
-#endif
-
-      meta_error_trap_pop (window->display);
+      meta_display_unregister_x_window (window->display,
+                                        window->user_time_window);
+      window->user_time_window = None;
    }

-#ifdef HAVE_WAYLAND
-  if (window->surface)
-    meta_wayland_surface_free (window->surface);
+#ifdef HAVE_SHAPE
+  if (META_DISPLAY_HAS_SHAPE (window->display))
+    XShapeSelectInput (window->display->xdisplay, window->xwindow, NoEventMask);
 #endif

+  meta_error_trap_pop (window->display);
+
  meta_prefs_remove_listener (prefs_changed_callback, window);

  meta_screen_queue_check_fullscreen (window->screen);
@@ -7399,9 +7218,6 @@ void
 meta_window_set_focused_internal (MetaWindow *window,
                                  gboolean    focused)
 {
-  if (window->unmanaging)
-    return;
-
  if (focused)
    {
      window->has_focus = TRUE;
@@ -7875,7 +7691,7 @@ meta_window_update_opaque_region (MetaWindow *window)
  meta_XFree (region);

  if (window->display->compositor)
-    meta_compositor_window_x11_shape_changed (window->display->compositor, window);
+    meta_compositor_window_shape_changed (window->display->compositor, window);
 }

 static void
--- a/src/meta/compositor.h
+++ b/src/meta/compositor.h
@@ -64,8 +64,8 @@ void meta_compositor_manage_screen   (MetaCompositor *compositor,
 void meta_compositor_unmanage_screen (MetaCompositor *compositor,
                                      MetaScreen     *screen);

-void meta_compositor_window_x11_shape_changed (MetaCompositor *compositor,
-                                               MetaWindow     *window);
+void meta_compositor_window_shape_changed (MetaCompositor *compositor,
+                                           MetaWindow     *window);

 gboolean meta_compositor_process_event (MetaCompositor *compositor,
                                        XEvent         *event,
--- a/src/meta/meta-cursor-tracker.h
+++ b/src/meta/meta-cursor-tracker.h
@@ -1,49 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/*
- * Copyright (C) 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.
- *
- * Author: Giovanni Campagna <gcampagn@redhat.com>
- */
-
-#ifndef META_CURSOR_TRACKER_H
-#define META_CURSOR_TRACKER_H
-
-#include <glib-object.h>
-#include <meta/types.h>
-#include <meta/workspace.h>
-
-#define META_TYPE_CURSOR_TRACKER            (meta_cursor_tracker_get_type ())
-#define META_CURSOR_TRACKER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_CURSOR_TRACKER, MetaCursorTracker))
-#define META_CURSOR_TRACKER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_CURSOR_TRACKER, MetaCursorTrackerClass))
-#define META_IS_CURSOR_TRACKER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_CURSOR_TRACKER))
-#define META_IS_CURSOR_TRACKER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_CURSOR_TRACKER))
-#define META_CURSOR_TRACKER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_CURSOR_TRACKER, MetaCursorTrackerClass))
-
-typedef struct _MetaCursorTrackerClass   MetaCursorTrackerClass;
-
-GType meta_cursor_tracker_get_type (void);
-
-MetaCursorTracker *meta_cursor_tracker_get_for_screen (MetaScreen *screen);
-
-void           meta_cursor_tracker_get_hot    (MetaCursorTracker *tracker,
-                                               int               *x,
-                                               int               *y);
-CoglTexture   *meta_cursor_tracker_get_sprite (MetaCursorTracker *tracker);
-
-#endif
--- a/src/meta/meta-idle-monitor.h
+++ b/src/meta/meta-idle-monitor.h
@@ -1,62 +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, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- */
-
-#ifndef META_IDLE_MONITOR_H
-#define META_IDLE_MONITOR_H
-
-#include <glib-object.h>
-#include <meta/types.h>
-
-#define META_TYPE_IDLE_MONITOR            (meta_idle_monitor_get_type ())
-#define META_IDLE_MONITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_IDLE_MONITOR, MetaIdleMonitor))
-#define META_IDLE_MONITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_IDLE_MONITOR, MetaIdleMonitorClass))
-#define META_IS_IDLE_MONITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_IDLE_MONITOR))
-#define META_IS_IDLE_MONITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_IDLE_MONITOR))
-#define META_IDLE_MONITOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_IDLE_MONITOR, MetaIdleMonitorClass))
-
-typedef struct _MetaIdleMonitor        MetaIdleMonitor;
-typedef struct _MetaIdleMonitorClass   MetaIdleMonitorClass;
-
-GType meta_idle_monitor_get_type (void);
-
-typedef void (*MetaIdleMonitorWatchFunc) (MetaIdleMonitor *monitor,
-                                          guint            watch_id,
-                                          gpointer         user_data);
-
-MetaIdleMonitor *meta_idle_monitor_get_core (void);
-MetaIdleMonitor *meta_idle_monitor_get_for_device (int device_id);
-
-guint         meta_idle_monitor_add_idle_watch        (MetaIdleMonitor          *monitor,
-						       guint64                   interval_msec,
-						       MetaIdleMonitorWatchFunc  callback,
-						       gpointer                  user_data,
-						       GDestroyNotify            notify);
-
-guint         meta_idle_monitor_add_user_active_watch (MetaIdleMonitor          *monitor,
-						       MetaIdleMonitorWatchFunc  callback,
-						       gpointer                  user_data,
-						       GDestroyNotify            notify);
-
-void          meta_idle_monitor_remove_watch          (MetaIdleMonitor          *monitor,
-						       guint                     id);
-guint64       meta_idle_monitor_get_idletime          (MetaIdleMonitor          *monitor);
-
-#endif
--- a/src/meta/meta-plugin.h
+++ b/src/meta/meta-plugin.h
@@ -396,6 +396,8 @@ typedef enum {

 gboolean
 meta_plugin_begin_modal (MetaPlugin      *plugin,
+                         Window           grab_window,
+                         Cursor           cursor,
                         MetaModalOptions options,
                         guint32          timestamp);

--- a/src/meta/meta-shaped-texture.h
+++ b/src/meta/meta-shaped-texture.h
@@ -29,11 +29,6 @@
 #include <clutter/clutter.h>
 #include <X11/Xlib.h>

-#ifdef HAVE_WAYLAND
-#include <wayland-server.h>
-#include "meta-wayland-private.h"
-#endif
-
 G_BEGIN_DECLS

 #define META_TYPE_SHAPED_TEXTURE            (meta_shaped_texture_get_type())
@@ -69,13 +64,7 @@ struct _MetaShapedTexture

 GType meta_shaped_texture_get_type (void) G_GNUC_CONST;

-ClutterActor *meta_shaped_texture_new_with_xwindow (Window xwindow);
-#ifdef HAVE_WAYLAND
-ClutterActor *meta_shaped_texture_new_with_wayland_surface  (MetaWaylandSurface *surface);
-void meta_shaped_texture_set_wayland_surface                (MetaShapedTexture  *stex,
-                                                             MetaWaylandSurface *surface);
-MetaWaylandSurface *meta_shaped_texture_get_wayland_surface (MetaShapedTexture *stex);
-#endif
+ClutterActor *meta_shaped_texture_new (void);

 void meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex,
 					     gboolean           create_mipmaps);
@@ -88,17 +77,11 @@ void meta_shaped_texture_update_area (MetaShapedTexture *stex,

 void meta_shaped_texture_set_pixmap (MetaShapedTexture *stex,
                                     Pixmap             pixmap);
-#ifdef HAVE_WAYLAND
-void meta_shaped_texture_attach_wayland_buffer (MetaShapedTexture  *stex,
-                                                MetaWaylandBuffer  *buffer);
-#endif

 CoglTexture * meta_shaped_texture_get_texture (MetaShapedTexture *stex);

 void meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
                                           CoglTexture       *mask_texture);
-void meta_shaped_texture_set_input_shape_region (MetaShapedTexture *stex,
-                                                 cairo_region_t    *shape_region);

 /* Assumes ownership of clip_region */
 void meta_shaped_texture_set_clip_region (MetaShapedTexture *stex,
--- a/src/meta/types.h
+++ b/src/meta/types.h
@@ -38,6 +38,5 @@ typedef struct _MetaWorkspace   MetaWorkspace;
 */
 typedef struct _MetaGroup       MetaGroup;
 typedef struct _MetaKeyBinding  MetaKeyBinding;
-typedef struct _MetaCursorTracker MetaCursorTracker;

 #endif
--- a/src/meta/util.h
+++ b/src/meta/util.h
@@ -37,8 +37,6 @@ void     meta_set_debugging (gboolean setting);
 gboolean meta_is_syncing (void);
 void     meta_set_syncing (gboolean setting);
 void     meta_set_replace_current_wm (gboolean setting);
-gboolean meta_is_wayland_compositor (void);
-void     meta_set_is_wayland_compositor (gboolean setting);

 void meta_debug_spew_real (const char *format,
                           ...) G_GNUC_PRINTF (1, 2);
@@ -112,6 +110,8 @@ void meta_topic_real      (MetaDebugTopic topic,
 void meta_add_verbose_topic    (MetaDebugTopic topic);
 void meta_remove_verbose_topic (MetaDebugTopic topic);

+void meta_debug_init      (void);
+
 void meta_push_no_msg_prefix (void);
 void meta_pop_no_msg_prefix  (void);

--- a/src/meta/window.h
+++ b/src/meta/window.h
@@ -81,16 +81,6 @@ typedef enum
  META_MAXIMIZE_VERTICAL   = 1 << 1
 } MetaMaximizeFlags;

-/**
- * MetaWindowClientType:
- * @META_WINDOW_CLIENT_TYPE_WAYLAND: A Wayland based window
- * @META_WINDOW_CLIENT_TYPE_X11: An X11 based window
- */
-typedef enum {
-  META_WINDOW_CLIENT_TYPE_WAYLAND,
-  META_WINDOW_CLIENT_TYPE_X11
-} MetaWindowClientType;
-
 #define META_TYPE_WINDOW            (meta_window_get_type ())
 #define META_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_WINDOW, MetaWindow))
 #define META_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_WINDOW, MetaWindowClass))
--- a/src/org.gnome.mutter.gschema.xml.in
+++ b/src/org.gnome.mutter.gschema.xml.in
@@ -116,34 +116,5 @@
      <_summary>Cancel tab popup</_summary>
    </key>

-    <key name="switch-to-session-1" type="as">
-      <default><![CDATA[['<Primary><Alt>F1']]]></default>
-      <_summary>Switch to VT 1</_summary>
-    </key>
-    <key name="switch-to-session-2" type="as">
-      <default><![CDATA[['<Primary><Alt>F2']]]></default>
-      <_summary>Switch to VT 2</_summary>
-    </key>
-    <key name="switch-to-session-3" type="as">
-      <default><![CDATA[['<Primary><Alt>F3']]]></default>
-      <_summary>Switch to VT 3</_summary>
-    </key>
-    <key name="switch-to-session-4" type="as">
-      <default><![CDATA[['<Primary><Alt>F4']]]></default>
-      <_summary>Switch to VT 4</_summary>
-    </key>
-    <key name="switch-to-session-5" type="as">
-      <default><![CDATA[['<Primary><Alt>F5']]]></default>
-      <_summary>Switch to VT 5</_summary>
-    </key>
-    <key name="switch-to-session-6" type="as">
-      <default><![CDATA[['<Primary><Alt>F6']]]></default>
-      <_summary>Switch to VT 6</_summary>
-    </key>
-    <key name="switch-to-session-7" type="as">
-      <default><![CDATA[['<Primary><Alt>F7']]]></default>
-      <_summary>Switch to VT 7</_summary>
-    </key>
-
  </schema>
 </schemalist>
--- a/src/wayland/meta-tty.c
+++ b/src/wayland/meta-tty.c
@@ -1,436 +0,0 @@
-/*
- * Copyright © 2010 Intel Corporation
- *             2013 Red Hat, Inc.
- *
- * Permission to use, copy, modify, distribute, and sell this software and
- * its documentation for any purpose is hereby granted without fee, provided
- * that the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of the copyright holders not be used in
- * advertising or publicity pertaining to distribution of the software
- * without specific, written prior permission.  The copyright holders make
- * no representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include "config.h"
-
-#include <termios.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <signal.h>
-#include <linux/kd.h>
-#include <linux/vt.h>
-#include <linux/major.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include "meta-tty.h"
-#include <gio/gio.h>
-#include <glib-unix.h>
-
-/* Introduced in 2.6.38 */
-#ifndef K_OFF
-#define K_OFF 0x04
-#endif
-
-struct _MetaTTYClass
-{
-  GObjectClass parent_class;
-};
-
-struct _MetaTTY
-{
-  GObject parent;
-
-  int fd;
-  struct termios terminal_attributes;
-
-  GMainContext *nested_context;
-  GMainLoop *nested_loop;
-
-  int input_source;
-  GSource *vt_enter_source, *vt_leave_source;
-  GSource *nested_term;
-  int vt, starting_vt;
-  int kb_mode;
-};
-
-enum {
-  SIGNAL_ENTER,
-  SIGNAL_LEAVE,
-  SIGNAL_LAST
-};
-
-static int signals[SIGNAL_LAST];
-
-static void meta_tty_initable_iface_init (GInitableIface *);
-
-G_DEFINE_TYPE_WITH_CODE (MetaTTY, meta_tty, G_TYPE_OBJECT,
-			 G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
-						meta_tty_initable_iface_init));
-
-static gboolean
-quit_nested_loop (gpointer user_data)
-{
-  MetaTTY *tty = user_data;
-
-  g_main_loop_quit (tty->nested_loop);
-
-  return FALSE;
-}
-
-static gboolean
-vt_release_handler (gpointer user_data)
-{
-  MetaTTY *tty = user_data;
-
-  g_signal_emit (tty, signals[SIGNAL_LEAVE], 0);
-
-  ioctl (tty->fd, VT_RELDISP, 1);
-
-  /* We can't do anything at this point, because we don't
-     have input devices and we don't have the DRM master,
-     so let's run a nested busy loop until the VT is reentered */
-  g_main_loop_run (tty->nested_loop);
-
-  ioctl (tty->fd, VT_RELDISP, VT_ACKACQ);
-
-  g_signal_emit (tty, signals[SIGNAL_ENTER], 0);
-
-  return FALSE;
-}
-
-static int
-on_tty_input (int          fd, 
-	      GIOCondition mask,
-	      gpointer     user_data)
-{
-  MetaTTY *tty = user_data;
-
-  /* Ignore input to tty.  We get keyboard events from evdev */
-  tcflush(tty->fd, TCIFLUSH);
-
-  return 1;
-}
-
-static int
-try_open_vt (MetaTTY  *tty,
-	     GError  **error)
-{
-  int tty0, fd;
-  char filename[16];
-
-  tty0 = open ("/dev/tty0", O_WRONLY | O_CLOEXEC);
-  if (tty0 < 0)
-    {
-      g_set_error (error, G_IO_ERROR,
-		   g_io_error_from_errno (errno),
-		   "Could not open tty0: %s", strerror (errno));
-      return -1;
-    }
-
-  if (ioctl (tty0, VT_OPENQRY, &tty->vt) < 0 || tty->vt == -1) {
-      g_set_error (error, G_IO_ERROR,
-		   g_io_error_from_errno (errno),
-		   "Could not open tty0: %s", strerror (errno));
-      close (tty0);
-      return -1;
-  }
-
-  close (tty0);
-  snprintf (filename, sizeof filename, "/dev/tty%d", tty->vt);
-  g_debug("compositor: using new vt %s\n", filename);
-  fd = open (filename, O_RDWR | O_NOCTTY | O_CLOEXEC);
-  return fd;
-}
-
-gboolean
-meta_tty_activate_vt (MetaTTY  *tty,
-		      int       vt,
-		      GError  **error)
-{
-  if (ioctl(tty->fd, VT_ACTIVATE, vt) < 0)
-    {
-      g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
-		   strerror (errno));
-      return FALSE;
-    }
-  else
-    return TRUE;
-}
-
-static int
-env_get_fd (const char *env)
-{
-  const char *value;
-
-  value = g_getenv (env);
-
-  if (value == NULL)
-    return -1;
-  else
-    return g_ascii_strtoll (value, NULL, 10);
-}
-
-static gboolean
-meta_tty_initable_init(GInitable     *initable,
-		       GCancellable  *cancellable,
-		       GError       **error)
-{
-  MetaTTY *tty = META_TTY (initable);
-  struct termios raw_attributes;
-  struct vt_mode mode = { 0 };
-  int ret;
-	
-  struct stat buf;
-  struct vt_stat vts;
-
-  tty->fd = env_get_fd ("WESTON_TTY_FD");
-  if (tty->fd < 0)
-    tty->fd = STDIN_FILENO;
-
-  if (fstat(tty->fd, &buf) == 0 &&
-      major(buf.st_rdev) == TTY_MAJOR &&
-      minor(buf.st_rdev) > 0)
-    {
-      if (tty->fd == STDIN_FILENO)
-	tty->fd = fcntl(STDIN_FILENO, F_DUPFD_CLOEXEC, 0);
-      tty->vt = minor(buf.st_rdev);
-    }
-  else
-    {
-      /* Fall back to try opening a new VT.  This typically
-       * requires root. */
-      tty->fd = try_open_vt(tty, error);
-    }
-
-  if (tty->fd <= 0 && (!error || !*error))
-    {
-      g_set_error (error, G_IO_ERROR,
-		   g_io_error_from_errno (errno),
-		   "Could not open tty0: %s", strerror (errno));
-      return FALSE;
-    }
-
-  if (ioctl(tty->fd, VT_GETSTATE, &vts) == 0)
-    tty->starting_vt = vts.v_active;
-  else
-    tty->starting_vt = tty->vt;
-  
-  if (tty->starting_vt != tty->vt)
-    {
-      if (ioctl(tty->fd, VT_ACTIVATE, tty->vt) < 0 ||
-	  ioctl(tty->fd, VT_WAITACTIVE, tty->vt) < 0)
-	{
-	  g_set_error (error, G_IO_ERROR,
-		       g_io_error_from_errno (errno),
-		       "Failed to switch to new vt: %s", strerror (errno));
-	  goto err;
-	}
-    }
-
-  if (tcgetattr(tty->fd, &tty->terminal_attributes) < 0)
-    {
-      g_set_error (error, G_IO_ERROR,
-		   g_io_error_from_errno (errno),
-		   "Could not get terminal attributes: %s", strerror (errno));
-      goto err;
-    }
-
-  /* Ignore control characters and disable echo */
-  raw_attributes = tty->terminal_attributes;
-  cfmakeraw(&raw_attributes);
-
-  /* Fix up line endings to be normal (cfmakeraw hoses them) */
-  raw_attributes.c_oflag |= OPOST | OCRNL;
-  /* Don't generate ttou signals */
-  raw_attributes.c_oflag &= ~TOSTOP;
-
-  if (tcsetattr(tty->fd, TCSANOW, &raw_attributes) < 0)
-    g_warning("Could not put terminal into raw mode: %s", strerror (errno));
-
-  ioctl(tty->fd, KDGKBMODE, &tty->kb_mode);
-  ret = ioctl(tty->fd, KDSKBMODE, K_OFF);
-  if (ret)
-    {
-      ret = ioctl(tty->fd, KDSKBMODE, K_RAW);
-      if (ret)
-	{
-	  g_set_error (error, G_IO_ERROR,
-		       g_io_error_from_errno (errno),
-		       "Failed to set keyboard mode: %s", strerror (errno));
-	  goto err_attr;
-	}
-
-      tty->input_source = g_unix_fd_add (tty->fd,
-					 G_IO_IN,
-					 on_tty_input, tty);
-    }
-
-  ret = ioctl(tty->fd, KDSETMODE, KD_GRAPHICS);
-  if (ret)
-    {
-      g_set_error (error, G_IO_ERROR,
-		   g_io_error_from_errno (errno),
-		   "Failed to set KD_GRAPHICS mode: %s", strerror (errno));
-      goto err_kdkbmode;
-    }
-
-  mode.mode = VT_PROCESS;
-  mode.relsig = SIGUSR1;
-  mode.acqsig = SIGUSR2;
-  if (ioctl(tty->fd, VT_SETMODE, &mode) < 0)
-    {
-      g_set_error (error, G_IO_ERROR,
-		   g_io_error_from_errno (errno),
-		   "Failed to take control of vt handling: %s", strerror (errno));
-      goto err_kdmode;
-    }
-
-  tty->vt_leave_source = g_unix_signal_source_new (SIGUSR1);
-  g_source_set_callback (tty->vt_leave_source, vt_release_handler, tty, NULL);
-
-  tty->vt_enter_source = g_unix_signal_source_new (SIGUSR2);
-  g_source_set_callback (tty->vt_enter_source, quit_nested_loop, tty, NULL);
-  tty->nested_term = g_unix_signal_source_new (SIGTERM);
-  g_source_set_callback (tty->nested_term, quit_nested_loop, tty, NULL);
-
-  tty->nested_context = g_main_context_new ();
-  tty->nested_loop = g_main_loop_new (tty->nested_context, FALSE);
-
-  g_source_attach (tty->vt_leave_source, NULL);
-  g_source_attach (tty->vt_enter_source, tty->nested_context);
-  g_source_attach (tty->nested_term, tty->nested_context);
-
-  return TRUE;
-
- err_kdmode:
-  ioctl (tty->fd, KDSETMODE, KD_TEXT);
-
- err_kdkbmode:
-  if (tty->input_source)
-    g_source_remove (tty->input_source);
-  ioctl (tty->fd, KDSKBMODE, tty->kb_mode);
-
- err_attr:
-  tcsetattr (tty->fd, TCSANOW, &tty->terminal_attributes);
-  
- err:
-  close (tty->fd);
-  return FALSE;
-}
-
-void
-meta_tty_reset (MetaTTY  *tty,
-		gboolean  warn_if_fail)
-{
-  struct vt_mode mode = { 0 };
-
-  if (ioctl (tty->fd, KDSKBMODE, tty->kb_mode) && warn_if_fail)
-    g_warning ("failed to restore keyboard mode: %s", strerror (errno));
-
-  if (ioctl (tty->fd, KDSETMODE, KD_TEXT) && warn_if_fail)
-    g_warning ("failed to set KD_TEXT mode on tty: %s", strerror (errno));
-
-  if (tcsetattr (tty->fd, TCSANOW, &tty->terminal_attributes) < 0 && warn_if_fail)
-    g_warning ("could not restore terminal to canonical mode");
-
-  mode.mode = VT_AUTO;
-  if (ioctl (tty->fd, VT_SETMODE, &mode) < 0 && warn_if_fail)
-    g_warning ("could not reset vt handling\n");
-
-  if (tty->vt != tty->starting_vt)
-    {
-      ioctl(tty->fd, VT_ACTIVATE, tty->starting_vt);
-      ioctl(tty->fd, VT_WAITACTIVE, tty->starting_vt);
-    }
-}
-
-static void
-meta_tty_finalize (GObject *object)
-{
-  MetaTTY *tty = META_TTY (object);
-
-  if (tty->input_source)
-    g_source_remove (tty->input_source);
-
-  g_source_destroy (tty->vt_enter_source);
-  g_source_destroy (tty->vt_leave_source);
-  g_source_destroy (tty->nested_term);
-
-  g_main_loop_unref (tty->nested_loop);
-  g_main_context_unref (tty->nested_context);
-
-  meta_tty_reset (tty, TRUE);
-
-  close (tty->fd);
-
-  G_OBJECT_CLASS (meta_tty_parent_class)->finalize (object);
-}
-
-static void
-meta_tty_init (MetaTTY *self)
-{
-}
-
-static void
-meta_tty_class_init (MetaTTYClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = meta_tty_finalize;
-
-  signals[SIGNAL_ENTER] = g_signal_new ("enter",
-					G_TYPE_FROM_CLASS (klass),
-					G_SIGNAL_RUN_FIRST,
-					0, /* class offset */
-					NULL, NULL, /* accumulator */
-					g_cclosure_marshal_VOID__VOID,
-					G_TYPE_NONE, 0);
-
-  signals[SIGNAL_LEAVE] = g_signal_new ("leave",
-					G_TYPE_FROM_CLASS (klass),
-					G_SIGNAL_RUN_FIRST,
-					0, /* class offset */
-					NULL, NULL, /* accumulator */
-					g_cclosure_marshal_VOID__VOID,
-					G_TYPE_NONE, 0);
-}
-
-static void
-meta_tty_initable_iface_init (GInitableIface *iface)
-{
-  iface->init = meta_tty_initable_init;
-}
-
-MetaTTY *
-meta_tty_new (void)
-{
-  GError *error;
-  MetaTTY *tty;
-
-  error = NULL;
-  tty = g_initable_new (META_TYPE_TTY, NULL, &error, NULL);
-
-  if (tty == NULL)
-    {
-      g_warning ("Failed to initalize TTY handling: %s", error->message);
-      g_error_free (error);
-    }
-
-  return tty;
-}
--- a/src/wayland/meta-tty.h
+++ b/src/wayland/meta-tty.h
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 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.
- */
-
-#ifndef META_TTY_H
-#define META_TTY_H
-
-#include <glib-object.h>
-
-G_BEGIN_DECLS
-
-#define META_TYPE_TTY              (meta_tty_get_type())
-#define META_TTY(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_TTY, MetaTTY))
-#define META_TTY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_TTY, MetaTTYClass))
-#define META_IS_TTY(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_TTY))
-#define META_IS_TTY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_TTY))
-#define META_TTY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TTY, MetaTTYClass))
-
-typedef struct _MetaTTY      MetaTTY;
-typedef struct _MetaTTYClass MetaTTYClass;
-
-GType             meta_tty_get_type                (void) G_GNUC_CONST;
-
-MetaTTY          *meta_tty_new                     (void);
-
-gboolean          meta_tty_activate_vt             (MetaTTY  *self,
-						    int       number,
-						    GError  **error);
-
-void              meta_tty_reset                   (MetaTTY  *self,
-						    gboolean  warn_if_fail);
-
-G_END_DECLS
-
-#endif /* META_TTY_H */
--- a/src/wayland/meta-wayland-data-device.c
+++ b/src/wayland/meta-wayland-data-device.c
@@ -1,548 +0,0 @@
-/*
- * Copyright © 2011 Kristian Høgsberg
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that copyright
- * notice and this permission notice appear in supporting documentation, and
- * that the name of the copyright holders not be used in advertising or
- * publicity pertaining to distribution of the software without specific,
- * written prior permission.  The copyright holders make no representations
- * about the suitability of this software for any purpose.  It is provided "as
- * is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
- * OF THIS SOFTWARE.
- */
-
-/* The file is based on src/data-device.c from Weston */
-
-#include "config.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <stdio.h>
-#include <glib.h>
-
-#include "meta-wayland-data-device.h"
-#include "meta-wayland-seat.h"
-#include "meta-wayland-pointer.h"
-
-static void
-data_offer_accept (struct wl_client *client,
-                   struct wl_resource *resource,
-                   guint32 serial,
-                   const char *mime_type)
-{
-  MetaWaylandDataOffer *offer = wl_resource_get_user_data (resource);
-
-  /* FIXME: Check that client is currently focused by the input
-   * device that is currently dragging this data source.  Should
-   * this be a wl_data_device request? */
-
-  if (offer->source)
-    offer->source->accept (offer->source, serial, mime_type);
-}
-
-static void
-data_offer_receive (struct wl_client *client, struct wl_resource *resource,
-                    const char *mime_type, int32_t fd)
-{
-  MetaWaylandDataOffer *offer = wl_resource_get_user_data (resource);
-
-  if (offer->source)
-    offer->source->send (offer->source, mime_type, fd);
-  else
-    close (fd);
-}
-
-static void
-data_offer_destroy (struct wl_client *client, struct wl_resource *resource)
-{
-  wl_resource_destroy (resource);
-}
-
-static const struct wl_data_offer_interface data_offer_interface = {
-  data_offer_accept,
-  data_offer_receive,
-  data_offer_destroy,
-};
-
-static void
-destroy_data_offer (struct wl_resource *resource)
-{
-  MetaWaylandDataOffer *offer = wl_resource_get_user_data (resource);
-
-  if (offer->source)
-    wl_list_remove (&offer->source_destroy_listener.link);
-  free (offer);
-}
-
-static void
-destroy_offer_data_source (struct wl_listener *listener, void *data)
-{
-  MetaWaylandDataOffer *offer;
-
-  offer = wl_container_of (listener, offer, source_destroy_listener);
-
-  offer->source = NULL;
-}
-
-static struct wl_resource *
-meta_wayland_data_source_send_offer (MetaWaylandDataSource *source,
-                                     struct wl_resource *target)
-{
-  MetaWaylandDataOffer *offer;
-  char **p;
-
-  offer = malloc (sizeof *offer);
-  if (offer == NULL)
-    return NULL;
-
-  offer->source = source;
-  offer->source_destroy_listener.notify = destroy_offer_data_source;
-
-  offer->resource = wl_client_add_object (wl_resource_get_client (target),
-                                          &wl_data_offer_interface,
-                                          &data_offer_interface,
-                                          0,
-                                          offer);
-  wl_resource_set_destructor (offer->resource, destroy_data_offer);
-  wl_resource_add_destroy_listener (source->resource,
-                                    &offer->source_destroy_listener);
-
-  wl_data_device_send_data_offer (target, offer->resource);
-
-  wl_array_for_each (p, &source->mime_types)
-    wl_data_offer_send_offer (offer->resource, *p);
-
-  return offer->resource;
-}
-
-static void
-data_source_offer (struct wl_client *client,
-                   struct wl_resource *resource, const char *type)
-{
-  MetaWaylandDataSource *source = wl_resource_get_user_data (resource);
-  char **p;
-
-  p = wl_array_add (&source->mime_types, sizeof *p);
-  if (p)
-    *p = strdup (type);
-  if (!p || !*p)
-    wl_resource_post_no_memory (resource);
-}
-
-static void
-data_source_destroy (struct wl_client *client, struct wl_resource *resource)
-{
-  wl_resource_destroy (resource);
-}
-
-static struct wl_data_source_interface data_source_interface = {
-  data_source_offer,
-  data_source_destroy
-};
-
-static void
-destroy_drag_focus (struct wl_listener *listener, void *data)
-{
-  MetaWaylandSeat *seat = wl_container_of (listener, seat, drag_focus_listener);
-
-  seat->drag_focus_resource = NULL;
-}
-
-static void
-drag_grab_focus (MetaWaylandPointerGrab *grab,
-                 MetaWaylandSurface *surface,
-                 wl_fixed_t x,
-                 wl_fixed_t y)
-{
-  MetaWaylandSeat *seat = wl_container_of (grab, seat, drag_grab);
-  struct wl_resource *resource, *offer = NULL;
-  struct wl_display *display;
-  guint32 serial;
-
-  if (seat->drag_focus_resource)
-    {
-      wl_data_device_send_leave (seat->drag_focus_resource);
-      wl_list_remove (&seat->drag_focus_listener.link);
-      seat->drag_focus_resource = NULL;
-      seat->drag_focus = NULL;
-    }
-
-  if (!surface)
-    return;
-
-  if (!seat->drag_data_source &&
-      wl_resource_get_client (surface->resource) != seat->drag_client)
-    return;
-
-  resource =
-    wl_resource_find_for_client (&seat->drag_resource_list,
-                                 wl_resource_get_client (surface->resource));
-  if (!resource)
-    return;
-
-  display = wl_client_get_display (wl_resource_get_client (resource));
-  serial = wl_display_next_serial (display);
-
-  if (seat->drag_data_source)
-    offer = meta_wayland_data_source_send_offer (seat->drag_data_source,
-                                                 resource);
-
-  wl_data_device_send_enter (resource, serial, surface->resource,
-                             x, y, offer);
-
-  seat->drag_focus = surface;
-  seat->drag_focus_listener.notify = destroy_drag_focus;
-  wl_resource_add_destroy_listener (resource, &seat->drag_focus_listener);
-  seat->drag_focus_resource = resource;
-  grab->focus = surface;
-}
-
-static void
-drag_grab_motion (MetaWaylandPointerGrab *grab,
-                  guint32 time, wl_fixed_t x, wl_fixed_t y)
-{
-  MetaWaylandSeat *seat = wl_container_of (grab, seat, drag_grab);
-
-  if (seat->drag_focus_resource)
-    wl_data_device_send_motion (seat->drag_focus_resource, time, x, y);
-}
-
-static void
-data_device_end_drag_grab (MetaWaylandSeat *seat)
-{
-  if (seat->drag_surface)
-    {
-      seat->drag_surface = NULL;
-      wl_signal_emit (&seat->drag_icon_signal, NULL);
-      wl_list_remove (&seat->drag_icon_listener.link);
-    }
-
-  drag_grab_focus (&seat->drag_grab, NULL,
-                   wl_fixed_from_int (0), wl_fixed_from_int (0));
-
-  meta_wayland_pointer_end_grab (&seat->pointer);
-
-  seat->drag_data_source = NULL;
-  seat->drag_client = NULL;
-}
-
-static void
-drag_grab_button (MetaWaylandPointerGrab *grab,
-                  guint32 time, guint32 button, guint32 state_w)
-{
-  MetaWaylandSeat *seat = wl_container_of (grab, seat, drag_grab);
-  enum wl_pointer_button_state state = state_w;
-
-  if (seat->drag_focus_resource &&
-      seat->pointer.grab_button == button &&
-      state == WL_POINTER_BUTTON_STATE_RELEASED)
-    wl_data_device_send_drop (seat->drag_focus_resource);
-
-  if (seat->pointer.button_count == 0 &&
-      state == WL_POINTER_BUTTON_STATE_RELEASED)
-    {
-      if (seat->drag_data_source)
-        wl_list_remove (&seat->drag_data_source_listener.link);
-      data_device_end_drag_grab (seat);
-    }
-}
-
-static const MetaWaylandPointerGrabInterface drag_grab_interface = {
-  drag_grab_focus,
-  drag_grab_motion,
-  drag_grab_button,
-};
-
-static void
-destroy_data_device_source (struct wl_listener *listener, void *data)
-{
-  MetaWaylandSeat *seat =
-    wl_container_of (listener, seat, drag_data_source_listener);
-
-  data_device_end_drag_grab (seat);
-}
-
-static void
-destroy_data_device_icon (struct wl_listener *listener, void *data)
-{
-  MetaWaylandSeat *seat =
-    wl_container_of (listener, seat, drag_icon_listener);
-
-  seat->drag_surface = NULL;
-}
-
-static void
-data_device_start_drag (struct wl_client *client,
-                        struct wl_resource *resource,
-                        struct wl_resource *source_resource,
-                        struct wl_resource *origin_resource,
-                        struct wl_resource *icon_resource, guint32 serial)
-{
-  MetaWaylandSeat *seat = wl_resource_get_user_data (resource);
-
-  /* FIXME: Check that client has implicit grab on the origin
-   * surface that matches the given time. */
-
-  /* FIXME: Check that the data source type array isn't empty. */
-
-  seat->drag_grab.interface = &drag_grab_interface;
-
-  seat->drag_client = client;
-  seat->drag_data_source = NULL;
-
-  if (source_resource)
-    {
-      seat->drag_data_source = wl_resource_get_user_data (source_resource);
-      seat->drag_data_source_listener.notify = destroy_data_device_source;
-      wl_resource_add_destroy_listener (source_resource,
-                                        &seat->drag_data_source_listener);
-    }
-
-  if (icon_resource)
-    {
-      seat->drag_surface = wl_resource_get_user_data (icon_resource);
-      seat->drag_icon_listener.notify = destroy_data_device_icon;
-      wl_resource_add_destroy_listener (icon_resource,
-                                        &seat->drag_icon_listener);
-      wl_signal_emit (&seat->drag_icon_signal, icon_resource);
-    }
-
-  meta_wayland_pointer_set_focus (&seat->pointer, NULL,
-                              wl_fixed_from_int (0),
-                              wl_fixed_from_int (0));
-  meta_wayland_pointer_start_grab (&seat->pointer, &seat->drag_grab);
-}
-
-static void
-destroy_selection_data_source (struct wl_listener *listener, void *data)
-{
-  MetaWaylandSeat *seat =
-    wl_container_of (listener, seat, selection_data_source_listener);
-  struct wl_resource *data_device;
-  struct wl_resource *focus = NULL;
-
-  seat->selection_data_source = NULL;
-
-  focus = seat->keyboard.focus_resource;
-
-  if (focus)
-    {
-      data_device =
-        wl_resource_find_for_client (&seat->drag_resource_list,
-                                     wl_resource_get_client (focus));
-      if (data_device)
-        wl_data_device_send_selection (data_device, NULL);
-    }
-
-  wl_signal_emit (&seat->selection_signal, seat);
-}
-
-void
-meta_wayland_seat_set_selection (MetaWaylandSeat *seat,
-                                 MetaWaylandDataSource *source,
-                                 guint32 serial)
-{
-  struct wl_resource *data_device, *offer;
-  struct wl_resource *focus = NULL;
-
-  if (seat->selection_data_source &&
-      seat->selection_serial - serial < UINT32_MAX / 2)
-    return;
-
-  if (seat->selection_data_source)
-    {
-      seat->selection_data_source->cancel (seat->selection_data_source);
-      wl_list_remove (&seat->selection_data_source_listener.link);
-      seat->selection_data_source = NULL;
-    }
-
-  seat->selection_data_source = source;
-  seat->selection_serial = serial;
-
-  focus = seat->keyboard.focus_resource;
-
-  if (focus)
-    {
-      data_device =
-        wl_resource_find_for_client (&seat->drag_resource_list,
-                                     wl_resource_get_client (focus));
-      if (data_device && source)
-        {
-          offer =
-            meta_wayland_data_source_send_offer (seat->selection_data_source,
-                                                 data_device);
-          wl_data_device_send_selection (data_device, offer);
-        }
-      else if (data_device)
-        {
-          wl_data_device_send_selection (data_device, NULL);
-        }
-    }
-
-  wl_signal_emit (&seat->selection_signal, seat);
-
-  if (source)
-    {
-      seat->selection_data_source_listener.notify =
-        destroy_selection_data_source;
-      wl_resource_add_destroy_listener (source->resource,
-                                        &seat->selection_data_source_listener);
-    }
-}
-
-static void
-data_device_set_selection (struct wl_client *client,
-                           struct wl_resource *resource,
-                           struct wl_resource *source_resource,
-                           guint32 serial)
-{
-  if (!source_resource)
-    return;
-
-  /* FIXME: Store serial and check against incoming serial here. */
-  meta_wayland_seat_set_selection (wl_resource_get_user_data (resource),
-                                   wl_resource_get_user_data (source_resource),
-                                   serial);
-}
-
-static const struct wl_data_device_interface data_device_interface = {
-  data_device_start_drag,
-  data_device_set_selection,
-};
-
-static void
-destroy_data_source (struct wl_resource *resource)
-{
-  MetaWaylandDataSource *source = wl_container_of (resource, source, resource);
-  char **p;
-
-  wl_array_for_each (p, &source->mime_types) free (*p);
-
-  wl_array_release (&source->mime_types);
-}
-
-static void
-client_source_accept (MetaWaylandDataSource *source,
-                      guint32 time, const char *mime_type)
-{
-  wl_data_source_send_target (source->resource, mime_type);
-}
-
-static void
-client_source_send (MetaWaylandDataSource *source,
-                    const char *mime_type, int32_t fd)
-{
-  wl_data_source_send_send (source->resource, mime_type, fd);
-  close (fd);
-}
-
-static void
-client_source_cancel (MetaWaylandDataSource *source)
-{
-  wl_data_source_send_cancelled (source->resource);
-}
-
-static void
-create_data_source (struct wl_client *client,
-                    struct wl_resource *resource, guint32 id)
-{
-  MetaWaylandDataSource *source;
-
-  source = malloc (sizeof *source);
-  if (source == NULL)
-    {
-      wl_resource_post_no_memory (resource);
-      return;
-    }
-
-  source->resource = wl_client_add_object (client,
-                                           &wl_data_source_interface,
-                                           &data_source_interface,
-                                           id,
-                                           source);
-  wl_resource_set_destructor (source->resource, destroy_data_source);
-
-  source->accept = client_source_accept;
-  source->send = client_source_send;
-  source->cancel = client_source_cancel;
-
-  wl_array_init (&source->mime_types);
-}
-
-static void
-unbind_data_device (struct wl_resource *resource)
-{
-  wl_list_remove (wl_resource_get_link (resource));
-}
-
-static void
-get_data_device (struct wl_client *client,
-                 struct wl_resource *manager_resource,
-                 guint32 id, struct wl_resource *seat_resource)
-{
-  MetaWaylandSeat *seat = wl_resource_get_user_data (seat_resource);
-  struct wl_resource *resource;
-
-  resource = wl_client_add_object (client, &wl_data_device_interface,
-                                   &data_device_interface, id, seat);
-
-  wl_list_insert (&seat->drag_resource_list, wl_resource_get_link (resource));
-  wl_resource_set_destructor (resource, unbind_data_device);
-}
-
-static const struct wl_data_device_manager_interface manager_interface = {
-  create_data_source,
-  get_data_device
-};
-
-static void
-bind_manager (struct wl_client *client,
-              void *data, guint32 version, guint32 id)
-{
-  wl_client_add_object (client, &wl_data_device_manager_interface,
-                        &manager_interface, id, NULL);
-}
-
-void
-meta_wayland_data_device_set_keyboard_focus (MetaWaylandSeat *seat)
-{
-  struct wl_resource *data_device, *focus, *offer;
-  MetaWaylandDataSource *source;
-
-  focus = seat->keyboard.focus_resource;
-  if (!focus)
-    return;
-
-  data_device = wl_resource_find_for_client (&seat->drag_resource_list,
-                                             wl_resource_get_client (focus));
-  if (!data_device)
-    return;
-
-  source = seat->selection_data_source;
-  if (source)
-    {
-      offer = meta_wayland_data_source_send_offer (source, data_device);
-      wl_data_device_send_selection (data_device, offer);
-    }
-}
-
-int
-meta_wayland_data_device_manager_init (struct wl_display *display)
-{
-  if (wl_display_add_global (display,
-                             &wl_data_device_manager_interface,
-                             NULL, bind_manager) == NULL)
-    return -1;
-
-  return 0;
-}
--- a/src/wayland/meta-wayland-data-device.h
+++ b/src/wayland/meta-wayland-data-device.h
@@ -1,42 +0,0 @@
-/*
- * Copyright © 2008 Kristian Høgsberg
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that copyright
- * notice and this permission notice appear in supporting documentation, and
- * that the name of the copyright holders not be used in advertising or
- * publicity pertaining to distribution of the software without specific,
- * written prior permission.  The copyright holders make no representations
- * about the suitability of this software for any purpose.  It is provided "as
- * is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
- * OF THIS SOFTWARE.
- */
-
-#ifndef __META_WAYLAND_DATA_DEVICE_H__
-#define __META_WAYLAND_DATA_DEVICE_H__
-
-#include <wayland-server.h>
-
-#include "meta-wayland-seat.h"
-
-void
-meta_wayland_data_device_set_keyboard_focus (MetaWaylandSeat *seat);
-
-int
-meta_wayland_data_device_manager_init (struct wl_display *display);
-
-void
-meta_wayland_seat_set_selection (MetaWaylandSeat *seat,
-                                 MetaWaylandDataSource *source,
-                                 uint32_t serial);
-
-
-#endif /* __META_WAYLAND_DATA_DEVICE_H__ */
--- a/src/wayland/meta-wayland-keyboard.c
+++ b/src/wayland/meta-wayland-keyboard.c
@@ -1,618 +0,0 @@
-/*
- * Wayland Support
- *
- * Copyright (C) 2013 Intel Corporation
- *
- * 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.
- */
-
-/*
- * Copyright © 2010-2011 Intel Corporation
- * Copyright © 2008-2011 Kristian Høgsberg
- * Copyright © 2012 Collabora, Ltd.
- *
- * Permission to use, copy, modify, distribute, and sell this software and
- * its documentation for any purpose is hereby granted without fee, provided
- * that the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of the copyright holders not be used in
- * advertising or publicity pertaining to distribution of the software
- * without specific, written prior permission.  The copyright holders make
- * no representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-/* The file is based on src/input.c from Weston */
-
-#define _GNU_SOURCE
-
-#include "config.h"
-
-#include <glib.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <clutter/evdev/clutter-evdev.h>
-
-#include "meta-wayland-keyboard.h"
-
-static MetaWaylandSeat *
-meta_wayland_keyboard_get_seat (MetaWaylandKeyboard *keyboard)
-{
-  MetaWaylandSeat *seat = wl_container_of (keyboard, seat, keyboard);
-
-  return seat;
-}
-
-static int
-create_anonymous_file (off_t size,
-                       GError **error)
-{
-  static const char template[] = "mutter-shared-XXXXXX";
-  char *path;
-  int fd, flags;
-
-  fd = g_file_open_tmp (template, &path, error);
-
-  if (fd == -1)
-    return -1;
-
-  unlink (path);
-  g_free (path);
-
-  flags = fcntl (fd, F_GETFD);
-  if (flags == -1)
-    goto err;
-
-  if (fcntl (fd, F_SETFD, flags | FD_CLOEXEC) == -1)
-    goto err;
-
-  if (ftruncate (fd, size) < 0)
-    goto err;
-
-  return fd;
-
- err:
-  g_set_error_literal (error,
-                       G_FILE_ERROR,
-                       g_file_error_from_errno (errno),
-                       strerror (errno));
-  close (fd);
-
-  return -1;
-}
-
-static gboolean
-meta_wayland_xkb_info_new_keymap (MetaWaylandXkbInfo *xkb_info)
-{
-  GError *error = NULL;
-  char *keymap_str;
-
-  xkb_info->shift_mod =
-    xkb_map_mod_get_index (xkb_info->keymap, XKB_MOD_NAME_SHIFT);
-  xkb_info->caps_mod =
-    xkb_map_mod_get_index (xkb_info->keymap, XKB_MOD_NAME_CAPS);
-  xkb_info->ctrl_mod =
-    xkb_map_mod_get_index (xkb_info->keymap, XKB_MOD_NAME_CTRL);
-  xkb_info->alt_mod =
-    xkb_map_mod_get_index (xkb_info->keymap, XKB_MOD_NAME_ALT);
-  xkb_info->mod2_mod = xkb_map_mod_get_index (xkb_info->keymap, "Mod2");
-  xkb_info->mod3_mod = xkb_map_mod_get_index (xkb_info->keymap, "Mod3");
-  xkb_info->super_mod =
-    xkb_map_mod_get_index (xkb_info->keymap, XKB_MOD_NAME_LOGO);
-  xkb_info->mod5_mod = xkb_map_mod_get_index (xkb_info->keymap, "Mod5");
-
-  keymap_str = xkb_map_get_as_string (xkb_info->keymap);
-  if (keymap_str == NULL)
-    {
-      g_warning ("failed to get string version of keymap\n");
-      return FALSE;
-    }
-  xkb_info->keymap_size = strlen (keymap_str) + 1;
-
-  xkb_info->keymap_fd = create_anonymous_file (xkb_info->keymap_size, &error);
-  if (xkb_info->keymap_fd < 0)
-    {
-      g_warning ("creating a keymap file for %lu bytes failed: %s\n",
-                 (unsigned long) xkb_info->keymap_size,
-                 error->message);
-      g_clear_error (&error);
-      goto err_keymap_str;
-    }
-
-  xkb_info->keymap_area = mmap (NULL, xkb_info->keymap_size,
-                                PROT_READ | PROT_WRITE,
-                                MAP_SHARED, xkb_info->keymap_fd, 0);
-  if (xkb_info->keymap_area == MAP_FAILED)
-    {
-      g_warning ("failed to mmap() %lu bytes\n",
-                 (unsigned long) xkb_info->keymap_size);
-      goto err_dev_zero;
-    }
-  strcpy (xkb_info->keymap_area, keymap_str);
-  free (keymap_str);
-
-  return TRUE;
-
-err_dev_zero:
-  close (xkb_info->keymap_fd);
-  xkb_info->keymap_fd = -1;
-err_keymap_str:
-  free (keymap_str);
-  return FALSE;
-}
-
-static gboolean
-meta_wayland_keyboard_build_global_keymap (struct xkb_context *xkb_context,
-                                           struct xkb_rule_names *xkb_names,
-                                           MetaWaylandXkbInfo *xkb_info)
-{
-  xkb_info->keymap = xkb_map_new_from_names (xkb_context,
-                                             xkb_names,
-                                             0 /* flags */);
-  if (xkb_info->keymap == NULL)
-    {
-      g_warning ("failed to compile global XKB keymap\n"
-                 "  tried rules %s, model %s, layout %s, variant %s, "
-                 "options %s\n",
-                 xkb_names->rules,
-                 xkb_names->model,
-                 xkb_names->layout,
-                 xkb_names->variant,
-                 xkb_names->options);
-      return FALSE;
-    }
-
-  if (!meta_wayland_xkb_info_new_keymap (xkb_info))
-    return FALSE;
-
-  return TRUE;
-}
-
-static void
-lose_keyboard_focus (struct wl_listener *listener, void *data)
-{
-  MetaWaylandKeyboard *keyboard =
-    wl_container_of (listener, keyboard, focus_listener);
-
-  keyboard->focus_resource = NULL;
-}
-
-static void
-default_grab_key (MetaWaylandKeyboardGrab *grab,
-                  uint32_t time, uint32_t key, uint32_t state)
-{
-  MetaWaylandKeyboard *keyboard = grab->keyboard;
-  struct wl_resource *resource;
-  uint32_t serial;
-
-  resource = keyboard->focus_resource;
-  if (resource)
-    {
-      struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display = wl_client_get_display (client);
-      serial = wl_display_next_serial (display);
-      wl_keyboard_send_key (resource, serial, time, key, state);
-    }
-}
-
-static struct wl_resource *
-find_resource_for_surface (struct wl_list *list, MetaWaylandSurface *surface)
-{
-  struct wl_client *client;
-
-  if (!surface)
-    return NULL;
-
-  if (!surface->resource)
-    return NULL;
-
-  client = wl_resource_get_client (surface->resource);
-
-  return wl_resource_find_for_client (list, client);
-}
-
-static void
-default_grab_modifiers (MetaWaylandKeyboardGrab *grab, uint32_t serial,
-                        uint32_t mods_depressed, uint32_t mods_latched,
-                        uint32_t mods_locked, uint32_t group)
-{
-  MetaWaylandKeyboard *keyboard = grab->keyboard;
-  MetaWaylandSeat *seat = meta_wayland_keyboard_get_seat (keyboard);
-  MetaWaylandPointer *pointer = &seat->pointer;
-  struct wl_resource *resource, *pr;
-
-  resource = keyboard->focus_resource;
-  if (!resource)
-    return;
-
-  wl_keyboard_send_modifiers (resource, serial, mods_depressed,
-                              mods_latched, mods_locked, group);
-
-  if (pointer && pointer->focus && pointer->focus != keyboard->focus)
-    {
-      pr = find_resource_for_surface (&keyboard->resource_list,
-                                      pointer->focus);
-      if (pr)
-        {
-          wl_keyboard_send_modifiers (pr, serial,
-				      mods_depressed,
-                                      mods_latched,
-                                      mods_locked,
-                                      group);
-        }
-    }
-}
-
-static const MetaWaylandKeyboardGrabInterface
-  default_keyboard_grab_interface = {
-  default_grab_key,
-  default_grab_modifiers,
-};
-
-gboolean
-meta_wayland_keyboard_init (MetaWaylandKeyboard *keyboard,
-                            struct wl_display   *display,
-			    gboolean             is_evdev)
-{
-  ClutterDeviceManager *manager;
-
-  memset (keyboard, 0, sizeof *keyboard);
-
-  wl_list_init (&keyboard->resource_list);
-  wl_array_init (&keyboard->keys);
-  keyboard->focus_listener.notify = lose_keyboard_focus;
-  keyboard->default_grab.interface = &default_keyboard_grab_interface;
-  keyboard->default_grab.keyboard = keyboard;
-  keyboard->grab = &keyboard->default_grab;
-  wl_signal_init (&keyboard->focus_signal);
-
-  keyboard->display = display;
-
-  keyboard->xkb_context = xkb_context_new (0 /* flags */);
-
-  meta_wayland_keyboard_build_global_keymap (keyboard->xkb_context,
-					     &keyboard->xkb_names,
-					     &keyboard->xkb_info);
-
-  keyboard->is_evdev = is_evdev;
-  if (is_evdev)
-    {
-      manager = clutter_device_manager_get_default ();
-
-      clutter_evdev_set_keyboard_map (manager, keyboard->xkb_info.keymap);
-      keyboard->xkb_state = clutter_evdev_get_keyboard_state (manager);
-      xkb_state_ref (keyboard->xkb_state);
-    }
-  else
-    {
-      keyboard->xkb_state = xkb_state_new (keyboard->xkb_info.keymap);
-    }
-
-  return TRUE;
-}
-
-static void
-meta_wayland_xkb_info_destroy (MetaWaylandXkbInfo *xkb_info)
-{
-  if (xkb_info->keymap)
-    xkb_map_unref (xkb_info->keymap);
-
-  if (xkb_info->keymap_area)
-    munmap (xkb_info->keymap_area, xkb_info->keymap_size);
-  if (xkb_info->keymap_fd >= 0)
-    close (xkb_info->keymap_fd);
-}
-
-static void
-update_state_from_clutter (MetaWaylandKeyboard *keyboard,
-			   ClutterModifierType  modifier_state)
-{
-  uint32_t depressed_mods = 0;
-  uint32_t locked_mods = 0;
-
-  if ((modifier_state & CLUTTER_SHIFT_MASK) &&
-      keyboard->xkb_info.shift_mod != XKB_MOD_INVALID)
-    depressed_mods |= (1 << keyboard->xkb_info.shift_mod);
-
-  if ((modifier_state & CLUTTER_LOCK_MASK) &&
-      keyboard->xkb_info.caps_mod != XKB_MOD_INVALID)
-    locked_mods |= (1 << keyboard->xkb_info.caps_mod);
-
-  if ((modifier_state & CLUTTER_CONTROL_MASK) &&
-      keyboard->xkb_info.ctrl_mod != XKB_MOD_INVALID)
-    depressed_mods |= (1 << keyboard->xkb_info.ctrl_mod);
-
-  if ((modifier_state & CLUTTER_MOD1_MASK) &&
-      keyboard->xkb_info.alt_mod != XKB_MOD_INVALID)
-    depressed_mods |= (1 << keyboard->xkb_info.alt_mod);
-
-  if ((modifier_state & CLUTTER_MOD2_MASK) &&
-      keyboard->xkb_info.mod2_mod != XKB_MOD_INVALID)
-    depressed_mods |= (1 << keyboard->xkb_info.mod2_mod);
-
-  if ((modifier_state & CLUTTER_MOD3_MASK) &&
-      keyboard->xkb_info.mod3_mod != XKB_MOD_INVALID)
-    depressed_mods |= (1 << keyboard->xkb_info.mod3_mod);
-
-  if ((modifier_state & CLUTTER_SUPER_MASK) &&
-      keyboard->xkb_info.super_mod != XKB_MOD_INVALID)
-    depressed_mods |= (1 << keyboard->xkb_info.super_mod);
-
-  if ((modifier_state & CLUTTER_MOD5_MASK) &&
-      keyboard->xkb_info.mod5_mod != XKB_MOD_INVALID)
-    depressed_mods |= (1 << keyboard->xkb_info.mod5_mod);
-
-  xkb_state_update_mask (keyboard->xkb_state,
-			 depressed_mods,
-			 0,
-			 locked_mods,
-			 0, 0, 0);
-}
-
-static gboolean
-state_equal (MetaWaylandXkbState *one,
-	     MetaWaylandXkbState *two)
-{
-  return one->mods_depressed == two->mods_depressed &&
-    one->mods_latched == two->mods_latched &&
-    one->mods_locked == two->mods_locked &&
-    one->group == two->group;
-}
-
-static void
-set_modifiers (MetaWaylandKeyboard *keyboard,
-               guint32 serial,
-               ClutterModifierType modifier_state)
-{
-  MetaWaylandKeyboardGrab *grab = keyboard->grab;
-  MetaWaylandXkbState new_state;
-
-  /* In the evdev case, the state is shared with the clutter backend, so
-     we don't need to update it */
-  if (!keyboard->is_evdev)
-    update_state_from_clutter (keyboard, modifier_state);
-
-  new_state.mods_depressed = xkb_state_serialize_mods (keyboard->xkb_state,
-						       XKB_STATE_MODS_DEPRESSED);
-  new_state.mods_latched = xkb_state_serialize_mods (keyboard->xkb_state,
-						     XKB_STATE_MODS_LATCHED);
-  new_state.mods_locked = xkb_state_serialize_mods (keyboard->xkb_state,
-						    XKB_STATE_MODS_LOCKED);
-  new_state.group = xkb_state_serialize_layout (keyboard->xkb_state,
-						XKB_STATE_LAYOUT_EFFECTIVE);
-
-  if (state_equal (&keyboard->modifier_state, &new_state))
-    return;
-
-  keyboard->modifier_state = new_state;
-
-  grab->interface->modifiers (grab,
-                              serial,
-                              new_state.mods_depressed,
-			      new_state.mods_latched,
-			      new_state.mods_locked,
-                              new_state.group);
-}
-
-void
-meta_wayland_keyboard_handle_event (MetaWaylandKeyboard *keyboard,
-                                    const ClutterKeyEvent *event)
-{
-  gboolean state = event->type == CLUTTER_KEY_PRESS;
-  guint evdev_code;
-  uint32_t serial;
-
-  /* We can't do anything with the event if we can't get an evdev
-     keycode for it */
-  if (event->device == NULL ||
-      !clutter_input_device_keycode_to_evdev (event->device,
-                                              event->hardware_keycode,
-                                              &evdev_code))
-    return;
-
-  /* We want to ignore events that are sent because of auto-repeat. In
-     the Clutter event stream these appear as a single key press
-     event. We can detect that because the key will already have been
-     pressed */
-  if (state)
-    {
-      uint32_t *end = (void *) ((char *) keyboard->keys.data +
-                                keyboard->keys.size);
-      uint32_t *k;
-
-      /* Ignore the event if the key is already down */
-      for (k = keyboard->keys.data; k < end; k++)
-        if (*k == evdev_code)
-          return;
-
-      /* Otherwise add the key to the list of pressed keys */
-      k = wl_array_add (&keyboard->keys, sizeof (*k));
-      *k = evdev_code;
-    }
-  else
-    {
-      uint32_t *end = (void *) ((char *) keyboard->keys.data +
-                                keyboard->keys.size);
-      uint32_t *k;
-
-      /* Remove the key from the array */
-      for (k = keyboard->keys.data; k < end; k++)
-        if (*k == evdev_code)
-          {
-            *k = *(end - 1);
-            keyboard->keys.size -= sizeof (*k);
-
-            goto found;
-          }
-
-      g_warning ("unexpected key release event for key 0x%x (%d)", evdev_code, event->keyval);
-
-    found:
-      (void) 0;
-    }
-
-  serial = wl_display_next_serial (keyboard->display);
-
-  set_modifiers (keyboard, serial, event->modifier_state);
-
-  keyboard->grab->interface->key (keyboard->grab,
-                                  event->time,
-                                  evdev_code,
-                                  state);
-}
-
-void
-meta_wayland_keyboard_set_focus (MetaWaylandKeyboard *keyboard,
-                                 MetaWaylandSurface *surface)
-{
-  struct wl_resource *resource;
-  uint32_t serial;
-
-  if (keyboard->focus_resource && keyboard->focus != surface)
-    {
-      struct wl_display *display;
-      struct wl_client *client;
-
-      resource = keyboard->focus_resource;
-      client = wl_resource_get_client (resource);
-      display = wl_client_get_display (client);
-      serial = wl_display_next_serial (display);
-      wl_keyboard_send_leave (resource, serial, keyboard->focus->resource);
-      wl_list_remove (&keyboard->focus_listener.link);
-    }
-
-  resource = find_resource_for_surface (&keyboard->resource_list, surface);
-  if (resource &&
-      (keyboard->focus != surface || keyboard->focus_resource != resource))
-    {
-      struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display;
-
-      display = wl_client_get_display (client);
-      serial = wl_display_next_serial (display);
-      wl_keyboard_send_modifiers (resource, serial,
-                                  keyboard->modifier_state.mods_depressed,
-                                  keyboard->modifier_state.mods_latched,
-                                  keyboard->modifier_state.mods_locked,
-                                  keyboard->modifier_state.group);
-      wl_keyboard_send_enter (resource, serial, surface->resource,
-                              &keyboard->keys);
-      wl_resource_add_destroy_listener (resource, &keyboard->focus_listener);
-      keyboard->focus_serial = serial;
-    }
-
-  keyboard->focus_resource = resource;
-  keyboard->focus = surface;
-  wl_signal_emit (&keyboard->focus_signal, keyboard);
-}
-
-void
-meta_wayland_keyboard_start_grab (MetaWaylandKeyboard *keyboard,
-                                  MetaWaylandKeyboardGrab *grab)
-{
-  keyboard->grab = grab;
-  grab->keyboard = keyboard;
-
-  /* XXX focus? */
-}
-
-void
-meta_wayland_keyboard_end_grab (MetaWaylandKeyboard *keyboard)
-{
-  keyboard->grab = &keyboard->default_grab;
-}
-
-void
-meta_wayland_keyboard_release (MetaWaylandKeyboard *keyboard)
-{
-  g_free ((char *) keyboard->xkb_names.rules);
-  g_free ((char *) keyboard->xkb_names.model);
-  g_free ((char *) keyboard->xkb_names.layout);
-  g_free ((char *) keyboard->xkb_names.variant);
-  g_free ((char *) keyboard->xkb_names.options);
-
-  meta_wayland_xkb_info_destroy (&keyboard->xkb_info);
-  xkb_context_unref (keyboard->xkb_context);
-  xkb_state_unref (keyboard->xkb_state);
-
-  /* XXX: What about keyboard->resource_list? */
-  if (keyboard->focus_resource)
-    wl_list_remove (&keyboard->focus_listener.link);
-  wl_array_release (&keyboard->keys);
-}
-
-static void
-modal_key (MetaWaylandKeyboardGrab *grab,
-	   uint32_t                 time,
-	   uint32_t                 key,
-	   uint32_t                 state)
-{
-}
-
-static void
-modal_modifiers (MetaWaylandKeyboardGrab *grab,
-		 uint32_t                 serial,
-		 uint32_t                 mods_depressed,
-		 uint32_t                 mods_latched,
-		 uint32_t                 mods_locked,
-		 uint32_t                 group)
-{
-}
-
-static MetaWaylandKeyboardGrabInterface modal_grab = {
-  modal_key,
-  modal_modifiers,
-};
-
-gboolean
-meta_wayland_keyboard_begin_modal (MetaWaylandKeyboard *keyboard)
-{
-  MetaWaylandKeyboardGrab *grab;
-
-  if (keyboard->grab != &keyboard->default_grab)
-    return FALSE;
-
-  grab = g_slice_new0 (MetaWaylandKeyboardGrab);
-  grab->interface = &modal_grab;
-  meta_wayland_keyboard_start_grab (keyboard, grab);
-
-  return TRUE;
-}
-
-void
-meta_wayland_keyboard_end_modal (MetaWaylandKeyboard *keyboard)
-{
-  MetaWaylandKeyboardGrab *grab;
-
-  grab = keyboard->grab;
-
-  g_assert (grab->interface == &modal_grab);
-
-  meta_wayland_keyboard_end_grab (keyboard);
-  g_slice_free (MetaWaylandKeyboardGrab, grab);
-}
--- a/src/wayland/meta-wayland-keyboard.h
+++ b/src/wayland/meta-wayland-keyboard.h
@@ -1,81 +0,0 @@
-/*
- * Wayland Support
- *
- * Copyright (C) 2013 Intel Corporation
- *
- * 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.
- */
-
-/*
- * Copyright © 2008-2011 Kristian Høgsberg
- * Copyright © 2012 Collabora, Ltd.
- *
- * Permission to use, copy, modify, distribute, and sell this software and
- * its documentation for any purpose is hereby granted without fee, provided
- * that the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of the copyright holders not be used in
- * advertising or publicity pertaining to distribution of the software
- * without specific, written prior permission.  The copyright holders make
- * no representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef __META_WAYLAND_KEYBOARD_H__
-#define __META_WAYLAND_KEYBOARD_H__
-
-#include <clutter/clutter.h>
-#include <wayland-server.h>
-
-#include "meta-wayland-seat.h"
-
-gboolean
-meta_wayland_keyboard_init (MetaWaylandKeyboard *keyboard,
-                            struct wl_display   *display,
-			    gboolean             is_evdev);
-
-void
-meta_wayland_keyboard_handle_event (MetaWaylandKeyboard *keyboard,
-                                    const ClutterKeyEvent *event);
-
-void
-meta_wayland_keyboard_set_focus (MetaWaylandKeyboard *keyboard,
-                                 MetaWaylandSurface *surface);
-
-void
-meta_wayland_keyboard_start_grab (MetaWaylandKeyboard *device,
-                                  MetaWaylandKeyboardGrab *grab);
-
-void
-meta_wayland_keyboard_end_grab (MetaWaylandKeyboard *keyboard);
-
-gboolean
-meta_wayland_keyboard_begin_modal (MetaWaylandKeyboard *keyboard);
-void
-meta_wayland_keyboard_end_modal   (MetaWaylandKeyboard *keyboard);
-
-void
-meta_wayland_keyboard_release (MetaWaylandKeyboard *keyboard);
-
-#endif /* __META_WAYLAND_KEYBOARD_H__ */
--- a/src/wayland/meta-wayland-pointer.c
+++ b/src/wayland/meta-wayland-pointer.c
@@ -1,326 +0,0 @@
-/*
- * Wayland Support
- *
- * Copyright (C) 2013 Intel Corporation
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * Copyright © 2008 Kristian Høgsberg
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that copyright
- * notice and this permission notice appear in supporting documentation, and
- * that the name of the copyright holders not be used in advertising or
- * publicity pertaining to distribution of the software without specific,
- * written prior permission.  The copyright holders make no representations
- * about the suitability of this software for any purpose.  It is provided "as
- * is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
- * OF THIS SOFTWARE.
- */
-
-/* The file is based on src/input.c from Weston */
-
-#include "config.h"
-
-#include "meta-wayland-pointer.h"
-
-#include <string.h>
-
-static MetaWaylandSeat *
-meta_wayland_pointer_get_seat (MetaWaylandPointer *pointer)
-{
-  MetaWaylandSeat *seat = wl_container_of (pointer, seat, pointer);
-
-  return seat;
-}
-
-static void
-lose_pointer_focus (struct wl_listener *listener, void *data)
-{
-  MetaWaylandPointer *pointer =
-    wl_container_of (listener, pointer, focus_listener);
-
-  pointer->focus_resource = NULL;
-  pointer->focus = NULL;
-}
-
-static void
-default_grab_focus (MetaWaylandPointerGrab *grab,
-                    MetaWaylandSurface *surface,
-                    wl_fixed_t x,
-                    wl_fixed_t y)
-{
-  MetaWaylandPointer *pointer = grab->pointer;
-
-  if (pointer->button_count > 0)
-    return;
-
-  meta_wayland_pointer_set_focus (pointer, surface, x, y);
-}
-
-static void
-default_grab_motion (MetaWaylandPointerGrab *grab,
-                     uint32_t time, wl_fixed_t x, wl_fixed_t y)
-{
-  struct wl_resource *resource;
-
-  resource = grab->pointer->focus_resource;
-  if (resource)
-    wl_pointer_send_motion (resource, time, x, y);
-}
-
-static void
-default_grab_button (MetaWaylandPointerGrab *grab,
-                     uint32_t time, uint32_t button, uint32_t state_w)
-{
-  MetaWaylandPointer *pointer = grab->pointer;
-  struct wl_resource *resource;
-  uint32_t serial;
-  enum wl_pointer_button_state state = state_w;
-
-  resource = pointer->focus_resource;
-  if (resource)
-    {
-      struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display = wl_client_get_display (client);
-      serial = wl_display_next_serial (display);
-      wl_pointer_send_button (resource, serial, time, button, state_w);
-    }
-
-  if (pointer->button_count == 0 && state == WL_POINTER_BUTTON_STATE_RELEASED)
-    meta_wayland_pointer_set_focus (pointer, pointer->current,
-                                pointer->current_x, pointer->current_y);
-}
-
-static const MetaWaylandPointerGrabInterface default_pointer_grab_interface = {
-  default_grab_focus,
-  default_grab_motion,
-  default_grab_button
-};
-
-void
-meta_wayland_pointer_init (MetaWaylandPointer *pointer)
-{
-  memset (pointer, 0, sizeof *pointer);
-  wl_list_init (&pointer->resource_list);
-  pointer->focus_listener.notify = lose_pointer_focus;
-  pointer->default_grab.interface = &default_pointer_grab_interface;
-  pointer->default_grab.pointer = pointer;
-  pointer->grab = &pointer->default_grab;
-  wl_signal_init (&pointer->focus_signal);
-
-  /* FIXME: Pick better co-ords. */
-  pointer->x = wl_fixed_from_int (100);
-  pointer->y = wl_fixed_from_int (100);
-}
-
-void
-meta_wayland_pointer_release (MetaWaylandPointer *pointer)
-{
-  /* XXX: What about pointer->resource_list? */
-  if (pointer->focus_resource)
-    wl_list_remove (&pointer->focus_listener.link);
-
-  pointer->focus = NULL;
-  pointer->focus_resource = NULL;
-}
-
-static struct wl_resource *
-find_resource_for_surface (struct wl_list *list, MetaWaylandSurface *surface)
-{
-  struct wl_client *client;
-
-  if (!surface)
-    return NULL;
-
-  g_assert (surface->resource);
-  client = wl_resource_get_client (surface->resource);
-
-  return wl_resource_find_for_client (list, client);
-}
-
-void
-meta_wayland_pointer_set_focus (MetaWaylandPointer *pointer,
-                                MetaWaylandSurface *surface,
-                                wl_fixed_t sx, wl_fixed_t sy)
-{
-  MetaWaylandSeat *seat = meta_wayland_pointer_get_seat (pointer);
-  MetaWaylandKeyboard *kbd = &seat->keyboard;
-  struct wl_resource *resource, *kr;
-  uint32_t serial;
-
-  resource = pointer->focus_resource;
-  if (resource && pointer->focus != surface)
-    {
-      struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display = wl_client_get_display (client);
-      serial = wl_display_next_serial (display);
-      wl_pointer_send_leave (resource, serial, pointer->focus->resource);
-      wl_list_remove (&pointer->focus_listener.link);
-    }
-
-  resource = find_resource_for_surface (&pointer->resource_list, surface);
-  if (resource &&
-      (pointer->focus != surface || pointer->focus_resource != resource))
-    {
-      struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display = wl_client_get_display (client);
-      serial = wl_display_next_serial (display);
-      if (kbd)
-        {
-          kr = find_resource_for_surface (&kbd->resource_list, surface);
-          if (kr)
-            {
-              wl_keyboard_send_modifiers (kr,
-                                          serial,
-                                          kbd->modifier_state.mods_depressed,
-                                          kbd->modifier_state.mods_latched,
-                                          kbd->modifier_state.mods_locked,
-                                          kbd->modifier_state.group);
-            }
-        }
-      wl_pointer_send_enter (resource, serial, surface->resource, sx, sy);
-      wl_resource_add_destroy_listener (resource, &pointer->focus_listener);
-      pointer->focus_serial = serial;
-    }
-
-  pointer->focus_resource = resource;
-  pointer->focus = surface;
-  pointer->default_grab.focus = surface;
-  wl_signal_emit (&pointer->focus_signal, pointer);
-}
-
-void
-meta_wayland_pointer_start_grab (MetaWaylandPointer *pointer,
-                                 MetaWaylandPointerGrab *grab)
-{
-  const MetaWaylandPointerGrabInterface *interface;
-
-  pointer->grab = grab;
-  interface = pointer->grab->interface;
-  grab->pointer = pointer;
-
-  if (pointer->current)
-    interface->focus (pointer->grab, pointer->current,
-                      pointer->current_x, pointer->current_y);
-}
-
-void
-meta_wayland_pointer_end_grab (MetaWaylandPointer *pointer)
-{
-  const MetaWaylandPointerGrabInterface *interface;
-
-  pointer->grab = &pointer->default_grab;
-  interface = pointer->grab->interface;
-  interface->focus (pointer->grab, pointer->current,
-                    pointer->current_x, pointer->current_y);
-}
-
-static void
-current_surface_destroy (struct wl_listener *listener, void *data)
-{
-  MetaWaylandPointer *pointer =
-    wl_container_of (listener, pointer, current_listener);
-
-  pointer->current = NULL;
-}
-
-void
-meta_wayland_pointer_set_current (MetaWaylandPointer *pointer,
-                                  MetaWaylandSurface *surface)
-{
-  if (pointer->current)
-    wl_list_remove (&pointer->current_listener.link);
-
-  pointer->current = surface;
-
-  if (!surface)
-    return;
-
-  wl_resource_add_destroy_listener (surface->resource,
-                                    &pointer->current_listener);
-  pointer->current_listener.notify = current_surface_destroy;
-}
-
-static void
-modal_focus (MetaWaylandPointerGrab *grab,
-	     MetaWaylandSurface     *surface,
-	     wl_fixed_t              x,
-	     wl_fixed_t              y)
-{
-}
-
-static void
-modal_motion (MetaWaylandPointerGrab *grab,
-	      uint32_t                time,
-	      wl_fixed_t              x,
-	      wl_fixed_t              y)
-{
-}
-
-static void
-modal_button (MetaWaylandPointerGrab *grab,
-	      uint32_t                time,
-	      uint32_t                button,
-	      uint32_t                state)
-{
-}
-
-static MetaWaylandPointerGrabInterface modal_grab = {
-  modal_focus,
-  modal_motion,
-  modal_button
-};
-
-gboolean
-meta_wayland_pointer_begin_modal (MetaWaylandPointer *pointer)
-{
-  MetaWaylandPointerGrab *grab;
-
-  if (pointer->grab != &pointer->default_grab)
-    return FALSE;
-
-  meta_wayland_pointer_set_focus (pointer, NULL,
-				  wl_fixed_from_int (0),
-				  wl_fixed_from_int (0));
-
-  grab = g_slice_new0 (MetaWaylandPointerGrab);
-  grab->interface = &modal_grab;
-  meta_wayland_pointer_start_grab (pointer, grab);
-
-  return TRUE;
-}
-
-void
-meta_wayland_pointer_end_modal (MetaWaylandPointer *pointer)
-{
-  MetaWaylandPointerGrab *grab;
-
-  grab = pointer->grab;
-
-  g_assert (grab->interface == &modal_grab);
-
-  meta_wayland_pointer_end_grab (pointer);
-  g_slice_free (MetaWaylandPointerGrab, grab);
-}
--- a/src/wayland/meta-wayland-pointer.h
+++ b/src/wayland/meta-wayland-pointer.h
@@ -1,54 +0,0 @@
-/*
- * Wayland Support
- *
- * Copyright (C) 2013 Intel Corporation
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __META_WAYLAND_POINTER_H__
-#define __META_WAYLAND_POINTER_H__
-
-#include <wayland-server.h>
-
-#include "meta-wayland-seat.h"
-
-void
-meta_wayland_pointer_init (MetaWaylandPointer *pointer);
-
-void
-meta_wayland_pointer_release (MetaWaylandPointer *pointer);
-
-void
-meta_wayland_pointer_set_focus (MetaWaylandPointer *pointer,
-                                MetaWaylandSurface *surface,
-                                wl_fixed_t sx,
-                                wl_fixed_t sy);
-void
-meta_wayland_pointer_start_grab (MetaWaylandPointer *pointer,
-                                 MetaWaylandPointerGrab *grab);
-
-void
-meta_wayland_pointer_end_grab (MetaWaylandPointer *pointer);
-
-gboolean
-meta_wayland_pointer_begin_modal (MetaWaylandPointer *pointer);
-void
-meta_wayland_pointer_end_modal   (MetaWaylandPointer *pointer);
-
-void
-meta_wayland_pointer_set_current (MetaWaylandPointer *pointer,
-                                  MetaWaylandSurface *surface);
-
-#endif /* __META_WAYLAND_POINTER_H__ */
--- a/src/wayland/meta-wayland-private.h
+++ b/src/wayland/meta-wayland-private.h
@@ -1,352 +0,0 @@
-/*
- * Copyright (C) 2012 Intel Corporation
- *
- * 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.
- */
-
-#ifndef META_WAYLAND_PRIVATE_H
-#define META_WAYLAND_PRIVATE_H
-
-#include <wayland-server.h>
-#include <xkbcommon/xkbcommon.h>
-#include <clutter/clutter.h>
-
-#include <glib.h>
-#include <cairo.h>
-
-#include "window-private.h"
-#include "meta-tty.h"
-#include <meta/meta-cursor-tracker.h>
-
-typedef struct _MetaWaylandCompositor MetaWaylandCompositor;
-
-typedef struct _MetaWaylandSeat MetaWaylandSeat;
-typedef struct _MetaWaylandPointer MetaWaylandPointer;
-typedef struct _MetaWaylandPointerGrab MetaWaylandPointerGrab;
-typedef struct _MetaWaylandPointerGrabInterface MetaWaylandPointerGrabInterface;
-typedef struct _MetaWaylandKeyboard MetaWaylandKeyboard;
-typedef struct _MetaWaylandKeyboardGrab MetaWaylandKeyboardGrab;
-typedef struct _MetaWaylandKeyboardGrabInterface MetaWaylandKeyboardGrabInterface;
-typedef struct _MetaWaylandDataOffer MetaWaylandDataOffer;
-typedef struct _MetaWaylandDataSource MetaWaylandDataSource;
-
-typedef struct
-{
-  struct wl_resource *resource;
-  struct wl_signal destroy_signal;
-  struct wl_listener destroy_listener;
-
-  union
-  {
-    struct wl_shm_buffer *shm_buffer;
-    struct wl_buffer *legacy_buffer;
-  };
-
-  int32_t width, height;
-  uint32_t busy_count;
-} MetaWaylandBuffer;
-
-typedef struct
-{
-  MetaWaylandBuffer *buffer;
-  struct wl_listener destroy_listener;
-} MetaWaylandBufferReference;
-
-typedef struct
-{
-  struct wl_resource *resource;
-  cairo_region_t *region;
-} MetaWaylandRegion;
-
-struct _MetaWaylandSurface
-{
-  struct wl_resource *resource;
-  MetaWaylandCompositor *compositor;
-  guint32 xid;
-  int x;
-  int y;
-  MetaWaylandBufferReference buffer_ref;
-  MetaWindow *window;
-  gboolean has_shell_surface;
-
-  /* All the pending state, that wl_surface.commit will apply. */
-  struct
-  {
-    /* wl_surface.attach */
-    gboolean newly_attached;
-    MetaWaylandBuffer *buffer;
-    struct wl_listener buffer_destroy_listener;
-    int32_t sx;
-    int32_t sy;
-
-    /* wl_surface.damage */
-    cairo_region_t *damage;
-
-    /* wl_surface.frame */
-    struct wl_list frame_callback_list;
-  } pending;
-};
-
-#ifndef HAVE_META_WAYLAND_SURFACE_TYPE
-typedef struct _MetaWaylandSurface MetaWaylandSurface;
-#endif
-
-typedef struct
-{
-  MetaWaylandSurface *surface;
-  struct wl_resource *resource;
-  struct wl_listener surface_destroy_listener;
-} MetaWaylandShellSurface;
-
-typedef struct
-{
-  GSource source;
-  GPollFD pfd;
-  struct wl_display *display;
-} WaylandEventSource;
-
-typedef struct
-{
-  struct wl_list link;
-
-  /* Pointer back to the compositor */
-  MetaWaylandCompositor *compositor;
-
-  struct wl_resource *resource;
-} MetaWaylandFrameCallback;
-
-struct _MetaWaylandCompositor
-{
-  GHashTable *outputs;
-
-  struct wl_display *wayland_display;
-  struct wl_event_loop *wayland_loop;
-  GMainLoop *init_loop;
-  ClutterActor *stage;
-  GSource *wayland_event_source;
-  GList *surfaces;
-  struct wl_list frame_callbacks;
-
-  int xwayland_display_index;
-  char *xwayland_lockfile;
-  int xwayland_abstract_fd;
-  int xwayland_unix_fd;
-  pid_t xwayland_pid;
-  struct wl_client *xwayland_client;
-  struct wl_resource *xserver_resource;
-
-  MetaTTY *tty;
-  int drm_fd;
-  GSocket *weston_launch;
-
-  MetaWaylandSeat *seat;
-
-  /* This surface is only used to keep drag of the implicit grab when
-     synthesizing XEvents for Mutter */
-  MetaWaylandSurface *implicit_grab_surface;
-  /* Button that was pressed to initiate an implicit grab. The
-     implicit grab will only be released when this button is
-     released */
-  guint32 implicit_grab_button;
-};
-
-struct _MetaWaylandPointerGrabInterface
-{
-  void (*focus) (MetaWaylandPointerGrab * grab,
-                 MetaWaylandSurface * surface, wl_fixed_t x, wl_fixed_t y);
-  void (*motion) (MetaWaylandPointerGrab * grab,
-                  uint32_t time, wl_fixed_t x, wl_fixed_t y);
-  void (*button) (MetaWaylandPointerGrab * grab,
-                  uint32_t time, uint32_t button, uint32_t state);
-};
-
-struct _MetaWaylandPointerGrab
-{
-  const MetaWaylandPointerGrabInterface *interface;
-  MetaWaylandPointer *pointer;
-  MetaWaylandSurface *focus;
-  wl_fixed_t x, y;
-};
-
-struct _MetaWaylandPointer
-{
-  struct wl_list resource_list;
-  MetaWaylandSurface *focus;
-  struct wl_resource *focus_resource;
-  struct wl_listener focus_listener;
-  guint32 focus_serial;
-  struct wl_signal focus_signal;
-
-  MetaWaylandPointerGrab *grab;
-  MetaWaylandPointerGrab default_grab;
-  wl_fixed_t grab_x, grab_y;
-  guint32 grab_button;
-  guint32 grab_serial;
-  guint32 grab_time;
-
-  wl_fixed_t x, y;
-  MetaWaylandSurface *current;
-  struct wl_listener current_listener;
-  wl_fixed_t current_x, current_y;
-
-  guint32 button_count;
-};
-
-struct _MetaWaylandKeyboardGrabInterface
-{
-  void (*key) (MetaWaylandKeyboardGrab * grab, uint32_t time,
-               uint32_t key, uint32_t state);
-  void (*modifiers) (MetaWaylandKeyboardGrab * grab, uint32_t serial,
-                     uint32_t mods_depressed, uint32_t mods_latched,
-                     uint32_t mods_locked, uint32_t group);
-};
-
-struct _MetaWaylandKeyboardGrab
-{
-  const MetaWaylandKeyboardGrabInterface *interface;
-  MetaWaylandKeyboard *keyboard;
-  MetaWaylandSurface *focus;
-  uint32_t key;
-};
-
-typedef struct
-{
-  struct xkb_keymap *keymap;
-  int keymap_fd;
-  size_t keymap_size;
-  char *keymap_area;
-  xkb_mod_index_t shift_mod;
-  xkb_mod_index_t caps_mod;
-  xkb_mod_index_t ctrl_mod;
-  xkb_mod_index_t alt_mod;
-  xkb_mod_index_t mod2_mod;
-  xkb_mod_index_t mod3_mod;
-  xkb_mod_index_t super_mod;
-  xkb_mod_index_t mod5_mod;
-} MetaWaylandXkbInfo;
-
-typedef struct
-{
-  uint32_t mods_depressed;
-  uint32_t mods_latched;
-  uint32_t mods_locked;
-  uint32_t group;
-} MetaWaylandXkbState;
-
-struct _MetaWaylandKeyboard
-{
-  struct wl_list resource_list;
-  MetaWaylandSurface *focus;
-  struct wl_resource *focus_resource;
-  struct wl_listener focus_listener;
-  uint32_t focus_serial;
-  struct wl_signal focus_signal;
-
-  MetaWaylandKeyboardGrab *grab;
-  MetaWaylandKeyboardGrab default_grab;
-  uint32_t grab_key;
-  uint32_t grab_serial;
-  uint32_t grab_time;
-
-  struct wl_array keys;
-
-  MetaWaylandXkbState modifier_state;
-
-  struct wl_display *display;
-
-  struct xkb_context *xkb_context;
-  struct xkb_state *xkb_state;
-  gboolean is_evdev;
-
-  MetaWaylandXkbInfo xkb_info;
-  struct xkb_rule_names xkb_names;
-
-  MetaWaylandKeyboardGrab input_method_grab;
-  struct wl_resource *input_method_resource;
-};
-
-struct _MetaWaylandDataOffer
-{
-  struct wl_resource *resource;
-  MetaWaylandDataSource *source;
-  struct wl_listener source_destroy_listener;
-};
-
-struct _MetaWaylandDataSource
-{
-  struct wl_resource *resource;
-  struct wl_array mime_types;
-
-  void (*accept) (MetaWaylandDataSource * source,
-                  uint32_t serial, const char *mime_type);
-  void (*send) (MetaWaylandDataSource * source,
-                const char *mime_type, int32_t fd);
-  void (*cancel) (MetaWaylandDataSource * source);
-};
-
-struct _MetaWaylandSeat
-{
-  struct wl_list base_resource_list;
-  struct wl_signal destroy_signal;
-
-  uint32_t selection_serial;
-  MetaWaylandDataSource *selection_data_source;
-  struct wl_listener selection_data_source_listener;
-  struct wl_signal selection_signal;
-
-  struct wl_list drag_resource_list;
-  struct wl_client *drag_client;
-  MetaWaylandDataSource *drag_data_source;
-  struct wl_listener drag_data_source_listener;
-  MetaWaylandSurface *drag_focus;
-  struct wl_resource *drag_focus_resource;
-  struct wl_listener drag_focus_listener;
-  MetaWaylandPointerGrab drag_grab;
-  MetaWaylandSurface *drag_surface;
-  struct wl_listener drag_icon_listener;
-  struct wl_signal drag_icon_signal;
-
-  MetaWaylandPointer pointer;
-  MetaWaylandKeyboard keyboard;
-
-  struct wl_display *display;
-
-  MetaCursorTracker *cursor_tracker;
-  MetaWaylandSurface *sprite;
-  int hotspot_x, hotspot_y;
-  struct wl_listener sprite_destroy_listener;
-
-  ClutterActor *current_stage;
-};
-
-void                    meta_wayland_init                       (void);
-void                    meta_wayland_finalize                   (void);
-
-/* We maintain a singleton MetaWaylandCompositor which can be got at via this
- * API after meta_wayland_init() has been called. */
-MetaWaylandCompositor  *meta_wayland_compositor_get_default     (void);
-
-void                    meta_wayland_compositor_repick          (MetaWaylandCompositor *compositor);
-
-void                    meta_wayland_compositor_set_input_focus (MetaWaylandCompositor *compositor,
-                                                                 MetaWindow            *window);
-
-MetaTTY                *meta_wayland_compositor_get_tty         (MetaWaylandCompositor *compositor);
-gboolean                meta_wayland_compositor_is_native       (MetaWaylandCompositor *compositor);
-
-void                    meta_wayland_surface_free               (MetaWaylandSurface    *surface);
-
-#endif /* META_WAYLAND_PRIVATE_H */
--- a/src/wayland/meta-wayland-seat.c
+++ b/src/wayland/meta-wayland-seat.c
@@ -1,552 +0,0 @@
-/*
- * Wayland Support
- *
- * Copyright (C) 2013 Intel Corporation
- *
- * 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.
- */
-
-#include "config.h"
-
-#include <cogl/cogl-wayland-server.h>
-#include <clutter/clutter.h>
-#include <clutter/wayland/clutter-wayland-compositor.h>
-#include <clutter/wayland/clutter-wayland-surface.h>
-#include <linux/input.h>
-#include <stdlib.h>
-#include <string.h>
-#include "meta-wayland-seat.h"
-#include "meta-wayland-private.h"
-#include "meta-wayland-keyboard.h"
-#include "meta-wayland-pointer.h"
-#include "meta-wayland-data-device.h"
-#include "meta-window-actor-private.h"
-#include "meta/meta-shaped-texture.h"
-#include "meta-wayland-stage.h"
-#include "meta-cursor-tracker-private.h"
-
-#define DEFAULT_AXIS_STEP_DISTANCE wl_fixed_from_int (10)
-
-static void
-unbind_resource (struct wl_resource *resource)
-{
-  wl_list_remove (wl_resource_get_link (resource));
-}
-
-static void
-transform_stage_point_fixed (MetaWaylandSurface *surface,
-                             wl_fixed_t x,
-                             wl_fixed_t y,
-                             wl_fixed_t *sx,
-                             wl_fixed_t *sy)
-{
-  float xf = 0.0f, yf = 0.0f;
-
-  if (surface->window)
-    {
-      ClutterActor *actor =
-        CLUTTER_ACTOR (meta_window_get_compositor_private (surface->window));
-
-      if (actor)
-        clutter_actor_transform_stage_point (actor,
-                                             wl_fixed_to_double (x),
-                                             wl_fixed_to_double (y),
-                                             &xf, &yf);
-    }
-
-  *sx = wl_fixed_from_double (xf);
-  *sy = wl_fixed_from_double (yf);
-}
-
-static void
-pointer_unmap_sprite (MetaWaylandSeat *seat)
-{
-  if (seat->cursor_tracker)
-    {
-      meta_cursor_tracker_set_sprite (seat->cursor_tracker,
-				      NULL, 0, 0);
-
-      if (seat->current_stage)
-	meta_cursor_tracker_queue_redraw (seat->cursor_tracker,
-					  CLUTTER_ACTOR (seat->current_stage));
-    }
-
-  if (seat->sprite)
-    {
-      wl_list_remove (&seat->sprite_destroy_listener.link);
-      seat->sprite = NULL;
-    }
-}
-
-void
-meta_wayland_seat_update_sprite (MetaWaylandSeat *seat)
-{
-  ClutterBackend *backend;
-  CoglContext *context;
-  struct wl_resource *buffer;
-  CoglTexture2D *texture;
-
-  if (seat->cursor_tracker == NULL)
-    return;
-
-  backend = clutter_get_default_backend ();
-  context = clutter_backend_get_cogl_context (backend);
-  buffer = seat->sprite->buffer_ref.buffer->resource;
-  texture = cogl_wayland_texture_2d_new_from_buffer (context, buffer, NULL);
-
-  meta_cursor_tracker_set_sprite (seat->cursor_tracker,
-				  texture,
-				  seat->hotspot_x,
-				  seat->hotspot_y);
-
-  if (seat->current_stage)
-    meta_cursor_tracker_queue_redraw (seat->cursor_tracker,
-				      CLUTTER_ACTOR (seat->current_stage));
-
-  cogl_object_unref (texture);
-}
-
-static void
-pointer_set_cursor (struct wl_client *client,
-                    struct wl_resource *resource,
-                    uint32_t serial,
-                    struct wl_resource *surface_resource,
-                    int32_t x, int32_t y)
-{
-  MetaWaylandSeat *seat = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface;
-
-  surface = (surface_resource ?
-             wl_resource_get_user_data (surface_resource) :
-             NULL);
-
-  if (seat->pointer.focus == NULL)
-    return;
-  if (wl_resource_get_client (seat->pointer.focus->resource) != client)
-    return;
-  if (seat->pointer.focus_serial - serial > G_MAXUINT32 / 2)
-    return;
-
-  seat->hotspot_x = x;
-  seat->hotspot_y = y;
-
-  if (seat->sprite != surface)
-    {
-      pointer_unmap_sprite (seat);
-
-      if (!surface)
-        return;
-
-      wl_resource_add_destroy_listener (surface->resource,
-                                        &seat->sprite_destroy_listener);
-
-      seat->sprite = surface;
-
-      if (seat->sprite->buffer_ref.buffer)
-        meta_wayland_seat_update_sprite (seat);
-    }
-}
-
-static const struct wl_pointer_interface
-pointer_interface =
-  {
-    pointer_set_cursor
-  };
-
-static void
-seat_get_pointer (struct wl_client *client,
-                  struct wl_resource *resource,
-                  uint32_t id)
-{
-  MetaWaylandSeat *seat = wl_resource_get_user_data (resource);
-  struct wl_resource *cr;
-
-  cr = wl_client_add_object (client, &wl_pointer_interface,
-                             &pointer_interface, id, seat);
-  wl_list_insert (&seat->pointer.resource_list, wl_resource_get_link (cr));
-  wl_resource_set_destructor (cr, unbind_resource);
-
-  if (seat->pointer.focus &&
-      wl_resource_get_client (seat->pointer.focus->resource) == client)
-    {
-      MetaWaylandSurface *surface;
-      wl_fixed_t sx, sy;
-
-      surface = (MetaWaylandSurface *) seat->pointer.focus;
-      transform_stage_point_fixed (surface,
-                                   seat->pointer.x,
-                                   seat->pointer.y,
-                                   &sx, &sy);
-      meta_wayland_pointer_set_focus (&seat->pointer,
-                                  seat->pointer.focus,
-                                  sx, sy);
-    }
-}
-
-static void
-seat_get_keyboard (struct wl_client *client,
-                   struct wl_resource *resource,
-                   uint32_t id)
-{
-  MetaWaylandSeat *seat = wl_resource_get_user_data (resource);
-  struct wl_resource *cr;
-
-  cr = wl_client_add_object (client, &wl_keyboard_interface, NULL, id, seat);
-  wl_list_insert (&seat->keyboard.resource_list, wl_resource_get_link (cr));
-  wl_resource_set_destructor (cr, unbind_resource);
-
-  wl_keyboard_send_keymap (cr,
-                           WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
-                           seat->keyboard.xkb_info.keymap_fd,
-                           seat->keyboard.xkb_info.keymap_size);
-
-  if (seat->keyboard.focus &&
-      wl_resource_get_client (seat->keyboard.focus->resource) == client)
-    {
-      meta_wayland_keyboard_set_focus (&seat->keyboard,
-                                   seat->keyboard.focus);
-      meta_wayland_data_device_set_keyboard_focus (seat);
-    }
-}
-
-static void
-seat_get_touch (struct wl_client *client,
-                struct wl_resource *resource,
-                uint32_t id)
-{
-  /* Touch not supported */
-}
-
-static const struct wl_seat_interface
-seat_interface =
-  {
-    seat_get_pointer,
-    seat_get_keyboard,
-    seat_get_touch
-  };
-
-static void
-bind_seat (struct wl_client *client,
-           void *data,
-           guint32 version,
-           guint32 id)
-{
-  MetaWaylandSeat *seat = data;
-  struct wl_resource *resource;
-
-  resource = wl_client_add_object (client,
-                                   &wl_seat_interface,
-                                   &seat_interface,
-                                   id,
-                                   data);
-  wl_list_insert (&seat->base_resource_list, wl_resource_get_link (resource));
-  wl_resource_set_destructor (resource, unbind_resource);
-
-  wl_seat_send_capabilities (resource,
-                             WL_SEAT_CAPABILITY_POINTER |
-                             WL_SEAT_CAPABILITY_KEYBOARD);
-}
-
-static void
-pointer_handle_sprite_destroy (struct wl_listener *listener, void *data)
-{
-  MetaWaylandSeat *seat =
-    wl_container_of (listener, seat, sprite_destroy_listener);
-
-  pointer_unmap_sprite (seat);
-}
-
-MetaWaylandSeat *
-meta_wayland_seat_new (struct wl_display *display,
-		       gboolean           is_native)
-{
-  MetaWaylandSeat *seat = g_new0 (MetaWaylandSeat, 1);
-
-  wl_signal_init (&seat->destroy_signal);
-
-  seat->selection_data_source = NULL;
-  wl_list_init (&seat->base_resource_list);
-  wl_signal_init (&seat->selection_signal);
-  wl_list_init (&seat->drag_resource_list);
-  wl_signal_init (&seat->drag_icon_signal);
-
-  meta_wayland_pointer_init (&seat->pointer);
-
-  meta_wayland_keyboard_init (&seat->keyboard, display, is_native);
-
-  seat->display = display;
-
-  seat->current_stage = 0;
-
-  seat->sprite = NULL;
-  seat->sprite_destroy_listener.notify = pointer_handle_sprite_destroy;
-  seat->hotspot_x = 16;
-  seat->hotspot_y = 16;
-
-  wl_display_add_global (display, &wl_seat_interface, seat, bind_seat);
-
-  return seat;
-}
-
-static void
-notify_motion (MetaWaylandSeat *seat,
-               const ClutterEvent *event)
-{
-  MetaWaylandPointer *pointer = &seat->pointer;
-  float x, y;
-
-  clutter_event_get_coords (event, &x, &y);
-  pointer->x = wl_fixed_from_double (x);
-  pointer->y = wl_fixed_from_double (y);
-
-  meta_wayland_seat_repick (seat,
-                        clutter_event_get_time (event),
-                        clutter_event_get_source (event));
-
-  pointer->grab->interface->motion (pointer->grab,
-                                    clutter_event_get_time (event),
-                                    pointer->grab->x,
-                                    pointer->grab->y);
-}
-
-static void
-handle_motion_event (MetaWaylandSeat *seat,
-                     const ClutterMotionEvent *event)
-{
-  notify_motion (seat, (const ClutterEvent *) event);
-}
-
-static void
-handle_button_event (MetaWaylandSeat *seat,
-                     const ClutterButtonEvent *event)
-{
-  MetaWaylandPointer *pointer = &seat->pointer;
-  gboolean state = event->type == CLUTTER_BUTTON_PRESS;
-  uint32_t button;
-
-  notify_motion (seat, (const ClutterEvent *) event);
-
-  switch (event->button)
-    {
-      /* The evdev input right and middle button numbers are swapped
-         relative to how Clutter numbers them */
-    case 2:
-      button = BTN_MIDDLE;
-      break;
-
-    case 3:
-      button = BTN_RIGHT;
-      break;
-
-    default:
-      button = event->button + BTN_LEFT - 1;
-      break;
-    }
-
-  if (state)
-    {
-      if (pointer->button_count == 0)
-        {
-          MetaWaylandSurface *surface = pointer->current;
-
-          pointer->grab_button = button;
-          pointer->grab_time = event->time;
-          pointer->grab_x = pointer->x;
-          pointer->grab_y = pointer->y;
-
-          if (button == BTN_LEFT &&
-              surface &&
-              surface->window &&
-              surface->window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
-            {
-              meta_window_raise (surface->window);
-            }
-        }
-
-      pointer->button_count++;
-    }
-  else
-    pointer->button_count--;
-
-  pointer->grab->interface->button (pointer->grab, event->time, button, state);
-
-  if (pointer->button_count == 1)
-    pointer->grab_serial = wl_display_get_serial (seat->display);
-}
-
-static void
-handle_scroll_event (MetaWaylandSeat *seat,
-                     const ClutterScrollEvent *event)
-{
-  enum wl_pointer_axis axis;
-  wl_fixed_t value;
-
-  notify_motion (seat, (const ClutterEvent *) event);
-
-  switch (event->direction)
-    {
-    case CLUTTER_SCROLL_UP:
-      axis = WL_POINTER_AXIS_VERTICAL_SCROLL;
-      value = -DEFAULT_AXIS_STEP_DISTANCE;
-      break;
-
-    case CLUTTER_SCROLL_DOWN:
-      axis = WL_POINTER_AXIS_VERTICAL_SCROLL;
-      value = DEFAULT_AXIS_STEP_DISTANCE;
-      break;
-
-    case CLUTTER_SCROLL_LEFT:
-      axis = WL_POINTER_AXIS_HORIZONTAL_SCROLL;
-      value = -DEFAULT_AXIS_STEP_DISTANCE;
-      break;
-
-    case CLUTTER_SCROLL_RIGHT:
-      axis = WL_POINTER_AXIS_HORIZONTAL_SCROLL;
-      value = DEFAULT_AXIS_STEP_DISTANCE;
-      break;
-
-    default:
-      return;
-    }
-
-  if (seat->pointer.focus_resource)
-    wl_pointer_send_axis (seat->pointer.focus_resource,
-                          event->time,
-                          axis,
-                          value);
-}
-
-void
-meta_wayland_seat_handle_event (MetaWaylandSeat *seat,
-                                const ClutterEvent *event)
-{
-  switch (event->type)
-    {
-    case CLUTTER_MOTION:
-      handle_motion_event (seat,
-                           (const ClutterMotionEvent *) event);
-      break;
-
-    case CLUTTER_BUTTON_PRESS:
-    case CLUTTER_BUTTON_RELEASE:
-      handle_button_event (seat,
-                           (const ClutterButtonEvent *) event);
-      break;
-
-    case CLUTTER_KEY_PRESS:
-    case CLUTTER_KEY_RELEASE:
-      meta_wayland_keyboard_handle_event (&seat->keyboard,
-                                          (const ClutterKeyEvent *) event);
-      break;
-
-    case CLUTTER_SCROLL:
-      handle_scroll_event (seat, (const ClutterScrollEvent *) event);
-      break;
-
-    default:
-      break;
-    }
-}
-
-static void
-update_pointer_position_for_actor (MetaWaylandPointer *pointer,
-                                   ClutterActor *actor)
-{
-  float ax, ay;
-
-  clutter_actor_transform_stage_point (actor,
-                                       wl_fixed_to_double (pointer->x),
-                                       wl_fixed_to_double (pointer->y),
-                                       &ax, &ay);
-  pointer->current_x = wl_fixed_from_double (ax);
-  pointer->current_y = wl_fixed_from_double (ay);
-}
-
-/* The actor argument can be NULL in which case a Clutter pick will be
-   performed to determine the right actor. An actor should only be
-   passed if the repick is being performed due to an event in which
-   case Clutter will have already performed a pick so we can avoid
-   redundantly doing another one */
-void
-meta_wayland_seat_repick (MetaWaylandSeat *seat,
-                          uint32_t time,
-                          ClutterActor *actor)
-{
-  MetaWaylandPointer *pointer = &seat->pointer;
-  MetaWaylandSurface *surface = NULL;
-
-  if (actor == NULL && seat->current_stage)
-    {
-      ClutterStage *stage = CLUTTER_STAGE (seat->current_stage);
-      actor = clutter_stage_get_actor_at_pos (stage,
-                                              CLUTTER_PICK_REACTIVE,
-                                              wl_fixed_to_double (pointer->x),
-                                              wl_fixed_to_double (pointer->y));
-    }
-
-  if (actor)
-    seat->current_stage = clutter_actor_get_stage (actor);
-  else
-    seat->current_stage = NULL;
-
-  if (META_IS_WINDOW_ACTOR (actor))
-    {
-      MetaWindow *window =
-        meta_window_actor_get_meta_window (META_WINDOW_ACTOR (actor));
-
-      update_pointer_position_for_actor (pointer, actor);
-
-      surface = window->surface;
-    }
-  else if (META_IS_SHAPED_TEXTURE (actor))
-    {
-      MetaShapedTexture *shaped_texture = META_SHAPED_TEXTURE (actor);
-
-      update_pointer_position_for_actor (pointer, actor);
-
-      surface = meta_shaped_texture_get_wayland_surface (shaped_texture);
-    }
-
-  pointer->current = surface;
-  if (surface != pointer->focus)
-    {
-      const MetaWaylandPointerGrabInterface *interface =
-        pointer->grab->interface;
-      interface->focus (pointer->grab,
-                        surface,
-                        pointer->current_x, pointer->current_y);
-    }
-
-  if (pointer->grab->focus)
-    transform_stage_point_fixed (pointer->grab->focus,
-                                 pointer->x,
-                                 pointer->y,
-                                 &pointer->grab->x,
-                                 &pointer->grab->y);
-}
-
-void
-meta_wayland_seat_free (MetaWaylandSeat *seat)
-{
-  pointer_unmap_sprite (seat);
-
-  meta_wayland_pointer_release (&seat->pointer);
-  meta_wayland_keyboard_release (&seat->keyboard);
-
-  wl_signal_emit (&seat->destroy_signal, seat);
-
-  g_slice_free (MetaWaylandSeat, seat);
-}
--- a/src/wayland/meta-wayland-seat.h
+++ b/src/wayland/meta-wayland-seat.h
@@ -1,51 +0,0 @@
-/*
- * Wayland Support
- *
- * Copyright (C) 2012 Intel Corporation
- *
- * 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.
- */
-
-#ifndef __META_WAYLAND_SEAT_H__
-#define __META_WAYLAND_SEAT_H__
-
-#include <wayland-server.h>
-#include <xkbcommon/xkbcommon.h>
-#include <clutter/clutter.h>
-#include <glib.h>
-
-#include "meta-wayland-private.h"
-
-MetaWaylandSeat *
-meta_wayland_seat_new (struct wl_display *display,
-		       gboolean           is_native);
-
-void
-meta_wayland_seat_handle_event (MetaWaylandSeat *seat,
-                                const ClutterEvent *event);
-
-void
-meta_wayland_seat_repick (MetaWaylandSeat *seat,
-                          uint32_t time,
-                          ClutterActor *actor);
-
-void
-meta_wayland_seat_update_sprite (MetaWaylandSeat *seat);
-
-void
-meta_wayland_seat_free (MetaWaylandSeat *seat);
-
-#endif /* __META_WAYLAND_SEAT_H__ */
--- a/src/wayland/meta-wayland-stage.c
+++ b/src/wayland/meta-wayland-stage.c
@@ -1,68 +0,0 @@
-/*
- * Wayland Support
- *
- * Copyright (C) 2012 Intel Corporation
- *
- * 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.
- */
-
-#include <config.h>
-
-#include <clutter/clutter.h>
-#include <gdk-pixbuf/gdk-pixbuf.h>
-#include <cogl/cogl-wayland-server.h>
-
-#include "meta-wayland-stage.h"
-#include "meta/meta-window-actor.h"
-#include "meta/meta-shaped-texture.h"
-#include "meta-cursor-tracker-private.h"
-
-G_DEFINE_TYPE (MetaWaylandStage, meta_wayland_stage, CLUTTER_TYPE_STAGE);
-
-static void
-meta_wayland_stage_paint (ClutterActor *actor)
-{
-  MetaWaylandCompositor *compositor;
-
-  CLUTTER_ACTOR_CLASS (meta_wayland_stage_parent_class)->paint (actor);
-
-  compositor = meta_wayland_compositor_get_default ();
-  if (compositor->seat->cursor_tracker)
-    meta_cursor_tracker_paint (compositor->seat->cursor_tracker);
-}
-
-static void
-meta_wayland_stage_class_init (MetaWaylandStageClass *klass)
-{
-  ClutterActorClass *actor_class = (ClutterActorClass *) klass;
-
-  actor_class->paint = meta_wayland_stage_paint;
-}
-
-static void
-meta_wayland_stage_init (MetaWaylandStage *self)
-{
-  clutter_stage_set_user_resizable (CLUTTER_STAGE (self), FALSE);
-}
-
-ClutterActor *
-meta_wayland_stage_new (void)
-{
-  return g_object_new (META_WAYLAND_TYPE_STAGE,
-                       "cursor-visible", FALSE,
-                       NULL);
-}
-
--- a/src/wayland/meta-wayland-stage.h
+++ b/src/wayland/meta-wayland-stage.h
@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2012 Intel Corporation
- *
- * 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.
- */
-
-#ifndef META_WAYLAND_STAGE_H
-#define META_WAYLAND_STAGE_H
-
-#include <clutter/clutter.h>
-#include <wayland-server.h>
-
-#include "window-private.h"
-
-G_BEGIN_DECLS
-
-#define META_WAYLAND_TYPE_STAGE                                         \
-  (meta_wayland_stage_get_type())
-#define META_WAYLAND_STAGE(obj)                                         \
-  (G_TYPE_CHECK_INSTANCE_CAST ((obj),                                   \
-                               META_WAYLAND_TYPE_STAGE,                 \
-                               MetaWaylandStage))
-#define META_WAYLAND_STAGE_CLASS(klass)                                 \
-  (G_TYPE_CHECK_CLASS_CAST ((klass),                                    \
-                            META_WAYLAND_TYPE_STAGE,                    \
-                            MetaWaylandStageClass))
-#define META_WAYLAND_IS_STAGE(obj)                                      \
-  (G_TYPE_CHECK_INSTANCE_TYPE ((obj),                                   \
-                               META_WAYLAND_TYPE_STAGE))
-#define META_WAYLAND_IS_STAGE_CLASS(klass)                              \
-  (G_TYPE_CHECK_CLASS_TYPE ((klass),                                    \
-                            META_WAYLAND_TYPE_STAGE))
-#define META_WAYLAND_STAGE_GET_CLASS(obj)                               \
-  (G_TYPE_INSTANCE_GET_CLASS ((obj),                                    \
-                              META_WAYLAND_STAGE,                       \
-                              MetaWaylandStageClass))
-
-typedef struct _MetaWaylandStage      MetaWaylandStage;
-typedef struct _MetaWaylandStageClass MetaWaylandStageClass;
-
-struct _MetaWaylandStageClass
-{
-  ClutterStageClass parent_class;
-};
-
-struct _MetaWaylandStage
-{
-  ClutterStage parent;
-};
-
-GType             meta_wayland_stage_get_type                (void) G_GNUC_CONST;
-
-ClutterActor     *meta_wayland_stage_new                     (void);
-
-G_END_DECLS
-
-#endif /* META_WAYLAND_STAGE_H */
--- a/src/wayland/meta-wayland.c
+++ b/src/wayland/meta-wayland.c
--- a/src/wayland/meta-weston-launch.c
+++ b/src/wayland/meta-weston-launch.c
@@ -1,203 +0,0 @@
-/*
- * Copyright (C) 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.
- */
-
-#include <config.h>
-
-#include <gio/gio.h>
-#include <gio/gunixfdmessage.h>
-
-#include <glib.h>
-#include <sys/time.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <stdlib.h>
-#include <sys/wait.h>
-
-#include <drm.h>
-#include <xf86drm.h>
-#include <xf86drmMode.h>
-
-#include "meta-weston-launch.h"
-
-static gboolean
-send_message_to_wl (GSocket                *weston_launch,
-		    void                   *message,
-		    gsize                   size,
-		    GSocketControlMessage  *out_cmsg,
-		    GSocketControlMessage **in_cmsg,
-		    GError                **error)
-{
-  int ok;
-  GInputVector in_iov = { &ok, sizeof (int) };
-  GOutputVector out_iov = { message, size };
-  GSocketControlMessage *out_all_cmsg[2];
-  GSocketControlMessage **in_all_cmsg;
-  int flags = 0;
-  int i;
-
-  out_all_cmsg[0] = out_cmsg;
-  out_all_cmsg[1] = NULL;
-  if (g_socket_send_message (weston_launch, NULL,
-			     &out_iov, 1,
-			     out_all_cmsg, -1,
-			     flags, NULL, error) != (gssize)size)
-    return FALSE;
-
-  if (g_socket_receive_message (weston_launch, NULL,
-				&in_iov, 1,
-				&in_all_cmsg, NULL,
-				&flags, NULL, error) != sizeof (int))
-    return FALSE;
-
-  if (ok != 0)
-    {
-      if (ok == -1)
-	g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
-		     "Got failure from weston-launch");
-      else
-	g_set_error (error, G_IO_ERROR, g_io_error_from_errno (-ok),
-		     "Got failure from weston-launch: %s", strerror (-ok));
-
-      for (i = 0; in_all_cmsg && in_all_cmsg[i]; i++)
-	g_object_unref (in_all_cmsg[i]);
-      g_free (in_all_cmsg);
-
-      return FALSE;
-    }
-
-  if (in_all_cmsg && in_all_cmsg[0])
-    {
-      for (i = 1; in_all_cmsg[i]; i++)
-	g_object_unref (in_all_cmsg[i]);
-      *in_cmsg = in_all_cmsg[0];
-    }
-
-  g_free (in_all_cmsg);
-  return TRUE;
-}	    
-
-gboolean
-meta_weston_launch_set_master (GSocket   *weston_launch,
-			       int        drm_fd,
-			       gboolean   master,
-			       GError   **error)
-{
-  if (weston_launch)
-    {
-      struct weston_launcher_set_master message;
-      GSocketControlMessage *cmsg;
-      gboolean ok;
-
-      message.header.opcode = WESTON_LAUNCHER_DRM_SET_MASTER;
-      message.set_master = master;
-
-      cmsg = g_unix_fd_message_new ();
-      if (g_unix_fd_message_append_fd (G_UNIX_FD_MESSAGE (cmsg),
-				       drm_fd, error) == FALSE)
-	{
-	  g_object_unref (cmsg);
-	  return FALSE;
-	}
-
-      ok = send_message_to_wl (weston_launch, &message, sizeof message, cmsg, NULL, error);
-
-      g_object_unref (cmsg);
-      return ok;
-    }
-  else
-    {
-      int ret;
-
-      if (master)
-	ret = drmSetMaster (drm_fd);
-      else
-	ret = drmDropMaster (drm_fd);
-
-      if (ret < 0)
-	{
-	  g_set_error (error, G_IO_ERROR, g_io_error_from_errno (-ret),
-		       "Failed to set DRM master directly: %s", strerror (-ret));
-	  return FALSE;
-	}
-      else
-	return TRUE;
-    }
-}
-
-int
-meta_weston_launch_open_input_device (GSocket    *weston_launch,
-				      const char *name,
-				      int         flags,
-				      GError    **error)
-{
-  if (weston_launch)
-    {
-      struct weston_launcher_open *message;
-      GSocketControlMessage *cmsg;
-      gboolean ok;
-      gsize size;
-      int *fds, n_fd;
-      int ret;
-
-      size = sizeof (struct weston_launcher_open) + strlen (name) + 1;
-      message = g_malloc (size);
-      message->header.opcode = WESTON_LAUNCHER_OPEN;
-      message->flags = flags;
-      strcpy (message->path, name);
-      message->path[strlen(name)] = 0;
-
-      ok = send_message_to_wl (weston_launch, message, size,
-			       NULL, &cmsg, error);
-
-      if (ok)
-	{
-	  g_assert (G_IS_UNIX_FD_MESSAGE (cmsg));
-
-	  fds = g_unix_fd_message_steal_fds (G_UNIX_FD_MESSAGE (cmsg), &n_fd);
-	  g_assert (n_fd == 1);
-
-	  ret = fds[0];
-	  g_free (fds);
-	  g_object_unref (cmsg);
-	}
-      else
-	ret = -1;
-
-      g_free (message);
-      return ret;
-    }
-  else
-    {
-      int ret;
-
-      ret = open (name, flags, 0);
-
-      if (ret < 0)
-	g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
-		     "Failed to open input device directly: %s", strerror (errno));
-
-      return ret;
-    }
-}
-
--- a/src/wayland/meta-weston-launch.h
+++ b/src/wayland/meta-weston-launch.h
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 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.
- */
-
-#ifndef META_WESTON_LAUNCH_H
-#define META_WESTON_LAUNCH_H
-
-#include <glib-object.h>
-
-/* Keep this in sync with weston-launch */
-
-enum weston_launcher_opcode {
-	WESTON_LAUNCHER_OPEN,
-	WESTON_LAUNCHER_DRM_SET_MASTER
-};
-
-struct weston_launcher_message {
-	int opcode;
-};
-
-struct weston_launcher_open {
-	struct weston_launcher_message header;
-	int flags;
-	char path[0];
-};
-
-struct weston_launcher_set_master {
-	struct weston_launcher_message header;
-	int set_master;
-};
-
-gboolean meta_weston_launch_set_master (GSocket   *weston_launch,
-					int        drm_fd,
-					gboolean   master,
-					GError   **error);
-int      meta_weston_launch_open_input_device (GSocket     *weston_launch,
-					       const char  *name,
-					       int          flags,
-					       GError     **error);
-
-#endif
--- a/src/wayland/meta-xwayland-private.h
+++ b/src/wayland/meta-xwayland-private.h
@@ -1,33 +0,0 @@
-/*
- * Copyright (C) 2013 Intel Corporation
- *
- * 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.
- */
-
-#ifndef META_XWAYLAND_PRIVATE_H
-#define META_XWAYLAND_PRIVATE_H
-
-#include "meta-wayland-private.h"
-
-#include <glib.h>
-
-gboolean
-meta_xwayland_start (MetaWaylandCompositor *compositor);
-
-void
-meta_xwayland_stop (MetaWaylandCompositor *compositor);
-
-#endif /* META_XWAYLAND_PRIVATE_H */
--- a/src/wayland/meta-xwayland.c
+++ b/src/wayland/meta-xwayland.c
@@ -1,456 +0,0 @@
-/*
- * X Wayland Support
- *
- * Copyright (C) 2013 Intel Corporation
- *
- * 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.
- */
-
-#include <glib.h>
-
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <sys/wait.h>
-#include <stdlib.h>
-
-#include "meta-xwayland-private.h"
-#include "meta-window-actor-private.h"
-#include "xserver-server-protocol.h"
-
-static void
-xserver_set_window_id (struct wl_client *client,
-                       struct wl_resource *compositor_resource,
-                       struct wl_resource *surface_resource,
-                       guint32 xid)
-{
-  MetaWaylandCompositor *compositor =
-    wl_resource_get_user_data (compositor_resource);
-  MetaWaylandSurface *surface = wl_resource_get_user_data (surface_resource);
-  MetaDisplay *display = meta_get_display ();
-  MetaWindow *window;
-
-  g_return_if_fail (surface->xid == None);
-
-  surface->xid = xid;
-
-  window  = meta_display_lookup_x_window (display, xid);
-  if (window)
-    {
-      MetaWindowActor *window_actor =
-        META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-
-      meta_window_actor_set_wayland_surface (window_actor, surface);
-
-      surface->window = window;
-      window->surface = surface;
-
-      /* If the window is already meant to have focus then the
-       * original attempt to call this in response to the FocusIn
-       * event will have been lost because there was no surface
-       * yet. */
-      if (window->has_focus)
-        meta_wayland_compositor_set_input_focus (compositor, window);
-
-    }
-}
-
-static const struct xserver_interface xserver_implementation = {
-    xserver_set_window_id
-};
-
-static void
-bind_xserver (struct wl_client *client,
-	      void *data,
-              guint32 version,
-              guint32 id)
-{
-  MetaWaylandCompositor *compositor = data;
-
-  /* If it's a different client than the xserver we launched,
-   * don't start the wm. */
-  if (client != compositor->xwayland_client)
-    return;
-
-  compositor->xserver_resource =
-    wl_resource_create (client, &xserver_interface, version, id);
-  wl_resource_set_implementation (compositor->xserver_resource,
-				  &xserver_implementation, compositor, NULL);
-
-  wl_resource_post_event (compositor->xserver_resource,
-                          XSERVER_LISTEN_SOCKET,
-                          compositor->xwayland_abstract_fd);
-
-  wl_resource_post_event (compositor->xserver_resource,
-                          XSERVER_LISTEN_SOCKET,
-                          compositor->xwayland_unix_fd);
-
-  /* Make sure xwayland will recieve the above sockets in a finite
-   * time before unblocking the initialization mainloop since we are
-   * then going to immediately try and connect to those as the window
-   * manager. */
-  wl_client_flush (client);
-
-  /* At this point xwayland is all setup to start accepting
-   * connections so we can quit the transient initialization mainloop
-   * and unblock meta_wayland_init() to continue initializing mutter.
-   * */
-  g_main_loop_quit (compositor->init_loop);
-  compositor->init_loop = NULL;
-}
-
-static char *
-create_lockfile (int display, int *display_out)
-{
-  char *filename;
-  int size;
-  char pid[11];
-  int fd;
-
-  do
-    {
-      char *end;
-      pid_t other;
-
-      filename = g_strdup_printf ("/tmp/.X%d-lock", display);
-      fd = open (filename, O_WRONLY | O_CLOEXEC | O_CREAT | O_EXCL, 0444);
-
-      if (fd < 0 && errno == EEXIST)
-        {
-          fd = open (filename, O_CLOEXEC, O_RDONLY);
-          if (fd < 0 || read (fd, pid, 11) != 11)
-            {
-              const char *msg = strerror (errno);
-              g_warning ("can't read lock file %s: %s", filename, msg);
-              g_free (filename);
-
-              /* ignore error and try the next display number */
-              display++;
-              continue;
-          }
-          close (fd);
-
-          other = strtol (pid, &end, 0);
-          if (end != pid + 10)
-            {
-              g_warning ("can't parse lock file %s", filename);
-              g_free (filename);
-
-              /* ignore error and try the next display number */
-              display++;
-              continue;
-          }
-
-          if (kill (other, 0) < 0 && errno == ESRCH)
-            {
-              g_warning ("unlinking stale lock file %s", filename);
-              if (unlink (filename) < 0)
-                {
-                  const char *msg = strerror (errno);
-                  g_warning ("failed to unlink stale lock file: %s", msg);
-                  display++;
-                }
-              g_free (filename);
-              continue;
-          }
-
-          g_free (filename);
-          display++;
-          continue;
-        }
-      else if (fd < 0)
-        {
-          const char *msg = strerror (errno);
-          g_warning ("failed to create lock file %s: %s", filename , msg);
-          g_free (filename);
-          return NULL;
-        }
-
-      break;
-    }
-  while (1);
-
-  /* Subtle detail: we use the pid of the wayland compositor, not the xserver
-   * in the lock file. */
-  size = snprintf (pid, 11, "%10d\n", getpid ());
-  if (size != 11 || write (fd, pid, 11) != 11)
-    {
-      unlink (filename);
-      close (fd);
-      g_warning ("failed to write pid to lock file %s", filename);
-      g_free (filename);
-      return NULL;
-    }
-
-  close (fd);
-
-  *display_out = display;
-  return filename;
-}
-
-static int
-bind_to_abstract_socket (int display)
-{
-  struct sockaddr_un addr;
-  socklen_t size, name_size;
-  int fd;
-
-  fd = socket (PF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0);
-  if (fd < 0)
-    return -1;
-
-  addr.sun_family = AF_LOCAL;
-  name_size = snprintf (addr.sun_path, sizeof addr.sun_path,
-                        "%c/tmp/.X11-unix/X%d", 0, display);
-  size = offsetof (struct sockaddr_un, sun_path) + name_size;
-  if (bind (fd, (struct sockaddr *) &addr, size) < 0)
-    {
-      g_warning ("failed to bind to @%s: %s\n",
-                 addr.sun_path + 1, strerror (errno));
-      close (fd);
-      return -1;
-    }
-
-  if (listen (fd, 1) < 0)
-    {
-      close (fd);
-      return -1;
-    }
-
-  return fd;
-}
-
-static int
-bind_to_unix_socket (int display)
-{
-  struct sockaddr_un addr;
-  socklen_t size, name_size;
-  int fd;
-
-  fd = socket (PF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0);
-  if (fd < 0)
-    return -1;
-
-  addr.sun_family = AF_LOCAL;
-  name_size = snprintf (addr.sun_path, sizeof addr.sun_path,
-                        "/tmp/.X11-unix/X%d", display) + 1;
-  size = offsetof (struct sockaddr_un, sun_path) + name_size;
-  unlink (addr.sun_path);
-  if (bind (fd, (struct sockaddr *) &addr, size) < 0)
-    {
-      char *msg = strerror (errno);
-      g_warning ("failed to bind to %s (%s)\n", addr.sun_path, msg);
-      close (fd);
-      return -1;
-    }
-
-  if (listen (fd, 1) < 0) {
-      unlink (addr.sun_path);
-      close (fd);
-      return -1;
-  }
-
-  return fd;
-}
-
-static void
-uncloexec_and_setpgid (gpointer user_data)
-{
-  int fd = GPOINTER_TO_INT (user_data);
-
-  /* Make sure the client end of the socket pair doesn't get closed
-   * when we exec xwayland. */
-  int flags = fcntl (fd, F_GETFD);
-  if (flags != -1)
-    fcntl (fd, F_SETFD, flags & ~FD_CLOEXEC);
-
-  /* Put this process in a background process group, so that Ctrl-C
-     goes to mutter only */
-  setpgid (0, 0);
-}
-
-static void
-xserver_died (GPid     pid,
-              gint     status,
-              gpointer user_data)
-{
-  if (!WIFEXITED (status))
-    g_error ("X Wayland crashed; aborting");
-  else
-    {
-      /* For now we simply abort if we see the server exit.
-       *
-       * In the future X will only be loaded lazily for legacy X support
-       * but for now it's a hard requirement. */
-      g_error ("Spurious exit of X Wayland server");
-    }
-}
-
-static int
-x_io_error (Display *display)
-{
-  g_error ("Connection to xwayland lost");
-
-  return 0;
-}
-
-gboolean
-meta_xwayland_start (MetaWaylandCompositor *compositor)
-{
-  int display = 0;
-  char *lockfile = NULL;
-  int sp[2];
-  pid_t pid;
-  char **env;
-  char *fd_string;
-  char *display_name;
-  char *args[11];
-  GError *error;
-
-  wl_global_create (compositor->wayland_display,
-		    &xserver_interface, 1,
-		    compositor, bind_xserver);
-
-  do
-    {
-      lockfile = create_lockfile (display, &display);
-      if (!lockfile)
-        {
-         g_warning ("Failed to create an X lock file");
-         return FALSE;
-        }
-
-      compositor->xwayland_abstract_fd = bind_to_abstract_socket (display);
-      if (compositor->xwayland_abstract_fd < 0)
-        {
-          unlink (lockfile);
-
-          if (errno == EADDRINUSE)
-            {
-              display++;
-              continue;
-            }
-          else
-            return FALSE;
-        }
-
-      compositor->xwayland_unix_fd = bind_to_unix_socket (display);
-      if (compositor->xwayland_abstract_fd < 0)
-        {
-          unlink (lockfile);
-          close (compositor->xwayland_abstract_fd);
-          return FALSE;
-        }
-
-      break;
-    }
-  while (1);
-
-  compositor->xwayland_display_index = display;
-  compositor->xwayland_lockfile = lockfile;
-
-  /* We want xwayland to be a wayland client so we make a socketpair to setup a
-   * wayland protocol connection. */
-  if (socketpair (AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sp) < 0)
-    {
-      g_warning ("socketpair failed\n");
-      unlink (lockfile);
-      return 1;
-    }
-
-  env = g_get_environ ();
-  fd_string = g_strdup_printf ("%d", sp[1]);
-  env = g_environ_setenv (env, "WAYLAND_SOCKET", fd_string, TRUE);
-  g_free (fd_string);
-
-  display_name = g_strdup_printf (":%d",
-                                  compositor->xwayland_display_index);
-
-  args[0] = XWAYLAND_PATH;
-  args[1] = display_name;
-  args[2] = "-wayland";
-  args[3] = "-rootless";
-  args[4] = "-retro";
-  args[5] = "-noreset";
-  args[6] = "-logfile";
-  args[7] = g_build_filename (g_get_user_cache_dir (), "xwayland.log", NULL);
-  args[8] = "-nolisten";
-  args[9] = "all";
-  args[10] = NULL;
-
-  error = NULL;
-  if (g_spawn_async (NULL, /* cwd */
-                     args,
-                     env,
-                     G_SPAWN_LEAVE_DESCRIPTORS_OPEN |
-                     G_SPAWN_DO_NOT_REAP_CHILD |
-                     G_SPAWN_STDOUT_TO_DEV_NULL |
-                     G_SPAWN_STDERR_TO_DEV_NULL,
-                     uncloexec_and_setpgid,
-                     GINT_TO_POINTER (sp[1]),
-                     &pid,
-                     &error))
-    {
-      g_message ("forked X server, pid %d\n", pid);
-
-      close (sp[1]);
-      compositor->xwayland_client =
-        wl_client_create (compositor->wayland_display, sp[0]);
-
-      compositor->xwayland_pid = pid;
-      g_child_watch_add (pid, xserver_died, NULL);
-    }
-  else
-    {
-      g_error ("Failed to fork for xwayland server: %s", error->message);
-    }
-
-  g_strfreev (env);
-  g_free (display_name);
-
-  /* We need to run a mainloop until we know xwayland has a binding
-   * for our xserver interface at which point we can assume it's
-   * ready to start accepting connections. */
-  compositor->init_loop = g_main_loop_new (NULL, FALSE);
-
-  g_main_loop_run (compositor->init_loop);
-
-  /* We install an X IO error handler in addition to the child watch,
-     because after Xlib connects our child watch may not be called soon
-     enough, and therefore we won't crash when X exits (and most important
-     we won't reset the tty).
-  */
-  XSetIOErrorHandler (x_io_error);
-
-  return TRUE;
-}
-
-void
-meta_xwayland_stop (MetaWaylandCompositor *compositor)
-{
-  char path[256];
-
-  snprintf (path, sizeof path, "/tmp/.X%d-lock",
-            compositor->xwayland_display_index);
-  unlink (path);
-  snprintf (path, sizeof path, "/tmp/.X11-unix/X%d",
-            compositor->xwayland_display_index);
-  unlink (path);
-
-  unlink (compositor->xwayland_lockfile);
-}
--- a/src/wayland/weston-launch.c
+++ b/src/wayland/weston-launch.c
@@ -1,703 +0,0 @@
-/*
- * Copyright © 2012 Benjamin Franzke
- *
- * Permission to use, copy, modify, distribute, and sell this software and
- * its documentation for any purpose is hereby granted without fee, provided
- * that the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of the copyright holders not be used in
- * advertising or publicity pertaining to distribution of the software
- * without specific, written prior permission.  The copyright holders make
- * no representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include "config.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <poll.h>
-#include <errno.h>
-
-#include <error.h>
-#include <getopt.h>
-
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <sys/wait.h>
-#include <sys/socket.h>
-#include <sys/signalfd.h>
-#include <signal.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <limits.h>
-
-#include <termios.h>
-#include <linux/vt.h>
-#include <linux/major.h>
-
-#include <pwd.h>
-#include <grp.h>
-#include <security/pam_appl.h>
-
-#include <xf86drm.h>
-
-#ifdef HAVE_SYSTEMD_LOGIN
-#include <systemd/sd-login.h>
-#endif
-
-#include "weston-launch.h"
-
-#define MAX_ARGV_SIZE 256
-
-struct weston_launch {
-	struct pam_conv pc;
-	pam_handle_t *ph;
-	int tty;
-	int ttynr;
-	int sock[2];
-	struct passwd *pw;
-
-	int signalfd;
-
-	pid_t child;
-	int verbose;
-	char *new_user;
-};
-
-union cmsg_data { unsigned char b[4]; int fd; };
-
-static gid_t *
-read_groups(void)
-{
-	int n;
-	gid_t *groups;
-	
-	n = getgroups(0, NULL);
-
-	if (n < 0) {
-		fprintf(stderr, "Unable to retrieve groups: %m\n");
-		return NULL;
-	}
-
-	groups = malloc(n * sizeof(gid_t));
-	if (!groups)
-		return NULL;
-
-	if (getgroups(n, groups) < 0) {
-		fprintf(stderr, "Unable to retrieve groups: %m\n");
-		free(groups);
-		return NULL;
-	}
-	return groups;
-}
-
-static int
-weston_launch_allowed(struct weston_launch *wl)
-{
-	struct group *gr;
-	gid_t *groups;
-	int i;
-#ifdef HAVE_SYSTEMD_LOGIN
-	char *session, *seat;
-	int err;
-#endif
-
-	if (getuid() == 0)
-		return 1;
-
-	gr = getgrnam("weston-launch");
-	if (gr) {
-		groups = read_groups();
-		if (groups) {
-			for (i = 0; groups[i]; ++i) {
-				if (groups[i] == gr->gr_gid) {
-					free(groups);
-					return 1;
-				}
-			}
-			free(groups);
-		}
-	}
-
-#ifdef HAVE_SYSTEMD_LOGIN
-	err = sd_pid_get_session(getpid(), &session);
-	if (err == 0 && session) {
-		if (sd_session_is_active(session) &&
-		    sd_session_get_seat(session, &seat) == 0) {
-			free(seat);
-			free(session);
-			return 1;
-		}
-		free(session);
-	}
-#endif
-	
-	return 0;
-}
-
-static int
-pam_conversation_fn(int msg_count,
-		    const struct pam_message **messages,
-		    struct pam_response **responses,
-		    void *user_data)
-{
-	return PAM_SUCCESS;
-}
-
-static int
-setup_pam(struct weston_launch *wl)
-{
-	int err;
-
-	wl->pc.conv = pam_conversation_fn;
-	wl->pc.appdata_ptr = wl;
-
-	err = pam_start("login", wl->pw->pw_name, &wl->pc, &wl->ph);
-	if (err != PAM_SUCCESS) {
-		fprintf(stderr, "failed to start pam transaction: %d: %s\n",
-			err, pam_strerror(wl->ph, err));
-		return -1;
-	}
-
-	err = pam_set_item(wl->ph, PAM_TTY, ttyname(wl->tty));
-	if (err != PAM_SUCCESS) {
-		fprintf(stderr, "failed to set PAM_TTY item: %d: %s\n",
-			err, pam_strerror(wl->ph, err));
-		return -1;
-	}
-
-	err = pam_open_session(wl->ph, 0);
-	if (err != PAM_SUCCESS) {
-		fprintf(stderr, "failed to open pam session: %d: %s\n",
-			err, pam_strerror(wl->ph, err));
-		return -1;
-	}
-
-	return 0;
-}
-
-static int
-setup_launcher_socket(struct weston_launch *wl)
-{
-	if (socketpair(AF_LOCAL, SOCK_DGRAM, 0, wl->sock) < 0)
-		error(1, errno, "socketpair failed");
-	
-	fcntl(wl->sock[0], F_SETFD, O_CLOEXEC);
-
-	return 0;
-}
-
-static int
-setup_signals(struct weston_launch *wl)
-{
-	int ret;
-	sigset_t mask;
-	struct sigaction sa;
-
-	memset(&sa, 0, sizeof sa);
-	sa.sa_handler = SIG_DFL;
-	sa.sa_flags = SA_NOCLDSTOP | SA_RESTART;
-	ret = sigaction(SIGCHLD, &sa, NULL);
-	assert(ret == 0);
-
-	sa.sa_handler = SIG_IGN;
-	sa.sa_flags = 0;
-	sigaction(SIGHUP, &sa, NULL);
-
-	ret = sigemptyset(&mask);
-	assert(ret == 0);
-	sigaddset(&mask, SIGCHLD);
-	sigaddset(&mask, SIGINT);
-	sigaddset(&mask, SIGTERM);
-	ret = sigprocmask(SIG_BLOCK, &mask, NULL);
-	assert(ret == 0);
-
-	wl->signalfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
-	if (wl->signalfd < 0)
-		return -errno;
-
-	return 0;
-}
-
-static void
-setenv_fd(const char *env, int fd)
-{
-	char buf[32];
-
-	snprintf(buf, sizeof buf, "%d", fd);
-	setenv(env, buf, 1);
-}
-
-static int
-handle_setmaster(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
-{
-	int ret = -1;
-	struct cmsghdr *cmsg;
-	struct weston_launcher_set_master *message;
-	union cmsg_data *data;
-
-	if (len != sizeof(*message)) {
-		error(0, 0, "missing value in setmaster request");
-		goto out;
-	}
-
-	message = msg->msg_iov->iov_base;
-
-	cmsg = CMSG_FIRSTHDR(msg);
-	if (!cmsg ||
-	    cmsg->cmsg_level != SOL_SOCKET ||
-	    cmsg->cmsg_type != SCM_RIGHTS) {
-		error(0, 0, "invalid control message");
-		goto out;
-	}
-
-	data = (union cmsg_data *) CMSG_DATA(cmsg);
-	if (data->fd == -1) {
-		error(0, 0, "missing drm fd in socket request");
-		goto out;
-	}
-
-	if (message->set_master)
-		ret = drmSetMaster(data->fd);
-	else
-		ret = drmDropMaster(data->fd);
-
-	close(data->fd);
-
-	if (wl->verbose)
-		fprintf(stderr, "weston-launch: %sMaster, ret: %d, fd: %d\n",
-			message->set_master ? "set" : "drop", ret, data->fd);
-
-out:
-	do {
-		len = send(wl->sock[0], &ret, sizeof ret, 0);
-	} while (len < 0 && errno == EINTR);
-	if (len < 0)
-		return -1;
-
-	return 0;
-}
-
-static int
-handle_open(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
-{
-	int fd = -1, ret = -1;
-	char control[CMSG_SPACE(sizeof(fd))];
-	struct cmsghdr *cmsg;
-	struct stat s;
-	struct msghdr nmsg;
-	struct iovec iov;
-	struct weston_launcher_open *message;
-	union cmsg_data *data;
-
-	message = msg->msg_iov->iov_base;
-	if ((size_t)len < sizeof(*message))
-		goto err0;
-
-	/* Ensure path is null-terminated */
-	((char *) message)[len-1] = '\0';
-
-	if (stat(message->path, &s) < 0)
-		goto err0;
-
-	fd = open(message->path, message->flags);
-	if (fd < 0) {
-		fprintf(stderr, "Error opening device %s: %m\n",
-			message->path);
-		goto err0;
-	}
-
-	if (major(s.st_rdev) != INPUT_MAJOR) {
-		close(fd);
-		fd = -1;
-		fprintf(stderr, "Device %s is not an input device\n",
-			message->path);
-		goto err0;
-	}
-
-err0:
-	memset(&nmsg, 0, sizeof nmsg);
-	nmsg.msg_iov = &iov;
-	nmsg.msg_iovlen = 1;
-	if (fd != -1) {
-		nmsg.msg_control = control;
-		nmsg.msg_controllen = sizeof control;
-		cmsg = CMSG_FIRSTHDR(&nmsg);
-		cmsg->cmsg_level = SOL_SOCKET;
-		cmsg->cmsg_type = SCM_RIGHTS;
-		cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
-		data = (union cmsg_data *) CMSG_DATA(cmsg);
-		data->fd = fd;
-		nmsg.msg_controllen = cmsg->cmsg_len;
-		ret = 0;
-	}
-	iov.iov_base = &ret;
-	iov.iov_len = sizeof ret;
-
-	if (wl->verbose)
-		fprintf(stderr, "weston-launch: opened %s: ret: %d, fd: %d\n",
-			message->path, ret, fd);
-	do {
-		len = sendmsg(wl->sock[0], &nmsg, 0);
-	} while (len < 0 && errno == EINTR);
-
-	close(fd);
-
-	if (len < 0)
-		return -1;
-
-	return 0;
-}
-
-static int
-handle_socket_msg(struct weston_launch *wl)
-{
-	char control[CMSG_SPACE(sizeof(int))];
-	char buf[BUFSIZ];
-	struct msghdr msg;
-	struct iovec iov;
-	int ret = -1;
-	ssize_t len;
-	struct weston_launcher_message *message;
-
-	memset(&msg, 0, sizeof(msg));
-	iov.iov_base = buf;
-	iov.iov_len  = sizeof buf;
-	msg.msg_iov = &iov;
-	msg.msg_iovlen = 1;
-	msg.msg_control = control;
-	msg.msg_controllen = sizeof control;
-
-	do {
-		len = recvmsg(wl->sock[0], &msg, 0);
-	} while (len < 0 && errno == EINTR);
-
-	if (len < 1)
-		return -1;
-
-	message = (void *) buf;
-	switch (message->opcode) {
-	case WESTON_LAUNCHER_OPEN:
-		ret = handle_open(wl, &msg, len);
-		break;
-	case WESTON_LAUNCHER_DRM_SET_MASTER:
-		ret = handle_setmaster(wl, &msg, len);
-		break;
-	}
-
-	return ret;
-}
-
-static void
-quit(struct weston_launch *wl, int status)
-{
-	int err;
-
-	close(wl->signalfd);
-	close(wl->sock[0]);
-
-	if (wl->new_user) {
-		err = pam_close_session(wl->ph, 0);
-		if (err)
-			fprintf(stderr, "pam_close_session failed: %d: %s\n",
-				err, pam_strerror(wl->ph, err));
-		pam_end(wl->ph, err);
-	}
-
-	exit(status);
-}
-
-static int
-handle_signal(struct weston_launch *wl)
-{
-	struct signalfd_siginfo sig;
-	int pid, status, ret;
-
-	if (read(wl->signalfd, &sig, sizeof sig) != sizeof sig) {
-		error(0, errno, "reading signalfd failed");
-		return -1;
-	}
-
-	switch (sig.ssi_signo) {
-	case SIGCHLD:
-		pid = waitpid(-1, &status, 0);
-		if (pid == wl->child) {
-			wl->child = 0;
-			if (WIFEXITED(status))
-				ret = WEXITSTATUS(status);
-			else if (WIFSIGNALED(status))
-				/*
-				 * If weston dies because of signal N, we
-				 * return 10+N. This is distinct from
-				 * weston-launch dying because of a signal
-				 * (128+N).
-				 */
-				ret = 10 + WTERMSIG(status);
-			else
-				ret = 0;
-			quit(wl, ret);
-		}
-		break;
-	case SIGTERM:
-	case SIGINT:
-		if (wl->child)
-			kill(wl->child, sig.ssi_signo);
-		break;
-	default:
-		return -1;
-	}
-
-	return 0;
-}
-
-static int
-setup_tty(struct weston_launch *wl, const char *tty)
-{
-	struct stat buf;
-	char *t;
-
-	if (!wl->new_user) {
-		wl->tty = STDIN_FILENO;
-	} else if (tty) {
-		t = ttyname(STDIN_FILENO);
-		if (t && strcmp(t, tty) == 0)
-			wl->tty = STDIN_FILENO;
-		else
-			wl->tty = open(tty, O_RDWR | O_NOCTTY);
-	} else {
-		int tty0 = open("/dev/tty0", O_WRONLY | O_CLOEXEC);
-		char filename[16];
-
-		if (tty0 < 0)
-			error(1, errno, "could not open tty0");
-
-		if (ioctl(tty0, VT_OPENQRY, &wl->ttynr) < 0 || wl->ttynr == -1)
-			error(1, errno, "failed to find non-opened console"); 
-
-		snprintf(filename, sizeof filename, "/dev/tty%d", wl->ttynr);
-		wl->tty = open(filename, O_RDWR | O_NOCTTY);
-		close(tty0);
-	}
-
-	if (wl->tty < 0)
-		error(1, errno, "failed to open tty");
-
-	if (tty) {
-		if (fstat(wl->tty, &buf) < 0)
-			error(1, errno, "stat %s failed", tty);
-
-		if (major(buf.st_rdev) != TTY_MAJOR)
-			error(1, 0, "invalid tty device: %s", tty);
-
-		wl->ttynr = minor(buf.st_rdev);
-	}
-
-	return 0;
-}
-
-static void
-setup_session(struct weston_launch *wl)
-{
-	char **env;
-	char *term;
-	int i;
-
-	if (wl->tty != STDIN_FILENO) {
-		if (setsid() < 0)
-			error(1, errno, "setsid failed");
-		if (ioctl(wl->tty, TIOCSCTTY, 0) < 0)
-			error(1, errno, "TIOCSCTTY failed - tty is in use");
-	}
-
-	if (setgid(wl->pw->pw_gid) < 0 ||
-#ifdef HAVE_INITGROUPS
-	    initgroups(wl->pw->pw_name, wl->pw->pw_gid) < 0 ||
-#endif
-	    setuid(wl->pw->pw_uid) < 0)
-		error(1, errno, "dropping privileges failed");
-
-	term = getenv("TERM");
-	clearenv();
-	setenv("TERM", term, 1);
-	setenv("USER", wl->pw->pw_name, 1);
-	setenv("LOGNAME", wl->pw->pw_name, 1);
-	setenv("HOME", wl->pw->pw_dir, 1);
-	setenv("SHELL", wl->pw->pw_shell, 1);
-
-	env = pam_getenvlist(wl->ph);
-	if (env) {
-		for (i = 0; env[i]; ++i) {
-			if (putenv(env[i]) < 0)
-				error(0, 0, "putenv %s failed", env[i]);
-		}
-		free(env);
-	}
-}
-
-static void
-launch_compositor(struct weston_launch *wl, int argc, char *argv[])
-{
-	char command[PATH_MAX];
-	char *child_argv[MAX_ARGV_SIZE];
-	sigset_t mask;
-	int i;
-
-	if (wl->verbose)
-		printf("weston-launch: spawned weston with pid: %d\n", getpid());
-	if (wl->new_user)
-		setup_session(wl);
-
-	if (wl->tty != STDIN_FILENO)
-		setenv_fd("WESTON_TTY_FD", wl->tty);
-
-	setenv_fd("WESTON_LAUNCHER_SOCK", wl->sock[1]);
-
-	unsetenv("DISPLAY");
-
-	/* Do not give our signal mask to the new process. */
-	sigemptyset(&mask);
-	sigaddset(&mask, SIGTERM);
-	sigaddset(&mask, SIGCHLD);
-	sigaddset(&mask, SIGINT);
-	sigprocmask(SIG_UNBLOCK, &mask, NULL);
-
-	snprintf (command, PATH_MAX, "%s \"$@\"", argv[0]);
-
-	child_argv[0] = wl->pw->pw_shell;
-	child_argv[1] = "-l";
-	child_argv[2] = "-c";
-	child_argv[3] = command;
-	for (i = 0; i < argc; ++i)
-		child_argv[4 + i] = argv[i];
-	child_argv[4 + i] = NULL;
-
-	execv(child_argv[0], child_argv);
-	error(1, errno, "exec failed");
-}
-
-static void
-help(const char *name)
-{
-	fprintf(stderr, "Usage: %s [args...] [-- [weston args..]]\n", name);
-	fprintf(stderr, "  -u, --user      Start session as specified username\n");
-	fprintf(stderr, "  -t, --tty       Start session on alternative tty\n");
-	fprintf(stderr, "  -v, --verbose   Be verbose\n");
-	fprintf(stderr, "  -h, --help      Display this help message\n");
-}
-
-int
-main(int argc, char *argv[])
-{
-	struct weston_launch wl;
-	int i, c;
-	char *tty = NULL;
-	struct option opts[] = {
-		{ "user",    required_argument, NULL, 'u' },
-		{ "tty",     required_argument, NULL, 't' },
-		{ "verbose", no_argument,       NULL, 'v' },
-		{ "help",    no_argument,       NULL, 'h' },
-		{ 0,         0,                 NULL,  0  }
-	};	
-
-	memset(&wl, 0, sizeof wl);
-
-	while ((c = getopt_long(argc, argv, "u:t::vh", opts, &i)) != -1) {
-		switch (c) {
-		case 'u':
-			wl.new_user = optarg;
-			if (getuid() != 0)
-				error(1, 0, "Permission denied. -u allowed for root only");
-			break;
-		case 't':
-			tty = optarg;
-			break;
-		case 'v':
-			wl.verbose = 1;
-			break;
-		case 'h':
-			help("weston-launch");
-			exit(EXIT_FAILURE);
-		}
-	}
-
-	if ((argc - optind) > (MAX_ARGV_SIZE - 6))
-		error(1, E2BIG, "Too many arguments to pass to weston");
-
-	if (strcmp (argv[optind], "mutter") &&
-	    strcmp (argv[optind], "gnome-shell") &&
-	    strcmp (argv[optind], "gnome-shell-real") && 0)
-		error(1, 0, "mutter-launch can only be used to launch mutter or gnome-shell");
-
-	if (wl.new_user)
-		wl.pw = getpwnam(wl.new_user);
-	else
-		wl.pw = getpwuid(getuid());
-	if (wl.pw == NULL)
-		error(1, errno, "failed to get username");
-
-	if (!weston_launch_allowed(&wl))
-		error(1, 0, "Permission denied. You should either:\n"
-#ifdef HAVE_SYSTEMD_LOGIN
-		      " - run from an active and local (systemd) session.\n"
-#else
-		      " - enable systemd session support for weston-launch.\n"
-#endif
-		      " - or add yourself to the 'weston-launch' group.");
-
-	if (setup_tty(&wl, tty) < 0)
-		exit(EXIT_FAILURE);
-
-	if (wl.new_user && setup_pam(&wl) < 0)
-		exit(EXIT_FAILURE);
-
-	if (setup_launcher_socket(&wl) < 0)
-		exit(EXIT_FAILURE);
-
-	if (setup_signals(&wl) < 0)
-		exit(EXIT_FAILURE);
-
-	wl.child = fork();
-	if (wl.child == -1) {
-		error(1, errno, "fork failed");
-		exit(EXIT_FAILURE);
-	}
-
-	if (wl.child == 0)
-		launch_compositor(&wl, argc - optind, argv + optind);
-
-	close(wl.sock[1]);
-	if (wl.tty != STDIN_FILENO)
-		close(wl.tty);
-
-	while (1) {
-		struct pollfd fds[2];
-		int n;
-
-		fds[0].fd = wl.sock[0];
-		fds[0].events = POLLIN;
-		fds[1].fd = wl.signalfd;
-		fds[1].events = POLLIN;
-
-		n = poll(fds, 2, -1);
-		if (n < 0)
-			error(0, errno, "poll failed");
-		if (fds[0].revents & POLLIN)
-			handle_socket_msg(&wl);
-		if (fds[1].revents)
-			handle_signal(&wl);
-	}
-
-	return 0;
-}
--- a/src/wayland/weston-launch.h
+++ b/src/wayland/weston-launch.h
@@ -1,46 +0,0 @@
-/*
- * Copyright © 2012 Benjamin Franzke
- *
- * Permission to use, copy, modify, distribute, and sell this software and
- * its documentation for any purpose is hereby granted without fee, provided
- * that the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of the copyright holders not be used in
- * advertising or publicity pertaining to distribution of the software
- * without specific, written prior permission.  The copyright holders make
- * no representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef _WESTON_LAUNCH_H_
-#define _WESTON_LAUNCH_H_
-
-enum weston_launcher_opcode {
-	WESTON_LAUNCHER_OPEN,
-	WESTON_LAUNCHER_DRM_SET_MASTER
-};
-
-struct weston_launcher_message {
-	int opcode;
-};
-
-struct weston_launcher_open {
-	struct weston_launcher_message header;
-	int flags;
-	char path[0];
-};
-
-struct weston_launcher_set_master {
-	struct weston_launcher_message header;
-	int set_master;
-};
-
-#endif
--- a/src/xrandr.xml
+++ b/src/xrandr.xml
@@ -149,11 +149,9 @@

 	@serial must match the serial from the last GetResources() call,
 	or org.freedesktop.DBus.AccessDenied will be generated.
-	(XXX: a better error maybe?)

 	If @persistent is true, mutter will attempt to replicate this
 	configuration the next time this HW layout appears.
-	(XXX: or is this gnome-settings-daemon role?)

 	@crtcs represents the new logical configuration, as a list
 	of structures containing:
Author	SHA1	Message	Date
Giovanni Campagna	78b41e542b	MonitorXrandr: follow the right order in applying the new configuration First disable CRTCs that should be off in the new configuration, then resize the framebuffer, then enable the new CRTCs. If we don't do that, and we're making the screen smaller, X complains with a BadMatch. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:57:33 +02:00
Giovanni Campagna	13557b39d0	MonitorXrandr: resize the framebuffer prior to setting the CRTC configuration Otherwise X11 will trim the new configuration and disable outputs outside the screen. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:57:33 +02:00
Giovanni Campagna	39aecd2dde	Monitor: restore correct display name handling Now that we have the right values from the EDID, we can load the PNP database and find the proper vendor name, to show in the control center UI. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:57:33 +02:00
Giovanni Campagna	c564515ef6	MonitorXrandr: implement correct EDID parsing To provide valid values for the vendor, product and serial fields we need to read the EDID and parse it. Parser kindly provided by gnome-desktop. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:57:33 +02:00
Giovanni Campagna	d7b2ea37b1	MonitorManager: add EDID properties to the output DBus description Add "edid-file", if we have one (in the KMS case, where we can point people to the right sysfs file), or "edid" with inline data. These are needed by colord to build the default ICC profile for uncalibrated displays. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:57:33 +02:00
Giovanni Campagna	0a1e0fe132	MonitorManager: split the XRandR parts in a subclass Instead of keeping a forest of if backend else ..., use a subclass and virtual functions to discriminate between XRandR and the dummy backend (which lives in the parent class togheter with the common code) https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:57:32 +02:00
Giovanni Campagna	1a0513ea61	MetaPlugin: add a UI hook for confirming display changes We want to show a dialog when a display change happens from the control center. To do so, add a new vfunc to MetaPlugin and call it when a configuration change is requested via DBus. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:56:58 +02:00
Giovanni Campagna	028fa6cd4e	MonitorConfig: handle changes in the laptop lid This way we don't need to track the current and previous configuration in gnome-settings-daemon, when we already do so in mutter. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:56:58 +02:00
Giovanni Campagna	194b11186c	MonitorManager: add gamma support Add GetCrtcGamma() and SetCrtcGamma(), that wrap the similarly named XRandR API. These are used by GnomeRR inside the color plugin of the control center (and may go away if the color plugin decides to do something different under wayland) https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:56:58 +02:00
Giovanni Campagna	40f064abc3	MonitorManager: ignore configuration changes that disable all outputs If we compute a screen size of 0 in either direction, we crash later on, as it is invalid for clutter, cogl and X. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:56:58 +02:00
Giovanni Campagna	27b8716795	MonitorManager: add support for backlight GnomeRR needs that too. The backlight is exported as a normalized 0-100 value, or -1 if not supported. Clamping to HW limits is handled by the backend. Changing backlight uses a different method call, to avoid recomputing the full display configuration every time the user presses the backlight keys. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:56:58 +02:00
Giovanni Campagna	50b44d0445	MonitorManager: further extend the dummy backend The default configuration is extended, which is only possible if there are as many CRTCs as outputs, so make sure that's true. Also, add more and bigger modes, so that different sizes will be chosen for the three outputs. A nice side effect of this is that with a real 1920x1080 + 1600x900 layout, if you disable the VGA you get a stage that matches the screen size, which triggers the legacy fullscreen path in the outside mutter. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:56:58 +02:00
Giovanni Campagna	c74d40ac41	MonitorManager: store the presentation mode bit in XRandR Use a private output property to store if the output is in presentation mode or not, so that this information is not lost after the configuration read back from the server. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:56:58 +02:00
Giovanni Campagna	c21f7d43bd	MonitorConfig: add support for default configurations Activate the presentation bit on new hotplugged monitors, while making a fully extended setup when running for the first time. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:56:58 +02:00
Giovanni Campagna	80e0b4aac9	MonitorConfig: add CRTC assignment Ripped off libgnome-desktop, trimming the parts that checked that the configuration was plausible, as that should be done in gnome-control-center before asking mutter for a change. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:56:57 +02:00
Giovanni Campagna	12cd4c216b	MonitorManager: add support for persistent monitor configurations Add a new object, MetaMonitorConfig, that takes care of converting between the logical configurations stored in monitors.xml and the HW resources exposed by MonitorManager. This commit includes loading and saving of configurations, but still missing is the actual CRTC assignments and a default configuration when none is found in the file. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:51:03 +02:00
Giovanni Campagna	91d193e5e8	MonitorManager: add support for DPMS levels To the XRandR and dummy backend (and as usual the dummy backend has no effect) https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:50:26 +02:00
Giovanni Campagna	f82f3ef67b	MonitorManager: inherit directly from DisplayConfig instead of handling signals This way we can handle properties too. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:50:26 +02:00
Giovanni Campagna	6125b3fa7e	MonitorManager: fix handling of output transform Read the current transform from XRandR, and expose the transforms that are really supported on the bus. The dummy backend now advertises all transforms, since it doesn't actually apply them. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:50:23 +02:00
Giovanni Campagna	169780346b	default plugin: add a random color background on each monitor Instead of a full white background, make one with a random color. This way the different "monitors" are visible and it's easier to debug the DBus API. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:36:46 +02:00
Giovanni Campagna	9b255f9292	DisplayConfig: make the dummy backend writable Add a number of dummy outputs and modes to the dummy backend, and implement the writing bits. The only visible effect is that you can change the screen size, which resizes the output window. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:36:46 +02:00
Giovanni Campagna	60e11fbae3	Reverse handling of XRandR events between Screen and MonitorManager Now MonitorManager does its own handling of XRandR events, which means we no longer handle ConfigureNotify on the root window. MetaScreen reacts to MonitorManager::monitor-changed and updates its internal state, including the new size. This paves the way for doing display configuration using only the dummy backend, which would allow testing wl_output interfaces. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:36:45 +02:00
Giovanni Campagna	355f0258b1	DisplayConfig: add the write side of the API Implement ApplyConfiguration in terms of XRandR calls. Error checking is done before actually committing the configuration. If mutter is using one of the other monitor config backends, an error is reported and nothing happens. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:36:39 +02:00
Giovanni Campagna	09984bb56d	Extend the DBus XRandR protocol to expose cloning restriction Turns out that even if two outputs say that they can be controlled by a given CRTC, you can't configure them in the same CRTC unless they are marked as "possible clones" one of the other. This can further restrict the configuration options, so we need to expose this limitation in the DBus API. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:26:32 +02:00
Giovanni Campagna	f48ddb3683	Add the write side of the DBus protocol too This is just in the documentation for now, to attract wider feedback before we start looking at how to implement this for real. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:26:31 +02:00
Giovanni Campagna	9ac92336c9	Introduce a new DBus interface for display configuration This new interface will be used by the control center and possibly the settings daemon to configure the screens. It is designed to resemble a simplified XRandR, while still exposing all the quirks of the hardware, so that the panel can limit the user choices appropriately. To do so, MetaMonitorMode needs to track CRTCs, outputs and modes, so the low level objects have been decoupled from the high-level MetaMonitorInfo, which is used by core and API and offers a simplified view of HW, that hides away the details of what is cloned and how. This is still not efficient as it should be, because on every HW change we drop all data structures and rebuild them from scratch (which is not expensive because there aren't many of them, but at least in the XRandR path it involves a few sync X calls) https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:24:01 +02:00
Giovanni Campagna	2bc5e89a5e	Rework and consolidate monitor handling in MetaScreen Consolidate all places that deal with output configuration in MetaScreen, which gets it either from XRandR or from a dummy static configuration. We still need to read the Xinerama config, even when running xwayland, because we need the indices for _NET_WM_FULLSCREEN_MONITORS, but now we do it only when needed. https://bugzilla.gnome.org/show_bug.cgi?id=705670	2013-08-17 16:17:07 +02:00
Giovanni Campagna	a413bc106f	MetaWindowActor: fix reference counting issue We need to use g_signal_connect_object(), rather than g_signal_connect(), because the window actor can be destroyed before the window emits the final notify::appears-focused inside unmanage, if the plugin decides that it doesn't want to animate the destruction (which happens with dialogs and the default plugin) https://bugzilla.gnome.org/show_bug.cgi?id=706207	2013-08-17 15:56:09 +02:00
Giovanni Campagna	b04ac57f02	Strip whitespace in warnings and errors The old log system did not add a newline at the end, but the new one does, so don't add another one.	2013-08-14 21:36:34 +02:00
Giovanni Campagna	c3a08ee589	main: use glib to handle sigterm We can remove a lot of code with that	2013-08-14 21:36:34 +02:00
Giovanni Campagna	1fdb161f54	main: remove a lot of code to handle wrong theme config mutter has a hard dependency on gnome-themes-standard, which provides the Adwaita theme. If that is not satisfied, it is a distribution problem, so we can just fail (and let the automatic smoketests notice it)	2013-08-14 21:36:34 +02:00
Giovanni Campagna	f3d1653f13	Improve handling of warnings and criticals Instead of squash everything into "window manager warnings", let the glib log framework handle Mutter (and other) warnings. META_USE_LOGFILE support is preserved by rerouting warnings in our domain. This way we get process name and PID, nice CRITICAL/WARNING/ERROR instead of a number, and the ability for plugins to override the log handler. For example gnome-shell uses this to output a JS backtrace.	2013-08-14 21:31:45 +02:00
Giovanni Campagna	3093b5c95d	MetaBackgroundGroup: don't use clutter_actor_get_children() In C code we can use ClutterActorIter and avoid allocating a GList.	2013-08-14 21:24:11 +02:00
Piotr Drąg	c3e8646af3	Updated POTFILES.in	2013-08-13 21:10:02 +02:00
Alban Crequy	8c17b670fb	keybindings: always acknowledge events to the X server https://bugzilla.gnome.org/show_bug.cgi?id=666101	2013-08-13 11:18:48 -04:00