window-actor: Split into two subclasses of MetaSurfaceActor

The rendering logic before was somewhat complex. We had three independent cases to take into account when doing rendering: * X11 compositor. In this case, we're a traditional X11 compositor, not a Wayland compositor. We use XCompositeNameWindowPixmap to get the backing pixmap for the window, and deal with the COMPOSITE extension messiness. In this case, meta_is_wayland_compositor() is FALSE. * Wayland clients. In this case, we're a Wayland compositor managing Wayland surfaces. The rendering for this is fairly straightforward, as Cogl handles most of the complexity with EGL and SHM buffers... Wayland clients give us the input and opaque regions through wl_surface. In this case, meta_is_wayland_compositor() is TRUE and priv->window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND. * XWayland clients. In this case, we're a Wayland compositor, like above, and XWayland hands us Wayland surfaces. XWayland handles the COMPOSITE extension messiness for us, and hands us a buffer like any other Wayland client. We have to fetch the input and opaque regions from the X11 window ourselves. In this case, meta_is_wayland_compositor() is TRUE and priv->window->client_type == META_WINDOW_CLIENT_TYPE_X11. We now split the rendering logic into two subclasses, which are: * MetaSurfaceActorX11, which handles the X11 compositor case, in that it uses XCompositeNameWindowPixmap to get the backing pixmap, and deal with all the COMPOSITE extension messiness. * MetaSurfaceActorWayland, which handles the Wayland compositor case for both native Wayland clients and XWayland clients. XWayland handles COMPOSITE for us, and handles pushing a surface over through the xf86-video-wayland DDX. Frame sync is still in MetaWindowActor, as it needs to work for both the X11 compositor and XWayland client cases. When Wayland's video display protocol lands, this will need to be significantly overhauled, as it would have to work for any wl_surface, including subsurfaces, so we would need surface-level discretion. https://bugzilla.gnome.org/show_bug.cgi?id=720631
window-actor: Kill off needs_pixmap
2014-02-19 10:24:38 -05:00 · 2014-02-19 10:24:38 -05:00 · 2014-02-19 10:24:38 -05:00 · 2014-02-19 10:24:36 -05:00 · 2014-02-19 01:11:42 -05:00 · 2014-02-18 23:36:46 -05:00
63 changed files with 4700 additions and 4129 deletions
--- a/.gitignore
+++ b/.gitignore
@ -79,13 +79,10 @@ src/meta-dbus-xrandr.[ch]
 src/meta-dbus-idle-monitor.[ch]
 src/mutter-plugins.pc
 src/wayland/gtk-shell-protocol.c
-src/wayland/gtk-shell-client-protocol.h
 src/wayland/gtk-shell-server-protocol.h
 src/wayland/xdg-shell-protocol.c
-src/wayland/xdg-shell-client-protocol.h
 src/wayland/xdg-shell-server-protocol.h
 src/wayland/xserver-protocol.c
-src/wayland/xserver-client-protocol.h
 src/wayland/xserver-server-protocol.h
 doc/reference/*.args
 doc/reference/*.bak
--- a/13
+++ b/13
@ -1,3 +1,16 @@
+3.11.5
+======
+* Fix CSD titlebars being placed off-screen [Jasper; #719772]
+* Add support for subsurfaces [Jonas; #705502]
+* Expose MetaWindow:skip-taskbar property [Florian; #723307]
+* Fix legacy tray icons showing up blank [Adel; #721596]
+* Fix configuration of cloned monitors [Adel; #710610]
+* Misc bug fixes and cleanups [Jasper, Adel, Marek, Jonas; #720631, #723468,
+  #720818, #723563, #723564]
+
+Contributors:
+  Jonas Ådahl, Marek Ch, Adel Gadllah, Florian Müllner, Jasper St. Pierre
+
 3.11.4
 ======
 * Don't leave focus on windows that are being unmanaged [Owen; #711618]
--- a/autogen.sh
+++ b/autogen.sh
@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 # Run this to generate all the initial makefiles, etc.

 srcdir=`dirname $0`
--- a/configure.ac
+++ b/configure.ac
@ -3,7 +3,7 @@ AC_CONFIG_MACRO_DIR([m4])

 m4_define([mutter_major_version], [3])
 m4_define([mutter_minor_version], [11])
-m4_define([mutter_micro_version], [4])
+m4_define([mutter_micro_version], [5])

 m4_define([mutter_version],
          [mutter_major_version.mutter_minor_version.mutter_micro_version])
@ -212,9 +212,6 @@ fi

 MUTTER_PC_MODULES="$MUTTER_PC_MODULES xcursor"

-# We always build with wayland enabled
-AC_DEFINE(HAVE_WAYLAND, , [Building with Wayland support])
-
 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]))
--- a/doc/reference/meta-sections.txt
+++ b/doc/reference/meta-sections.txt
@ -96,8 +96,6 @@ meta_compositor_hide_window
 meta_compositor_switch_workspace
 meta_compositor_maximize_window
 meta_compositor_unmaximize_window
-meta_compositor_window_mapped
-meta_compositor_window_unmapped
 meta_compositor_sync_window_geometry
 meta_compositor_set_updates_frozen
 meta_compositor_queue_frame_drawn
--- a/protocol/xdg-shell.xml
+++ b/protocol/xdg-shell.xml
@ -43,7 +43,7 @@
 	Use this enum to check the protocol version, and it will be updated
 	automatically.
      </description>
-      <entry name="current" value="1" summary="Always the latest version"/>
+      <entry name="current" value="2" summary="Always the latest version"/>
    </enum>


@ -84,6 +84,28 @@
      <arg name="y" type="int"/>
      <arg name="flags" type="uint"/>
    </request>
+
+    <event name="ping">
+      <description summary="check if the client is alive">
+        The ping event asks the client if it's still alive. Pass the
+        serial specified in the event back to the compositor by sending
+        a "pong" request back with the specified serial.
+
+        Compositors can use this to determine if the client is still
+        alive. It's unspecified what will happen if the client doesn't
+        respond to the ping request, or in what timeframe. Clients should
+        try to respond in a reasonable amount of time.
+      </description>
+      <arg name="serial" type="uint" summary="pass this to the callback"/>
+    </event>
+
+    <request name="pong">
+      <description summary="respond to a ping event">
+	A client must respond to a ping event with a pong request or
+	the client may be deemed unresponsive.
+      </description>
+      <arg name="serial" type="uint" summary="serial of the ping event"/>
+    </request>
  </interface>

  <interface name="xdg_surface" version="1">
@ -124,6 +146,32 @@
      <arg name="parent" type="object" interface="wl_surface" allow-null="true"/>
    </request>

+    <request name="set_margin">
+      <description summary="set the visible frame boundaries">
+        This tells the compositor what the visible size of the window
+        should be, so it can use it to determine what borders to use for
+        constrainment and alignment.
+
+        CSD often has invisible areas for decoration purposes, like drop
+        shadows. These "shadow" drawings need to be subtracted out of the
+        normal boundaries of the window when computing where to place
+        windows (e.g. to set this window so it's centered on top of another,
+        or to put it to the left or right of the screen.)
+
+        This value should change as little as possible at runtime, to
+        prevent flicker.
+
+        This value is also ignored when the window is maximized or
+        fullscreen, and assumed to be 0.
+
+        If never called, this value is assumed to be 0.
+      </description>
+      <arg name="left_margin" type="int"/>
+      <arg name="right_margin" type="int"/>
+      <arg name="top_margin" type="int"/>
+      <arg name="bottom_margin" type="int"/>
+    </request>
+
    <request name="set_title">
      <description summary="set surface title">
 	Set a short title for the surface.
@ -150,22 +198,6 @@
      <arg name="app_id" type="string"/>
    </request>

-    <request name="pong">
-      <description summary="respond to a ping event">
-	A client must respond to a ping event with a pong request or
-	the client may be deemed unresponsive.
-      </description>
-      <arg name="serial" type="uint" summary="serial of the ping event"/>
-    </request>
-
-    <event name="ping">
-      <description summary="ping client">
-	Ping a client to check if it is receiving events and sending
-	requests. A client is expected to reply with a pong request.
-      </description>
-      <arg name="serial" type="uint"/>
-    </event>
-
    <request name="move">
      <description summary="start an interactive move">
 	Start a pointer-driven move of the surface.
@ -217,12 +249,6 @@
 	ignore it if it doesn't resize, pick a smaller size (to
 	satisfy aspect ratio or resize in steps of NxM pixels).

-	The edges parameter provides a hint about how the surface
-	was resized. The client may use this information to decide
-	how to adjust its content to the new size (e.g. a scrolling
-	area might adjust its content position to leave the viewable
-	content unmoved). Valid edge values are from resize_edge enum.
-
 	The client is free to dismiss all but the last configure
 	event it received.

@ -230,7 +256,6 @@
 	in surface local coordinates.
      </description>

-      <arg name="edges" type="uint"/>
      <arg name="width" type="int"/>
      <arg name="height" type="int"/>
    </event>
@ -360,18 +385,38 @@
      </description>
    </request>

-    <event name="focused_set">
-      <description summary="surface was focused">
-	The focused_set event is sent when this surface has been
-	activated. Window decorations should be updated accordingly.
+    <event name="activated">
+      <description summary="surface was activated">
+	The activated_set event is sent when this surface has been
+	activated, which means that the surface has user attention.
+        Window decorations should be updated accordingly. You should
+        not use this event for anything but the style of decorations
+        you display, use wl_keyboard.enter and wl_keyboard.leave for
+        determining keyboard focus.
      </description>
    </event>

-    <event name="focused_unset">
-      <description summary="surface was unfocused">
-	The focused_unset event is sent when this surface has been
-	deactivated, because another surface has been activated. Window
-	decorations should be updated accordingly.
+    <event name="deactivated">
+      <description summary="surface was deactivated">
+	The deactivate event is sent when this surface has been
+        deactivated, which means that the surface lost user attention.
+        Window decorations should be updated accordingly. You should
+        not use this event for anything but the style of decorations
+        you display, use wl_keyboard.enter and wl_keyboard.leave for
+        determining keyboard focus.
+      </description>
+    </event>
+
+    <event name="delete">
+      <description summary="surface wants to be closed">
+        The delete event is sent by the compositor when the user
+        wants the surface to be closed. This should be equivalent to
+        the user clicking the close button in client-side decorations,
+        if your application has any...
+
+        This is only a request that the user intends to close your
+        window. The client may choose to ignore this request, or show
+        a dialog to ask the user to save their data...
      </description>
    </event>
  </interface>
@ -409,22 +454,6 @@
      </description>
    </request>

-    <request name="pong">
-      <description summary="respond to a ping event">
-	A client must respond to a ping event with a pong request or
-	the client may be deemed unresponsive.
-      </description>
-      <arg name="serial" type="uint" summary="serial of the ping event"/>
-    </request>
-
-    <event name="ping">
-      <description summary="ping client">
-	Ping a client to check if it is receiving events and sending
-	requests. A client is expected to reply with a pong request.
-      </description>
-      <arg name="serial" type="uint"/>
-    </event>
-
    <event name="popup_done">
      <description summary="popup interaction is done">
 	The popup_done event is sent out when a popup grab is broken,
--- a/src/Makefile.am
+++ b/src/Makefile.am
@ -42,13 +42,10 @@ mutter_built_sources = \
 	mutter-enum-types.c			\
 	wayland/gtk-shell-protocol.c		\
 	wayland/gtk-shell-server-protocol.h	\
-	wayland/gtk-shell-client-protocol.h	\
 	wayland/xdg-shell-protocol.c		\
 	wayland/xdg-shell-server-protocol.h	\
-	wayland/xdg-shell-client-protocol.h	\
 	wayland/xserver-protocol.c		\
-	wayland/xserver-server-protocol.h	\
-	wayland/xserver-client-protocol.h
+	wayland/xserver-server-protocol.h

 libmutter_wayland_la_SOURCES =			\
 	core/async-getprop.c			\
@ -83,6 +80,10 @@ libmutter_wayland_la_SOURCES =			\
 	compositor/meta-shaped-texture-private.h 	\
 	compositor/meta-surface-actor.c		\
 	compositor/meta-surface-actor.h		\
+	compositor/meta-surface-actor-x11.c	\
+	compositor/meta-surface-actor-x11.h	\
+	compositor/meta-surface-actor-wayland.c	\
+	compositor/meta-surface-actor-wayland.h	\
 	compositor/meta-texture-rectangle.c	\
 	compositor/meta-texture-rectangle.h	\
 	compositor/meta-texture-tower.c		\
@ -163,6 +164,8 @@ libmutter_wayland_la_SOURCES =			\
 	core/util-private.h			\
 	core/window-props.c			\
 	core/window-props.h			\
+	core/window-x11.c			\
+	core/window-x11.h			\
 	core/window.c				\
 	core/window-private.h			\
 	meta/window.h				\
@ -189,12 +192,7 @@ libmutter_wayland_la_SOURCES =			\
 	ui/theme.c				\
 	meta/theme.h				\
 	ui/theme-private.h			\
-	ui/ui.c
-
-nodist_libmutter_wayland_la_SOURCES =		\
-	$(mutter_built_sources)
-
-libmutter_wayland_la_SOURCES +=			\
+	ui/ui.c					\
 	wayland/meta-wayland.c			\
 	wayland/meta-wayland-private.h		\
 	wayland/meta-xwayland-private.h		\
@ -216,6 +214,9 @@ libmutter_wayland_la_SOURCES +=			\
 	wayland/meta-weston-launch.c		\
 	wayland/meta-weston-launch.h

+nodist_libmutter_wayland_la_SOURCES =		\
+	$(mutter_built_sources)
+
 libmutter_wayland_la_LDFLAGS = -no-undefined
 libmutter_wayland_la_LIBADD  = $(MUTTER_LIBS)

@ -418,6 +419,3 @@ wayland/%-protocol.c : $(top_builddir)/protocol/%.xml
 wayland/%-server-protocol.h : $(top_builddir)/protocol/%.xml
 	mkdir -p wayland
 	$(AM_V_GEN)$(WAYLAND_SCANNER) server-header < $< > $@
-wayland/%-client-protocol.h : $(top_builddir)/protocol/%.xml
-	mkdir -p wayland
-	$(AM_V_GEN)$(WAYLAND_SCANNER) client-header < $< > $@
--- a/src/compositor/compositor-private.h
+++ b/src/compositor/compositor-private.h
@ -46,11 +46,8 @@ struct _MetaCompScreen
  CoglFrameClosure      *frame_closure;

  /* Used for unredirecting fullscreen windows */
-  guint                   disable_unredirect_count;
-  MetaWindowActor             *unredirected_window;
-
-  /* Before we create the output window */
-  XserverRegion     pending_input_region;
+  guint                  disable_unredirect_count;
+  MetaWindow            *unredirected_window;

  gint                   switch_workspace_in_progress;

--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@ -42,15 +42,6 @@
 * the call, so it may be necessary to readjust the display based on the
 * old_rect to start the animation.
 *
- * meta_compositor_window_mapped() and meta_compositor_window_unmapped() are
- * notifications when the toplevel window (frame or client window) is mapped or
- * unmapped. That is, when the result of meta_window_toplevel_is_mapped()
- * changes. The main use of this is to drop resources when a window is unmapped.
- * A window will always be mapped before meta_compositor_show_window()
- * is called and will not be unmapped until after meta_compositor_hide_window()
- * is called. If the live_hidden_windows preference is set, windows will never
- * be unmapped.
- *
 * # Containers #
 *
 * There's two containers in the stage that are used to place window actors, here
@ -149,19 +140,6 @@ meta_compositor_destroy (MetaCompositor *compositor)
  clutter_threads_remove_repaint_func (compositor->repaint_func_id);
 }

-static void
-add_win (MetaWindow *window)
-{
-  MetaScreen		*screen = meta_window_get_screen (window);
-  MetaCompScreen        *info = meta_screen_get_compositor_data (screen);
-
-  g_return_if_fail (info != NULL);
-
-  meta_window_actor_new (window);
-
-  sync_actor_stacking (info);
-}
-
 static void
 process_damage (MetaCompositor     *compositor,
                XDamageNotifyEvent *event,
@ -283,25 +261,6 @@ meta_get_window_actors (MetaScreen *screen)
  return info->windows;
 }

-static void
-do_set_stage_input_region (MetaScreen   *screen,
-                           XserverRegion region)
-{
-  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-  MetaDisplay *display = meta_screen_get_display (screen);
-  Display        *xdpy = meta_display_get_xdisplay (display);
-  Window        xstage = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));
-
-  XFixesSetWindowShapeRegion (xdpy, xstage, ShapeInput, 0, 0, region);
-
-  /* It's generally a good heuristic that when a crossing event is generated because
-   * we reshape the overlay, we don't want it to affect focus-follows-mouse focus -
-   * it's not the user doing something, it's the environment changing under the user.
-   */
-  meta_display_add_ignored_crossing_serial (display, XNextRequest (xdpy));
-  XFixesSetWindowShapeRegion (xdpy, info->output, ShapeInput, 0, 0, region);
-}
-
 void
 meta_set_stage_input_region (MetaScreen   *screen,
                             XserverRegion region)
@ -313,29 +272,19 @@ meta_set_stage_input_region (MetaScreen   *screen,
   */
  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);
+      Window          xstage  = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));

-      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);
-            }
-        } 
+      XFixesSetWindowShapeRegion (xdpy, xstage, ShapeInput, 0, 0, region);
+
+      /* It's generally a good heuristic that when a crossing event is generated because
+       * we reshape the overlay, we don't want it to affect focus-follows-mouse focus -
+       * it's not the user doing something, it's the environment changing under the user.
+       */
+      meta_display_add_ignored_crossing_serial (display, XNextRequest (xdpy));
+      XFixesSetWindowShapeRegion (xdpy, info->output, ShapeInput, 0, 0, region);
    }
 }

@ -677,21 +626,6 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
    return;

  info = g_new0 (MetaCompScreen, 1);
-  /*
-   * We use an empty input region for Clutter as a default because that allows
-   * the user to interact with all the windows displayed on the screen.
-   * 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->screen = screen;

  meta_screen_set_compositor_data (screen, info);
@ -777,6 +711,8 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
      info->output = get_output_window (screen);
      XReparentWindow (xdisplay, xwin, info->output, 0, 0);

+      meta_empty_stage_input_region (screen);
+
      /* Make sure there isn't any left-over output shape on the 
       * overlay window by setting the whole screen to be an
       * output region.
@ -787,13 +723,6 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
       */
      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.
       */
@ -863,19 +792,50 @@ meta_shape_cow_for_window (MetaScreen *screen,
    }
 }

+static void
+set_unredirected_window (MetaCompScreen *info,
+                         MetaWindow     *window)
+{
+  if (info->unredirected_window == window)
+    return;
+
+  if (info->unredirected_window != NULL)
+    {
+      MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (info->unredirected_window));
+      meta_window_actor_set_unredirected (window_actor, FALSE);
+    }
+
+  info->unredirected_window = window;
+
+  if (info->unredirected_window != NULL)
+    {
+      MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (info->unredirected_window));
+      meta_window_actor_set_unredirected (window_actor, TRUE);
+    }
+
+  meta_shape_cow_for_window (info->screen, info->unredirected_window);
+}
+
 void
 meta_compositor_add_window (MetaCompositor    *compositor,
                            MetaWindow        *window)
 {
  MetaScreen *screen = meta_window_get_screen (window);
  MetaDisplay *display = meta_screen_get_display (screen);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  g_return_if_fail (info != NULL);
+
+  /* Window was already added previously, probably coming
+   * back from hiding */
+  if (window->compositor_private != NULL)
+    return;

-  DEBUG_TRACE ("meta_compositor_add_window\n");
  meta_error_trap_push (display);
-
-  add_win (window);
-
+  meta_window_actor_new (window);
  meta_error_trap_pop (display);
+
+  sync_actor_stacking (info);
 }

 void
@ -891,19 +851,11 @@ 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 (info->unredirected_window == window)
+    set_unredirected_window (info, NULL);

  meta_window_actor_destroy (window_actor);
 }
@ -1402,30 +1354,6 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
  sync_actor_stacking (info);
 }

-void
-meta_compositor_window_mapped (MetaCompositor *compositor,
-                               MetaWindow     *window)
-{
-  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  DEBUG_TRACE ("meta_compositor_window_mapped\n");
-  if (!window_actor)
-    return;
-
-  meta_window_actor_mapped (window_actor);
-}
-
-void
-meta_compositor_window_unmapped (MetaCompositor *compositor,
-                                 MetaWindow     *window)
-{
-  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  DEBUG_TRACE ("meta_compositor_window_unmapped\n");
-  if (!window_actor)
-    return;
-
-  meta_window_actor_unmapped (window_actor);
-}
-
 void
 meta_compositor_sync_window_geometry (MetaCompositor *compositor,
 				      MetaWindow *window,
@ -1533,7 +1461,6 @@ pre_paint_windows (MetaCompScreen *info)
 {
  GList *l;
  MetaWindowActor *top_window;
-  MetaWindowActor *expected_unredirected_window = NULL;

  if (info->onscreen == NULL)
    {
@ -1547,33 +1474,13 @@ pre_paint_windows (MetaCompScreen *info)
  if (info->windows == NULL)
    return;

-  if (!meta_is_wayland_compositor ())
-    {
-      top_window = g_list_last (info->windows)->data;
+  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)
-            {
-              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;
-        }
-    }
+  if (meta_window_actor_should_unredirect (top_window) &&
+      info->disable_unredirect_count == 0)
+    set_unredirected_window (info, meta_window_actor_get_meta_window (top_window));
+  else
+    set_unredirected_window (info, NULL);

  for (l = info->windows; l; l = l->next)
    meta_window_actor_pre_paint (l->data);
--- a/src/compositor/meta-cullable.c
+++ b/src/compositor/meta-cullable.c
@ -70,10 +70,16 @@ meta_cullable_cull_out_children (MetaCullable   *cullable,
  while (clutter_actor_iter_prev (&iter, &child))
    {
      float x, y;
+      gboolean needs_culling;

-      if (!CLUTTER_ACTOR_IS_VISIBLE (child))
+      if (!META_IS_CULLABLE (child))
        continue;

+      needs_culling = (unobscured_region != NULL && clip_region != NULL);
+
+      if (needs_culling && !CLUTTER_ACTOR_IS_VISIBLE (child))
+        needs_culling = FALSE;
+
      /* If an actor has effects applied, then that can change the area
       * it paints and the opacity, so we no longer can figure out what
       * portion of the actor is obscured and what portion of the screen
@ -90,25 +96,29 @@ meta_cullable_cull_out_children (MetaCullable   *cullable,
       * as well for the same reason, but omitted for simplicity in the
       * hopes that no-one will do that.
       */
-      if (clutter_actor_has_effects (child))
-        continue;
+      if (needs_culling && clutter_actor_has_effects (child))
+        needs_culling = FALSE;

-      if (!META_IS_CULLABLE (child))
-        continue;
+      if (needs_culling && !meta_actor_is_untransformed (child, NULL, NULL))
+        needs_culling = FALSE;

-      if (!meta_actor_is_untransformed (child, NULL, NULL))
-        continue;
+      if (needs_culling)
+        {
+          clutter_actor_get_position (child, &x, &y);

-      clutter_actor_get_position (child, &x, &y);
+          /* Temporarily move to the coordinate system of the actor */
+          cairo_region_translate (unobscured_region, - x, - y);
+          cairo_region_translate (clip_region, - x, - y);

-      /* Temporarily move to the coordinate system of the actor */
-      cairo_region_translate (unobscured_region, - x, - y);
-      cairo_region_translate (clip_region, - x, - y);
+          meta_cullable_cull_out (META_CULLABLE (child), unobscured_region, clip_region);

-      meta_cullable_cull_out (META_CULLABLE (child), unobscured_region, clip_region);
-
-      cairo_region_translate (unobscured_region, x, y);
-      cairo_region_translate (clip_region, x, y);
+          cairo_region_translate (unobscured_region, x, y);
+          cairo_region_translate (clip_region, x, y);
+        }
+      else
+        {
+          meta_cullable_cull_out (META_CULLABLE (child), NULL, NULL);
+        }
    }
 }

--- a/src/compositor/meta-shaped-texture-private.h
+++ b/src/compositor/meta-shaped-texture-private.h
@ -32,5 +32,8 @@
 ClutterActor *meta_shaped_texture_new (void);
 void meta_shaped_texture_set_texture (MetaShapedTexture *stex,
                                      CoglTexture       *texture);
+gboolean meta_shaped_texture_get_unobscured_bounds (MetaShapedTexture     *stex,
+                                                    cairo_rectangle_int_t *unobscured_bounds);
+gboolean meta_shaped_texture_is_obscured (MetaShapedTexture *self);

 #endif
--- a/src/compositor/meta-shaped-texture.c
+++ b/src/compositor/meta-shaped-texture.c
@ -42,8 +42,6 @@
 static void meta_shaped_texture_dispose  (GObject    *object);

 static void meta_shaped_texture_paint (ClutterActor       *actor);
-static void meta_shaped_texture_pick  (ClutterActor       *actor,
-				       const ClutterColor *color);

 static void meta_shaped_texture_get_preferred_width (ClutterActor *self,
                                                     gfloat        for_height,
@ -73,10 +71,13 @@ struct _MetaShapedTexturePrivate
  CoglTexture *texture;
  CoglTexture *mask_texture;

-  cairo_region_t *clip_region;
-  cairo_region_t *input_shape_region;
+  /* The region containing only fully opaque pixels */
  cairo_region_t *opaque_region;

+  /* MetaCullable regions, see that documentation for more details */
+  cairo_region_t *clip_region;
+  cairo_region_t *unobscured_region;
+
  guint tex_width, tex_height;

  guint create_mipmaps : 1;
@ -93,7 +94,6 @@ meta_shaped_texture_class_init (MetaShapedTextureClass *klass)
  actor_class->get_preferred_width = meta_shaped_texture_get_preferred_width;
  actor_class->get_preferred_height = meta_shaped_texture_get_preferred_height;
  actor_class->paint = meta_shaped_texture_paint;
-  actor_class->pick = meta_shaped_texture_pick;
  actor_class->get_paint_volume = meta_shaped_texture_get_paint_volume;

  g_type_class_add_private (klass, sizeof (MetaShapedTexturePrivate));
@ -113,6 +113,21 @@ meta_shaped_texture_init (MetaShapedTexture *self)
  priv->create_mipmaps = TRUE;
 }

+static void
+set_unobscured_region (MetaShapedTexture *self,
+                       cairo_region_t    *unobscured_region)
+{
+  MetaShapedTexturePrivate *priv = self->priv;
+
+  g_clear_pointer (&priv->unobscured_region, (GDestroyNotify) cairo_region_destroy);
+  if (unobscured_region)
+    {
+      cairo_rectangle_int_t bounds = { 0, 0, priv->tex_width, priv->tex_height };
+      priv->unobscured_region = cairo_region_copy (unobscured_region);
+      cairo_region_intersect_rectangle (priv->unobscured_region, &bounds);
+    }
+}
+
 static void
 set_clip_region (MetaShapedTexture *self,
                 cairo_region_t    *clip_region)
@ -138,6 +153,7 @@ meta_shaped_texture_dispose (GObject *object)
  g_clear_pointer (&priv->opaque_region, cairo_region_destroy);

  meta_shaped_texture_set_mask_texture (self, NULL);
+  set_unobscured_region (self, NULL);
  set_clip_region (self, NULL);

  G_OBJECT_CLASS (meta_shaped_texture_parent_class)->dispose (object);
@ -442,71 +458,6 @@ meta_shaped_texture_paint (ClutterActor *actor)
    cairo_region_destroy (blended_region);
 }

-static void
-meta_shaped_texture_pick (ClutterActor       *actor,
-			  const ClutterColor *color)
-{
-  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)
-    CLUTTER_ACTOR_CLASS (meta_shaped_texture_parent_class)->pick (actor, color);
-  else
-    {
-      int n_rects;
-      float *rectangles;
-      int i;
-      CoglPipeline *pipeline;
-      CoglContext *ctx;
-      CoglFramebuffer *fb;
-      CoglColor cogl_color;
-
-      /* 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.
-       */
-
-      n_rects = cairo_region_num_rectangles (priv->input_shape_region);
-      rectangles = g_alloca (sizeof (float) * 4 * n_rects);
-
-      for (i = 0; i < n_rects; i++)
-        {
-          cairo_rectangle_int_t rect;
-          int pos = i * 4;
-
-          cairo_region_get_rectangle (priv->input_shape_region, i, &rect);
-
-          rectangles[pos] = rect.x;
-          rectangles[pos + 1] = rect.y;
-          rectangles[pos + 2] = rect.x + rect.width;
-          rectangles[pos + 3] = rect.y + rect.height;
-        }
-
-      ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
-      fb = cogl_get_draw_framebuffer ();
-
-      cogl_color_init_from_4ub (&cogl_color, color->red, color->green, color->blue, color->alpha);
-
-      pipeline = cogl_pipeline_new (ctx);
-      cogl_pipeline_set_color (pipeline, &cogl_color);
-
-      cogl_framebuffer_draw_rectangles (fb, pipeline,
-                                        rectangles, n_rects);
-      cogl_object_unref (pipeline);
-    }
-}
-
 static void
 meta_shaped_texture_get_preferred_width (ClutterActor *self,
                                         gfloat        for_height,
@ -546,10 +497,37 @@ meta_shaped_texture_get_preferred_height (ClutterActor *self,
 }

 static gboolean
-meta_shaped_texture_get_paint_volume (ClutterActor *self,
+meta_shaped_texture_get_paint_volume (ClutterActor *actor,
                                      ClutterPaintVolume *volume)
 {
-  return clutter_paint_volume_set_from_allocation (volume, self);
+  MetaShapedTexture *self = META_SHAPED_TEXTURE (actor);
+  cairo_rectangle_int_t unobscured_bounds;
+
+  if (!clutter_paint_volume_set_from_allocation (volume, actor))
+    return FALSE;
+
+  if (meta_shaped_texture_get_unobscured_bounds (self, &unobscured_bounds))
+    {
+      ClutterVertex origin;
+      cairo_rectangle_int_t bounds;
+
+      /* I hate ClutterPaintVolume so much... */
+      clutter_paint_volume_get_origin (volume, &origin);
+      bounds.x = origin.x;
+      bounds.y = origin.y;
+      bounds.width = clutter_paint_volume_get_width (volume);
+      bounds.height = clutter_paint_volume_get_height (volume);
+
+      gdk_rectangle_intersect (&bounds, &unobscured_bounds, &bounds);
+
+      origin.x = bounds.x;
+      origin.y = bounds.y;
+      clutter_paint_volume_set_origin (volume, &origin);
+      clutter_paint_volume_set_width (volume, bounds.width);
+      clutter_paint_volume_set_height (volume, bounds.height);
+    }
+
+  return TRUE;
 }

 void
@ -594,50 +572,38 @@ meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }

-static gboolean
-get_clip (MetaShapedTexture *stex,
-          int x,
-          int y,
-          int width,
-          int height,
-          cairo_rectangle_int_t *clip)
+static cairo_region_t *
+effective_unobscured_region (MetaShapedTexture *self)
 {
-  ClutterActor *self = CLUTTER_ACTOR (stex);
-  MetaShapedTexturePrivate *priv;
-  ClutterActorBox allocation;
-  float scale_x;
-  float scale_y;
+  MetaShapedTexturePrivate *priv = self->priv;

-  /* 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...
-   */
+  return clutter_actor_has_mapped_clones (CLUTTER_ACTOR (self)) ? NULL : priv->unobscured_region;
+}

-  /* 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))
+gboolean
+meta_shaped_texture_get_unobscured_bounds (MetaShapedTexture     *self,
+                                           cairo_rectangle_int_t *unobscured_bounds)
+{
+  cairo_region_t *unobscured_region = effective_unobscured_region (self);
+
+  if (unobscured_region)
+    {
+      cairo_region_get_extents (unobscured_region, unobscured_bounds);
+      return TRUE;
+    }
+  else
    return FALSE;
+}

-  priv = stex->priv;
+gboolean
+meta_shaped_texture_is_obscured (MetaShapedTexture *self)
+{
+  cairo_region_t *unobscured_region = effective_unobscured_region (self);

-  if (priv->tex_width == 0 || priv->tex_height == 0)
+  if (unobscured_region)
+    return cairo_region_is_empty (unobscured_region);
+  else
    return FALSE;
-
-  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;
-
-  return TRUE;
 }

 /**
@ -647,14 +613,9 @@ get_clip (MetaShapedTexture *stex,
 * @y: the y coordinate of the damaged area
 * @width: the width of the damaged area
 * @height: the height of the damaged area
- * @unobscured_region: The unobscured region of the window or %NULL if
- * there is no valid one (like when the actor is transformed or
- * has a mapped clone)
 *
 * Repairs the damaged area indicated by @x, @y, @width and @height
- * and queues a redraw for the intersection @unobscured_region and
- * the damage area. If @unobscured_region is %NULL a redraw will always
- * get queued.
+ * and potentially queues a redraw.
 *
 * Return value: Whether a redraw have been queued or not
 */
@ -663,12 +624,11 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
 				 int                x,
 				 int                y,
 				 int                width,
-				 int                height,
-				 cairo_region_t    *unobscured_region)
+				 int                height)
 {
  MetaShapedTexturePrivate *priv;
-  cairo_rectangle_int_t clip;
-  gboolean has_clip;
+  cairo_region_t *unobscured_region;
+  const cairo_rectangle_int_t clip = { x, y, width, height };

  priv = stex->priv;

@ -677,8 +637,7 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,

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

-  has_clip = get_clip (stex, x, y, width, height, &clip);
-
+  unobscured_region = effective_unobscured_region (stex);
  if (unobscured_region)
    {
      cairo_region_t *intersection;
@ -687,8 +646,7 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
        return FALSE;

      intersection = cairo_region_copy (unobscured_region);
-      if (has_clip)
-	cairo_region_intersect_rectangle (intersection, &clip);
+      cairo_region_intersect_rectangle (intersection, &clip);

      if (!cairo_region_is_empty (intersection))
        {
@ -696,21 +654,17 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
          cairo_region_get_extents (intersection, &damage_rect);
          clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (stex), &damage_rect);
          cairo_region_destroy (intersection);
-
          return TRUE;
        }

      cairo_region_destroy (intersection);
-
      return FALSE;
    }
-
-  if (has_clip)
-    clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (stex), &clip);
  else
-    clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
-
-  return TRUE;
+    {
+      clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (stex), &clip);
+      return TRUE;
+    }
 }

 /**
@ -740,41 +694,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_opaque_region:
 * @stex: a #MetaShapedTexture
@ -911,14 +830,17 @@ meta_shaped_texture_cull_out (MetaCullable   *cullable,
  MetaShapedTexture *self = META_SHAPED_TEXTURE (cullable);
  MetaShapedTexturePrivate *priv = self->priv;

+  set_unobscured_region (self, unobscured_region);
  set_clip_region (self, clip_region);

  if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (self)) == 0xff)
    {
      if (priv->opaque_region)
        {
-          cairo_region_subtract (unobscured_region, priv->opaque_region);
-          cairo_region_subtract (clip_region, priv->opaque_region);
+          if (unobscured_region)
+            cairo_region_subtract (unobscured_region, priv->opaque_region);
+          if (clip_region)
+            cairo_region_subtract (clip_region, priv->opaque_region);
        }
    }
 }
--- a/src/compositor/meta-surface-actor-wayland.c
+++ b/src/compositor/meta-surface-actor-wayland.c
@ -0,0 +1,153 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2013 Red Hat
+ *
+ * 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.
+ *
+ * Written by:
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#include "config.h"
+
+#include "meta-surface-actor-wayland.h"
+
+#include <cogl/cogl-wayland-server.h>
+#include "meta-shaped-texture-private.h"
+
+struct _MetaSurfaceActorWaylandPrivate
+{
+  MetaWaylandSurface *surface;
+  MetaWaylandBuffer *buffer;
+};
+typedef struct _MetaSurfaceActorWaylandPrivate MetaSurfaceActorWaylandPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (MetaSurfaceActorWayland, meta_surface_actor_wayland, META_TYPE_SURFACE_ACTOR)
+
+static void
+meta_surface_actor_wayland_process_damage (MetaSurfaceActor *actor,
+                                           int x, int y, int width, int height)
+{
+  MetaSurfaceActorWayland *self = META_SURFACE_ACTOR_WAYLAND (actor);
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+
+  struct wl_resource *resource = priv->buffer->resource;
+  struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get (resource);
+
+  if (shm_buffer)
+    {
+      CoglTexture2D *texture = COGL_TEXTURE_2D (priv->buffer->texture);
+      cogl_wayland_texture_set_region_from_shm_buffer (texture, x, y, width, height, shm_buffer, x, y, 0, NULL);
+    }
+
+  meta_surface_actor_update_area (META_SURFACE_ACTOR (self), x, y, width, height);
+}
+
+static void
+meta_surface_actor_wayland_pre_paint (MetaSurfaceActor *actor)
+{
+}
+
+static gboolean
+meta_surface_actor_wayland_is_argb32 (MetaSurfaceActor *actor)
+{
+  /* XXX -- look at the SHM buffer format. */
+  return TRUE;
+}
+
+static gboolean
+meta_surface_actor_wayland_is_visible (MetaSurfaceActor *actor)
+{
+  /* TODO: ensure that the buffer isn't NULL, implement
+   * wayland mapping semantics */
+  return TRUE;
+}
+
+static gboolean
+meta_surface_actor_wayland_should_unredirect (MetaSurfaceActor *actor)
+{
+  return FALSE;
+}
+
+static void
+meta_surface_actor_wayland_set_unredirected (MetaSurfaceActor *actor,
+                                             gboolean          unredirected)
+{
+  /* Do nothing. In the future, we'll use KMS to set this
+   * up as a hardware overlay or something. */
+}
+
+static gboolean
+meta_surface_actor_wayland_is_unredirected (MetaSurfaceActor *actor)
+{
+  return FALSE;
+}
+
+static void
+meta_surface_actor_wayland_class_init (MetaSurfaceActorWaylandClass *klass)
+{
+  MetaSurfaceActorClass *surface_actor_class = META_SURFACE_ACTOR_CLASS (klass);
+
+  surface_actor_class->process_damage = meta_surface_actor_wayland_process_damage;
+  surface_actor_class->pre_paint = meta_surface_actor_wayland_pre_paint;
+  surface_actor_class->is_argb32 = meta_surface_actor_wayland_is_argb32;
+  surface_actor_class->is_visible = meta_surface_actor_wayland_is_visible;
+
+  surface_actor_class->should_unredirect = meta_surface_actor_wayland_should_unredirect;
+  surface_actor_class->set_unredirected = meta_surface_actor_wayland_set_unredirected;
+  surface_actor_class->is_unredirected = meta_surface_actor_wayland_is_unredirected;
+}
+
+static void
+meta_surface_actor_wayland_init (MetaSurfaceActorWayland *self)
+{
+}
+
+MetaSurfaceActor *
+meta_surface_actor_wayland_new (MetaWaylandSurface *surface)
+{
+  MetaSurfaceActorWayland *self = g_object_new (META_TYPE_SURFACE_ACTOR_WAYLAND, NULL);
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+
+  g_assert (meta_is_wayland_compositor ());
+
+  priv->surface = surface;
+
+  return META_SURFACE_ACTOR (self);
+}
+
+void
+meta_surface_actor_wayland_set_buffer (MetaSurfaceActorWayland *self,
+                                       MetaWaylandBuffer       *buffer)
+{
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+  MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
+
+  priv->buffer = buffer;
+
+  if (buffer)
+    meta_shaped_texture_set_texture (stex, buffer->texture);
+  else
+    meta_shaped_texture_set_texture (stex, NULL);
+}
+
+MetaWaylandSurface *
+meta_surface_actor_wayland_get_surface (MetaSurfaceActorWayland *self)
+{
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+  return priv->surface;
+}
--- a/src/compositor/meta-surface-actor-wayland.h
+++ b/src/compositor/meta-surface-actor-wayland.h
@ -0,0 +1,66 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2013 Red Hat
+ *
+ * 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.
+ *
+ * Written by:
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#ifndef __META_SURFACE_ACTOR_WAYLAND_H__
+#define __META_SURFACE_ACTOR_WAYLAND_H__
+
+#include <glib-object.h>
+
+#include "meta-surface-actor.h"
+
+#include "meta-wayland-private.h"
+
+G_BEGIN_DECLS
+
+#define META_TYPE_SURFACE_ACTOR_WAYLAND            (meta_surface_actor_wayland_get_type ())
+#define META_SURFACE_ACTOR_WAYLAND(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SURFACE_ACTOR_WAYLAND, MetaSurfaceActorWayland))
+#define META_SURFACE_ACTOR_WAYLAND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_SURFACE_ACTOR_WAYLAND, MetaSurfaceActorWaylandClass))
+#define META_IS_SURFACE_ACTOR_WAYLAND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SURFACE_ACTOR_WAYLAND))
+#define META_IS_SURFACE_ACTOR_WAYLAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_SURFACE_ACTOR_WAYLAND))
+#define META_SURFACE_ACTOR_WAYLAND_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_SURFACE_ACTOR_WAYLAND, MetaSurfaceActorWaylandClass))
+
+typedef struct _MetaSurfaceActorWayland      MetaSurfaceActorWayland;
+typedef struct _MetaSurfaceActorWaylandClass MetaSurfaceActorWaylandClass;
+
+struct _MetaSurfaceActorWayland
+{
+  MetaSurfaceActor parent;
+};
+
+struct _MetaSurfaceActorWaylandClass
+{
+  MetaSurfaceActorClass parent_class;
+};
+
+GType meta_surface_actor_wayland_get_type (void);
+
+MetaSurfaceActor * meta_surface_actor_wayland_new (MetaWaylandSurface *surface);
+MetaWaylandSurface * meta_surface_actor_wayland_get_surface (MetaSurfaceActorWayland *self);
+
+void meta_surface_actor_wayland_set_buffer (MetaSurfaceActorWayland *self,
+                                            MetaWaylandBuffer         *buffer);
+
+G_END_DECLS
+
+#endif /* __META_SURFACE_ACTOR_WAYLAND_H__ */
--- a/src/compositor/meta-surface-actor-x11.c
+++ b/src/compositor/meta-surface-actor-x11.c
@ -0,0 +1,453 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2013 Red Hat
+ *
+ * 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.
+ *
+ * Written by:
+ *     Owen Taylor <otaylor@redhat.com>
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#include "config.h"
+
+#include "meta-surface-actor-x11.h"
+
+#include <X11/extensions/Xcomposite.h>
+#include <X11/extensions/Xrender.h>
+#include <cogl/cogl-texture-pixmap-x11.h>
+
+#include <meta/errors.h>
+#include "window-private.h"
+#include "meta-shaped-texture-private.h"
+#include "meta-cullable.h"
+
+struct _MetaSurfaceActorX11Private
+{
+  MetaWindow *window;
+
+  MetaDisplay *display;
+
+  CoglTexture *texture;
+  Pixmap pixmap;
+  Damage damage;
+
+  int last_width;
+  int last_height;
+
+  /* This is used to detect fullscreen windows that need to be unredirected */
+  guint full_damage_frames_count;
+  guint does_full_damage  : 1;
+
+  /* Other state... */
+  guint argb32 : 1;
+  guint received_damage : 1;
+  guint size_changed : 1;
+
+  guint unredirected   : 1;
+};
+typedef struct _MetaSurfaceActorX11Private MetaSurfaceActorX11Private;
+
+G_DEFINE_TYPE_WITH_PRIVATE (MetaSurfaceActorX11, meta_surface_actor_x11, META_TYPE_SURFACE_ACTOR)
+
+static void
+free_damage (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  if (priv->damage == None)
+    return;
+
+  meta_error_trap_push (display);
+  XDamageDestroy (xdisplay, priv->damage);
+  priv->damage = None;
+  meta_error_trap_pop (display);
+}
+
+static void
+detach_pixmap (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
+
+  if (priv->pixmap == None)
+    return;
+
+  /* Get rid of all references to the pixmap before freeing it; it's unclear whether
+   * you are supposed to be able to free a GLXPixmap after freeing the underlying
+   * pixmap, but it certainly doesn't work with current DRI/Mesa
+   */
+  meta_shaped_texture_set_texture (stex, NULL);
+  cogl_flush ();
+
+  meta_error_trap_push (display);
+  XFreePixmap (xdisplay, priv->pixmap);
+  priv->pixmap = None;
+  meta_error_trap_pop (display);
+
+  cogl_object_unref (priv->texture);
+  priv->texture = NULL;
+}
+
+static void
+set_pixmap (MetaSurfaceActorX11 *self,
+            Pixmap               pixmap)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  CoglContext *ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
+  MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
+  CoglTexture *texture;
+
+  g_assert (priv->pixmap == None);
+  priv->pixmap = pixmap;
+
+  texture = COGL_TEXTURE (cogl_texture_pixmap_x11_new (ctx, priv->pixmap, FALSE, NULL));
+
+  if (G_UNLIKELY (!cogl_texture_pixmap_x11_is_using_tfp_extension (COGL_TEXTURE_PIXMAP_X11 (texture))))
+    g_warning ("NOTE: Not using GLX TFP!\n");
+
+  priv->texture = texture;
+  meta_shaped_texture_set_texture (stex, texture);
+}
+
+static void
+update_pixmap (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  if (priv->size_changed)
+    {
+      detach_pixmap (self);
+      priv->size_changed = FALSE;
+    }
+
+  if (priv->pixmap == None)
+    {
+      Pixmap new_pixmap;
+      Window xwindow = meta_window_get_toplevel_xwindow (priv->window);
+
+      meta_error_trap_push (display);
+      new_pixmap = XCompositeNameWindowPixmap (xdisplay, xwindow);
+
+      if (meta_error_trap_pop_with_return (display) != Success)
+        {
+          /* Probably a BadMatch if the window isn't viewable; we could
+           * GrabServer/GetWindowAttributes/NameWindowPixmap/UngrabServer/Sync
+           * to avoid this, but there's no reason to take two round trips
+           * when one will do. (We need that Sync if we want to handle failures
+           * for any reason other than !viewable. That's unlikely, but maybe
+           * we'll BadAlloc or something.)
+           */
+          new_pixmap = None;
+        }
+
+      if (new_pixmap == None)
+        {
+          meta_verbose ("Unable to get named pixmap for %s\n",
+                        meta_window_get_description (priv->window));
+          return;
+        }
+
+      set_pixmap (self, new_pixmap);
+    }
+}
+
+static gboolean
+is_visible (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  return (priv->pixmap != None) && !priv->unredirected;
+}
+
+static void
+damage_area (MetaSurfaceActorX11 *self,
+             int x, int y, int width, int height)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  if (!is_visible (self))
+    return;
+
+  cogl_texture_pixmap_x11_update_area (priv->texture, x, y, width, height);
+  meta_surface_actor_update_area (META_SURFACE_ACTOR (self), x, y, width, height);
+}
+
+static void
+meta_surface_actor_x11_process_damage (MetaSurfaceActor *actor,
+                                       int x, int y, int width, int height)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  priv->received_damage = TRUE;
+
+  if (meta_window_is_fullscreen (priv->window) && !priv->unredirected && !priv->does_full_damage)
+    {
+      MetaRectangle window_rect;
+      meta_window_get_frame_rect (priv->window, &window_rect);
+
+      if (window_rect.x == x &&
+          window_rect.y == y &&
+          window_rect.width == width &&
+          window_rect.height == height)
+        priv->full_damage_frames_count++;
+      else
+        priv->full_damage_frames_count = 0;
+
+      if (priv->full_damage_frames_count >= 100)
+        priv->does_full_damage = TRUE;
+    }
+
+  /* Drop damage event for unredirected windows */
+  if (priv->unredirected)
+    return;
+
+  damage_area (self, x, y, width, height);
+}
+
+static void
+meta_surface_actor_x11_pre_paint (MetaSurfaceActor *actor)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  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;
+    }
+
+  update_pixmap (self);
+}
+
+static void
+update_is_argb32 (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  XRenderPictFormat *format;
+  format = XRenderFindVisualFormat (xdisplay, priv->window->xvisual);
+
+  priv->argb32 = (format && format->type == PictTypeDirect && format->direct.alphaMask);
+}
+
+static gboolean
+meta_surface_actor_x11_is_argb32 (MetaSurfaceActor *actor)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  return priv->argb32;
+}
+
+static gboolean
+meta_surface_actor_x11_is_visible (MetaSurfaceActor *actor)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  return is_visible (self);
+}
+
+static gboolean
+meta_surface_actor_x11_should_unredirect (MetaSurfaceActor *actor)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  MetaWindow *window = priv->window;
+
+  if (meta_window_requested_dont_bypass_compositor (window))
+    return FALSE;
+
+  if (window->opacity != 0xFF)
+    return FALSE;
+
+  if (window->shape_region != NULL)
+    return FALSE;
+
+  if (priv->argb32 && !meta_window_requested_bypass_compositor (window))
+    return FALSE;
+
+  if (!meta_window_is_monitor_sized (window))
+    return FALSE;
+
+  if (meta_window_requested_bypass_compositor (window))
+    return TRUE;
+
+  if (meta_window_is_override_redirect (window))
+    return TRUE;
+
+  if (priv->does_full_damage)
+    return TRUE;
+
+  return FALSE;
+}
+
+static void
+sync_unredirected (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  Window xwindow = meta_window_get_toplevel_xwindow (priv->window);
+
+  meta_error_trap_push (display);
+
+  if (priv->unredirected)
+    {
+      detach_pixmap (self);
+      XCompositeUnredirectWindow (xdisplay, xwindow, CompositeRedirectManual);
+    }
+  else
+    {
+      XCompositeRedirectWindow (xdisplay, xwindow, CompositeRedirectManual);
+    }
+
+  meta_error_trap_pop (display);
+}
+
+static void
+meta_surface_actor_x11_set_unredirected (MetaSurfaceActor *actor,
+                                         gboolean          unredirected)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  if (priv->unredirected == unredirected)
+    return;
+
+  priv->unredirected = unredirected;
+  sync_unredirected (self);
+}
+
+static gboolean
+meta_surface_actor_x11_is_unredirected (MetaSurfaceActor *actor)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  return priv->unredirected;
+}
+
+static void
+meta_surface_actor_x11_dispose (GObject *object)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (object);
+
+  detach_pixmap (self);
+  free_damage (self);
+
+  G_OBJECT_CLASS (meta_surface_actor_x11_parent_class)->dispose (object);
+}
+
+static void
+meta_surface_actor_x11_class_init (MetaSurfaceActorX11Class *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  MetaSurfaceActorClass *surface_actor_class = META_SURFACE_ACTOR_CLASS (klass);
+
+  object_class->dispose = meta_surface_actor_x11_dispose;
+
+  surface_actor_class->process_damage = meta_surface_actor_x11_process_damage;
+  surface_actor_class->pre_paint = meta_surface_actor_x11_pre_paint;
+  surface_actor_class->is_argb32 = meta_surface_actor_x11_is_argb32;
+  surface_actor_class->is_visible = meta_surface_actor_x11_is_visible;
+
+  surface_actor_class->should_unredirect = meta_surface_actor_x11_should_unredirect;
+  surface_actor_class->set_unredirected = meta_surface_actor_x11_set_unredirected;
+  surface_actor_class->is_unredirected = meta_surface_actor_x11_is_unredirected;
+}
+
+static void
+meta_surface_actor_x11_init (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  priv->last_width = -1;
+  priv->last_height = -1;
+}
+
+MetaSurfaceActor *
+meta_surface_actor_x11_new (MetaWindow *window)
+{
+  MetaSurfaceActorX11 *self = g_object_new (META_TYPE_SURFACE_ACTOR_X11, NULL);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = meta_window_get_display (window);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  Window xwindow = meta_window_get_toplevel_xwindow (window);
+
+  g_assert (!meta_is_wayland_compositor ());
+
+  priv->window = window;
+  priv->display = display;
+
+  priv->damage = XDamageCreate (xdisplay, xwindow, XDamageReportBoundingBox);
+  update_is_argb32 (self);
+
+  priv->unredirected = FALSE;
+  sync_unredirected (self);
+
+  return META_SURFACE_ACTOR (self);
+}
+
+void
+meta_surface_actor_x11_set_size (MetaSurfaceActorX11 *self,
+                                 int width, int height)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  if (priv->last_width == width &&
+      priv->last_height == height)
+    return;
+
+  priv->size_changed = TRUE;
+  priv->last_width = width;
+  priv->last_height = height;
+}
--- a/src/compositor/meta-surface-actor-x11.h
+++ b/src/compositor/meta-surface-actor-x11.h
@ -0,0 +1,69 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2013 Red Hat
+ *
+ * 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.
+ *
+ * Written by:
+ *     Owen Taylor <otaylor@redhat.com>
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#ifndef __META_SURFACE_ACTOR_X11_H__
+#define __META_SURFACE_ACTOR_X11_H__
+
+#include <glib-object.h>
+
+#include "meta-surface-actor.h"
+
+#include <X11/extensions/Xdamage.h>
+
+#include <meta/display.h>
+#include <meta/window.h>
+
+G_BEGIN_DECLS
+
+#define META_TYPE_SURFACE_ACTOR_X11            (meta_surface_actor_x11_get_type ())
+#define META_SURFACE_ACTOR_X11(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SURFACE_ACTOR_X11, MetaSurfaceActorX11))
+#define META_SURFACE_ACTOR_X11_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_SURFACE_ACTOR_X11, MetaSurfaceActorX11Class))
+#define META_IS_SURFACE_ACTOR_X11(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SURFACE_ACTOR_X11))
+#define META_IS_SURFACE_ACTOR_X11_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_SURFACE_ACTOR_X11))
+#define META_SURFACE_ACTOR_X11_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_SURFACE_ACTOR_X11, MetaSurfaceActorX11Class))
+
+typedef struct _MetaSurfaceActorX11      MetaSurfaceActorX11;
+typedef struct _MetaSurfaceActorX11Class MetaSurfaceActorX11Class;
+
+struct _MetaSurfaceActorX11
+{
+  MetaSurfaceActor parent;
+};
+
+struct _MetaSurfaceActorX11Class
+{
+  MetaSurfaceActorClass parent_class;
+};
+
+GType meta_surface_actor_x11_get_type (void);
+
+MetaSurfaceActor * meta_surface_actor_x11_new (MetaWindow *window);
+
+void meta_surface_actor_x11_set_size (MetaSurfaceActorX11 *self,
+                                      int width, int height);
+
+G_END_DECLS
+
+#endif /* __META_SURFACE_ACTOR_X11_H__ */
--- a/src/compositor/meta-surface-actor.c
+++ b/src/compositor/meta-surface-actor.c
@ -10,30 +10,110 @@
 */

 #include <config.h>
-#include <clutter/clutter.h>
-#include <cogl/cogl-wayland-server.h>
-#include <cogl/cogl-texture-pixmap-x11.h>
-#include <meta/meta-shaped-texture.h>
+
 #include "meta-surface-actor.h"
+
+#include <clutter/clutter.h>
+#include <meta/meta-shaped-texture.h>
 #include "meta-wayland-private.h"
 #include "meta-cullable.h"
-
 #include "meta-shaped-texture-private.h"

 struct _MetaSurfaceActorPrivate
 {
  MetaShapedTexture *texture;
-  MetaWaylandBuffer *buffer;
+
+  cairo_region_t *input_region;
+
+  /* Freeze/thaw accounting */
+  guint freeze_count;
+  guint needs_damage_all : 1;
 };

 static void cullable_iface_init (MetaCullableInterface *iface);

-G_DEFINE_TYPE_WITH_CODE (MetaSurfaceActor, meta_surface_actor, CLUTTER_TYPE_ACTOR,
-                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
+G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MetaSurfaceActor, meta_surface_actor, CLUTTER_TYPE_ACTOR,
+                                  G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
+
+gboolean
+meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
+                                          cairo_rectangle_int_t *unobscured_bounds)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+  return meta_shaped_texture_get_unobscured_bounds (priv->texture, unobscured_bounds);
+}
+
+static void
+meta_surface_actor_pick (ClutterActor       *actor,
+                         const ClutterColor *color)
+{
+  MetaSurfaceActor *self = META_SURFACE_ACTOR (actor);
+  MetaSurfaceActorPrivate *priv = self->priv;
+
+  if (!clutter_actor_should_pick_paint (actor))
+    return;
+
+  /* If there is no region then use the regular pick */
+  if (priv->input_region == NULL)
+    CLUTTER_ACTOR_CLASS (meta_surface_actor_parent_class)->pick (actor, color);
+  else
+    {
+      int n_rects;
+      float *rectangles;
+      int i;
+      CoglPipeline *pipeline;
+      CoglContext *ctx;
+      CoglFramebuffer *fb;
+      CoglColor cogl_color;
+
+      n_rects = cairo_region_num_rectangles (priv->input_region);
+      rectangles = g_alloca (sizeof (float) * 4 * n_rects);
+
+      for (i = 0; i < n_rects; i++)
+        {
+          cairo_rectangle_int_t rect;
+          int pos = i * 4;
+
+          cairo_region_get_rectangle (priv->input_region, i, &rect);
+
+          rectangles[pos + 0] = rect.x;
+          rectangles[pos + 1] = rect.y;
+          rectangles[pos + 2] = rect.x + rect.width;
+          rectangles[pos + 3] = rect.y + rect.height;
+        }
+
+      ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
+      fb = cogl_get_draw_framebuffer ();
+
+      cogl_color_init_from_4ub (&cogl_color, color->red, color->green, color->blue, color->alpha);
+
+      pipeline = cogl_pipeline_new (ctx);
+      cogl_pipeline_set_color (pipeline, &cogl_color);
+      cogl_framebuffer_draw_rectangles (fb, pipeline, rectangles, n_rects);
+      cogl_object_unref (pipeline);
+    }
+}
+
+static void
+meta_surface_actor_dispose (GObject *object)
+{
+  MetaSurfaceActor *self = META_SURFACE_ACTOR (object);
+  MetaSurfaceActorPrivate *priv = self->priv;
+
+  g_clear_pointer (&priv->input_region, cairo_region_destroy);
+
+  G_OBJECT_CLASS (meta_surface_actor_parent_class)->dispose (object);
+}

 static void
 meta_surface_actor_class_init (MetaSurfaceActorClass *klass)
 {
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+
+  object_class->dispose = meta_surface_actor_dispose;
+  actor_class->pick = meta_surface_actor_pick;
+
  g_type_class_add_private (klass, sizeof (MetaSurfaceActorPrivate));
 }

@ -84,80 +164,19 @@ meta_surface_actor_get_texture (MetaSurfaceActor *self)
  return self->priv->texture;
 }

-static void
-update_area (MetaSurfaceActor *self,
-             int x, int y, int width, int height)
+gboolean
+meta_surface_actor_update_area (MetaSurfaceActor *self,
+                                int x, int y, int width, int height)
 {
  MetaSurfaceActorPrivate *priv = self->priv;
-
-  if (meta_is_wayland_compositor ())
-    {
-      struct wl_resource *resource = priv->buffer->resource;
-      struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get (resource);
-
-      if (shm_buffer)
-        {
-          CoglTexture2D *texture = COGL_TEXTURE_2D (priv->buffer->texture);
-          cogl_wayland_texture_set_region_from_shm_buffer (texture, x, y, width, height, shm_buffer, x, y, 0, NULL);
-        }
-    }
-  else
-    {
-      CoglTexturePixmapX11 *texture = COGL_TEXTURE_PIXMAP_X11 (meta_shaped_texture_get_texture (priv->texture));
-      cogl_texture_pixmap_x11_update_area (texture, x, y, width, height);
-    }
+  return meta_shaped_texture_update_area (priv->texture, x, y, width, height);
 }

 gboolean
-meta_surface_actor_damage_all (MetaSurfaceActor *self,
-                               cairo_region_t   *unobscured_region)
+meta_surface_actor_is_obscured (MetaSurfaceActor *self)
 {
  MetaSurfaceActorPrivate *priv = self->priv;
-  CoglTexture *texture = meta_shaped_texture_get_texture (priv->texture);
-
-  update_area (self, 0, 0, cogl_texture_get_width (texture), cogl_texture_get_height (texture));
-  return meta_shaped_texture_update_area (priv->texture,
-                                          0, 0,
-                                          cogl_texture_get_width (texture),
-                                          cogl_texture_get_height (texture),
-                                          unobscured_region);
-}
-
-gboolean
-meta_surface_actor_damage_area (MetaSurfaceActor *self,
-                                int               x,
-                                int               y,
-                                int               width,
-                                int               height,
-                                cairo_region_t   *unobscured_region)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-
-  update_area (self, x, y, width, height);
-  return meta_shaped_texture_update_area (priv->texture,
-                                          x, y, width, height,
-                                          unobscured_region);
-}
-
-void
-meta_surface_actor_attach_wayland_buffer (MetaSurfaceActor *self,
-                                          MetaWaylandBuffer *buffer)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-  priv->buffer = buffer;
-
-  if (buffer)
-    meta_shaped_texture_set_texture (priv->texture, buffer->texture);
-  else
-    meta_shaped_texture_set_texture (priv->texture, NULL);
-}
-
-void
-meta_surface_actor_set_texture (MetaSurfaceActor *self,
-                                CoglTexture      *texture)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-  meta_shaped_texture_set_texture (priv->texture, texture);
+  return meta_shaped_texture_is_obscured (priv->texture);
 }

 void
@ -165,7 +184,14 @@ meta_surface_actor_set_input_region (MetaSurfaceActor *self,
                                     cairo_region_t   *region)
 {
  MetaSurfaceActorPrivate *priv = self->priv;
-  meta_shaped_texture_set_input_shape_region (priv->texture, region);
+
+  if (priv->input_region)
+    cairo_region_destroy (priv->input_region);
+
+  if (region)
+    priv->input_region = cairo_region_reference (region);
+  else
+    priv->input_region = NULL;
 }

 void
@ -176,8 +202,114 @@ meta_surface_actor_set_opaque_region (MetaSurfaceActor *self,
  meta_shaped_texture_set_opaque_region (priv->texture, region);
 }

-MetaSurfaceActor *
-meta_surface_actor_new (void)
+static gboolean
+is_frozen (MetaSurfaceActor *self)
 {
-  return g_object_new (META_TYPE_SURFACE_ACTOR, NULL);
+  MetaSurfaceActorPrivate *priv = self->priv;
+  return (priv->freeze_count > 0);
+}
+
+void
+meta_surface_actor_process_damage (MetaSurfaceActor *self,
+                                   int x, int y, int width, int height)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+
+  if (is_frozen (self))
+    {
+      /* The window is frozen due to an effect in progress: we ignore damage
+       * here on the off chance that this will stop the corresponding
+       * texture_from_pixmap from being update.
+       *
+       * needs_damage_all tracks that some unknown damage happened while the
+       * window was frozen so that when the window becomes unfrozen we can
+       * issue a full window update to cover any lost damage.
+       *
+       * It should be noted that this is an unreliable mechanism since it's
+       * quite likely that drivers will aim to provide a zero-copy
+       * implementation of the texture_from_pixmap extension and in those cases
+       * any drawing done to the window is always immediately reflected in the
+       * texture regardless of damage event handling.
+       */
+      priv->needs_damage_all = TRUE;
+      return;
+    }
+
+  META_SURFACE_ACTOR_GET_CLASS (self)->process_damage (self, x, y, width, height);
+}
+
+void
+meta_surface_actor_pre_paint (MetaSurfaceActor *self)
+{
+  META_SURFACE_ACTOR_GET_CLASS (self)->pre_paint (self);
+}
+
+gboolean
+meta_surface_actor_is_argb32 (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->is_argb32 (self);
+}
+
+gboolean
+meta_surface_actor_is_visible (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->is_visible (self);
+}
+
+void
+meta_surface_actor_freeze (MetaSurfaceActor *self)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+
+  priv->freeze_count ++;
+}
+
+void
+meta_surface_actor_thaw (MetaSurfaceActor *self)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+
+  if (priv->freeze_count == 0)
+    {
+      g_critical ("Error in freeze/thaw accounting.");
+      return;
+    }
+
+  priv->freeze_count --;
+
+  /* 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 (priv->needs_damage_all)
+    {
+      meta_surface_actor_process_damage (self, 0, 0,
+                                         clutter_actor_get_width (CLUTTER_ACTOR (priv->texture)),
+                                         clutter_actor_get_height (CLUTTER_ACTOR (priv->texture)));
+      priv->needs_damage_all = FALSE;
+    }
+}
+
+gboolean
+meta_surface_actor_is_frozen (MetaSurfaceActor *self)
+{
+  return is_frozen (self);
+}
+
+gboolean
+meta_surface_actor_should_unredirect (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->should_unredirect (self);
+}
+
+void
+meta_surface_actor_set_unredirected (MetaSurfaceActor *self,
+                                     gboolean          unredirected)
+{
+  META_SURFACE_ACTOR_GET_CLASS (self)->set_unredirected (self, unredirected);
+}
+
+gboolean
+meta_surface_actor_is_unredirected (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->is_unredirected (self);
 }
--- a/src/compositor/meta-surface-actor.h
+++ b/src/compositor/meta-surface-actor.h
@ -6,7 +6,6 @@
 #include <config.h>

 #include <meta/meta-shaped-texture.h>
-#include "meta-wayland-types.h"

 G_BEGIN_DECLS

@ -25,6 +24,17 @@ struct _MetaSurfaceActorClass
 {
  /*< private >*/
  ClutterActorClass parent_class;
+
+  void     (* process_damage)    (MetaSurfaceActor *actor,
+                                  int x, int y, int width, int height);
+  void     (* pre_paint)         (MetaSurfaceActor *actor);
+  gboolean (* is_argb32)         (MetaSurfaceActor *actor);
+  gboolean (* is_visible)        (MetaSurfaceActor *actor);
+
+  gboolean (* should_unredirect) (MetaSurfaceActor *actor);
+  void     (* set_unredirected)  (MetaSurfaceActor *actor,
+                                  gboolean          unredirected);
+  gboolean (* is_unredirected)   (MetaSurfaceActor *actor);
 };

 struct _MetaSurfaceActor
@ -36,32 +46,38 @@ struct _MetaSurfaceActor

 GType meta_surface_actor_get_type (void);

-MetaSurfaceActor *meta_surface_actor_new (void);
-
 cairo_surface_t *meta_surface_actor_get_image (MetaSurfaceActor      *self,
                                               cairo_rectangle_int_t *clip);

 MetaShapedTexture *meta_surface_actor_get_texture (MetaSurfaceActor *self);

-gboolean meta_surface_actor_damage_all (MetaSurfaceActor *self,
-                                        cairo_region_t   *unobscured_region);
+gboolean meta_surface_actor_is_obscured (MetaSurfaceActor *self);
+gboolean meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
+                                                   cairo_rectangle_int_t *unobscured_bounds);

-gboolean meta_surface_actor_damage_area (MetaSurfaceActor *self,
-                                         int               x,
-                                         int               y,
-                                         int               width,
-                                         int               height,
-                                         cairo_region_t   *unobscured_region);
-
-void meta_surface_actor_set_texture (MetaSurfaceActor *self,
-                                     CoglTexture      *texture);
-void meta_surface_actor_attach_wayland_buffer (MetaSurfaceActor  *self,
-                                               MetaWaylandBuffer *buffer);
 void meta_surface_actor_set_input_region (MetaSurfaceActor *self,
                                          cairo_region_t   *region);
 void meta_surface_actor_set_opaque_region (MetaSurfaceActor *self,
                                           cairo_region_t   *region);

+gboolean meta_surface_actor_update_area (MetaSurfaceActor *actor,
+                                         int x, int y, int width, int height);
+
+void meta_surface_actor_process_damage (MetaSurfaceActor *actor,
+                                        int x, int y, int width, int height);
+void meta_surface_actor_pre_paint (MetaSurfaceActor *actor);
+gboolean meta_surface_actor_is_argb32 (MetaSurfaceActor *actor);
+gboolean meta_surface_actor_is_visible (MetaSurfaceActor *actor);
+
+void meta_surface_actor_freeze (MetaSurfaceActor *actor);
+void meta_surface_actor_thaw (MetaSurfaceActor *actor);
+gboolean meta_surface_actor_is_frozen (MetaSurfaceActor *actor);
+
+gboolean meta_surface_actor_should_unredirect (MetaSurfaceActor *actor);
+void meta_surface_actor_set_unredirected (MetaSurfaceActor *actor,
+                                          gboolean          unredirected);
+gboolean meta_surface_actor_is_unredirected (MetaSurfaceActor *actor);
+
 G_END_DECLS

 #endif /* META_SURFACE_ACTOR_PRIVATE_H */
--- a/src/compositor/meta-window-actor-private.h
+++ b/src/compositor/meta-window-actor-private.h
@ -39,13 +39,13 @@ void meta_window_actor_frame_complete (MetaWindowActor    *self,

 void meta_window_actor_invalidate_shadow (MetaWindowActor *self);

-void meta_window_actor_set_redirected (MetaWindowActor *self, gboolean state);
-
-gboolean meta_window_actor_should_unredirect (MetaWindowActor *self);
-
 void meta_window_actor_get_shape_bounds (MetaWindowActor       *self,
                                          cairo_rectangle_int_t *bounds);

+gboolean meta_window_actor_should_unredirect   (MetaWindowActor *self);
+void     meta_window_actor_set_unredirected    (MetaWindowActor *self,
+                                                gboolean         unredirected);
+
 gboolean meta_window_actor_effect_in_progress  (MetaWindowActor *self);
 void     meta_window_actor_sync_actor_geometry (MetaWindowActor *self,
                                                gboolean         did_placement);
@ -59,9 +59,6 @@ void     meta_window_actor_set_updates_frozen  (MetaWindowActor *self,
 void     meta_window_actor_queue_frame_drawn   (MetaWindowActor *self,
                                                gboolean         no_delay_frame);

-void meta_window_actor_set_unobscured_region      (MetaWindowActor *self,
-                                                   cairo_region_t  *unobscured_region);
-
 void meta_window_actor_effect_completed (MetaWindowActor *actor,
                                         gulong           event);

--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
--- a/src/compositor/meta-window-group.c
+++ b/src/compositor/meta-window-group.c
@ -115,8 +115,6 @@ meta_window_group_paint (ClutterActor *actor)
 {
  cairo_region_t *clip_region;
  cairo_region_t *unobscured_region;
-  ClutterActorIter iter;
-  ClutterActor *child;
  cairo_rectangle_int_t visible_rect, clip_rect;
  int paint_x_offset, paint_y_offset;
  int paint_x_origin, paint_y_origin;
@ -125,18 +123,6 @@ meta_window_group_paint (ClutterActor *actor)
  MetaWindowGroup *window_group = META_WINDOW_GROUP (actor);
  ClutterActor *stage = clutter_actor_get_stage (actor);

-  /* Start off by treating all windows as completely unobscured, so damage anywhere
-   * in a window queues redraws, but confine it more below. */
-  clutter_actor_iter_init (&iter, actor);
-  while (clutter_actor_iter_next (&iter, &child))
-    {
-      if (META_IS_WINDOW_ACTOR (child))
-        {
-          MetaWindowActor *window_actor = META_WINDOW_ACTOR (child);
-          meta_window_actor_set_unobscured_region (window_actor, NULL);
-        }
-    }
-
  /* 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
   * case and we need to compensate. We look at the position of the window
@ -178,20 +164,6 @@ meta_window_group_paint (ClutterActor *actor)
  paint_y_offset = paint_y_origin - actor_y_origin;
  cairo_region_translate (clip_region, -paint_x_offset, -paint_y_offset);

-  if (!meta_is_wayland_compositor ())
-    {
-      MetaCompScreen *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);
-
-          meta_window_get_frame_rect (window, (MetaRectangle *)&unredirected_rect);
-          cairo_region_subtract_rectangle (unobscured_region, &unredirected_rect);
-          cairo_region_subtract_rectangle (clip_region, &unredirected_rect);
-        }
-    }
-
  meta_cullable_cull_out (META_CULLABLE (window_group), unobscured_region, clip_region);

  cairo_region_destroy (unobscured_region);
--- a/src/compositor/plugins/default.c
+++ b/src/compositor/plugins/default.c
@ -32,7 +32,7 @@
 #include <gmodule.h>
 #include <string.h>

-#define DESTROY_TIMEOUT   250
+#define DESTROY_TIMEOUT   100
 #define MINIMIZE_TIMEOUT  250
 #define MAXIMIZE_TIMEOUT  250
 #define MAP_TIMEOUT       250
@ -289,26 +289,13 @@ on_switch_workspace_effect_complete (ClutterTimeline *timeline, gpointer data)
  meta_plugin_switch_workspace_completed (plugin);
 }

-static gboolean
-show_stage (MetaPlugin *plugin)
-{
-  MetaScreen *screen;
-  ClutterActor *stage;
-
-  screen = meta_plugin_get_screen (plugin);
-  stage = meta_get_stage_for_screen (screen);
-
-  clutter_actor_show (stage);
-
-  return FALSE;
-}
-
 static void
 on_monitors_changed (MetaScreen *screen,
                     MetaPlugin *plugin)
 {
  MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin);
  int i, n;
+  GRand *rand = g_rand_new_with_seed (12345);

  clutter_actor_destroy_all_children (self->priv->background_group);

@ -331,14 +318,16 @@ on_monitors_changed (MetaScreen *screen,
         reproducible.
      */
      clutter_color_init (&color,
-                          g_random_int () % 255,
-                          g_random_int () % 255,
-                          g_random_int () % 255,
+                          g_rand_int_range (rand, 0, 255),
+                          g_rand_int_range (rand, 0, 255),
+                          g_rand_int_range (rand, 0, 255),
                          255);
      clutter_actor_set_background_color (background, &color);

      clutter_actor_add_child (self->priv->background_group, background);
    }
+
+  g_rand_free (rand);
 }

 static void
@ -355,10 +344,7 @@ start (MetaPlugin *plugin)
                    G_CALLBACK (on_monitors_changed), plugin);
  on_monitors_changed (screen, plugin);

-  meta_later_add (META_LATER_BEFORE_REDRAW,
-                  (GSourceFunc) show_stage,
-                  plugin,
-                  NULL);
+  clutter_actor_show (meta_get_stage_for_screen (screen));
 }

 static void
@ -407,9 +393,11 @@ switch_workspace (MetaPlugin *plugin,
      MetaWindowActor *window_actor = l->data;
      ActorPrivate    *apriv	    = get_actor_private (window_actor);
      ClutterActor    *actor	    = CLUTTER_ACTOR (window_actor);
+      MetaWorkspace   *workspace;
      gint             win_workspace;

-      win_workspace = meta_window_actor_get_workspace (window_actor);
+      workspace = meta_window_get_workspace (meta_window_actor_get_meta_window (window_actor));
+      win_workspace = meta_workspace_index (workspace);

      if (win_workspace == to || win_workspace == from)
        {
@ -481,8 +469,6 @@ on_minimize_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data
  /* FIXME - we shouldn't assume the original scale, it should be saved
   * at the start of the effect */
  clutter_actor_set_scale (data->actor, 1.0, 1.0);
-  clutter_actor_move_anchor_point_from_gravity (data->actor,
-                                                CLUTTER_GRAVITY_NORTH_WEST);

  /* Now notify the manager that we are done with this effect */
  meta_plugin_minimize_completed (plugin, window_actor);
@ -519,9 +505,6 @@ minimize (MetaPlugin *plugin, MetaWindowActor *window_actor)

      apriv->is_minimized = TRUE;

-      clutter_actor_move_anchor_point_from_gravity (actor,
-                                                    CLUTTER_GRAVITY_CENTER);
-
      animation = clutter_actor_animate (actor,
                                         CLUTTER_EASE_IN_SINE,
                                         MINIMIZE_TIMEOUT,
@ -560,8 +543,6 @@ on_maximize_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data

  /* FIXME - don't assume the original scale was 1.0 */
  clutter_actor_set_scale (data->actor, 1.0, 1.0);
-  clutter_actor_move_anchor_point_from_gravity (data->actor,
-                                                CLUTTER_GRAVITY_NORTH_WEST);

  /* Now notify the manager that we are done with this effect */
  meta_plugin_maximize_completed (plugin, window_actor);
@ -586,10 +567,8 @@ maximize (MetaPlugin *plugin,
  ClutterActor *actor = CLUTTER_ACTOR (window_actor);
  MetaWindow *meta_window = meta_window_actor_get_meta_window (window_actor);

-  gdouble  scale_x    = 1.0;
-  gdouble  scale_y    = 1.0;
-  gfloat   anchor_x   = 0;
-  gfloat   anchor_y   = 0;
+  gdouble  scale_x = 1.0;
+  gdouble  scale_y = 1.0;

  type = meta_window_get_window_type (meta_window);

@ -613,13 +592,6 @@ maximize (MetaPlugin *plugin,
      scale_x = (gdouble)end_width / (gdouble) width;
      scale_y = (gdouble)end_height / (gdouble) height;

-      anchor_x = (gdouble)(x - end_x)*(gdouble)width /
-        ((gdouble)(end_width - width));
-      anchor_y = (gdouble)(y - end_y)*(gdouble)height /
-        ((gdouble)(end_height - height));
-
-      clutter_actor_move_anchor_point (actor, anchor_x, anchor_y);
-
      animation = clutter_actor_animate (actor,
                                         CLUTTER_EASE_IN_SINE,
                                         MAXIMIZE_TIMEOUT,
@ -674,9 +646,6 @@ on_map_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data)

  apriv->tml_map = NULL;

-  clutter_actor_move_anchor_point_from_gravity (data->actor,
-                                                CLUTTER_GRAVITY_NORTH_WEST);
-
  /* Now notify the manager that we are done with this effect */
  meta_plugin_map_completed (plugin, window_actor);

@ -702,15 +671,15 @@ map (MetaPlugin *plugin, MetaWindowActor *window_actor)
      EffectCompleteData *data = g_new0 (EffectCompleteData, 1);
      ActorPrivate *apriv = get_actor_private (window_actor);

-      clutter_actor_move_anchor_point_from_gravity (actor,
-                                                    CLUTTER_GRAVITY_CENTER);
-
-      clutter_actor_set_scale (actor, 0.0, 0.0);
+      clutter_actor_set_pivot_point (actor, 0.5, 0.5);
+      clutter_actor_set_opacity (actor, 0);
+      clutter_actor_set_scale (actor, 0.5, 0.5);
      clutter_actor_show (actor);

      animation = clutter_actor_animate (actor,
-                                         CLUTTER_EASE_IN_SINE,
+                                         CLUTTER_EASE_OUT_QUAD,
                                         MAP_TIMEOUT,
+                                         "opacity", 255,
                                         "scale-x", 1.0,
                                         "scale-y", 1.0,
                                         NULL);
@ -762,14 +731,12 @@ destroy (MetaPlugin *plugin, MetaWindowActor *window_actor)
      EffectCompleteData *data = g_new0 (EffectCompleteData, 1);
      ActorPrivate *apriv = get_actor_private (window_actor);

-      clutter_actor_move_anchor_point_from_gravity (actor,
-                                                    CLUTTER_GRAVITY_CENTER);
-
      animation = clutter_actor_animate (actor,
-                                         CLUTTER_EASE_IN_SINE,
+                                         CLUTTER_EASE_OUT_QUAD,
                                         DESTROY_TIMEOUT,
-                                         "scale-x", 0.0,
-                                         "scale-y", 1.0,
+                                         "opacity", 0,
+                                         "scale-x", 0.8,
+                                         "scale-y", 0.8,
                                         NULL);
      apriv->tml_destroy = clutter_animation_get_timeline (animation);
      data->plugin = plugin;
--- a/src/core/constraints.c
+++ b/src/core/constraints.c
@ -1353,7 +1353,6 @@ constrain_titlebar_visible (MetaWindow         *window,
      window->type == META_WINDOW_DOCK    ||
      window->fullscreen                  ||
      !window->require_titlebar_visible   ||
-      !window->decorated                  ||
      unconstrained_user_action)
    return TRUE;

--- a/src/core/delete.c
+++ b/src/core/delete.c
@ -37,6 +37,8 @@
 #include <stdlib.h>
 #include <stdio.h>

+#include "meta-wayland-surface.h"
+
 static void meta_window_present_delete_dialog (MetaWindow *window,
                                               guint32     timestamp);

@ -130,35 +132,42 @@ void
 meta_window_check_alive (MetaWindow *window,
                         guint32     timestamp)
 {
-  meta_window_ping (window,
-                    timestamp,
-                    delete_ping_reply_func,
-                    delete_ping_timeout_func,
-                    NULL);
+  meta_display_ping_window (window,
+                            timestamp,
+                            delete_ping_reply_func,
+                            delete_ping_timeout_func,
+                            NULL);
 }

 void
 meta_window_delete (MetaWindow  *window,
                    guint32      timestamp)
 {
-  meta_error_trap_push (window->display);
-  if (window->delete_window)
+  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
    {
-      meta_topic (META_DEBUG_WINDOW_OPS,
-                  "Deleting %s with delete_window request\n",
-                  window->desc);
-      meta_window_send_icccm_message (window,
-                                      window->display->atom_WM_DELETE_WINDOW,
-                                      timestamp);
+      meta_error_trap_push (window->display);
+      if (window->delete_window)
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "Deleting %s with delete_window request\n",
+                      window->desc);
+          meta_window_send_icccm_message (window,
+                                          window->display->atom_WM_DELETE_WINDOW,
+                                          timestamp);
+        }
+      else
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "Deleting %s with explicit kill\n",
+                      window->desc);
+          XKillClient (window->display->xdisplay, window->xwindow);
+        }
+      meta_error_trap_pop (window->display);
    }
  else
    {
-      meta_topic (META_DEBUG_WINDOW_OPS,
-                  "Deleting %s with explicit kill\n",
-                  window->desc);
-      XKillClient (window->display->xdisplay, window->xwindow);
+      meta_wayland_surface_delete (window->surface);
    }
-  meta_error_trap_pop (window->display);

  meta_window_check_alive (window, timestamp);

--- a/src/core/display-private.h
+++ b/src/core/display-private.h
@ -55,6 +55,10 @@ typedef struct _MetaWindowPropHooks MetaWindowPropHooks;

 typedef struct MetaEdgeResistanceData MetaEdgeResistanceData;

+typedef void (* MetaWindowPingFunc) (MetaWindow  *window,
+                                     guint32      timestamp,
+                                     gpointer     user_data);
+
 typedef enum {
  META_LIST_DEFAULT                   = 0,      /* normal windows */
  META_LIST_INCLUDE_OVERRIDE_REDIRECT = 1 << 0, /* normal and O-R */
@ -183,7 +187,7 @@ struct _MetaDisplay
  guint32 window_sequence_counter;

  /* Pings which we're waiting for a reply from */
-  GHashTable *pending_pings;
+  GSList     *pending_pings;

  /* Pending focus change */
  guint       focus_timeout_id;
@ -449,6 +453,14 @@ void meta_display_retheme_all (void);
 void meta_display_set_cursor_theme (const char *theme, 
 				    int         size);

+void meta_display_ping_window      (MetaWindow         *window,
+                                    guint32             timestamp,
+                                    MetaWindowPingFunc  ping_reply_func,
+                                    MetaWindowPingFunc  ping_timeout_func,
+                                    void               *user_data);
+void meta_display_pong_for_serial  (MetaDisplay        *display,
+                                    guint32             serial);
+
 int meta_resize_gravity_from_grab_op (MetaGrabOp op);

 gboolean meta_grab_op_is_moving   (MetaGrabOp op);
--- a/src/core/display.c
+++ b/src/core/display.c
@ -36,6 +36,7 @@
 #include <meta/main.h>
 #include "screen-private.h"
 #include "window-private.h"
+#include "window-x11.h"
 #include "window-props.h"
 #include "group-props.h"
 #include "frame.h"
@ -72,6 +73,7 @@
 #include <unistd.h>

 #include "meta-xwayland-private.h"
+#include "meta-surface-actor-wayland.h"

 #define GRAB_OP_IS_WINDOW_SWITCH(g)                     \
        (g == META_GRAB_OP_KEYBOARD_TABBING_NORMAL  ||  \
@ -81,6 +83,40 @@
         g == META_GRAB_OP_KEYBOARD_ESCAPING_DOCK   ||  \
         g == META_GRAB_OP_KEYBOARD_ESCAPING_GROUP)

+/*
+ * SECTION:pings
+ *
+ * Sometimes we want to see whether a window is responding,
+ * so we send it a "ping" message and see whether it sends us back a "pong"
+ * message within a reasonable time. Here we have a system which lets us
+ * nominate one function to be called if we get the pong in time and another
+ * function if we don't. The system is rather more complicated than it needs
+ * to be, since we only ever use it to destroy windows which are asked to
+ * close themselves and don't do so within a reasonable amount of time, and
+ * therefore we always use the same callbacks. It's possible that we might
+ * use it for other things in future, or on the other hand we might decide
+ * that we're never going to do so and simplify it a bit.
+ */
+
+/**
+ * MetaPingData:
+ *
+ * Describes a ping on a window. When we send a ping to a window, we build
+ * one of these structs, and it eventually gets passed to the timeout function
+ * or to the function which handles the response from the window. If the window
+ * does or doesn't respond to the ping, we use this information to deal with
+ * these facts; we have a handler function for each.
+ */
+typedef struct
+{
+  MetaWindow  *window;
+  guint32      timestamp;
+  MetaWindowPingFunc ping_reply_func;
+  MetaWindowPingFunc ping_timeout_func;
+  void        *user_data;
+  guint        ping_timeout_id;
+} MetaPingData;
+
 G_DEFINE_TYPE(MetaDisplay, meta_display, G_TYPE_OBJECT);

 /* Signals */
@ -282,6 +318,62 @@ meta_display_class_init (MetaDisplayClass *klass)
                                                        G_PARAM_READABLE));
 }

+
+/**
+ * ping_data_free:
+ *
+ * Destructor for #MetaPingData structs. Will destroy the
+ * event source for the struct as well.
+ */
+static void
+ping_data_free (MetaPingData *ping_data)
+{
+  /* Remove the timeout */
+  if (ping_data->ping_timeout_id != 0)
+    g_source_remove (ping_data->ping_timeout_id);
+
+  g_free (ping_data);
+}
+
+/**
+ * remove_pending_pings_for_window:
+ * @display: The display the window appears on
+ * @xwindow: The X ID of the window whose pings we should remove
+ *
+ * Frees every pending ping structure for the given X window on the
+ * given display. This means that we also destroy the timeouts.
+ */
+static void
+remove_pending_pings_for_window (MetaDisplay *display, Window xwindow)
+{
+  GSList *tmp;
+  GSList *dead;
+
+  /* could obviously be more efficient, don't care */
+
+  /* build list to be removed */
+  dead = NULL;
+  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      if (ping_data->window->xwindow == xwindow)
+        dead = g_slist_prepend (dead, ping_data);
+    }
+
+  /* remove what we found */
+  for (tmp = dead; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      display->pending_pings = g_slist_remove (display->pending_pings, ping_data);
+      ping_data_free (ping_data);
+    }
+
+  g_slist_free (dead);
+}
+
+
 #ifdef HAVE_STARTUP_NOTIFICATION
 static void
 sn_error_trap_push (SnDisplay *sn_display,
@ -387,7 +479,6 @@ meta_display_open (void)
  Display *xdisplay;
  GSList *screens;
  MetaScreen *screen;
-  GSList *tmp;
  int i;
  guint32 timestamp;

@ -433,6 +524,7 @@ meta_display_open (void)
  the_display->server_grab_count = 0;
  the_display->display_opening = TRUE;

+  the_display->pending_pings = NULL;
  the_display->autoraise_timeout_id = 0;
  the_display->autoraise_window = NULL;
  the_display->focus_window = NULL;
@ -504,7 +596,6 @@ meta_display_open (void)

  the_display->xids = g_hash_table_new (meta_unsigned_long_hash,
                                        meta_unsigned_long_equal);
-  the_display->pending_pings = g_hash_table_new (g_int_hash, g_int_equal);
  the_display->wayland_windows = g_hash_table_new (NULL, NULL);

  i = 0;
@ -807,12 +898,7 @@ meta_display_open (void)

  screen = meta_screen_new (the_display, i, timestamp);

-  if (screen)
-    screens = g_slist_prepend (screens, screen);
-  
-  the_display->screens = screens;
-  
-  if (screens == NULL)
+  if (!screen)
    {
      /* This would typically happen because all the screens already
       * have window managers.
@ -821,34 +907,19 @@ meta_display_open (void)
      return FALSE;
    }

+  screens = g_slist_prepend (screens, screen);
+
+  the_display->screens = screens;
+
  enable_compositor (the_display);
-   
-  /* Now manage all existing windows */
-  tmp = the_display->screens;
-  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_create_guard_window (screen);

-      tmp = tmp->next;
-    }
+  /* We know that if mutter is running as a Wayland compositor,
+   * we start out with no windows.
+   */
+  if (!meta_is_wayland_compositor ())
+    meta_screen_manage_all_windows (screen);

  {
    Window focus;
@ -1581,7 +1652,7 @@ handle_net_restack_window (MetaDisplay* display,
       *
       * Also, unconditionally following these is REALLY stupid--we should
       * combine this code with the stuff in
-       * meta_window_configure_request() which is smart about whether to
+       * meta_window_x11_configure_request() which is smart about whether to
       * follow the request or do something else (though not smart enough
       * and is also too stupid to handle the sibling stuff).
       */
@ -1612,8 +1683,12 @@ get_window_for_event (MetaDisplay        *display,
    return display->grab_window;

  source = clutter_event_get_source (event);
-  if (META_IS_WINDOW_ACTOR (source))
-    return meta_window_actor_get_meta_window (META_WINDOW_ACTOR (source));
+  if (META_IS_SURFACE_ACTOR_WAYLAND (source))
+    {
+      MetaWaylandSurface *surface = meta_surface_actor_wayland_get_surface (META_SURFACE_ACTOR_WAYLAND (source));
+      g_assert (surface != NULL);
+      return surface->window;
+    }

  return NULL;
 }
@ -1984,18 +2059,17 @@ meta_display_handle_event (MetaDisplay        *display,
                           const ClutterEvent *event)
 {
  MetaWindow *window;
+  gboolean bypass_clutter = FALSE, bypass_wayland = FALSE;
+  MetaWaylandCompositor *compositor = NULL;

  /* XXX -- we need to fill this in properly at some point... */
  gboolean frame_was_receiver = FALSE;
-#ifdef HAVE_WAYLAND
-  MetaWaylandCompositor *compositor = NULL;

  if (meta_is_wayland_compositor ())
    {
      compositor = meta_wayland_compositor_get_default ();
      meta_wayland_compositor_update (compositor, event);
    }
-#endif  /* HAVE_WAYLAND */

  window = get_window_for_event (display, event);

@ -2055,8 +2129,9 @@ meta_display_handle_event (MetaDisplay        *display,
                meta_stack_set_positions (window->screen->stack,
                                          display->grab_old_window_stacking);
            }
-          meta_display_end_grab_op (display,
-                                    event->any.time);
+          meta_display_end_grab_op (display, event->any.time);
+          bypass_clutter = TRUE;
+          bypass_wayland = TRUE;
        }
      else if (window && display->grab_op == META_GRAB_OP_NONE)
        {
@ -2171,20 +2246,8 @@ meta_display_handle_event (MetaDisplay        *display,
                                     event->button.y,
                                     event->button.button,
                                     event->any.time);
-            }
-
-          if (!frame_was_receiver && unmodified)
-            {
-              /* This is from our synchronous grab since
-               * it has no modifiers and was on the client window
-               */
-
-              meta_verbose ("Allowing events time %u\n",
-                            (unsigned int) event->any.time);
-
-              /* XXX -- implement this in Wayland */
-              XIAllowEvents (display->xdisplay, META_VIRTUAL_CORE_POINTER_ID,
-                             XIReplayDevice, event->any.time);
+              bypass_clutter = TRUE;
+              bypass_wayland = TRUE;
            }

          if (begin_move && window->has_move_func)
@ -2200,6 +2263,8 @@ meta_display_handle_event (MetaDisplay        *display,
                                          event->any.time,
                                          event->button.x,
                                          event->button.y);
+              bypass_clutter = TRUE;
+              bypass_wayland = TRUE;
            }
        }
      break;
@ -2211,7 +2276,11 @@ meta_display_handle_event (MetaDisplay        *display,

      if (display->grab_window == window &&
          meta_grab_op_is_mouse (display->grab_op))
-        meta_window_handle_mouse_grab_op_event (window, event);
+        {
+          meta_window_handle_mouse_grab_op_event (window, event);
+          bypass_clutter = TRUE;
+          bypass_wayland = TRUE;
+        }
      break;
    case CLUTTER_MOTION:
      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
@ -2219,7 +2288,11 @@ meta_display_handle_event (MetaDisplay        *display,

      if (display->grab_window == window &&
          meta_grab_op_is_mouse (display->grab_op))
-        meta_window_handle_mouse_grab_op_event (window, event);
+        {
+          meta_window_handle_mouse_grab_op_event (window, event);
+          bypass_clutter = TRUE;
+          bypass_wayland = TRUE;
+        }
      break;

    case CLUTTER_KEY_PRESS:
@ -2231,22 +2304,26 @@ meta_display_handle_event (MetaDisplay        *display,
       * want to pass the key event to the compositor or Wayland at all.
       */
      if (meta_display_process_key_event (display, window, (ClutterKeyEvent *) event))
-        return TRUE;
+        {
+          bypass_clutter = TRUE;
+          bypass_wayland = TRUE;
+        }

    default:
      break;
    }

-#ifdef HAVE_WAYLAND
-  if (compositor && (display->grab_op == META_GRAB_OP_NONE))
+  /* If the compositor has a grab, don't pass that through to Wayland */
+  if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+    bypass_wayland = TRUE;
+
+  if (compositor && !bypass_wayland)
    {
      if (meta_wayland_compositor_handle_event (compositor, event))
-        return TRUE;
+        bypass_clutter = TRUE;
    }
-#endif /* HAVE_WAYLAND */

-  return (display->grab_op != META_GRAB_OP_NONE &&
-          display->grab_op != META_GRAB_OP_COMPOSITOR);
+  return bypass_clutter;
 }

 static gboolean
@ -2686,9 +2763,9 @@ handle_other_xevent (MetaDisplay *display,
          XShapeEvent *sev = (XShapeEvent*) event;

          if (sev->kind == ShapeBounding)
-            meta_window_update_shape_region_x11 (window);
+            meta_window_x11_update_shape_region (window);
          else if (sev->kind == ShapeInput)
-            meta_window_update_input_region_x11 (window);
+            meta_window_x11_update_input_region (window);
        }
      else
        {
@ -2777,7 +2854,7 @@ handle_other_xevent (MetaDisplay *display,

          if (display->grab_op != META_GRAB_OP_NONE &&
              display->grab_window == window &&
-              ((window->frame == NULL) || !window->frame->mapped))
+              window->frame == NULL)
            meta_display_end_grab_op (display, timestamp);

          if (!frame_was_receiver)
@ -2810,15 +2887,15 @@ handle_other_xevent (MetaDisplay *display,
      if (display->compositor && window == NULL
          && meta_display_screen_for_root (display, event->xmap.event))
        {
-          window = meta_window_new (display, event->xmap.window,
-                                    FALSE, META_COMP_EFFECT_CREATE);
+          window = meta_window_x11_new (display, event->xmap.window,
+                                        FALSE, META_COMP_EFFECT_CREATE);
        }
      break;
    case MapRequest:
      if (window == NULL)
        {
-          window = meta_window_new (display, event->xmaprequest.window,
-                                    FALSE, META_COMP_EFFECT_CREATE);
+          window = meta_window_x11_new (display, event->xmaprequest.window,
+                                        FALSE, META_COMP_EFFECT_CREATE);
        }
      /* if frame was receiver it's some malicious send event or something */
      else if (!frame_was_receiver && window)
@ -2897,7 +2974,7 @@ handle_other_xevent (MetaDisplay *display,
      else
        {
          if (!frame_was_receiver)
-            meta_window_configure_request (window, event);
+            meta_window_x11_configure_request (window, event);
        }
      break;
    case GravityNotify:
@ -2914,9 +2991,9 @@ handle_other_xevent (MetaDisplay *display,
        MetaScreen *screen;

        if (window && !frame_was_receiver)
-          meta_window_property_notify (window, event);
+          meta_window_x11_property_notify (window, event);
        else if (property_for_window && !frame_was_receiver)
-          meta_window_property_notify (property_for_window, event);
+          meta_window_x11_property_notify (property_for_window, event);

        group = meta_display_lookup_group (display,
                                           event->xproperty.window);
@ -2987,7 +3064,7 @@ handle_other_xevent (MetaDisplay *display,
      if (window)
        {
          if (!frame_was_receiver)
-            meta_window_client_message (window, event);
+            meta_window_x11_client_message (window, event);
        }
      else
        {
@ -3070,12 +3147,8 @@ handle_other_xevent (MetaDisplay *display,
                  if ((Atom)event->xclient.data.l[0] == display->atom__NET_WM_PING)
                    {
                      guint32 timestamp = event->xclient.data.l[1];
-                      window = g_hash_table_lookup (display->pending_pings, &timestamp);

-                      if (window)
-                        meta_window_pong (window, timestamp);
-                      else
-                        meta_verbose ("Received invalid _NET_WM_PING for unknown timestamp %d\n", timestamp);
+                      meta_display_pong_for_serial (display, timestamp);

                      /* We don't want ping reply events going into
                       * the GTK+ event loop because gtk+ will treat
@ -3984,6 +4057,9 @@ meta_display_unregister_x_window (MetaDisplay *display,
  g_return_if_fail (g_hash_table_lookup (display->xids, &xwindow) != NULL);

  g_hash_table_remove (display->xids, &xwindow);
+
+  /* Remove any pending pings */
+  remove_pending_pings_for_window (display, xwindow);
 }

 void
@ -4832,6 +4908,115 @@ meta_set_syncing (gboolean setting)
    }
 }

+/*
+ * How long, in milliseconds, we should wait after pinging a window
+ * before deciding it's not going to get back to us.
+ */
+#define PING_TIMEOUT_DELAY 5000
+
+/**
+ * meta_display_ping_timeout:
+ * @data: All the information about this ping. It is a #MetaPingData
+ *        cast to a #gpointer in order to be passable to a timeout function.
+ *        This function will also free this parameter.
+ *
+ * Does whatever it is we decided to do when a window didn't respond
+ * to a ping. We also remove the ping from the display's list of
+ * pending pings. This function is called by the event loop when the timeout
+ * times out which we created at the start of the ping.
+ *
+ * Returns: Always returns %FALSE, because this function is called as a
+ *          timeout and we don't want to run the timer again.
+ */
+static gboolean
+meta_display_ping_timeout (gpointer data)
+{
+  MetaPingData *ping_data = data;
+  MetaDisplay *display = ping_data->window->display;
+
+  ping_data->ping_timeout_id = 0;
+
+  meta_topic (META_DEBUG_PING,
+              "Ping %u on window %s timed out\n",
+              ping_data->timestamp, ping_data->window->desc);
+
+  (* ping_data->ping_timeout_func) (ping_data->window, ping_data->timestamp, ping_data->user_data);
+
+  display->pending_pings = g_slist_remove (display->pending_pings, ping_data);
+  ping_data_free (ping_data);
+
+  return FALSE;
+}
+
+/**
+ * meta_display_ping_window:
+ * @display: The #MetaDisplay that the window is on
+ * @window: The #MetaWindow to send the ping to
+ * @timestamp: The timestamp of the ping. Used for uniqueness.
+ *             Cannot be CurrentTime; use a real timestamp!
+ * @ping_reply_func: The callback to call if we get a response.
+ * @ping_timeout_func: The callback to call if we don't get a response.
+ * @user_data: Arbitrary data that will be passed to the callback
+ *             function. (In practice it's often a pointer to
+ *             the window.)
+ *
+ * Sends a ping request to a window. The window must respond to
+ * the request within a certain amount of time. If it does, we
+ * will call one callback; if the time passes and we haven't had
+ * a response, we call a different callback. The window must have
+ * the hint showing that it can respond to a ping; if it doesn't,
+ * we call the "got a response" callback immediately and return.
+ * This function returns straight away after setting things up;
+ * the callbacks will be called from the event loop.
+ */
+void
+meta_display_ping_window (MetaWindow        *window,
+			  guint32            timestamp,
+			  MetaWindowPingFunc ping_reply_func,
+			  MetaWindowPingFunc ping_timeout_func,
+			  gpointer           user_data)
+{
+  MetaDisplay *display = window->display;
+  MetaPingData *ping_data;
+
+  if (timestamp == CurrentTime)
+    {
+      meta_warning ("Tried to ping a window with CurrentTime! Not allowed.\n");
+      return;
+    }
+
+  if (!window->can_ping)
+    {
+      if (ping_reply_func)
+        (* ping_reply_func) (window, timestamp, user_data);
+
+      return;
+    }
+
+  ping_data = g_new (MetaPingData, 1);
+  ping_data->window = window;
+  ping_data->timestamp = timestamp;
+  ping_data->ping_reply_func = ping_reply_func;
+  ping_data->ping_timeout_func = ping_timeout_func;
+  ping_data->user_data = user_data;
+  ping_data->ping_timeout_id = g_timeout_add (PING_TIMEOUT_DELAY,
+					      meta_display_ping_timeout,
+					      ping_data);
+
+  display->pending_pings = g_slist_prepend (display->pending_pings, ping_data);
+
+  meta_topic (META_DEBUG_PING,
+              "Sending ping with timestamp %u to window %s\n",
+              timestamp, window->desc);
+
+  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
+    meta_window_send_icccm_message (window,
+                                    display->atom__NET_WM_PING,
+                                    timestamp);
+  else
+    meta_wayland_surface_ping (window->surface, timestamp);
+}
+
 static void
 process_request_frame_extents (MetaDisplay    *display,
                               XEvent         *event)
@ -4892,6 +5077,56 @@ process_request_frame_extents (MetaDisplay    *display,
  meta_XFree (hints);
 }

+/**
+ * meta_display_pong_for_serial:
+ * @display: the display we got the pong from
+ * @serial: the serial in the pong repsonse
+ *
+ * Process the pong (the response message) from the ping we sent
+ * to the window. This involves removing the timeout, calling the
+ * reply handler function, and freeing memory.
+ */
+void
+meta_display_pong_for_serial (MetaDisplay    *display,
+                              guint32         serial)
+{
+  GSList *tmp;
+
+  meta_topic (META_DEBUG_PING, "Received a pong with serial %u\n", serial);
+
+  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      if (serial == ping_data->timestamp)
+        {
+          meta_topic (META_DEBUG_PING,
+                      "Matching ping found for pong %u\n",
+                      ping_data->timestamp);
+
+          /* Remove the ping data from the list */
+          display->pending_pings = g_slist_remove (display->pending_pings,
+                                                   ping_data);
+
+          /* Remove the timeout */
+          if (ping_data->ping_timeout_id != 0)
+            {
+              g_source_remove (ping_data->ping_timeout_id);
+              ping_data->ping_timeout_id = 0;
+            }
+
+          /* Call callback */
+          (* ping_data->ping_reply_func) (ping_data->window,
+                                          ping_data->timestamp,
+                                          ping_data->user_data);
+
+          ping_data_free (ping_data);
+
+          break;
+        }
+    }
+}
+
 MetaGroup*
 get_focussed_group (MetaDisplay *display)
 {
--- a/src/core/frame.c
+++ b/src/core/frame.c
@ -62,7 +62,6 @@ meta_window_ensure_frame (MetaWindow *window)
  frame->right_width = 0;
  frame->current_cursor = 0;

-  frame->mapped = FALSE;
  frame->is_flashing = FALSE;
  frame->borders_cached = FALSE;
  
@ -157,6 +156,8 @@ meta_window_ensure_frame (MetaWindow *window)

  /* Move keybindings to frame instead of window */
  meta_window_grab_keys (window);
+
+  meta_ui_map_frame (frame->window->screen->ui, frame->xwindow);
 }

 void
--- a/src/core/frame.h
+++ b/src/core/frame.h
@ -47,7 +47,6 @@ struct _MetaFrame
  int right_width;
  int bottom_height;

-  guint mapped : 1;
  guint need_reapply_frame_shape : 1;
  guint is_flashing : 1; /* used by the visual bell flash */
  guint borders_cached : 1;
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@ -28,7 +28,6 @@
 */

 #define _GNU_SOURCE
-#define _SVID_SOURCE /* for putenv() */

 #include <config.h>
 #include "keybindings-private.h"
@ -42,6 +41,7 @@
 #include "screen-private.h"
 #include <meta/prefs.h>
 #include "util-private.h"
+#include "meta-wayland-private.h"

 #include <X11/keysym.h>
 #include <string.h>
@ -52,13 +52,6 @@
 #include <X11/XKBlib.h>
 #endif

-#ifdef HAVE_WAYLAND
-#include "meta-wayland-private.h"
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <linux/vt.h>
-#endif
-
 #define SCHEMA_COMMON_KEYBINDINGS "org.gnome.desktop.wm.keybindings"
 #define SCHEMA_MUTTER_KEYBINDINGS "org.gnome.mutter.keybindings"
 #define SCHEMA_MUTTER_WAYLAND_KEYBINDINGS "org.gnome.mutter.wayland.keybindings"
@ -4083,19 +4076,6 @@ handle_set_spew_mark (MetaDisplay     *display,
  meta_verbose ("-- MARK MARK MARK MARK --\n");
 }

-#ifdef HAVE_WAYLAND
-static gboolean
-activate_vt (int vt)
-{
-  int tty, reply;
-
-  tty = open ("/dev/tty", O_RDWR | O_NOCTTY | O_CLOEXEC);
-  reply = ioctl (tty, VT_ACTIVATE, vt);
-  close (tty);
-
-  return (reply == 0);
-}
-
 static void
 handle_switch_vt (MetaDisplay     *display,
                  MetaScreen      *screen,
@ -4105,11 +4085,15 @@ handle_switch_vt (MetaDisplay     *display,
                  gpointer         dummy)
 {
  gint vt = binding->handler->data;
+  MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
+  GError *error = NULL;

-  if (!activate_vt (vt))
-    g_warning ("Failed to switch VT");
+  if (!meta_wayland_compositor_activate_vt (compositor, vt, &error))
+    {
+      g_warning ("Failed to switch VT: %s", error->message);
+      g_error_free (error);
+    }
 }
-#endif

 /**
 * meta_keybindings_set_custom_handler:
@ -4414,7 +4398,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,
@ -4466,7 +4449,6 @@ init_builtin_key_bindings (MetaDisplay *display)
                              META_KEYBINDING_ACTION_NONE,
                              handle_switch_vt, 7);
    }
-#endif

 #undef REVERSES_AND_REVERSED

--- a/src/core/main.c
+++ b/src/core/main.c
@ -254,19 +254,8 @@ meta_get_option_context (void)
  bindtextdomain (GETTEXT_PACKAGE, MUTTER_LOCALEDIR);
  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

-  /* We must set the windowing backend here, because Clutter creates the backend
-     object when the first call is made.
-
-     We consider running from mutter-launch equivalent to running from bare metal.
-  */
-  if (getenv ("WESTON_LAUNCHER_SOCK"))
-    clutter_set_windowing_backend (CLUTTER_WINDOWING_EGL);
-
  ctx = g_option_context_new (NULL);
  g_option_context_add_main_entries (ctx, meta_options, GETTEXT_PACKAGE);
-  g_option_context_add_group (ctx, clutter_get_option_group_without_init ());
-  g_option_context_add_group (ctx, cogl_get_option_group ());
-
  return ctx;
 }

@ -302,8 +291,12 @@ event_dispatch (GSource    *source,
                gpointer    user_data)
 {
  ClutterEvent *event = clutter_event_get ();
+
  if (event)
-    clutter_do_event (event);
+    {
+      clutter_do_event (event);
+      clutter_event_free (event);
+    }

  return TRUE;
 }
@ -341,16 +334,17 @@ meta_clutter_init (void)
 * also is %NULL, use the default - :0.0
 */
 static void
-meta_select_display (gchar *display_name)
+meta_select_display (char *display_arg)
 {
-  gchar *envVar = "";
+  const char *display_name;
+
+  if (display_arg)
+    display_name = (const char *) display_arg;
+  else
+    display_name = g_getenv ("MUTTER_DISPLAY");
+
  if (display_name)
-    envVar = g_strconcat ("DISPLAY=", display_name, NULL);
-  else if (g_getenv ("MUTTER_DISPLAY"))
-    envVar = g_strconcat ("DISPLAY=",
-      g_getenv ("MUTTER_DISPLAY"), NULL);
-  /* DO NOT FREE envVar, putenv() sucks */
-  putenv (envVar);
+    g_setenv ("DISPLAY", display_name, TRUE);
 }

 static void
@ -385,7 +379,8 @@ meta_init (void)
 {
  struct sigaction act;
  sigset_t empty_mask;
-  
+  ClutterSettings *clutter_settings;
+
  sigemptyset (&empty_mask);
  act.sa_handler = SIG_IGN;
  act.sa_mask    = empty_mask;
@ -406,6 +401,10 @@ meta_init (void)
  if (g_getenv ("MUTTER_DEBUG"))
    meta_set_debugging (TRUE);

+  /* We consider running from mutter-launch equivalent to running from bare metal. */
+  if (getenv ("WESTON_LAUNCHER_SOCK"))
+    clutter_set_windowing_backend (CLUTTER_WINDOWING_EGL);
+
  meta_set_is_wayland_compositor (opt_wayland);

  if (g_get_home_dir ())
@ -437,7 +436,7 @@ meta_init (void)
    meta_fatal ("Can't specify both SM save file and SM client id\n");
  
  meta_main_loop = g_main_loop_new (NULL, FALSE);
-  
+
  meta_ui_init ();

  /* If we are running with wayland then we don't wait until we have
@ -451,6 +450,13 @@ meta_init (void)
       */
      meta_clutter_init ();
    }
+
+  /*
+   * XXX: We cannot handle high dpi scaling yet, so fix the scale to 1
+   * for now.
+   */
+  clutter_settings = clutter_settings_get_default ();
+  g_object_set (clutter_settings, "window-scaling-factor", 1, NULL);
 }

 /**
--- a/src/core/meta-cursor-tracker.c
+++ b/src/core/meta-cursor-tracker.c
@ -570,12 +570,14 @@ make_wayland_cursor_tracker (MetaScreen *screen)
  compositor = meta_wayland_compositor_get_default ();
  compositor->seat->cursor_tracker = self;

-  if (meta_wayland_compositor_is_native (compositor))
+#if defined(CLUTTER_WINDOWING_EGL)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
    {
      CoglRenderer *cogl_renderer = cogl_display_get_renderer (cogl_context_get_display (ctx));
      self->drm_fd = cogl_kms_renderer_get_kms_fd (cogl_renderer);
      self->gbm = gbm_create_device (self->drm_fd);
    }
+#endif

  monitors = meta_monitor_manager_get ();
  g_signal_connect_object (monitors, "monitors-changed",
@ -613,11 +615,9 @@ meta_cursor_tracker_get_for_screen (MetaScreen *screen)
  if (screen->cursor_tracker)
    return screen->cursor_tracker;

-#ifdef HAVE_WAYLAND
  if (meta_is_wayland_compositor ())
    self = make_wayland_cursor_tracker (screen);
  else
-#endif
    self = make_x11_cursor_tracker (screen);

  screen->cursor_tracker = self;
--- a/src/core/meta-idle-monitor.c
+++ b/src/core/meta-idle-monitor.c
@ -535,7 +535,7 @@ make_watch (MetaIdleMonitor           *monitor,
          watch->timeout_source = source;
        }
    }
-  else
+  else if (monitor->user_active_alarm != None)
    {
      if (timeout_msec != 0)
        {
--- a/src/core/monitor-kms.c
+++ b/src/core/monitor-kms.c
@ -111,8 +111,7 @@ make_output_name (drmModeConnector *connector)
  };
  const char *connector_type_name;

-  if (connector->connector_type >= 0 &&
-      connector->connector_type < G_N_ELEMENTS (connector_type_names))
+  if (connector->connector_type < G_N_ELEMENTS (connector_type_names))
    connector_type_name = connector_type_names[connector->connector_type];
  else
    connector_type_name = "unknown";
--- a/src/core/monitor-private.h
+++ b/src/core/monitor-private.h
@ -42,9 +42,7 @@
 #include <meta/screen.h>
 #include "stack-tracker.h"
 #include "ui.h"
-#ifdef HAVE_WAYLAND
 #include <wayland-server.h>
-#endif
 #include "meta-xrandr-shared.h"

 #include "meta-dbus-xrandr.h"
@ -54,19 +52,6 @@ typedef struct _MetaMonitorManager         MetaMonitorManager;
 typedef struct _MetaMonitorConfigClass    MetaMonitorConfigClass;
 typedef struct _MetaMonitorConfig         MetaMonitorConfig;

-#ifndef HAVE_WAYLAND
-enum wl_output_transform {
-  WL_OUTPUT_TRANSFORM_NORMAL,
-  WL_OUTPUT_TRANSFORM_90,
-  WL_OUTPUT_TRANSFORM_180,
-  WL_OUTPUT_TRANSFORM_270,
-  WL_OUTPUT_TRANSFORM_FLIPPED,
-  WL_OUTPUT_TRANSFORM_FLIPPED_90,
-  WL_OUTPUT_TRANSFORM_FLIPPED_180,
-  WL_OUTPUT_TRANSFORM_FLIPPED_270
-};
-#endif
-
 typedef struct _MetaOutput MetaOutput;
 typedef struct _MetaCRTC MetaCRTC;
 typedef struct _MetaMonitorMode MetaMonitorMode;
--- a/src/core/monitor.c
+++ b/src/core/monitor.c
@ -288,7 +288,7 @@ make_logical_config (MetaMonitorManager *manager)

      for (j = 0; j < monitor_infos->len; j++)
        {
-          MetaMonitorInfo *info = &g_array_index (monitor_infos, MetaMonitorInfo, i);
+          MetaMonitorInfo *info = &g_array_index (monitor_infos, MetaMonitorInfo, j);
          if (meta_rectangle_equal (&crtc->rect,
                                    &info->rect))
            {
@ -356,19 +356,35 @@ make_logical_config (MetaMonitorManager *manager)
 static GType
 get_default_backend (void)
 {
-  if (meta_is_wayland_compositor ())
+#if defined(CLUTTER_WINDOWING_EGL)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
+    return META_TYPE_MONITOR_MANAGER_KMS;
+#endif
+
+#if defined(CLUTTER_WINDOWING_X11)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))
    {
-      MetaWaylandCompositor *compositor;
-
-      compositor = meta_wayland_compositor_get_default ();
-
-      if (meta_wayland_compositor_is_native (compositor))
-        return META_TYPE_MONITOR_MANAGER_KMS;
-      else
+      /* If we're a Wayland compositor using the X11 backend,
+       * we're a nested configuration, so return the dummy
+       * monitor setup. */
+      if (meta_is_wayland_compositor ())
        return META_TYPE_MONITOR_MANAGER;
+      else
+        return META_TYPE_MONITOR_MANAGER_XRANDR;
    }
-  else
-    return META_TYPE_MONITOR_MANAGER_XRANDR;
+#endif
+
+#if defined(CLUTTER_WINDOWING_WAYLAND)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_WAYLAND))
+    {
+      /* Use the dummy implementation on Wayland for now.
+       * In the future, we should support wl_fullscreen_output
+       * which will have CRTC management in the protocol. */
+      return META_TYPE_MONITOR_MANAGER;
+    }
+#endif
+
+  g_assert_not_reached ();
 }

 static MetaMonitorManager *
--- a/src/core/screen-private.h
+++ b/src/core/screen-private.h
@ -241,7 +241,7 @@ 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);
+void meta_screen_create_guard_window (MetaScreen *screen);

 gboolean meta_screen_handle_xevent (MetaScreen *screen,
                                    XEvent     *xevent);
--- a/src/core/screen.c
+++ b/src/core/screen.c
@ -389,6 +389,8 @@ int
 meta_screen_monitor_index_to_xinerama_index (MetaScreen *screen,
                                             int         index)
 {
+  g_return_val_if_fail (index >= 0 && index < screen->n_monitor_infos, -1);
+
  meta_screen_ensure_xinerama_indices (screen);

  return screen->monitor_infos[index].xinerama_index;
@ -445,17 +447,16 @@ 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;
-  attributes.background_pixel = BlackPixel (xdisplay, screen->number);

  /* We have to call record_add() after we have the new window ID,
   * so save the serial for the CreateWindow request until then */
@ -468,10 +469,10 @@ meta_screen_create_guard_window (Display *xdisplay, MetaScreen *screen)
 		   screen->rect.width,
 		   screen->rect.height,
 		   0, /* border width */
-		   CopyFromParent, /* depth */
-		   CopyFromParent, /* class */
+		   0, /* depth */
+		   InputOnly, /* class */
 		   CopyFromParent, /* visual */
-		   CWEventMask|CWOverrideRedirect|CWBackPixel,
+		   CWEventMask|CWOverrideRedirect,
 		   &attributes);

  {
@ -878,6 +879,13 @@ meta_screen_free (MetaScreen *screen,
  meta_display_ungrab (display);
 }

+void
+meta_screen_create_guard_window (MetaScreen *screen)
+{
+  if (screen->guard_window == None)
+    screen->guard_window = create_guard_window (screen->display->xdisplay, screen);
+}
+
 void
 meta_screen_manage_all_windows (MetaScreen *screen)
 {
@ -885,10 +893,6 @@ meta_screen_manage_all_windows (MetaScreen *screen)
  MetaStackWindow *children;
  int n_children, i;

-  if (screen->guard_window == None)
-    screen->guard_window =
-      meta_screen_create_guard_window (screen->display->xdisplay, screen);
-
  meta_stack_freeze (screen->stack);
  meta_stack_tracker_get_stack (screen->stack_tracker, &_children, &n_children);

@ -897,8 +901,8 @@ meta_screen_manage_all_windows (MetaScreen *screen)

  for (i = 0; i < n_children; ++i)
    {
-      meta_window_new (screen->display, children[i].x11.xwindow, TRUE,
-                       META_COMP_EFFECT_NONE);
+      meta_window_x11_new (screen->display, children[i].x11.xwindow, TRUE,
+                           META_COMP_EFFECT_NONE);
    }

  g_free (children);
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@ -79,9 +79,7 @@ struct _MetaWindow
  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;
@ -240,7 +238,7 @@ struct _MetaWindow
  /* These are the flags from WM_PROTOCOLS */
  guint take_focus : 1;
  guint delete_window : 1;
-  guint net_wm_ping : 1;
+  guint can_ping : 1;
  /* Globally active / No input */
  guint input : 1;
  
@ -467,8 +465,6 @@ struct _MetaWindow

  /* Bypass compositor hints */
  guint bypass_compositor;
-
-  GSList *pending_pings;
 };

 struct _MetaWindowClass
@ -506,12 +502,22 @@ struct _MetaWindowClass
 #define META_WINDOW_ALLOWS_HORIZONTAL_RESIZE(w) (META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS (w) && (w)->size_hints.min_width < (w)->size_hints.max_width)
 #define META_WINDOW_ALLOWS_VERTICAL_RESIZE(w)   (META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS (w) && (w)->size_hints.min_height < (w)->size_hints.max_height)

-MetaWindow* meta_window_new                (MetaDisplay *display,
-                                            Window       xwindow,
-                                            gboolean     must_be_viewable,
-                                            MetaCompEffect     effect);
-MetaWindow *meta_window_new_for_wayland    (MetaDisplay        *display,
+MetaWindow * _meta_window_shared_new       (MetaDisplay         *display,
+                                            MetaScreen          *screen,
+                                            MetaWindowClientType client_type,
+                                            MetaWaylandSurface  *surface,
+                                            Window               xwindow,
+                                            gulong               existing_wm_state,
+                                            MetaCompEffect       effect,
+                                            XWindowAttributes   *attrs);
+
+MetaWindow * meta_window_x11_new           (MetaDisplay        *display,
+                                            Window              xwindow,
+                                            gboolean            must_be_viewable,
+                                            MetaCompEffect      effect);
+MetaWindow * meta_window_wayland_new       (MetaDisplay        *display,
                                            MetaWaylandSurface *surface);
+
 void        meta_window_unmanage           (MetaWindow  *window,
                                            guint32      timestamp);
 void        meta_window_calc_showing       (MetaWindow  *window);
@ -615,12 +621,6 @@ void     meta_window_move_resize_wayland (MetaWindow *window,
                                          int         height,
                                          int         dx,
                                          int         dy);
-gboolean meta_window_configure_request (MetaWindow *window,
-                                        XEvent     *event);
-gboolean meta_window_property_notify   (MetaWindow *window,
-                                        XEvent     *event);
-gboolean meta_window_client_message    (MetaWindow *window,
-                                        XEvent     *event);
 void     meta_window_set_focused_internal (MetaWindow *window,
                                           gboolean    focused);

@ -697,8 +697,6 @@ void meta_window_set_user_time (MetaWindow *window,

 void meta_window_update_icon_now (MetaWindow *window);

-void meta_window_update_role (MetaWindow *window);
-void meta_window_update_net_wm_type (MetaWindow *window);
 void meta_window_update_for_monitors_changed (MetaWindow *window);
 void meta_window_update_on_all_workspaces (MetaWindow *window);

@ -712,10 +710,6 @@ void meta_window_compute_tile_match (MetaWindow *window);

 gboolean meta_window_updates_are_frozen (MetaWindow *window);

-void meta_window_update_opaque_region_x11 (MetaWindow *window);
-void meta_window_update_input_region_x11  (MetaWindow *window);
-void meta_window_update_shape_region_x11  (MetaWindow *window);
-
 void meta_window_set_title                (MetaWindow *window,
                                           const char *title);
 void meta_window_set_wm_class             (MetaWindow *window,
@ -735,6 +729,9 @@ void meta_window_set_transient_for        (MetaWindow *window,
 void meta_window_set_opacity              (MetaWindow *window,
                                           guint       opacity);

+void meta_window_set_custom_frame_extents (MetaWindow *window,
+                                           GtkBorder  *extents);
+
 void meta_window_handle_enter (MetaWindow  *window,
                               guint32      timestamp,
                               guint        root_x,
@ -743,17 +740,11 @@ void meta_window_handle_enter (MetaWindow  *window,
 void meta_window_set_surface_mapped (MetaWindow *window,
                                     gboolean    surface_mapped);

-typedef void (* MetaWindowPingFunc) (MetaWindow  *window,
-				     guint32      timestamp,
-				     gpointer     user_data);
-
-void meta_window_ping (MetaWindow         *window,
-                       guint32             timestamp,
-                       MetaWindowPingFunc  ping_reply_func,
-                       MetaWindowPingFunc  ping_timeout_func,
-                       void               *user_data);
-void meta_window_pong (MetaWindow *window,
-                       guint32     timestamp);
 Window meta_window_get_toplevel_xwindow (MetaWindow *window);

+void meta_window_activate_full (MetaWindow     *window,
+                                guint32         timestamp,
+                                MetaClientType  source_indication,
+                                MetaWorkspace  *workspace);
+
 #endif
--- a/src/core/window-props.c
+++ b/src/core/window-props.c
@ -39,6 +39,7 @@

 #include <config.h>
 #include "window-props.h"
+#include "window-x11.h"
 #include <meta/errors.h>
 #include "xprops.h"
 #include "frame.h"
@ -229,7 +230,7 @@ reload_net_wm_window_type (MetaWindow    *window,
                           MetaPropValue *value,
                           gboolean       initial)
 {
-  meta_window_update_net_wm_type (window);
+  meta_window_x11_update_net_wm_type (window);
 }

 static void
@ -302,22 +303,18 @@ reload_gtk_frame_extents (MetaWindow    *window,
        }
      else
        {
-          GtkBorder *extents = &window->custom_frame_extents;
-
-          window->has_custom_frame_extents = TRUE;
-          extents->left   = (int)value->v.cardinal_list.cardinals[0];
-          extents->right  = (int)value->v.cardinal_list.cardinals[1];
-          extents->top    = (int)value->v.cardinal_list.cardinals[2];
-          extents->bottom = (int)value->v.cardinal_list.cardinals[3];
+          GtkBorder extents;
+          extents.left   = (int)value->v.cardinal_list.cardinals[0];
+          extents.right  = (int)value->v.cardinal_list.cardinals[1];
+          extents.top    = (int)value->v.cardinal_list.cardinals[2];
+          extents.bottom = (int)value->v.cardinal_list.cardinals[3];
+          meta_window_set_custom_frame_extents (window, &extents);
        }
    }
  else
    {
-      window->has_custom_frame_extents = FALSE;
+      meta_window_set_custom_frame_extents (window, NULL);
    }
-
-  if (!initial)
-    meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
 }

 static void
@ -333,7 +330,7 @@ reload_wm_window_role (MetaWindow    *window,
                       MetaPropValue *value,
                       gboolean       initial)
 {
-  meta_window_update_role (window);
+  meta_window_x11_update_role (window);
 }

 static void
@ -558,7 +555,7 @@ reload_opaque_region (MetaWindow    *window,
                      MetaPropValue *value,
                      gboolean       initial)
 {
-  meta_window_update_opaque_region_x11 (window);
+  meta_window_x11_update_opaque_region (window);
 }

 static void
@ -845,7 +842,7 @@ reload_mwm_hints (MetaWindow    *window,

  meta_window_recalc_features (window);
  
-  /* We do all this anyhow at the end of meta_window_new() */
+  /* We do all this anyhow at the end of meta_window_x11_new() */
  if (!window->constructing)
    {
      if (window->decorated)
@ -1410,7 +1407,7 @@ reload_wm_protocols (MetaWindow    *window,
  
  window->take_focus = FALSE;
  window->delete_window = FALSE;
-  window->net_wm_ping = FALSE;
+  window->can_ping = FALSE;
  
  if (value->type == META_PROP_VALUE_INVALID)    
    return;
@ -1426,7 +1423,7 @@ reload_wm_protocols (MetaWindow    *window,
        window->delete_window = TRUE;
      else if (value->v.atom_list.atoms[i] ==
               window->display->atom__NET_WM_PING)
-        window->net_wm_ping = TRUE;
+        window->can_ping = TRUE;
      ++i;
    }
  
@ -1764,8 +1761,8 @@ meta_display_init_window_prop_hooks (MetaDisplay *display)
    { display->atom__NET_WM_ICON_GEOMETRY, META_PROP_VALUE_CARDINAL_LIST, reload_icon_geometry,     FALSE, FALSE },
    { display->atom_WM_CLIENT_LEADER,  META_PROP_VALUE_INVALID, complain_about_broken_client, FALSE, FALSE },
    { display->atom_SM_CLIENT_ID,      META_PROP_VALUE_INVALID, complain_about_broken_client, FALSE, FALSE },
-    { display->atom_WM_WINDOW_ROLE,    META_PROP_VALUE_INVALID, reload_wm_window_role,        FALSE, FALSE },
-    { display->atom__NET_WM_WINDOW_TYPE, META_PROP_VALUE_INVALID, reload_net_wm_window_type,  FALSE, TRUE },
+    { display->atom_WM_WINDOW_ROLE,    META_PROP_VALUE_INVALID, reload_wm_window_role,         TRUE, FALSE },
+    { display->atom__NET_WM_WINDOW_TYPE, META_PROP_VALUE_INVALID, reload_net_wm_window_type,  TRUE, TRUE },
    { display->atom__NET_WM_STRUT,         META_PROP_VALUE_INVALID, reload_struts,            FALSE, FALSE },
    { display->atom__NET_WM_STRUT_PARTIAL, META_PROP_VALUE_INVALID, reload_struts,            FALSE, FALSE },
    { display->atom__NET_WM_BYPASS_COMPOSITOR, META_PROP_VALUE_CARDINAL,  reload_bypass_compositor, FALSE, FALSE },
--- a/src/core/window-x11.c
+++ b/src/core/window-x11.c
--- a/src/core/window-x11.h
+++ b/src/core/window-x11.h
@ -0,0 +1,45 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef META_WINDOW_X11_H
+#define META_WINDOW_X11_H
+
+#include <meta/window.h>
+#include <X11/Xlib.h>
+
+void meta_window_x11_set_net_wm_state            (MetaWindow *window);
+void meta_window_x11_set_wm_state                (MetaWindow *window);
+
+void meta_window_x11_update_role                 (MetaWindow *window);
+void meta_window_x11_update_net_wm_type          (MetaWindow *window);
+void meta_window_x11_update_opaque_region        (MetaWindow *window);
+void meta_window_x11_update_input_region         (MetaWindow *window);
+void meta_window_x11_update_shape_region         (MetaWindow *window);
+
+gboolean meta_window_x11_configure_request       (MetaWindow *window,
+                                                  XEvent     *event);
+gboolean meta_window_x11_property_notify         (MetaWindow *window,
+                                                  XEvent     *event);
+gboolean meta_window_x11_client_message          (MetaWindow *window,
+                                                  XEvent     *event);
+
+#endif
--- a/src/core/window.c
+++ b/src/core/window.c
--- a/src/meta/compositor.h
+++ b/src/meta/compositor.h
@ -75,11 +75,10 @@ gboolean meta_compositor_filter_keybinding (MetaCompositor *compositor,
                                            MetaScreen     *screen,
                                            MetaKeyBinding *binding);

-void meta_compositor_add_window    (MetaCompositor *compositor,
-                                    MetaWindow     *window);
-void meta_compositor_remove_window (MetaCompositor *compositor,
-                                    MetaWindow     *window);
-
+void meta_compositor_add_window        (MetaCompositor      *compositor,
+                                        MetaWindow          *window);
+void meta_compositor_remove_window     (MetaCompositor      *compositor,
+                                        MetaWindow          *window);
 void meta_compositor_show_window       (MetaCompositor      *compositor,
                                        MetaWindow          *window,
                                        MetaCompEffect       effect);
@ -101,10 +100,6 @@ void meta_compositor_unmaximize_window (MetaCompositor      *compositor,
                                        MetaRectangle       *old_rect,
                                        MetaRectangle       *new_rect);

-void meta_compositor_window_mapped        (MetaCompositor *compositor,
-                                           MetaWindow     *window);
-void meta_compositor_window_unmapped      (MetaCompositor *compositor,
-                                           MetaWindow     *window);
 void meta_compositor_sync_window_geometry (MetaCompositor *compositor,
                                           MetaWindow     *window,
                                           gboolean        did_placement);
--- a/src/meta/meta-shaped-texture.h
+++ b/src/meta/meta-shaped-texture.h
@ -69,16 +69,12 @@ gboolean meta_shaped_texture_update_area (MetaShapedTexture *stex,
                                          int                x,
                                          int                y,
                                          int                width,
-                                          int                height,
-                                          cairo_region_t    *unobscured_region);
+                                          int                height);

 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);
-
 void meta_shaped_texture_set_opaque_region (MetaShapedTexture *stex,
                                            cairo_region_t    *opaque_region);

--- a/src/meta/meta-window-actor.h
+++ b/src/meta/meta-window-actor.h
@ -58,11 +58,8 @@ struct _MetaWindowActor
 GType meta_window_actor_get_type (void);

 Window             meta_window_actor_get_x_window         (MetaWindowActor *self);
-gint               meta_window_actor_get_workspace        (MetaWindowActor *self);
 MetaWindow *       meta_window_actor_get_meta_window      (MetaWindowActor *self);
 ClutterActor *     meta_window_actor_get_texture          (MetaWindowActor *self);
-gboolean           meta_window_actor_is_override_redirect (MetaWindowActor *self);
-gboolean       meta_window_actor_showing_on_its_workspace (MetaWindowActor *self);
 gboolean       meta_window_actor_is_destroyed (MetaWindowActor *self);

 #endif /* META_WINDOW_ACTOR_H */
--- a/src/meta/window.h
+++ b/src/meta/window.h
@ -189,8 +189,6 @@ gboolean          meta_window_requested_bypass_compositor (MetaWindow *window);
 gboolean          meta_window_requested_dont_bypass_compositor (MetaWindow *window);
 gint             *meta_window_get_all_monitors (MetaWindow *window, gsize *length);

-gboolean meta_window_is_mapped (MetaWindow  *window);
-gboolean meta_window_toplevel_is_mapped (MetaWindow  *window);
 gboolean meta_window_get_icon_geometry (MetaWindow    *window,
                                        MetaRectangle *rect);
 void meta_window_set_icon_geometry (MetaWindow    *window,
--- a/src/wayland/meta-wayland-keyboard.c
+++ b/src/wayland/meta-wayland-keyboard.c
@ -60,14 +60,6 @@

 #include "meta-wayland-private.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)
@ -115,7 +107,7 @@ inform_clients_of_new_keymap (MetaWaylandKeyboard *keyboard,
  struct wl_resource *keyboard_resource;

  compositor = meta_wayland_compositor_get_default ();
-  xclient = compositor->xwayland_client;
+  xclient = compositor->xwayland_manager.client;

  wl_resource_for_each (keyboard_resource, &keyboard->resource_list)
    {
@ -201,13 +193,17 @@ meta_wayland_keyboard_take_keymap (MetaWaylandKeyboard *keyboard,
  strcpy (xkb_info->keymap_area, keymap_str);
  free (keymap_str);

-  if (keyboard->is_evdev)
+#if defined(CLUTTER_WINDOWING_EGL)
+  /* XXX -- the evdev backend can be used regardless of the
+   * windowing backend. To do this properly we need a Clutter
+   * API to check the input backend. */
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
    {
      ClutterDeviceManager *manager;
-
      manager = clutter_device_manager_get_default ();
      clutter_evdev_set_keyboard_map (manager, xkb_info->keymap);
    }
+#endif

  inform_clients_of_new_keymap (keyboard, flags);

@ -222,13 +218,27 @@ err_keymap_str:
 }

 static void
-lose_keyboard_focus (struct wl_listener *listener, void *data)
+release_focus (MetaWaylandKeyboard *keyboard)
 {
-  MetaWaylandKeyboard *keyboard =
-    wl_container_of (listener, keyboard, focus_listener);
+  wl_list_remove (&keyboard->focus_surface_listener.link);
+  wl_list_remove (&keyboard->focus_resource_listener.link);

  keyboard->focus_resource = NULL;
-  keyboard->focus = NULL;
+  keyboard->focus_surface = NULL;
+}
+
+static void
+keyboard_handle_focus_surface_destroy (struct wl_listener *listener, void *data)
+{
+  MetaWaylandKeyboard *keyboard = wl_container_of (listener, keyboard, focus_surface_listener);
+  release_focus (keyboard);
+}
+
+static void
+keyboard_handle_focus_resource_destroy (struct wl_listener *listener, void *data)
+{
+  MetaWaylandKeyboard *keyboard = wl_container_of (listener, keyboard, focus_resource_listener);
+  release_focus (keyboard);
 }

 static gboolean
@ -273,29 +283,11 @@ default_grab_modifiers (MetaWaylandKeyboardGrab *grab, uint32_t serial,
                        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)
+  if (keyboard->focus_resource)
    {
-      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);
-        }
+      wl_keyboard_send_modifiers (keyboard->focus_resource, serial, mods_depressed,
+                                  mods_latched, mods_locked, group);
    }
 }

@ -332,15 +324,17 @@ static MetaWaylandKeyboardGrabInterface modal_grab = {

 gboolean
 meta_wayland_keyboard_init (MetaWaylandKeyboard *keyboard,
-                            struct wl_display   *display,
-			    gboolean             is_evdev)
+                            struct wl_display   *display)
 {
  memset (keyboard, 0, sizeof *keyboard);
  keyboard->xkb_info.keymap_fd = -1;

  wl_list_init (&keyboard->resource_list);
  wl_array_init (&keyboard->keys);
-  keyboard->focus_listener.notify = lose_keyboard_focus;
+
+  keyboard->focus_surface_listener.notify = keyboard_handle_focus_surface_destroy;
+  keyboard->focus_resource_listener.notify = keyboard_handle_focus_resource_destroy;
+
  keyboard->default_grab.interface = &default_keyboard_grab_interface;
  keyboard->default_grab.keyboard = keyboard;
  keyboard->grab = &keyboard->default_grab;
@ -348,7 +342,6 @@ meta_wayland_keyboard_init (MetaWaylandKeyboard *keyboard,
  keyboard->display = display;

  keyboard->xkb_context = xkb_context_new (0 /* flags */);
-  keyboard->is_evdev = is_evdev;

  /* Compute a default until gnome-settings-daemon starts and sets
     the appropriate values
@ -509,62 +502,66 @@ void
 meta_wayland_keyboard_set_focus (MetaWaylandKeyboard *keyboard,
                                 MetaWaylandSurface *surface)
 {
-  struct wl_resource *resource;
-  uint32_t serial;
-
-  if (keyboard->focus == surface && keyboard->focus_resource != NULL)
+  if (keyboard->focus_surface == surface && keyboard->focus_resource != NULL)
    return;

-  resource = keyboard->focus_resource;
-  if (keyboard->focus_resource && keyboard->focus->resource)
+  if (keyboard->focus_surface != NULL)
    {
-      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_leave (resource, serial, keyboard->focus->resource);
-      wl_list_remove (&keyboard->focus_listener.link);
+      if (keyboard->focus_resource)
+        {
+          if (keyboard->focus_surface->resource)
+            {
+              struct wl_client *client = wl_resource_get_client (keyboard->focus_resource);
+              struct wl_display *display = wl_client_get_display (client);
+              uint32_t serial = wl_display_next_serial (display);
+              wl_keyboard_send_leave (keyboard->focus_resource, serial, keyboard->focus_surface->resource);
+            }

-      meta_wayland_surface_focused_unset (keyboard->focus);
+          wl_list_remove (&keyboard->focus_resource_listener.link);
+          keyboard->focus_resource = NULL;
+        }
+
+      wl_list_remove (&keyboard->focus_surface_listener.link);
+      keyboard->focus_surface = NULL;
    }

-  resource = find_resource_for_surface (&keyboard->resource_list, surface);
-  if (resource)
+  if (surface != NULL)
    {
-      struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display = wl_client_get_display (client);
+      keyboard->focus_surface = surface;
+      wl_resource_add_destroy_listener (keyboard->focus_surface->resource, &keyboard->focus_surface_listener);

-      serial = wl_display_next_serial (display);
+      keyboard->focus_resource = find_resource_for_surface (&keyboard->resource_list, surface);
+      if (keyboard->focus_resource)
+        {
+          struct wl_client *client = wl_resource_get_client (keyboard->focus_resource);
+          struct wl_display *display = wl_client_get_display (client);
+          uint32_t serial = wl_display_next_serial (display);

-      /* If we're in a modal grab, the client is focused but doesn't see
-	 modifiers or pressed keys (and fix that up when we exit the modal) */
-      if (keyboard->grab->interface == &modal_grab)
-	{
-	  struct wl_array empty;
-	  wl_array_init (&empty);
+          /* If we're in a modal grab, the client is focused but doesn't see
+             modifiers or pressed keys (and fix that up when we exit the modal) */
+          if (keyboard->grab->interface == &modal_grab)
+            {
+              struct wl_array empty;
+              wl_array_init (&empty);

-	  wl_keyboard_send_modifiers (resource, serial,
-				      0, 0, 0, 0);
-	  wl_keyboard_send_enter (resource, serial, surface->resource,
-				  &empty);
-	}
-      else
-	{
-	  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;
+              wl_keyboard_send_modifiers (keyboard->focus_resource, serial, 0, 0, 0, 0);
+              wl_keyboard_send_enter (keyboard->focus_resource, serial, keyboard->focus_surface->resource, &empty);
+            }
+          else
+            {
+              wl_keyboard_send_modifiers (keyboard->focus_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 (keyboard->focus_resource, serial, keyboard->focus_surface->resource,
+                                      &keyboard->keys);
+            }

-      meta_wayland_surface_focused_set (surface);
+          wl_resource_add_destroy_listener (keyboard->focus_resource, &keyboard->focus_resource_listener);
+          keyboard->focus_serial = serial;
+        }
    }
-
-  keyboard->focus_resource = resource;
-  keyboard->focus = surface;
 }

 void
@ -590,8 +587,6 @@ meta_wayland_keyboard_release (MetaWaylandKeyboard *keyboard)
  xkb_context_unref (keyboard->xkb_context);

  /* XXX: What about keyboard->resource_list? */
-  if (keyboard->focus_resource)
-    wl_list_remove (&keyboard->focus_listener.link);
  wl_array_release (&keyboard->keys);
 }

@ -610,7 +605,7 @@ meta_wayland_keyboard_begin_modal (MetaWaylandKeyboard *keyboard,
  if (keyboard->grab != &keyboard->default_grab)
    return FALSE;

-  if (keyboard->focus)
+  if (keyboard->focus_surface)
    {
      /* Fake key release events for the focused app */
      serial = wl_display_next_serial (keyboard->display);
@ -652,7 +647,7 @@ meta_wayland_keyboard_end_modal (MetaWaylandKeyboard *keyboard,
  meta_wayland_keyboard_end_grab (keyboard);
  g_slice_free (MetaWaylandKeyboardGrab, grab);

-  if (keyboard->focus)
+  if (keyboard->focus_surface)
    {
      /* Fake key press events for the focused app */
      serial = wl_display_next_serial (keyboard->display);
--- a/src/wayland/meta-wayland-keyboard.h
+++ b/src/wayland/meta-wayland-keyboard.h
@ -92,9 +92,11 @@ typedef struct
 struct _MetaWaylandKeyboard
 {
  struct wl_list resource_list;
-  MetaWaylandSurface *focus;
+
+  MetaWaylandSurface *focus_surface;
+  struct wl_listener focus_surface_listener;
  struct wl_resource *focus_resource;
-  struct wl_listener focus_listener;
+  struct wl_listener focus_resource_listener;
  uint32_t focus_serial;

  MetaWaylandKeyboardGrab *grab;
@ -110,7 +112,6 @@ struct _MetaWaylandKeyboard
  struct wl_display *display;

  struct xkb_context *xkb_context;
-  gboolean is_evdev;
  MetaWaylandXkbInfo xkb_info;

  MetaWaylandKeyboardGrab input_method_grab;
@ -119,8 +120,7 @@ struct _MetaWaylandKeyboard

 gboolean
 meta_wayland_keyboard_init (MetaWaylandKeyboard *keyboard,
-                            struct wl_display   *display,
-			    gboolean             is_evdev);
+                            struct wl_display   *display);

 typedef enum {
  META_WAYLAND_KEYBOARD_SKIP_XCLIENTS = 1,
--- a/src/wayland/meta-wayland-pointer.c
+++ b/src/wayland/meta-wayland-pointer.c
@ -55,22 +55,28 @@

 static void meta_wayland_pointer_end_popup_grab (MetaWaylandPointer *pointer);

-static MetaWaylandSeat *
-meta_wayland_pointer_get_seat (MetaWaylandPointer *pointer)
+static void
+release_focus (MetaWaylandPointer *pointer)
 {
-  MetaWaylandSeat *seat = wl_container_of (pointer, seat, pointer);
+  wl_list_remove (&pointer->focus_surface_listener.link);
+  wl_list_remove (&pointer->focus_resource_listener.link);

-  return seat;
+  pointer->focus_resource = NULL;
+  pointer->focus_surface = NULL;
 }

 static void
-lose_pointer_focus (struct wl_listener *listener, void *data)
+pointer_handle_focus_surface_destroy (struct wl_listener *listener, void *data)
 {
-  MetaWaylandPointer *pointer =
-    wl_container_of (listener, pointer, focus_listener);
+  MetaWaylandPointer *pointer = wl_container_of (listener, pointer, focus_surface_listener);
+  release_focus (pointer);
+}

-  pointer->focus_resource = NULL;
-  pointer->focus = NULL;
+static void
+pointer_handle_focus_resource_destroy (struct wl_listener *listener, void *data)
+{
+  MetaWaylandPointer *pointer = wl_container_of (listener, pointer, focus_resource_listener);
+  release_focus (pointer);
 }

 static void
@ -98,7 +104,7 @@ default_grab_motion (MetaWaylandPointerGrab *grab,
      wl_fixed_t sx, sy;

      meta_wayland_pointer_get_relative_coordinates (grab->pointer,
-						     grab->pointer->focus,
+						     grab->pointer->focus_surface,
 						     &sx, &sy);
      wl_pointer_send_motion (resource, clutter_event_get_time (event), sx, sy);
    }
@ -258,8 +264,7 @@ pointer_constrain_callback (ClutterInputDevice *device,
 }

 void
-meta_wayland_pointer_init (MetaWaylandPointer *pointer,
-			   gboolean            is_native)
+meta_wayland_pointer_init (MetaWaylandPointer *pointer)
 {
  ClutterDeviceManager *manager;
  ClutterInputDevice *device;
@ -267,7 +272,10 @@ 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->focus_surface_listener.notify = pointer_handle_focus_surface_destroy;
+  pointer->focus_resource_listener.notify = pointer_handle_focus_resource_destroy;
+
  pointer->default_grab.interface = &default_pointer_grab_interface;
  pointer->default_grab.pointer = pointer;
  pointer->grab = &pointer->default_grab;
@ -275,9 +283,16 @@ meta_wayland_pointer_init (MetaWaylandPointer *pointer,
  manager = clutter_device_manager_get_default ();
  device = clutter_device_manager_get_core_device (manager, CLUTTER_POINTER_DEVICE);

-  if (is_native)
-    clutter_evdev_set_pointer_constrain_callback (manager, pointer_constrain_callback,
-						  pointer, NULL);
+#if defined(CLUTTER_WINDOWING_EGL)
+  /* XXX -- the evdev backend can be used regardless of the
+   * windowing backend. To do this properly we need a Clutter
+   * API to check the input backend. */
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
+    {
+      clutter_evdev_set_pointer_constrain_callback (manager, pointer_constrain_callback,
+                                                    pointer, NULL);
+    }
+#endif

  clutter_input_device_get_coords (device, NULL, &current);
  pointer->x = wl_fixed_from_double (current.x);
@ -287,12 +302,7 @@ meta_wayland_pointer_init (MetaWaylandPointer *pointer,
 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;
+  release_focus (pointer);
 }

 static struct wl_resource *
@ -313,60 +323,58 @@ void
 meta_wayland_pointer_set_focus (MetaWaylandPointer *pointer,
                                MetaWaylandSurface *surface)
 {
-  MetaWaylandSeat *seat = meta_wayland_pointer_get_seat (pointer);
-  MetaWaylandKeyboard *kbd = &seat->keyboard;
-  struct wl_resource *resource, *kr;
-  uint32_t serial;
-
-  if (pointer->focus == surface && pointer->focus_resource != NULL)
+  if (pointer->focus_surface == surface && pointer->focus_resource != NULL)
    return;

-  resource = pointer->focus_resource;
-  if (resource && pointer->focus->resource)
+  if (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)
-    {
-      struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display = wl_client_get_display (client);
-      wl_fixed_t sx, sy;
-
-      serial = wl_display_next_serial (display);
-
-      if (kbd)
+      if (pointer->focus_resource)
        {
-          kr = find_resource_for_surface (&kbd->resource_list, surface);
-          if (kr)
+          if (pointer->focus_surface->resource)
            {
-              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);
+              struct wl_client *client = wl_resource_get_client (pointer->focus_resource);
+              struct wl_display *display = wl_client_get_display (client);
+              uint32_t serial = wl_display_next_serial (display);
+              wl_pointer_send_leave (pointer->focus_resource, serial, pointer->focus_surface->resource);
            }
+
+          wl_list_remove (&pointer->focus_resource_listener.link);
+          pointer->focus_resource = NULL;
        }

-      meta_wayland_pointer_get_relative_coordinates (pointer, surface, &sx, &sy);
-      meta_window_handle_enter (surface->window,
-                                /* XXX -- can we reliably get a timestamp for setting focus? */
-                                clutter_get_current_event_time (),
-                                wl_fixed_to_int (pointer->x),
-                                wl_fixed_to_int (pointer->y));
-      wl_pointer_send_enter (resource, serial, surface->resource, sx, sy);
-      wl_resource_add_destroy_listener (resource, &pointer->focus_listener);
-      pointer->focus_serial = serial;
+      wl_list_remove (&pointer->focus_surface_listener.link);
+      pointer->focus_surface = NULL;
    }

-  pointer->focus_resource = resource;
-  pointer->focus = surface;
+  if (surface != NULL)
+    {
+      pointer->focus_surface = surface;
+      wl_resource_add_destroy_listener (pointer->focus_surface->resource, &pointer->focus_surface_listener);
+
+      pointer->focus_resource = find_resource_for_surface (&pointer->resource_list, surface);
+      if (pointer->focus_resource)
+        {
+          struct wl_client *client = wl_resource_get_client (pointer->focus_resource);
+          struct wl_display *display = wl_client_get_display (client);
+          uint32_t serial = wl_display_next_serial (display);
+
+          meta_window_handle_enter (pointer->focus_surface->window,
+                                    /* XXX -- can we reliably get a timestamp for setting focus? */
+                                    clutter_get_current_event_time (),
+                                    wl_fixed_to_int (pointer->x),
+                                    wl_fixed_to_int (pointer->y));
+
+          {
+            wl_fixed_t sx, sy;
+
+            meta_wayland_pointer_get_relative_coordinates (pointer, pointer->focus_surface, &sx, &sy);
+            wl_pointer_send_enter (pointer->focus_resource, serial, pointer->focus_surface->resource, sx, sy);
+          }
+
+          wl_resource_add_destroy_listener (pointer->focus_resource, &pointer->focus_resource_listener);
+          pointer->focus_serial = serial;
+        }
+    }
 }

 void
@ -563,15 +571,13 @@ meta_wayland_pointer_start_popup_grab (MetaWaylandPointer *pointer,

  if (pointer->grab != &pointer->default_grab)
    {
-      if (pointer->grab->interface == &popup_grab_interface)
-	{
-	  grab = (MetaWaylandPopupGrab*)pointer->grab;
+      if (pointer->grab->interface != &popup_grab_interface)
+        return FALSE;

-	  if (wl_resource_get_client (surface->resource) != grab->grab_client)
-	    return FALSE;
-	}
+      grab = (MetaWaylandPopupGrab*)pointer->grab;

-      return FALSE;
+      if (wl_resource_get_client (surface->resource) != grab->grab_client)
+        return FALSE;
    }

  if (pointer->grab == &pointer->default_grab)
--- a/src/wayland/meta-wayland-pointer.h
+++ b/src/wayland/meta-wayland-pointer.h
@ -46,9 +46,11 @@ struct _MetaWaylandPointerGrab
 struct _MetaWaylandPointer
 {
  struct wl_list resource_list;
-  MetaWaylandSurface *focus;
+
+  MetaWaylandSurface *focus_surface;
+  struct wl_listener focus_surface_listener;
  struct wl_resource *focus_resource;
-  struct wl_listener focus_listener;
+  struct wl_listener focus_resource_listener;
  guint32 focus_serial;
  guint32 click_serial;

@ -67,8 +69,7 @@ struct _MetaWaylandPointer
 };

 void
-meta_wayland_pointer_init (MetaWaylandPointer *pointer,
-			   gboolean            is_native);
+meta_wayland_pointer_init (MetaWaylandPointer *pointer);

 void
 meta_wayland_pointer_release (MetaWaylandPointer *pointer);
--- a/src/wayland/meta-wayland-private.h
+++ b/src/wayland/meta-wayland-private.h
@ -59,28 +59,34 @@ typedef struct
  struct wl_resource *resource;
 } MetaWaylandFrameCallback;

+typedef struct
+{
+  int display_index;
+  char *lockfile;
+  int abstract_fd;
+  int unix_fd;
+  pid_t pid;
+  struct wl_client *client;
+  struct wl_resource *xserver_resource;
+  char *display_name;
+
+  GMainLoop *init_loop;
+} MetaXWaylandManager;
+
 struct _MetaWaylandCompositor
 {
  struct wl_display *wayland_display;
  char *display_name;
  struct wl_event_loop *wayland_loop;
-  GMainLoop *init_loop;
  ClutterActor *stage;
  GHashTable *outputs;
  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;
+  MetaXWaylandManager xwayland_manager;

  MetaLauncher *launcher;
-  gboolean native;

  MetaWaylandSeat *seat;
 };
@ -99,15 +105,16 @@ void                    meta_wayland_compositor_set_input_focus (MetaWaylandComp
 gboolean                meta_wayland_compositor_handle_event    (MetaWaylandCompositor *compositor,
                                                                 const ClutterEvent    *event);

-gboolean                meta_wayland_compositor_is_native       (MetaWaylandCompositor *compositor);
-
-MetaWaylandBuffer *     meta_wayland_buffer_from_resource       (struct wl_resource *resource);
-
-void                    meta_wayland_buffer_reference           (MetaWaylandBufferReference *ref,
-								 MetaWaylandBuffer          *buffer);
+MetaWaylandBuffer *     meta_wayland_buffer_from_resource       (struct wl_resource    *resource);
+void                    meta_wayland_buffer_ref                 (MetaWaylandBuffer     *buffer);
+void                    meta_wayland_buffer_unref               (MetaWaylandBuffer     *buffer);

 void                    meta_wayland_compositor_update          (MetaWaylandCompositor *compositor,
                                                                 const ClutterEvent    *event);
 void                    meta_wayland_compositor_paint_finished  (MetaWaylandCompositor *compositor);

+gboolean                meta_wayland_compositor_activate_vt     (MetaWaylandCompositor  *compositor,
+                                                                 int                     vt,
+                                                                 GError                **error);
+
 #endif /* META_WAYLAND_PRIVATE_H */
--- a/src/wayland/meta-wayland-seat.c
+++ b/src/wayland/meta-wayland-seat.c
@ -38,6 +38,7 @@
 #include "meta-shaped-texture-private.h"
 #include "meta-wayland-stage.h"
 #include "meta-cursor-tracker-private.h"
+#include "meta-surface-actor-wayland.h"

 #define DEFAULT_AXIS_STEP_DISTANCE wl_fixed_from_int (10)

@ -48,28 +49,32 @@ unbind_resource (struct wl_resource *resource)
 }

 static void
-pointer_unmap_sprite (MetaWaylandSeat *seat)
+set_cursor_surface (MetaWaylandSeat    *seat,
+                    MetaWaylandSurface *surface)
 {
-  if (seat->cursor_tracker)
-    meta_cursor_tracker_set_window_cursor (seat->cursor_tracker, NULL, 0, 0);
+  if (seat->cursor_surface == surface)
+    return;

-  if (seat->sprite)
-    {
-      wl_list_remove (&seat->sprite_destroy_listener.link);
-      seat->sprite = NULL;
-    }
+  if (seat->cursor_surface)
+    wl_list_remove (&seat->cursor_surface_destroy_listener.link);
+
+  seat->cursor_surface = surface;
+
+  if (seat->cursor_surface)
+    wl_resource_add_destroy_listener (seat->cursor_surface->resource,
+                                      &seat->cursor_surface_destroy_listener);
 }

 void
-meta_wayland_seat_update_sprite (MetaWaylandSeat *seat)
+meta_wayland_seat_update_cursor_surface (MetaWaylandSeat *seat)
 {
  struct wl_resource *buffer;

  if (seat->cursor_tracker == NULL)
    return;

-  if (seat->sprite->buffer_ref.buffer)
-    buffer = seat->sprite->buffer_ref.buffer->resource;
+  if (seat->cursor_surface && seat->cursor_surface->buffer)
+    buffer = seat->cursor_surface->buffer->resource;
  else
    buffer = NULL;

@ -89,42 +94,24 @@ pointer_set_cursor (struct wl_client *client,
  MetaWaylandSeat *seat = wl_resource_get_user_data (resource);
  MetaWaylandSurface *surface;

-  surface = (surface_resource ?
-             wl_resource_get_user_data (surface_resource) :
-             NULL);
+  surface = (surface_resource ? wl_resource_get_user_data (surface_resource) : NULL);

-  if (seat->pointer.focus == NULL)
+  if (seat->pointer.focus_surface == NULL)
    return;
-  if (wl_resource_get_client (seat->pointer.focus->resource) != client)
+  if (wl_resource_get_client (seat->pointer.focus_surface->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);
-    }
+  set_cursor_surface (seat, surface);
+  meta_wayland_seat_update_cursor_surface (seat);
 }

-static const struct wl_pointer_interface
-pointer_interface =
-  {
-    pointer_set_cursor
-  };
+static const struct wl_pointer_interface pointer_interface = {
+  pointer_set_cursor
+};

 static void
 seat_get_pointer (struct wl_client *client,
@ -139,9 +126,9 @@ seat_get_pointer (struct wl_client *client,
  wl_resource_set_implementation (cr, &pointer_interface, seat, unbind_resource);
  wl_list_insert (&seat->pointer.resource_list, wl_resource_get_link (cr));

-  if (seat->pointer.focus &&
-      wl_resource_get_client (seat->pointer.focus->resource) == client)
-    meta_wayland_pointer_set_focus (&seat->pointer, seat->pointer.focus);
+  if (seat->pointer.focus_surface &&
+      wl_resource_get_client (seat->pointer.focus_surface->resource) == client)
+    meta_wayland_pointer_set_focus (&seat->pointer, seat->pointer.focus_surface);
 }

 static void
@ -162,10 +149,10 @@ seat_get_keyboard (struct wl_client *client,
                           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)
+  if (seat->keyboard.focus_surface &&
+      wl_resource_get_client (seat->keyboard.focus_surface->resource) == client)
    {
-      meta_wayland_keyboard_set_focus (&seat->keyboard, seat->keyboard.focus);
+      meta_wayland_keyboard_set_focus (&seat->keyboard, seat->keyboard.focus_surface);
      meta_wayland_data_device_set_keyboard_focus (seat);
    }
 }
@ -209,17 +196,16 @@ bind_seat (struct wl_client *client,
 }

 static void
-pointer_handle_sprite_destroy (struct wl_listener *listener, void *data)
+pointer_handle_cursor_surface_destroy (struct wl_listener *listener, void *data)
 {
-  MetaWaylandSeat *seat =
-    wl_container_of (listener, seat, sprite_destroy_listener);
+  MetaWaylandSeat *seat = wl_container_of (listener, seat, cursor_surface_destroy_listener);

-  pointer_unmap_sprite (seat);
+  set_cursor_surface (seat, NULL);
+  meta_wayland_seat_update_cursor_surface (seat);
 }

 MetaWaylandSeat *
-meta_wayland_seat_new (struct wl_display *display,
-		       gboolean           is_native)
+meta_wayland_seat_new (struct wl_display *display)
 {
  MetaWaylandSeat *seat = g_new0 (MetaWaylandSeat, 1);

@ -227,16 +213,15 @@ meta_wayland_seat_new (struct wl_display *display,
  wl_list_init (&seat->base_resource_list);
  wl_list_init (&seat->data_device_resource_list);

-  meta_wayland_pointer_init (&seat->pointer, is_native);
-
-  meta_wayland_keyboard_init (&seat->keyboard, display, is_native);
+  meta_wayland_pointer_init (&seat->pointer);
+  meta_wayland_keyboard_init (&seat->keyboard, display);

  seat->display = display;

  seat->current_stage = 0;

-  seat->sprite = NULL;
-  seat->sprite_destroy_listener.notify = pointer_handle_sprite_destroy;
+  seat->cursor_surface = NULL;
+  seat->cursor_surface_destroy_listener.notify = pointer_handle_cursor_surface_destroy;
  seat->hotspot_x = 16;
  seat->hotspot_y = 16;

@ -436,16 +421,11 @@ meta_wayland_seat_repick (MetaWaylandSeat    *seat,
  else
    seat->current_stage = NULL;

-  if (META_IS_WINDOW_ACTOR (actor))
-    {
-      MetaWindow *window =
-        meta_window_actor_get_meta_window (META_WINDOW_ACTOR (actor));
-
-      surface = window->surface;
-    }
+  if (META_IS_SURFACE_ACTOR_WAYLAND (actor))
+    surface = meta_surface_actor_wayland_get_surface (META_SURFACE_ACTOR_WAYLAND (actor));

  pointer->current = surface;
-  if (surface != pointer->focus)
+  if (surface != pointer->focus_surface)
    {
      const MetaWaylandPointerGrabInterface *interface =
        pointer->grab->interface;
@ -457,7 +437,7 @@ meta_wayland_seat_repick (MetaWaylandSeat    *seat,
 void
 meta_wayland_seat_free (MetaWaylandSeat *seat)
 {
-  pointer_unmap_sprite (seat);
+  set_cursor_surface (seat, NULL);

  meta_wayland_pointer_release (&seat->pointer);
  meta_wayland_keyboard_release (&seat->keyboard);
--- a/src/wayland/meta-wayland-seat.h
+++ b/src/wayland/meta-wayland-seat.h
@ -66,16 +66,15 @@ struct _MetaWaylandSeat
  struct wl_display *display;

  MetaCursorTracker *cursor_tracker;
-  MetaWaylandSurface *sprite;
+  MetaWaylandSurface *cursor_surface;
  int hotspot_x, hotspot_y;
-  struct wl_listener sprite_destroy_listener;
+  struct wl_listener cursor_surface_destroy_listener;

  ClutterActor *current_stage;
 };

 MetaWaylandSeat *
-meta_wayland_seat_new (struct wl_display *display,
-		       gboolean           is_native);
+meta_wayland_seat_new (struct wl_display *display);

 void
 meta_wayland_seat_update_pointer (MetaWaylandSeat *seat,
@ -90,7 +89,7 @@ meta_wayland_seat_repick (MetaWaylandSeat    *seat,
 			  const ClutterEvent *for_event);

 void
-meta_wayland_seat_update_sprite (MetaWaylandSeat *seat);
+meta_wayland_seat_update_cursor_surface (MetaWaylandSeat *seat);

 void
 meta_wayland_seat_free (MetaWaylandSeat *seat);
--- a/src/wayland/meta-wayland-surface.c
+++ b/src/wayland/meta-wayland-surface.c
--- a/src/wayland/meta-wayland-surface.h
+++ b/src/wayland/meta-wayland-surface.h
@ -38,15 +38,14 @@ struct _MetaWaylandBuffer
  struct wl_listener destroy_listener;

  CoglTexture *texture;
-  int32_t width, height;
-  uint32_t busy_count;
+  uint32_t ref_count;
 };

-struct _MetaWaylandBufferReference
+typedef struct
 {
-  MetaWaylandBuffer *buffer;
-  struct wl_listener destroy_listener;
-};
+  guint changed : 1;
+  guint value : 1;
+} MetaWaylandStateFlag;

 typedef struct
 {
@ -65,6 +64,12 @@ typedef struct

  /* wl_surface.frame */
  struct wl_list frame_callback_list;
+
+  gboolean frame_extents_changed;
+  GtkBorder frame_extents;
+
+  MetaWaylandStateFlag fullscreen;
+  MetaWaylandStateFlag maximized;
 } MetaWaylandDoubleBufferedState;

 typedef struct
@ -77,7 +82,6 @@ struct _MetaWaylandSurface
 {
  struct wl_resource *resource;
  MetaWaylandCompositor *compositor;
-  MetaWaylandBufferReference buffer_ref;
  MetaSurfaceActor *surface_actor;
  MetaWindow *window;
  MetaWaylandSurfaceExtension xdg_surface;
@ -85,6 +89,24 @@ struct _MetaWaylandSurface
  MetaWaylandSurfaceExtension gtk_surface;
  MetaWaylandSurfaceExtension subsurface;

+  MetaWaylandBuffer *buffer;
+  struct wl_listener buffer_destroy_listener;
+
+  GList *subsurfaces;
+
+  struct {
+    MetaWaylandSurface *parent;
+    struct wl_listener parent_destroy_listener;
+
+    gboolean synchronous;
+    MetaWaylandDoubleBufferedState pending_surface_state;
+
+    int32_t pending_x;
+    int32_t pending_y;
+    gboolean pending_pos;
+    GSList *pending_placement_ops;
+  } sub;
+
  /* All the pending state, that wl_surface.commit will apply. */
  MetaWaylandDoubleBufferedState pending;
 };
@ -95,15 +117,18 @@ MetaWaylandSurface *meta_wayland_surface_create (MetaWaylandCompositor *composit
 						 struct wl_client      *client,
 						 guint32                id,
 						 guint32                version);
+
+void                meta_wayland_surface_window_unmanaged (MetaWaylandSurface *surface);
+
 void                meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
 							   int                 width,
-							   int                 height,
-							   int                 edges);
+							   int                 height);

-void                meta_wayland_surface_focused_set (MetaWaylandSurface *surface);
-void                meta_wayland_surface_focused_unset (MetaWaylandSurface *surface);
+void                meta_wayland_surface_activated (MetaWaylandSurface *surface);
+void                meta_wayland_surface_deactivated (MetaWaylandSurface *surface);

 void                meta_wayland_surface_ping (MetaWaylandSurface *surface,
                                               guint32             serial);
+void                meta_wayland_surface_delete (MetaWaylandSurface *surface);

 #endif
--- a/src/wayland/meta-wayland-versions.h
+++ b/src/wayland/meta-wayland-versions.h
@ -41,7 +41,6 @@
 #define META_WL_OUTPUT_VERSION              2
 #define META_XSERVER_VERSION                1
 #define META_GTK_SHELL_VERSION              1
-#define META_XDG_SHELL_VERSION              1
 #define META_WL_SUBCOMPOSITOR_VERSION       1

 /* Slave objects (version inherited from a master object) */
--- a/src/wayland/meta-wayland.c
+++ b/src/wayland/meta-wayland.c
@ -138,6 +138,24 @@ meta_wayland_buffer_destroy_handler (struct wl_listener *listener,
  g_slice_free (MetaWaylandBuffer, buffer);
 }

+void
+meta_wayland_buffer_ref (MetaWaylandBuffer *buffer)
+{
+  buffer->ref_count++;
+}
+
+void
+meta_wayland_buffer_unref (MetaWaylandBuffer *buffer)
+{
+  buffer->ref_count--;
+  if (buffer->ref_count == 0)
+    {
+      g_clear_pointer (&buffer->texture, cogl_object_unref);
+      g_assert (wl_resource_get_client (buffer->resource));
+      wl_resource_queue_event (buffer->resource, WL_BUFFER_RELEASE);
+    }
+}
+
 MetaWaylandBuffer *
 meta_wayland_buffer_from_resource (struct wl_resource *resource)
 {
@ -165,46 +183,6 @@ meta_wayland_buffer_from_resource (struct wl_resource *resource)
  return buffer;
 }

-static void
-meta_wayland_buffer_reference_handle_destroy (struct wl_listener *listener,
-                                              void *data)
-{
-  MetaWaylandBufferReference *ref =
-    wl_container_of (listener, ref, destroy_listener);
-
-  g_assert (data == ref->buffer);
-
-  ref->buffer = NULL;
-}
-
-void
-meta_wayland_buffer_reference (MetaWaylandBufferReference *ref,
-                               MetaWaylandBuffer *buffer)
-{
-  if (ref->buffer && buffer != ref->buffer)
-    {
-      ref->buffer->busy_count--;
-
-      if (ref->buffer->busy_count == 0)
-        {
-	  g_clear_pointer (&ref->buffer->texture, cogl_object_unref);
-          g_assert (wl_resource_get_client (ref->buffer->resource));
-          wl_resource_queue_event (ref->buffer->resource, WL_BUFFER_RELEASE);
-        }
-
-      wl_list_remove (&ref->destroy_listener.link);
-    }
-
-  if (buffer && buffer != ref->buffer)
-    {
-      buffer->busy_count++;
-      wl_signal_add (&buffer->destroy_signal, &ref->destroy_listener);
-    }
-
-  ref->buffer = buffer;
-  ref->destroy_listener.notify = meta_wayland_buffer_reference_handle_destroy;
-}
-
 void
 meta_wayland_compositor_set_input_focus (MetaWaylandCompositor *compositor,
                                         MetaWindow            *window)
@ -505,8 +483,7 @@ meta_wayland_compositor_paint_finished (MetaWaylandCompositor *compositor)
      MetaWaylandFrameCallback *callback =
        wl_container_of (compositor->frame_callbacks.next, callback, link);

-      wl_resource_post_event (callback->resource,
-                              WL_CALLBACK_DONE, get_time ());
+      wl_callback_send_done (callback->resource, get_time ());
      wl_resource_destroy (callback->resource);
    }
 }
@ -623,31 +600,11 @@ meta_wayland_log_func (const char *fmt,
  g_free (str);
 }

-static gboolean
-are_we_native (int *out_drm_fd)
-{
-  ClutterBackend *backend = clutter_get_default_backend ();
-  CoglContext *cogl_context = clutter_backend_get_cogl_context (backend);
-  CoglRenderer *cogl_renderer = cogl_display_get_renderer (cogl_context_get_display (cogl_context));
-
-  if (cogl_renderer_get_winsys_id (cogl_renderer) == COGL_WINSYS_ID_EGL_KMS)
-    {
-      *out_drm_fd = cogl_kms_renderer_get_kms_fd (cogl_renderer);
-      return TRUE;
-    }
-  else
-    {
-      return FALSE;
-    }
-}
-
 void
 meta_wayland_init (void)
 {
  MetaWaylandCompositor *compositor = &_meta_wayland_compositor;
  MetaMonitorManager *monitors;
-  char *display_name;
-  int drm_fd;

  memset (compositor, 0, sizeof (MetaWaylandCompositor));

@ -686,27 +643,24 @@ meta_wayland_init (void)

  clutter_wayland_set_compositor_display (compositor->wayland_display);

-  if (getenv ("WESTON_LAUNCHER_SOCK"))
-      compositor->launcher = meta_launcher_new ();
+#if defined(CLUTTER_WINDOWING_EGL)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
+    compositor->launcher = meta_launcher_new ();
+#endif

  if (clutter_init (NULL, NULL) != CLUTTER_INIT_SUCCESS)
    g_error ("Failed to initialize Clutter");

-  if (are_we_native (&drm_fd))
+#if defined(CLUTTER_WINDOWING_EGL)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
    {
-      GError *error = NULL;
-      if (!meta_launcher_set_drm_fd (compositor->launcher, drm_fd, &error))
-	{
-	  g_error ("Failed to set DRM fd to weston-launch and become DRM master: %s", error->message);
-	  g_error_free (error);
-	}
-
-      compositor->native = TRUE;
-    }
-  else
-    {
-      compositor->native = FALSE;
+      ClutterBackend *backend = clutter_get_default_backend ();
+      CoglContext *cogl_context = clutter_backend_get_cogl_context (backend);
+      CoglRenderer *cogl_renderer = cogl_display_get_renderer (cogl_context_get_display (cogl_context));
+      int drm_fd = cogl_kms_renderer_get_kms_fd (cogl_renderer);
+      meta_launcher_set_drm_fd (compositor->launcher, drm_fd, NULL);
    }
+#endif

  meta_monitor_manager_initialize ();
  monitors = meta_monitor_manager_get ();
@ -722,7 +676,7 @@ meta_wayland_init (void)

  meta_wayland_data_device_manager_init (compositor->wayland_display);

-  compositor->seat = meta_wayland_seat_new (compositor->wayland_display, compositor->native);
+  compositor->seat = meta_wayland_seat_new (compositor->wayland_display);

  meta_wayland_init_shell (compositor);

@ -743,13 +697,10 @@ meta_wayland_init (void)
   * and so EGL must be initialized by this point.
   */

-  if (!meta_xwayland_start (compositor))
+  if (!meta_xwayland_start (&compositor->xwayland_manager, compositor->wayland_display))
    g_error ("Failed to start X Wayland");

-  display_name = g_strdup_printf (":%d", compositor->xwayland_display_index);
-  set_gnome_env ("DISPLAY", display_name);
-  g_free (display_name);
-
+  set_gnome_env ("DISPLAY", compositor->xwayland_manager.display_name);
  set_gnome_env ("WAYLAND_DISPLAY", compositor->display_name);
 }

@ -760,12 +711,24 @@ meta_wayland_finalize (void)

  compositor = meta_wayland_compositor_get_default ();

-  meta_xwayland_stop (compositor);
-  meta_launcher_free (compositor->launcher);
+  meta_xwayland_stop (&compositor->xwayland_manager);
+
+  if (compositor->launcher)
+    meta_launcher_free (compositor->launcher);
 }

 gboolean
-meta_wayland_compositor_is_native (MetaWaylandCompositor *compositor)
+meta_wayland_compositor_activate_vt (MetaWaylandCompositor  *compositor,
+                                     int                     vt,
+                                     GError                **error)
 {
-  return compositor->native;
+  if (compositor->launcher)
+    {
+      return meta_launcher_activate_vt (compositor->launcher, vt, error);
+    }
+  else
+    {
+      g_debug ("Ignoring VT switch keybinding, not running as VT manager");
+      return TRUE;
+    }
 }
--- a/src/wayland/meta-weston-launch.c
+++ b/src/wayland/meta-weston-launch.c
@ -385,3 +385,17 @@ meta_launcher_free (MetaLauncher *launcher)

  g_slice_free (MetaLauncher, launcher);
 }
+
+gboolean
+meta_launcher_activate_vt (MetaLauncher  *launcher,
+			   int            vt,
+			   GError       **error)
+{
+  struct weston_launcher_activate_vt message;
+
+  message.header.opcode = WESTON_LAUNCHER_ACTIVATE_VT;
+  message.vt = vt;
+
+  return send_message_to_wl (launcher, &message, sizeof (message), NULL, NULL, error);
+}
+
--- a/src/wayland/meta-weston-launch.h
+++ b/src/wayland/meta-weston-launch.h
@ -28,6 +28,10 @@ typedef struct _MetaLauncher MetaLauncher;
 MetaLauncher     *meta_launcher_new                     (void);
 void              meta_launcher_free                    (MetaLauncher  *self);

+gboolean          meta_launcher_activate_vt             (MetaLauncher  *self,
+							 int            number,
+							 GError       **error);
+
 gboolean          meta_launcher_set_drm_fd              (MetaLauncher  *self,
 							 int            drm_fd,
 							 GError       **error);
--- a/src/wayland/meta-xwayland-private.h
+++ b/src/wayland/meta-xwayland-private.h
@ -25,12 +25,13 @@
 #include <glib.h>

 gboolean
-meta_xwayland_start (MetaWaylandCompositor *compositor);
+meta_xwayland_start (MetaXWaylandManager *manager,
+                     struct wl_display   *display);

 void
 meta_xwayland_complete_init (void);

 void
-meta_xwayland_stop (MetaWaylandCompositor *compositor);
+meta_xwayland_stop (MetaXWaylandManager *manager);

 #endif /* META_XWAYLAND_PRIVATE_H */
--- a/src/wayland/meta-xwayland.c
+++ b/src/wayland/meta-xwayland.c
@ -44,15 +44,17 @@ xserver_set_window_id (struct wl_client *client,
  MetaWindow *window;

  window = meta_display_lookup_x_window (display, xid);
-  if (window)
-    {
-      surface->window = window;
-      window->surface = surface;
-    }
+  if (!window)
+    return;
+
+  surface->window = window;
+  window->surface = surface;
+
+  meta_window_set_surface_mapped (window, TRUE);
 }

 static const struct xserver_interface xserver_implementation = {
-    xserver_set_window_id
+  xserver_set_window_id
 };

 static void
@ -61,25 +63,20 @@ bind_xserver (struct wl_client *client,
              guint32 version,
              guint32 id)
 {
-  MetaWaylandCompositor *compositor = data;
+  MetaXWaylandManager *manager = data;

  /* If it's a different client than the xserver we launched,
-   * don't start the wm. */
-  if (client != compositor->xwayland_client)
+   * just freeze up... */
+  if (client != manager->client)
    return;

-  compositor->xserver_resource = wl_resource_create (client, &xserver_interface,
-						     MIN (META_XSERVER_VERSION, version), id);
-  wl_resource_set_implementation (compositor->xserver_resource,
-				  &xserver_implementation, compositor, NULL);
+  manager->xserver_resource = wl_resource_create (client, &xserver_interface,
+                                                  MIN (META_XSERVER_VERSION, version), id);
+  wl_resource_set_implementation (manager->xserver_resource,
+				  &xserver_implementation, manager, 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);
+  xserver_send_listen_socket (manager->xserver_resource, manager->abstract_fd);
+  xserver_send_listen_socket (manager->xserver_resource, manager->unix_fd);

  /* Make sure xwayland will recieve the above sockets in a finite
   * time before unblocking the initialization mainloop since we are
@ -91,8 +88,8 @@ bind_xserver (struct wl_client *client,
   * 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);
-  g_clear_pointer (&compositor->init_loop, g_main_loop_unref);
+  g_main_loop_quit (manager->init_loop);
+  g_clear_pointer (&manager->init_loop, g_main_loop_unref);
 }

 static char *
@ -123,7 +120,7 @@ create_lockfile (int display, int *display_out)
              /* ignore error and try the next display number */
              display++;
              continue;
-          }
+            }
          close (fd);

          other = strtol (pid, &end, 0);
@ -135,7 +132,7 @@ create_lockfile (int display, int *display_out)
              /* ignore error and try the next display number */
              display++;
              continue;
-          }
+            }

          if (kill (other, 0) < 0 && errno == ESRCH)
            {
@ -148,7 +145,7 @@ create_lockfile (int display, int *display_out)
                }
              g_free (filename);
              continue;
-          }
+            }

          g_free (filename);
          display++;
@ -240,11 +237,12 @@ bind_to_unix_socket (int display)
      return -1;
    }

-  if (listen (fd, 1) < 0) {
+  if (listen (fd, 1) < 0)
+    {
      unlink (addr.sun_path);
      close (fd);
      return -1;
-  }
+    }

  return fd;
 }
@ -287,7 +285,8 @@ x_io_error (Display *display)
 }

 gboolean
-meta_xwayland_start (MetaWaylandCompositor *compositor)
+meta_xwayland_start (MetaXWaylandManager *manager,
+                     struct wl_display   *wl_display)
 {
  int display = 0;
  char *lockfile = NULL;
@ -295,27 +294,25 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
  pid_t pid;
  char **env;
  char *fd_string;
-  char *display_name;
  char *log_path;
-  char *args[11];
+  char *args[10];
  GError *error;

-  wl_global_create (compositor->wayland_display,
-		    &xserver_interface,
+  wl_global_create (wl_display, &xserver_interface,
 		    META_XSERVER_VERSION,
-		    compositor, bind_xserver);
+		    manager, bind_xserver);

  do
    {
      lockfile = create_lockfile (display, &display);
      if (!lockfile)
        {
-         g_warning ("Failed to create an X lock file");
-         return FALSE;
+          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)
+      manager->abstract_fd = bind_to_abstract_socket (display);
+      if (manager->abstract_fd < 0)
        {
          unlink (lockfile);

@ -328,11 +325,11 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
            return FALSE;
        }

-      compositor->xwayland_unix_fd = bind_to_unix_socket (display);
-      if (compositor->xwayland_abstract_fd < 0)
+      manager->unix_fd = bind_to_unix_socket (display);
+      if (manager->abstract_fd < 0)
        {
          unlink (lockfile);
-          close (compositor->xwayland_abstract_fd);
+          close (manager->abstract_fd);
          return FALSE;
        }

@ -340,8 +337,8 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
    }
  while (1);

-  compositor->xwayland_display_index = display;
-  compositor->xwayland_lockfile = lockfile;
+  manager->display_index = display;
+  manager->lockfile = lockfile;

  /* We want xwayland to be a wayland client so we make a socketpair to setup a
   * wayland protocol connection. */
@ -357,21 +354,19 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
  env = g_environ_setenv (env, "WAYLAND_SOCKET", fd_string, TRUE);
  g_free (fd_string);

-  display_name = g_strdup_printf (":%d",
-                                  compositor->xwayland_display_index);
+  manager->display_name = g_strdup_printf (":%d", manager->display_index);
  log_path = g_build_filename (g_get_user_cache_dir (), "xwayland.log", NULL);

  args[0] = XWAYLAND_PATH;
-  args[1] = display_name;
+  args[1] = manager->display_name;
  args[2] = "-wayland";
  args[3] = "-rootless";
-  args[4] = "-retro";
-  args[5] = "-noreset";
-  args[6] = "-logfile";
-  args[7] = log_path;
-  args[8] = "-nolisten";
-  args[9] = "all";
-  args[10] = NULL;
+  args[4] = "-noreset";
+  args[5] = "-logfile";
+  args[6] = log_path;
+  args[7] = "-nolisten";
+  args[8] = "all";
+  args[9] = NULL;

  error = NULL;
  if (g_spawn_async (NULL, /* cwd */
@ -389,10 +384,9 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
      g_message ("forked X server, pid %d\n", pid);

      close (sp[1]);
-      compositor->xwayland_client =
-        wl_client_create (compositor->wayland_display, sp[0]);
+      manager->client = wl_client_create (wl_display, sp[0]);

-      compositor->xwayland_pid = pid;
+      manager->pid = pid;
      g_child_watch_add (pid, xserver_died, NULL);
    }
  else
@ -401,15 +395,13 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
    }

  g_strfreev (env);
-  g_free (display_name);
  g_free (log_path);

  /* 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);
+  manager->init_loop = g_main_loop_new (NULL, FALSE);
+  g_main_loop_run (manager->init_loop);

  return TRUE;
 }
@ -427,16 +419,14 @@ meta_xwayland_complete_init (void)
 }

 void
-meta_xwayland_stop (MetaWaylandCompositor *compositor)
+meta_xwayland_stop (MetaXWaylandManager *manager)
 {
  char path[256];

-  snprintf (path, sizeof path, "/tmp/.X%d-lock",
-            compositor->xwayland_display_index);
+  snprintf (path, sizeof path, "/tmp/.X%d-lock", manager->display_index);
  unlink (path);
-  snprintf (path, sizeof path, "/tmp/.X11-unix/X%d",
-            compositor->xwayland_display_index);
+  snprintf (path, sizeof path, "/tmp/.X11-unix/X%d", manager->display_index);
  unlink (path);

-  unlink (compositor->xwayland_lockfile);
+  unlink (manager->lockfile);
 }
--- a/src/wayland/weston-launch.c
+++ b/src/wayland/weston-launch.c
@ -269,6 +269,40 @@ out:
 	return 0;
 }

+static int
+handle_activate_vt(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
+{
+        struct weston_launcher_reply reply;
+	struct weston_launcher_activate_vt *message;
+
+	reply.header.opcode = WESTON_LAUNCHER_ACTIVATE_VT;
+	reply.ret = -1;
+
+	if (len != sizeof(*message)) {
+		error(0, 0, "missing value in activate_vt request");
+		goto out;
+	}
+
+	message = msg->msg_iov->iov_base;
+
+	reply.ret = ioctl(wl->tty, VT_ACTIVATE, message->vt);
+	if (reply.ret < 0)
+		reply.ret = -errno;
+
+	if (wl->verbose)
+		fprintf(stderr, "mutter-launch: activate VT, ret: %d\n", reply.ret);
+
+out:
+	do {
+		len = send(wl->sock[0], &reply, sizeof reply, 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)
 {
@ -385,6 +419,9 @@ handle_socket_msg(struct weston_launch *wl)
 	case WESTON_LAUNCHER_CONFIRM_VT_SWITCH:
 		ret = handle_confirm_vt_switch(wl, &msg, len);
 		break;
+	case WESTON_LAUNCHER_ACTIVATE_VT:
+		ret = handle_activate_vt(wl, &msg, len);
+		break;
 	}

 	return ret;
--- a/src/wayland/weston-launch.h
+++ b/src/wayland/weston-launch.h
@ -32,7 +32,8 @@ enum weston_launcher_message_type {
 enum weston_launcher_opcode {
 	WESTON_LAUNCHER_OPEN              = (1 << 1 | WESTON_LAUNCHER_REQUEST),
 	WESTON_LAUNCHER_DRM_SET_FD        = (2 << 1 | WESTON_LAUNCHER_REQUEST),
-	WESTON_LAUNCHER_CONFIRM_VT_SWITCH = (3 << 1 | WESTON_LAUNCHER_REQUEST),
+	WESTON_LAUNCHER_ACTIVATE_VT       = (3 << 1 | WESTON_LAUNCHER_REQUEST),
+	WESTON_LAUNCHER_CONFIRM_VT_SWITCH = (4 << 1 | WESTON_LAUNCHER_REQUEST),
 };

 enum weston_launcher_server_opcode {