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
27 changed files with 1266 additions and 815 deletions
--- a/11
+++ b/11
@@ -1,14 +1,3 @@
-3.11.90
-=======
-* Fix double-scaling on high DPI resolutions [Adel; #723931]
-* Make tile previews a compositor effect [Stefano, Florian; #665758]
-* Misc. bug fixes and cleanups [Ryan, Giovanni, Jasper, Adel; #722530, #724257,
-  #724258, #720631, #724364, #724472]
-
-Contributors:
-  Giovanni Campagna, Marek Chalupa, Stefano Facchini, Adel Gadllah,
-  Ryan Lortie, Florian Müllner, Jasper St. Pierre, Rico Tzschichholz
-
 3.11.5
 ======
 * Fix CSD titlebars being placed off-screen [Jasper; #719772]
--- 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], [90])
+m4_define([mutter_micro_version], [5])

 m4_define([mutter_version],
          [mutter_major_version.mutter_minor_version.mutter_micro_version])
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -80,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		\
@@ -182,6 +186,8 @@ libmutter_wayland_la_SOURCES =			\
 	ui/resizepopup.h			\
 	ui/tabpopup.c				\
 	ui/tabpopup.h				\
+	ui/tile-preview.c			\
+	ui/tile-preview.h			\
 	ui/theme-parser.c			\
 	ui/theme.c				\
 	meta/theme.h				\
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -1695,31 +1695,3 @@ meta_compositor_monotonic_time_to_server_time (MetaDisplay *display,
  else
    return monotonic_time + compositor->server_time_offset;
 }
-
-void
-meta_compositor_show_tile_preview (MetaCompositor *compositor,
-                                   MetaScreen     *screen,
-                                   MetaWindow     *window,
-                                   MetaRectangle  *tile_rect,
-                                   int             tile_monitor_number)
-{
-  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-
-  if (!info->plugin_mgr)
-    return;
-
-  meta_plugin_manager_show_tile_preview (info->plugin_mgr,
-                                         window, tile_rect, tile_monitor_number);
-}
-
-void
-meta_compositor_hide_tile_preview (MetaCompositor *compositor,
-                                   MetaScreen     *screen)
-{
-  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-
-  if (!info->plugin_mgr)
-    return;
-
-  meta_plugin_manager_hide_tile_preview (info->plugin_mgr);
-}
--- a/src/compositor/meta-plugin-manager.c
+++ b/src/compositor/meta-plugin-manager.c
@@ -324,44 +324,3 @@ meta_plugin_manager_confirm_display_change (MetaPluginManager *plugin_mgr)
  else
    return meta_plugin_complete_display_change (plugin, TRUE);
 }
-
-gboolean
-meta_plugin_manager_show_tile_preview (MetaPluginManager *plugin_mgr,
-                                       MetaWindow        *window,
-                                       MetaRectangle     *tile_rect,
-                                       int                tile_monitor_number)
-{
-  MetaPlugin *plugin = plugin_mgr->plugin;
-  MetaPluginClass *klass = META_PLUGIN_GET_CLASS (plugin);
-  MetaDisplay *display  = meta_screen_get_display (plugin_mgr->screen);
-
-  if (display->display_opening)
-    return FALSE;
-
-  if (klass->show_tile_preview)
-    {
-      klass->show_tile_preview (plugin, window, tile_rect, tile_monitor_number);
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
-gboolean
-meta_plugin_manager_hide_tile_preview (MetaPluginManager *plugin_mgr)
-{
-  MetaPlugin *plugin = plugin_mgr->plugin;
-  MetaPluginClass *klass = META_PLUGIN_GET_CLASS (plugin);
-  MetaDisplay *display  = meta_screen_get_display (plugin_mgr->screen);
-
-  if (display->display_opening)
-    return FALSE;
-
-  if (klass->hide_tile_preview)
-    {
-      klass->hide_tile_preview (plugin);
-      return TRUE;
-    }
-
-  return FALSE;
-}
--- a/src/compositor/meta-plugin-manager.h
+++ b/src/compositor/meta-plugin-manager.h
@@ -75,9 +75,4 @@ gboolean _meta_plugin_xevent_filter (MetaPlugin *plugin,

 void     meta_plugin_manager_confirm_display_change (MetaPluginManager *mgr);

-gboolean meta_plugin_manager_show_tile_preview (MetaPluginManager *mgr,
-                                                MetaWindow        *window,
-                                                MetaRectangle     *tile_rect,
-                                                int                tile_monitor_number);
-gboolean meta_plugin_manager_hide_tile_preview (MetaPluginManager *mgr);
 #endif
--- 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,30 @@
 */

 #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
 {
-  MetaWaylandSurface *surface;
-
  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,
@@ -164,50 +164,11 @@ 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)
-{
-  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);
-    }
-}
-
 gboolean
-meta_surface_actor_damage_all (MetaSurfaceActor *self)
+meta_surface_actor_update_area (MetaSurfaceActor *self,
+                                int x, int y, int width, int height)
 {
  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));
-}
-
-gboolean
-meta_surface_actor_damage_area (MetaSurfaceActor *self,
-                                int               x,
-                                int               y,
-                                int               width,
-                                int               height)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-
-  update_area (self, x, y, width, height);
  return meta_shaped_texture_update_area (priv->texture, x, y, width, height);
 }

@@ -218,27 +179,6 @@ meta_surface_actor_is_obscured (MetaSurfaceActor *self)
  return meta_shaped_texture_is_obscured (priv->texture);
 }

-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);
-}
-
 void
 meta_surface_actor_set_input_region (MetaSurfaceActor *self,
                                     cairo_region_t   *region)
@@ -262,20 +202,114 @@ meta_surface_actor_set_opaque_region (MetaSurfaceActor *self,
  meta_shaped_texture_set_opaque_region (priv->texture, region);
 }

-MetaWaylandSurface *
-meta_surface_actor_get_surface (MetaSurfaceActor *self)
+static gboolean
+is_frozen (MetaSurfaceActor *self)
 {
  MetaSurfaceActorPrivate *priv = self->priv;
-  return priv->surface;
+  return (priv->freeze_count > 0);
 }

-MetaSurfaceActor *
-meta_surface_actor_new (MetaWaylandSurface *surface)
+void
+meta_surface_actor_process_damage (MetaSurfaceActor *self,
+                                   int x, int y, int width, int height)
 {
-  MetaSurfaceActor *self = g_object_new (META_TYPE_SURFACE_ACTOR, NULL);
  MetaSurfaceActorPrivate *priv = self->priv;

-  priv->surface = surface;
+  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;
+    }

-  return self;
+  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,34 +46,37 @@ struct _MetaSurfaceActor

 GType meta_surface_actor_get_type (void);

-MetaSurfaceActor *meta_surface_actor_new (MetaWaylandSurface *surface);
-
 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);
-gboolean meta_surface_actor_damage_area (MetaSurfaceActor *self,
-                                         int               x,
-                                         int               y,
-                                         int               width,
-                                         int               height);
-
 gboolean meta_surface_actor_is_obscured (MetaSurfaceActor *self);
 gboolean meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
                                                   cairo_rectangle_int_t *unobscured_bounds);

-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);

-MetaWaylandSurface *meta_surface_actor_get_surface (MetaSurfaceActor *surface);
+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

--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@@ -10,10 +10,6 @@

 #include <math.h>

-#include <X11/extensions/Xcomposite.h>
-#include <X11/extensions/Xdamage.h>
-#include <X11/extensions/Xrender.h>
-
 #include <clutter/x11/clutter-x11.h>
 #include <cogl/cogl-texture-pixmap-x11.h>
 #include <gdk/gdk.h> /* for gdk_rectangle_union() */
@@ -30,13 +26,15 @@
 #include "meta-shaped-texture-private.h"
 #include "meta-shadow-factory-private.h"
 #include "meta-window-actor-private.h"
-#include "meta-surface-actor.h"
 #include "meta-texture-rectangle.h"
 #include "region-utils.h"
 #include "meta-wayland-private.h"
 #include "monitor-private.h"
 #include "meta-cullable.h"

+#include "meta-surface-actor.h"
+#include "meta-surface-actor-x11.h"
+
 struct _MetaWindowActorPrivate
 {
  MetaWindow       *window;
@@ -63,19 +61,13 @@ struct _MetaWindowActorPrivate
  /* The region we should clip to when painting the shadow */
  cairo_region_t   *shadow_clip;

-  guint              send_frame_messages_timer;
-  gint64             frame_drawn_time;
-
  /* Extracted size-invariant shape used for shadows */
  MetaWindowShape  *shadow_shape;
-
-  gint              last_width;
-  gint              last_height;
-
-  gint              freeze_count;
-
  char *            shadow_class;

+  guint             send_frame_messages_timer;
+  gint64            frame_drawn_time;
+
  /*
   * These need to be counters rather than flags, since more plugins
   * can implement same effect; the practicality of stacking effects
@@ -90,11 +82,7 @@ struct _MetaWindowActorPrivate
  /* List of FrameData for recent frames */
  GList            *frames;

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

@@ -111,24 +99,7 @@ struct _MetaWindowActorPrivate

  guint             no_shadow              : 1;

-
-  /* 
-   * None of these are used in wayland compositor mode...
-   */
-
-  guint		    needs_damage_all       : 1;
-  guint		    received_x11_damage    : 1;
-
-  guint		    needs_pixmap           : 1;
-
-  guint		    x11_size_changed       : 1;
  guint             updates_frozen         : 1;
-
-  guint             unredirected           : 1;
-
-  /* This is used to detect fullscreen windows that need to be unredirected */
-  guint             full_damage_frames_count;
-  guint             does_full_damage  : 1;
 };

 typedef struct _FrameData FrameData;
@@ -165,7 +136,6 @@ static gboolean meta_window_actor_get_paint_volume (ClutterActor       *actor,
                                                    ClutterPaintVolume *volume);


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

 static void meta_window_actor_handle_updates (MetaWindowActor *self);
@@ -256,9 +226,6 @@ window_decorated_notify (MetaWindow *mw,
 {
  MetaWindowActor        *self     = META_WINDOW_ACTOR (data);
  MetaWindowActorPrivate *priv     = self->priv;
-  MetaScreen             *screen   = priv->screen;
-  MetaDisplay            *display  = meta_screen_get_display (screen);
-  Display                *xdisplay = meta_display_get_xdisplay (display);

  /*
   * Basically, we have to reconstruct the the internals of this object
@@ -266,23 +233,6 @@ window_decorated_notify (MetaWindow *mw,
   */
  priv->redecorating = TRUE;

-  if (!meta_is_wayland_compositor ())
-    {
-      meta_window_actor_detach_x11_pixmap (self);
-
-      /*
-       * First of all, clean up any resources we are currently using and will
-       * be replacing.
-       */
-      if (priv->damage != None)
-        {
-          meta_error_trap_push (display);
-          XDamageDestroy (xdisplay, priv->damage);
-          meta_error_trap_pop (display);
-          priv->damage = None;
-        }
-    }
-
  /*
   * Recreate the contents.
   */
@@ -307,13 +257,52 @@ surface_allocation_changed_notify (ClutterActor           *actor,
  meta_window_actor_update_shape (self);
 }

+static gboolean
+is_argb32 (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+  return meta_surface_actor_is_argb32 (priv->surface);
+}
+
 static gboolean
 is_non_opaque (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;
  MetaWindow *window = priv->window;

-  return priv->argb32 || (window->opacity != 0xFF);
+  return is_argb32 (self) || (window->opacity != 0xFF);
+}
+
+static gboolean
+is_frozen (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+  return meta_surface_actor_is_frozen (priv->surface);
+}
+
+static void
+meta_window_actor_freeze (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+  meta_surface_actor_freeze (priv->surface);
+}
+
+static void
+meta_window_actor_thaw (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+
+  meta_surface_actor_thaw (priv->surface);
+
+  if (is_frozen (self))
+    return;
+
+  /* We sometimes ignore moves and resizes on frozen windows */
+  meta_window_actor_sync_actor_geometry (self, FALSE);
+
+  /* We do this now since we might be going right back into the
+   * frozen state */
+  meta_window_actor_handle_updates (self);
 }

 static void
@@ -322,38 +311,15 @@ meta_window_actor_constructed (GObject *object)
  MetaWindowActor        *self     = META_WINDOW_ACTOR (object);
  MetaWindowActorPrivate *priv     = self->priv;
  MetaWindow             *window   = priv->window;
-  Window                  xwindow  = meta_window_get_toplevel_xwindow (window);
-  MetaScreen             *screen   = meta_window_get_screen (window);
-  MetaDisplay            *display  = meta_screen_get_display (screen);
-  Display                *xdisplay = meta_display_get_xdisplay (display);

-  priv->screen = screen;
-
-  if (!meta_is_wayland_compositor ())
-    priv->damage = XDamageCreate (xdisplay, xwindow,
-                                  XDamageReportBoundingBox);
-
-  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
-    {
-      XRenderPictFormat      *format;
-
-      format = XRenderFindVisualFormat (xdisplay, window->xvisual);
-
-      if (format && format->type == PictTypeDirect && format->direct.alphaMask)
-        priv->argb32 = TRUE;
-    }
-  else
-    {
-      /* XXX: parse shm formats to determine argb32 */
-      priv->argb32 = TRUE;
-    }
+  priv->screen = window->screen;

  if (!priv->surface)
    {
      if (window->surface)
        priv->surface = window->surface->surface_actor;
      else
-        priv->surface = meta_surface_actor_new (NULL);
+        priv->surface = meta_surface_actor_x11_new (window);
      g_object_ref_sink (priv->surface);

      clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (priv->surface));
@@ -376,8 +342,6 @@ meta_window_actor_dispose (GObject *object)
  MetaWindowActor        *self = META_WINDOW_ACTOR (object);
  MetaWindowActorPrivate *priv = self->priv;
  MetaScreen             *screen;
-  MetaDisplay            *display;
-  Display                *xdisplay;
  MetaCompScreen         *info;

  if (priv->disposed)
@@ -388,9 +352,6 @@ meta_window_actor_dispose (GObject *object)
  screen   = priv->screen;
  info     = meta_screen_get_compositor_data (screen);

-  if (!meta_is_wayland_compositor ())
-    meta_window_actor_detach_x11_pixmap (self);
-
  if (priv->send_frame_messages_timer != 0)
    {
      g_source_remove (priv->send_frame_messages_timer);
@@ -405,18 +366,6 @@ meta_window_actor_dispose (GObject *object)
  g_clear_pointer (&priv->unfocused_shadow, meta_shadow_unref);
  g_clear_pointer (&priv->shadow_shape, meta_window_shape_unref);

-  if (!meta_is_wayland_compositor () && priv->damage != None)
-    {
-      display  = meta_screen_get_display (screen);
-      xdisplay = meta_display_get_xdisplay (display);
-
-      meta_error_trap_push (display);
-      XDamageDestroy (xdisplay, priv->damage);
-      meta_error_trap_pop (display);
-
-      priv->damage = None;
-    }
-
  info->windows = g_list_remove (info->windows, (gconstpointer) self);

  g_clear_object (&priv->window);
@@ -827,13 +776,6 @@ meta_window_actor_is_destroyed (MetaWindowActor *self)
  return self->priv->disposed;
 }

-static void
-meta_window_actor_freeze (MetaWindowActor *self)
-{
-  if (!meta_is_wayland_compositor ())
-    self->priv->freeze_count++;
-}
-
 static gboolean
 send_frame_messages_timeout (gpointer data)
 {
@@ -888,55 +830,6 @@ queue_send_frame_messages_timeout (MetaWindowActor *self)
  priv->send_frame_messages_timer = g_timeout_add_full (META_PRIORITY_REDRAW, offset, send_frame_messages_timeout, self, NULL);
 }

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

-static gboolean
-is_frozen (MetaWindowActor *self)
-{
-  return self->priv->freeze_count ? TRUE : FALSE;
-}
-
-static void
-meta_window_actor_queue_create_x11_pixmap (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  priv->needs_pixmap = TRUE;
-
-  if (is_frozen (self))
-    return;
-
-  /* This will cause the compositor paint function to be run
-   * if the actor is visible or a clone of the actor is visible.
-   * if the actor isn't visible in any way, then we don't
-   * need to repair the window anyways, and can wait until
-   * the stage is redrawn for some other reason
-   *
-   * The compositor paint function repairs all windows.
-   */
-  clutter_actor_queue_redraw (CLUTTER_ACTOR (priv->surface));
-}
-
 static gboolean
 is_freeze_thaw_effect (gulong event)
 {
@@ -1098,12 +964,6 @@ meta_window_actor_after_effects (MetaWindowActor *self)

  meta_window_actor_sync_visibility (self);
  meta_window_actor_sync_actor_geometry (self, FALSE);
-
-  if (!meta_is_wayland_compositor ())
-    {
-      if (priv->needs_pixmap)
-        clutter_actor_queue_redraw (CLUTTER_ACTOR (priv->surface));
-    }
 }

 void
@@ -1178,95 +1038,19 @@ meta_window_actor_effect_completed (MetaWindowActor *self,
    meta_window_actor_after_effects (self);
 }

-/* Called to drop our reference to a window backing pixmap that we
- * previously obtained with XCompositeNameWindowPixmap. We do this
- * when the window is unmapped or when we want to update to a new
- * pixmap for a new size.
- */
-static void
-meta_window_actor_detach_x11_pixmap (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv     = self->priv;
-  MetaScreen            *screen   = priv->screen;
-  MetaDisplay           *display  = meta_screen_get_display (screen);
-  Display               *xdisplay = meta_display_get_xdisplay (display);
-
-  if (!priv->back_pixmap)
-    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_surface_actor_set_texture (priv->surface, NULL);
-  cogl_flush();
-
-  XFreePixmap (xdisplay, priv->back_pixmap);
-  priv->back_pixmap = None;
-
-  meta_window_actor_queue_create_x11_pixmap (self);
-}
-
 gboolean
 meta_window_actor_should_unredirect (MetaWindowActor *self)
 {
-  MetaWindow *metaWindow = meta_window_actor_get_meta_window (self);
  MetaWindowActorPrivate *priv = self->priv;
-
-  if (meta_is_wayland_compositor ())
-    return FALSE;
-
-  if (meta_window_requested_dont_bypass_compositor (metaWindow))
-    return FALSE;
-
-  if (metaWindow->opacity != 0xFF)
-    return FALSE;
-
-  if (metaWindow->shape_region != NULL)
-    return FALSE;
-
-  if (priv->argb32 && !meta_window_requested_bypass_compositor (metaWindow))
-    return FALSE;
-
-  if (!meta_window_is_monitor_sized (metaWindow))
-    return FALSE;
-
-  if (meta_window_requested_bypass_compositor (metaWindow))
-    return TRUE;
-
-  if (meta_window_is_override_redirect (metaWindow))
-    return TRUE;
-
-  if (priv->does_full_damage)
-    return TRUE;
-
-  return FALSE;
+  return meta_surface_actor_should_unredirect (priv->surface);
 }

 void
 meta_window_actor_set_unredirected (MetaWindowActor *self,
                                    gboolean         unredirected)
 {
-  MetaWindow *metaWindow = meta_window_actor_get_meta_window (self);
-  MetaDisplay *display = meta_window_get_display (metaWindow);
-
-  Display *xdisplay = meta_display_get_xdisplay (display);
-  Window  xwin = meta_window_get_toplevel_xwindow (metaWindow);
-
-  meta_error_trap_push (display);
-
-  if (unredirected)
-    {
-      XCompositeUnredirectWindow (xdisplay, xwin, CompositeRedirectManual);
-    }
-  else
-    {
-      XCompositeRedirectWindow (xdisplay, xwin, CompositeRedirectManual);
-      meta_window_actor_detach_x11_pixmap (self);
-    }
-
-  self->priv->unredirected = unredirected;
-  meta_error_trap_pop (display);
+  MetaWindowActorPrivate *priv = self->priv;
+  meta_surface_actor_set_unredirected (priv->surface, unredirected);
 }

 void
@@ -1326,19 +1110,11 @@ meta_window_actor_sync_actor_geometry (MetaWindowActor *self,

  meta_window_get_input_rect (priv->window, &window_rect);

-  /* When running as a display server we catch size changes when new
-     buffers are attached */
-  if (!meta_is_wayland_compositor ())
-    {
-      if (priv->last_width != window_rect.width ||
-          priv->last_height != window_rect.height)
-        {
-          priv->x11_size_changed = TRUE;
-
-          priv->last_width = window_rect.width;
-          priv->last_height = window_rect.height;
-        }
-    }
+  /* When running as a Wayland compositor we catch size changes when new
+   * buffers are attached */
+  if (META_IS_SURFACE_ACTOR_X11 (priv->surface))
+    meta_surface_actor_x11_set_size (META_SURFACE_ACTOR_X11 (priv->surface),
+                                     window_rect.width, window_rect.height);

  /* Normally we want freezing a window to also freeze its position; this allows
   * windows to atomically move and resize together, either under app control,
@@ -1350,15 +1126,6 @@ meta_window_actor_sync_actor_geometry (MetaWindowActor *self,
  if (is_frozen (self) && !did_placement)
    return;

-  if (!meta_is_wayland_compositor ())
-    {
-      if (priv->x11_size_changed)
-        {
-          meta_window_actor_queue_create_x11_pixmap (self);
-          meta_window_actor_update_shape (self);
-        }
-    }
-
  if (meta_window_actor_effect_in_progress (self))
    return;

@@ -1525,22 +1292,13 @@ meta_window_actor_new (MetaWindow *window)

  priv = self->priv;

-  if (!meta_is_wayland_compositor ())
-    {
-      priv->last_width = -1;
-      priv->last_height = -1;
+  meta_window_actor_set_updates_frozen (self, meta_window_updates_are_frozen (priv->window));

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

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

@@ -1649,13 +1407,6 @@ meta_window_actor_cull_out (MetaCullable   *cullable,
                            cairo_region_t *clip_region)
 {
  MetaWindowActor *self = META_WINDOW_ACTOR (cullable);
-  MetaWindowActorPrivate *priv = self->priv;
-
-  meta_cullable_cull_out_children (cullable, unobscured_region, clip_region);
-
-  /* Don't do any culling for the unredirected window */
-  if (priv->unredirected)
-    return;

  meta_window_actor_set_clip_region_beneath (self, clip_region);
 }
@@ -1678,68 +1429,6 @@ cullable_iface_init (MetaCullableInterface *iface)
  iface->reset_culling = meta_window_actor_reset_culling;
 }

-/* When running as a wayland compositor we don't make requests for
- * replacement pixmaps when resizing windows, we will instead be
- * asked to attach replacement buffers by the clients. */
-static void
-check_needs_x11_pixmap (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaDisplay *display = meta_screen_get_display (priv->screen);
-  Display *xdisplay = meta_display_get_xdisplay (display);
-  Window xwindow  = meta_window_get_toplevel_xwindow (priv->window);
-
-  if (!priv->needs_pixmap)
-    return;
-
-  if (priv->x11_size_changed)
-    {
-      meta_window_actor_detach_x11_pixmap (self);
-      priv->x11_size_changed = FALSE;
-    }
-
-  meta_error_trap_push (display);
-
-  if (priv->back_pixmap == None)
-    {
-      CoglContext *ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
-      CoglTexture *texture;
-
-      meta_error_trap_push (display);
-
-      priv->back_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.)
-           */
-          priv->back_pixmap = None;
-        }
-
-      if (priv->back_pixmap == None)
-        {
-          meta_verbose ("Unable to get named pixmap for %p\n", self);
-          goto out;
-        }
-
-      texture = COGL_TEXTURE (cogl_texture_pixmap_x11_new (ctx, priv->back_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");
-
-      meta_surface_actor_set_texture (META_SURFACE_ACTOR (priv->surface), texture);
-    }
-
-  priv->needs_pixmap = FALSE;
-
- out:
-  meta_error_trap_pop (display);
-}
-
 static void
 check_needs_shadow (MetaWindowActor *self)
 {
@@ -1807,61 +1496,12 @@ meta_window_actor_process_x11_damage (MetaWindowActor    *self,
                                      XDamageNotifyEvent *event)
 {
  MetaWindowActorPrivate *priv = self->priv;
-  MetaCompScreen *info = meta_screen_get_compositor_data (priv->screen);
-  gboolean redraw_queued;

-  priv->received_x11_damage = TRUE;
-
-  if (meta_window_is_fullscreen (priv->window) && g_list_last (info->windows)->data == self && !priv->unredirected)
-    {
-      MetaRectangle window_rect;
-      meta_window_get_frame_rect (priv->window, &window_rect);
-
-      if (window_rect.x == event->area.x &&
-          window_rect.y == event->area.y &&
-          window_rect.width == event->area.width &&
-          window_rect.height == event->area.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;
-
-  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;
-    }
-
-  if (priv->needs_pixmap)
-    return;
-
-  redraw_queued = meta_surface_actor_damage_area (priv->surface,
-                                                  event->area.x,
-                                                  event->area.y,
-                                                  event->area.width,
-                                                  event->area.height);
-  priv->repaint_scheduled = priv->repaint_scheduled || redraw_queued;
+  meta_surface_actor_process_damage (priv->surface,
+                                     event->area.x,
+                                     event->area.y,
+                                     event->area.width,
+                                     event->area.height);
 }

 void
@@ -2089,8 +1729,9 @@ meta_window_actor_update_opaque_region (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;
  cairo_region_t *opaque_region;
+  gboolean argb32 = is_argb32 (self);

-  if (priv->argb32 && priv->window->opaque_region != NULL)
+  if (argb32 && priv->window->opaque_region != NULL)
    {
      MetaFrameBorders borders;

@@ -2110,7 +1751,7 @@ meta_window_actor_update_opaque_region (MetaWindowActor *self)
      cairo_region_translate (opaque_region, borders.total.left, borders.total.top);
      cairo_region_intersect (opaque_region, priv->shape_region);
    }
-  else if (priv->argb32)
+  else if (argb32)
    opaque_region = NULL;
  else
    opaque_region = cairo_region_reference (priv->shape_region);
@@ -2167,9 +1808,6 @@ static void
 meta_window_actor_handle_updates (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;
-  MetaScreen          *screen   = priv->screen;
-  MetaDisplay         *display  = meta_screen_get_display (screen);
-  Display             *xdisplay = meta_display_get_xdisplay (display);

  if (is_frozen (self))
    {
@@ -2178,45 +1816,13 @@ meta_window_actor_handle_updates (MetaWindowActor *self)
      return;
    }

-  if (!meta_is_wayland_compositor ())
-    {
-      if (priv->unredirected)
-        {
-          /* Nothing to do here until/if the window gets redirected again */
-          return;
-        }
+  if (meta_surface_actor_is_unredirected (priv->surface))
+    return;

-      if (priv->received_x11_damage)
-        {
-          meta_error_trap_push (display);
-          XDamageSubtract (xdisplay, priv->damage, None, None);
-          meta_error_trap_pop (display);
+  meta_surface_actor_pre_paint (priv->surface);

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

  check_needs_reshape (self);
  check_needs_shadow (self);
@@ -2405,20 +2011,16 @@ void
 meta_window_actor_set_updates_frozen (MetaWindowActor *self,
                                      gboolean         updates_frozen)
 {
-  /* On wayland we shouldn't need to ever freeze updates... */
-  if (!meta_is_wayland_compositor ())
+  MetaWindowActorPrivate *priv = self->priv;
+
+  updates_frozen = updates_frozen != FALSE;
+
+  if (priv->updates_frozen != updates_frozen)
    {
-      MetaWindowActorPrivate *priv = self->priv;
-
-      updates_frozen = updates_frozen != FALSE;
-
-      if (priv->updates_frozen != updates_frozen)
-        {
-          priv->updates_frozen = updates_frozen;
-          if (updates_frozen)
-            meta_window_actor_freeze (self);
-          else
-            meta_window_actor_thaw (self);
-        }
+      priv->updates_frozen = updates_frozen;
+      if (updates_frozen)
+        meta_window_actor_freeze (self);
+      else
+        meta_window_actor_thaw (self);
    }
 }
--- a/src/compositor/plugins/default.c
+++ b/src/compositor/plugins/default.c
@@ -39,7 +39,6 @@
 #define SWITCH_TIMEOUT    500

 #define ACTOR_DATA_KEY "MCCP-Default-actor-data"
-#define SCREEN_TILE_PREVIEW_DATA_KEY "MCCP-Default-screen-tile-preview-data"

 #define META_TYPE_DEFAULT_PLUGIN            (meta_default_plugin_get_type ())
 #define META_DEFAULT_PLUGIN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_DEFAULT_PLUGIN, MetaDefaultPlugin))
@@ -68,7 +67,6 @@ struct _MetaDefaultPluginClass
 };

 static GQuark actor_data_quark = 0;
-static GQuark screen_tile_preview_data_quark = 0;

 static void start      (MetaPlugin      *plugin);
 static void minimize   (MetaPlugin      *plugin,
@@ -99,12 +97,6 @@ static void kill_window_effects   (MetaPlugin      *plugin,
                                   MetaWindowActor *actor);
 static void kill_switch_workspace (MetaPlugin      *plugin);

-static void show_tile_preview (MetaPlugin      *plugin,
-                               MetaWindow      *window,
-                               MetaRectangle   *tile_rect,
-                               int              tile_monitor_number);
-static void hide_tile_preview (MetaPlugin      *plugin);
-
 static void confirm_display_change (MetaPlugin *plugin);

 static const MetaPluginInfo * plugin_info (MetaPlugin *plugin);
@@ -151,15 +143,6 @@ typedef struct
 } EffectCompleteData;


-typedef struct _ScreenTilePreview
-{
-  ClutterActor   *actor;
-
-  GdkRGBA        *preview_color;
-
-  MetaRectangle   tile_rect;
-} ScreenTilePreview;
-
 static void
 meta_default_plugin_dispose (GObject *object)
 {
@@ -220,8 +203,6 @@ meta_default_plugin_class_init (MetaDefaultPluginClass *klass)
  plugin_class->unmaximize       = unmaximize;
  plugin_class->destroy          = destroy;
  plugin_class->switch_workspace = switch_workspace;
-  plugin_class->show_tile_preview = show_tile_preview;
-  plugin_class->hide_tile_preview = hide_tile_preview;
  plugin_class->plugin_info      = plugin_info;
  plugin_class->kill_window_effects   = kill_window_effects;
  plugin_class->kill_switch_workspace = kill_switch_workspace;
@@ -768,82 +749,6 @@ destroy (MetaPlugin *plugin, MetaWindowActor *window_actor)
    meta_plugin_destroy_completed (plugin, window_actor);
 }

-/*
- * Tile preview private data accessor
- */
-static void
-free_screen_tile_preview (gpointer data)
-{
-  ScreenTilePreview *preview = data;
-
-  if (G_LIKELY (preview != NULL)) {
-    clutter_actor_destroy (preview->actor);
-    g_slice_free (ScreenTilePreview, preview);
-  }
-}
-
-static ScreenTilePreview *
-get_screen_tile_preview (MetaScreen *screen)
-{
-  ScreenTilePreview *preview = g_object_get_qdata (G_OBJECT (screen), screen_tile_preview_data_quark);
-
-  if (G_UNLIKELY (screen_tile_preview_data_quark == 0))
-    screen_tile_preview_data_quark = g_quark_from_static_string (SCREEN_TILE_PREVIEW_DATA_KEY);
-
-  if (G_UNLIKELY (!preview))
-    {
-      preview = g_slice_new0 (ScreenTilePreview);
-
-      preview->actor = clutter_actor_new ();
-      clutter_actor_set_background_color (preview->actor, CLUTTER_COLOR_Blue);
-      clutter_actor_set_opacity (preview->actor, 100);
-
-      clutter_actor_add_child (meta_get_window_group_for_screen (screen), preview->actor);
-      g_object_set_qdata_full (G_OBJECT (screen),
-                               screen_tile_preview_data_quark, preview,
-                               free_screen_tile_preview);
-    }
-
-  return preview;
-}
-
-static void
-show_tile_preview (MetaPlugin    *plugin,
-                   MetaWindow    *window,
-                   MetaRectangle *tile_rect,
-                   int            tile_monitor_number)
-{
-  MetaScreen *screen = meta_plugin_get_screen (plugin);
-  ScreenTilePreview *preview = get_screen_tile_preview (screen);
-  ClutterActor *window_actor;
-
-  if (CLUTTER_ACTOR_IS_VISIBLE (preview->actor)
-      && preview->tile_rect.x == tile_rect->x
-      && preview->tile_rect.y == tile_rect->y
-      && preview->tile_rect.width == tile_rect->width
-      && preview->tile_rect.height == tile_rect->height)
-    return; /* nothing to do */
-
-  clutter_actor_set_position (preview->actor, tile_rect->x, tile_rect->y);
-  clutter_actor_set_size (preview->actor, tile_rect->width, tile_rect->height);
-
-  clutter_actor_show (preview->actor);
-
-  window_actor = CLUTTER_ACTOR (meta_window_get_compositor_private (window));
-  clutter_actor_lower (preview->actor, window_actor);
-
-  preview->tile_rect = *tile_rect;
-}
-
-static void
-hide_tile_preview (MetaPlugin *plugin)
-{
-  MetaScreen *screen = meta_plugin_get_screen (plugin);
-  ScreenTilePreview *preview = get_screen_tile_preview (screen);
-
-  clutter_actor_hide (preview->actor);
-}
-
 static void
 kill_switch_workspace (MetaPlugin     *plugin)
 {
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -73,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  ||  \
@@ -1682,9 +1683,9 @@ get_window_for_event (MetaDisplay        *display,
    return display->grab_window;

  source = clutter_event_get_source (event);
-  if (META_IS_SURFACE_ACTOR (source))
+  if (META_IS_SURFACE_ACTOR_WAYLAND (source))
    {
-      MetaWaylandSurface *surface = meta_surface_actor_get_surface (META_SURFACE_ACTOR (source));
+      MetaWaylandSurface *surface = meta_surface_actor_wayland_get_surface (META_SURFACE_ACTOR_WAYLAND (source));
      g_assert (surface != NULL);
      return surface->window;
    }
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -2165,7 +2165,7 @@ process_mouse_move_resize_grab (MetaDisplay     *display,
    {
      /* Hide the tiling preview if necessary */
      if (window->tile_mode != META_TILE_NONE)
-        meta_screen_hide_tile_preview (screen);
+        meta_screen_tile_preview_hide (screen);

      /* Restore the original tile mode */
      window->tile_mode = display->grab_tile_mode;
--- a/src/core/screen-private.h
+++ b/src/core/screen-private.h
@@ -65,6 +65,7 @@ struct _MetaScreen
  MetaRectangle rect;  /* Size of screen; rect.x & rect.y are always 0 */
  MetaUI *ui;
  MetaTabPopup *tab_popup, *ws_popup;
+  MetaTilePreview *tile_preview;

  guint tile_preview_timeout_id;

@@ -166,9 +167,9 @@ void          meta_screen_workspace_popup_select       (MetaScreen    *screen,
 MetaWorkspace*meta_screen_workspace_popup_get_selected (MetaScreen    *screen);
 void          meta_screen_workspace_popup_destroy      (MetaScreen    *screen);

-void          meta_screen_update_tile_preview          (MetaScreen    *screen,
+void          meta_screen_tile_preview_update          (MetaScreen    *screen,
                                                        gboolean       delay);
-void          meta_screen_hide_tile_preview            (MetaScreen    *screen);
+void          meta_screen_tile_preview_hide            (MetaScreen    *screen);

 MetaWindow*   meta_screen_get_mouse_window     (MetaScreen                 *screen,
                                                MetaWindow                 *not_this_one);
--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -762,6 +762,7 @@ meta_screen_new (MetaDisplay *display,

  screen->tab_popup = NULL;
  screen->ws_popup = NULL;
+  screen->tile_preview = NULL;

  screen->tile_preview_timeout_id = 0;

@@ -867,6 +868,9 @@ meta_screen_free (MetaScreen *screen,
  if (screen->tile_preview_timeout_id)
    g_source_remove (screen->tile_preview_timeout_id);

+  if (screen->tile_preview)
+    meta_tile_preview_free (screen->tile_preview);
+  
  g_free (screen->screen_name);

  g_object_unref (screen);
@@ -1676,7 +1680,7 @@ meta_screen_workspace_popup_destroy (MetaScreen *screen)
 }

 static gboolean
-meta_screen_update_tile_preview_timeout (gpointer data)
+meta_screen_tile_preview_update_timeout (gpointer data)
 {
  MetaScreen *screen = data;
  MetaWindow *window = screen->display->grab_window;
@@ -1684,6 +1688,22 @@ meta_screen_update_tile_preview_timeout (gpointer data)

  screen->tile_preview_timeout_id = 0;

+  if (!screen->tile_preview)
+    {
+      Window xwindow;
+      gulong create_serial;
+      MetaStackWindow stack_window;
+
+      screen->tile_preview = meta_tile_preview_new (screen->number);
+      xwindow = meta_tile_preview_get_xwindow (screen->tile_preview,
+                                               &create_serial);
+      stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
+      stack_window.x11.xwindow = xwindow;
+      meta_stack_tracker_record_add (screen->stack_tracker,
+                                     &stack_window,
+                                     create_serial);
+    }
+
  if (window)
    {
      switch (window->tile_mode)
@@ -1708,16 +1728,12 @@ meta_screen_update_tile_preview_timeout (gpointer data)
  if (needs_preview)
    {
      MetaRectangle tile_rect;
-      int monitor;

-      monitor = meta_window_get_current_tile_monitor_number (window);
      meta_window_get_current_tile_area (window, &tile_rect);
-      meta_compositor_show_tile_preview (screen->display->compositor,
-                                         screen, window, &tile_rect, monitor);
+      meta_tile_preview_show (screen->tile_preview, &tile_rect);
    }
  else
-    meta_compositor_hide_tile_preview (screen->display->compositor,
-                                       screen);
+    meta_tile_preview_hide (screen->tile_preview);

  return FALSE;
 }
@@ -1725,7 +1741,7 @@ meta_screen_update_tile_preview_timeout (gpointer data)
 #define TILE_PREVIEW_TIMEOUT_MS 200

 void
-meta_screen_update_tile_preview (MetaScreen *screen,
+meta_screen_tile_preview_update (MetaScreen *screen,
                                 gboolean    delay)
 {
  if (delay)
@@ -1735,7 +1751,7 @@ meta_screen_update_tile_preview (MetaScreen *screen,

      screen->tile_preview_timeout_id =
        g_timeout_add (TILE_PREVIEW_TIMEOUT_MS,
-                       meta_screen_update_tile_preview_timeout,
+                       meta_screen_tile_preview_update_timeout,
                       screen);
    }
  else
@@ -1743,18 +1759,18 @@ meta_screen_update_tile_preview (MetaScreen *screen,
      if (screen->tile_preview_timeout_id > 0)
        g_source_remove (screen->tile_preview_timeout_id);

-      meta_screen_update_tile_preview_timeout ((gpointer)screen);
+      meta_screen_tile_preview_update_timeout ((gpointer)screen);
    }
 }

 void
-meta_screen_hide_tile_preview (MetaScreen *screen)
+meta_screen_tile_preview_hide (MetaScreen *screen)
 {
  if (screen->tile_preview_timeout_id > 0)
    g_source_remove (screen->tile_preview_timeout_id);

-  meta_compositor_hide_tile_preview (screen->display->compositor,
-                                     screen);
+  if (screen->tile_preview)
+    meta_tile_preview_hide (screen->tile_preview);
 }

 MetaWindow*
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -652,7 +652,6 @@ void meta_window_handle_mouse_grab_op_xevent (MetaWindow         *window,

 GList* meta_window_get_workspaces (MetaWindow *window);

-int meta_window_get_current_tile_monitor_number (MetaWindow *window);
 void meta_window_get_current_tile_area         (MetaWindow    *window,
                                                MetaRectangle *tile_area);

--- a/src/core/window.c
+++ b/src/core/window.c
@@ -1177,6 +1177,9 @@ _meta_window_shared_new (MetaDisplay         *display,
  if (!window->override_redirect)
    meta_stack_add (window->screen->stack,
                    window);
+  else if (window->screen->tile_preview != NULL &&
+           meta_tile_preview_get_xwindow (window->screen->tile_preview, NULL) == xwindow)
+    window->layer = META_LAYER_NORMAL;
  else
    window->layer = META_LAYER_OVERRIDE_REDIRECT; /* otherwise set by MetaStack */

@@ -3366,7 +3369,7 @@ meta_window_tile (MetaWindow *window)
    directions = META_MAXIMIZE_VERTICAL;

  meta_window_maximize_internal (window, directions, NULL);
-  meta_screen_update_tile_preview (window->screen, FALSE);
+  meta_screen_tile_preview_update (window->screen, FALSE);

  if (window->display->compositor)
    {
@@ -8105,7 +8108,7 @@ update_move (MetaWindow  *window,
   * trigger it unwittingly, e.g. when shaking loose the window or moving
   * it to another monitor.
   */
-  meta_screen_update_tile_preview (window->screen,
+  meta_screen_tile_preview_update (window->screen,
                                   window->tile_mode != META_TILE_NONE);

  meta_window_get_client_root_coords (window, &old);
@@ -8953,20 +8956,6 @@ meta_window_get_work_area_all_monitors (MetaWindow    *window,
              window->desc, area->x, area->y, area->width, area->height);
 }

-int
-meta_window_get_current_tile_monitor_number (MetaWindow *window)
-{
-  int tile_monitor_number = window->tile_monitor_number;
-
-  if (tile_monitor_number < 0)
-    {
-      meta_warning ("%s called with an invalid monitor number; using 0 instead\n", G_STRFUNC);
-      tile_monitor_number = 0;
-    }
-
-  return tile_monitor_number;
-}
-
 void
 meta_window_get_current_tile_area (MetaWindow    *window,
                                   MetaRectangle *tile_area)
@@ -8975,7 +8964,12 @@ meta_window_get_current_tile_area (MetaWindow    *window,

  g_return_if_fail (window->tile_mode != META_TILE_NONE);

-  tile_monitor_number = meta_window_get_current_tile_monitor_number (window);
+  tile_monitor_number = window->tile_monitor_number;
+  if (tile_monitor_number < 0)
+    {
+      meta_warning ("%s called with an invalid monitor number; using 0 instead\n", G_STRFUNC);
+      tile_monitor_number = 0;
+    }

  meta_window_get_work_area_for_monitor (window, tile_monitor_number, tile_area);

--- a/src/meta/compositor.h
+++ b/src/meta/compositor.h
@@ -121,12 +121,4 @@ void meta_compositor_sync_screen_size          (MetaCompositor *compositor,
 void meta_compositor_flash_screen              (MetaCompositor *compositor,
                                                MetaScreen     *screen);

-void meta_compositor_show_tile_preview (MetaCompositor *compositor,
-                                        MetaScreen     *screen,
-                                        MetaWindow     *window,
-                                        MetaRectangle  *tile_rect,
-                                        int             tile_monitor_number);
-void meta_compositor_hide_tile_preview (MetaCompositor *compositor,
-                                        MetaScreen     *screen);
-
 #endif /* META_COMPOSITOR_H */
--- a/src/meta/meta-plugin.h
+++ b/src/meta/meta-plugin.h
@@ -158,11 +158,6 @@ struct _MetaPluginClass
                            gint                to,
                            MetaMotionDirection direction);

-  void (*show_tile_preview) (MetaPlugin      *plugin,
-                             MetaWindow      *window,
-                             MetaRectangle   *tile_rect,
-                             int              tile_monitor_number);
-  void (*hide_tile_preview) (MetaPlugin      *plugin);

  /**
   * MetaPluginClass::kill_window_effects:
--- a/src/ui/tile-preview.c
+++ b/src/ui/tile-preview.c
@@ -0,0 +1,196 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Mutter tile-preview marks the area a window will *ehm* snap to */
+
+/*
+ * Copyright (C) 2010 Florian Müllner
+ *
+ * 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/>.
+ */
+
+#include <config.h>
+
+#include <gtk/gtk.h>
+#include <cairo.h>
+
+#include "tile-preview.h"
+#include "core.h"
+
+#define OUTLINE_WIDTH 5  /* frame width in non-composite case */
+
+
+struct _MetaTilePreview {
+  GtkWidget     *preview_window;
+  gulong         create_serial;
+
+  GdkRGBA       *preview_color;
+
+  MetaRectangle  tile_rect;
+};
+
+static gboolean
+meta_tile_preview_draw (GtkWidget *widget,
+                        cairo_t   *cr,
+                        gpointer   user_data)
+{
+  MetaTilePreview *preview = user_data;
+
+  cairo_set_line_width (cr, 1.0);
+
+  /* Fill the preview area with a transparent color */
+  gdk_cairo_set_source_rgba (cr, preview->preview_color);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_paint (cr);
+
+  /* Use the opaque color for the border */
+  cairo_set_source_rgb (cr,
+                        preview->preview_color->red,
+                        preview->preview_color->green,
+                        preview->preview_color->blue);
+
+  cairo_rectangle (cr,
+                   0.5, 0.5,
+                   preview->tile_rect.width - 1,
+                   preview->tile_rect.height - 1);
+  cairo_stroke (cr);
+
+  return FALSE;
+}
+
+MetaTilePreview *
+meta_tile_preview_new (int      screen_number)
+{
+  MetaTilePreview *preview;
+  GdkScreen *screen;
+  GtkStyleContext *context;
+  GtkWidgetPath *path;
+  guchar selection_alpha = 0xFF;
+
+  screen = gdk_display_get_screen (gdk_display_get_default (), screen_number);
+
+  preview = g_new (MetaTilePreview, 1);
+
+  preview->preview_window = gtk_window_new (GTK_WINDOW_POPUP);
+
+  gtk_window_set_screen (GTK_WINDOW (preview->preview_window), screen);
+  gtk_widget_set_app_paintable (preview->preview_window, TRUE);
+
+  preview->preview_color = NULL;
+
+  preview->tile_rect.x = preview->tile_rect.y = 0;
+  preview->tile_rect.width = preview->tile_rect.height = 0;
+
+  gtk_widget_set_visual (preview->preview_window,
+                         gdk_screen_get_rgba_visual (screen));
+
+  path = gtk_widget_path_new ();
+  gtk_widget_path_append_type (path, GTK_TYPE_ICON_VIEW);
+
+  context = gtk_style_context_new ();
+  gtk_style_context_set_path (context, path);
+  gtk_style_context_add_class (context,
+                               GTK_STYLE_CLASS_RUBBERBAND);
+
+  gtk_widget_path_free (path);
+
+  gtk_style_context_get (context, GTK_STATE_FLAG_SELECTED,
+                         "background-color", &preview->preview_color,
+                         NULL);
+
+  /* The background-color for the .rubberband class should probably
+   * contain the correct alpha value - unfortunately, at least for now
+   * it doesn't. Hopefully the following workaround can be removed
+   * when GtkIconView gets ported to GtkStyleContext.
+   */
+  gtk_style_context_get_style (context,
+                               "selection-box-alpha", &selection_alpha,
+                               NULL);
+  preview->preview_color->alpha = (double)selection_alpha / 0xFF;
+
+  g_object_unref (context);
+
+  /* We make an assumption that XCreateWindow will be the first operation
+   * when calling gtk_widget_realize() (via gdk_window_new()), or that it
+   * is at least "close enough".
+   */
+  preview->create_serial = XNextRequest (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+  gtk_widget_realize (preview->preview_window);
+  g_signal_connect (preview->preview_window, "draw",
+                    G_CALLBACK (meta_tile_preview_draw), preview);
+
+  return preview;
+}
+
+void
+meta_tile_preview_free (MetaTilePreview *preview)
+{
+  gtk_widget_destroy (preview->preview_window);
+
+  if (preview->preview_color)
+    gdk_rgba_free (preview->preview_color);
+
+  g_free (preview);
+}
+
+void
+meta_tile_preview_show (MetaTilePreview *preview,
+                        MetaRectangle   *tile_rect)
+{
+  GdkWindow *window;
+  GdkRectangle old_rect;
+
+  if (gtk_widget_get_visible (preview->preview_window)
+      && preview->tile_rect.x == tile_rect->x
+      && preview->tile_rect.y == tile_rect->y
+      && preview->tile_rect.width == tile_rect->width
+      && preview->tile_rect.height == tile_rect->height)
+    return; /* nothing to do */
+
+  gtk_widget_show (preview->preview_window);
+  window = gtk_widget_get_window (preview->preview_window);
+  meta_core_lower_beneath_grab_window (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                       GDK_WINDOW_XID (window),
+                                       gtk_get_current_event_time ());
+
+  old_rect.x = old_rect.y = 0;
+  old_rect.width = preview->tile_rect.width;
+  old_rect.height = preview->tile_rect.height;
+
+  gdk_window_invalidate_rect (window, &old_rect, FALSE);
+
+  preview->tile_rect = *tile_rect;
+
+  gdk_window_move_resize (window,
+                          preview->tile_rect.x, preview->tile_rect.y,
+                          preview->tile_rect.width, preview->tile_rect.height);
+}
+
+void
+meta_tile_preview_hide (MetaTilePreview *preview)
+{
+  gtk_widget_hide (preview->preview_window);
+}
+
+Window
+meta_tile_preview_get_xwindow (MetaTilePreview *preview,
+                               gulong          *create_serial)
+{
+  GdkWindow *window = gtk_widget_get_window (preview->preview_window);
+
+  if (create_serial)
+    *create_serial = preview->create_serial;
+
+  return GDK_WINDOW_XID (window);
+}
--- a/src/ui/tile-preview.h
+++ b/src/ui/tile-preview.h
@@ -0,0 +1,36 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Meta tile preview */
+
+/*
+ * Copyright (C) 2010 Florian Müllner
+ *
+ * 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_TILE_PREVIEW_H
+#define META_TILE_PREVIEW_H
+
+#include <meta/boxes.h>
+
+typedef struct _MetaTilePreview MetaTilePreview;
+
+MetaTilePreview   *meta_tile_preview_new    (int                screen_number);
+void               meta_tile_preview_free   (MetaTilePreview   *preview);
+void               meta_tile_preview_show   (MetaTilePreview   *preview,
+                                             MetaRectangle     *rect);
+void               meta_tile_preview_hide   (MetaTilePreview   *preview);
+Window             meta_tile_preview_get_xwindow (MetaTilePreview   *preview,
+                                                  gulong            *create_serial);
+
+#endif /* META_TILE_PREVIEW_H */
--- a/src/ui/ui.h
+++ b/src/ui/ui.h
@@ -179,5 +179,6 @@ int      meta_ui_get_drag_threshold       (MetaUI *ui);
 MetaUIDirection meta_ui_get_direction (void);

 #include "tabpopup.h"
+#include "tile-preview.h"

 #endif
--- 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)

@@ -420,8 +421,8 @@ meta_wayland_seat_repick (MetaWaylandSeat    *seat,
  else
    seat->current_stage = NULL;

-  if (META_IS_SURFACE_ACTOR (actor))
-    surface = meta_surface_actor_get_surface (META_SURFACE_ACTOR (actor));
+  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_surface)
--- a/src/wayland/meta-wayland-surface.c
+++ b/src/wayland/meta-wayland-surface.c
@@ -44,11 +44,11 @@
 #include "meta-wayland-private.h"
 #include "meta-xwayland-private.h"
 #include "meta-wayland-stage.h"
-#include "meta-surface-actor.h"
 #include "meta-wayland-seat.h"
 #include "meta-wayland-keyboard.h"
 #include "meta-wayland-pointer.h"
 #include "meta-wayland-data-device.h"
+
 #include "meta-cursor-tracker-private.h"
 #include "display-private.h"
 #include "window-private.h"
@@ -58,6 +58,9 @@
 #include "meta-idle-monitor-private.h"
 #include "monitor-private.h"

+#include "meta-surface-actor.h"
+#include "meta-surface-actor-wayland.h"
+
 typedef enum
 {
  META_WAYLAND_SUBSURFACE_PLACEMENT_ABOVE,
@@ -114,8 +117,8 @@ surface_process_damage (MetaWaylandSurface *surface,
    {
      cairo_rectangle_int_t rect;
      cairo_region_get_rectangle (region, i, &rect);
-      meta_surface_actor_damage_area (surface->surface_actor,
-                                      rect.x, rect.y, rect.width, rect.height);
+      meta_surface_actor_process_damage (surface->surface_actor,
+                                         rect.x, rect.y, rect.width, rect.height);
    }
 }

@@ -295,7 +298,7 @@ actor_surface_commit (MetaWaylandSurface             *surface,
  if (buffer_changed)
    {
      ensure_buffer_texture (buffer);
-      meta_surface_actor_attach_wayland_buffer (surface_actor, buffer);
+      meta_surface_actor_wayland_set_buffer (META_SURFACE_ACTOR_WAYLAND (surface->surface_actor), buffer);
    }

  surface_process_damage (surface, pending->damage);
@@ -645,7 +648,7 @@ meta_wayland_surface_create (MetaWaylandCompositor *compositor,
  wl_resource_set_implementation (surface->resource, &meta_wayland_surface_interface, surface, wl_surface_destructor);

  surface->buffer_destroy_listener.notify = surface_handle_buffer_destroy;
-  surface->surface_actor = g_object_ref_sink (meta_surface_actor_new (surface));
+  surface->surface_actor = g_object_ref_sink (meta_surface_actor_wayland_new (surface));
  clutter_actor_set_reactive (CLUTTER_ACTOR (surface->surface_actor), TRUE);

  double_buffered_state_init (&surface->pending);