Introduce regional stage rendering

Add support for drawing a stage using multiple framebuffers each making
up one part of the stage. This works by the stage backend
(ClutterStageWindow) providing a list of views which will be for
splitting up the stage in different regions.

A view layout, for now, is a set of rectangles. The stage window (i.e.
stage "backend" will use this information when drawing a frame, using
one framebuffer for each view. The scene graph is adapted to explictly
take a view when painting the stage. It will use this view, its
assigned framebuffer and layout to offset and clip the drawing
accordingly.

This effectively removes any notion of "stage framebuffer", since each
stage now may consist of multiple framebuffers. Therefore, API
involving this has been deprecated and made no-ops; namely
clutter_stage_ensure_context(). Callers are now assumed to either
always use a framebuffer reference explicitly, or push/pop the
framebuffer of a given view where the code has not yet changed to use
the explicit-buffer-using cogl API.

Currently only the nested X11 backend supports this mode fully, and the
per view framebuffers are all offscreen. Upon frame completion, it'll
blit each view's framebuffer onto the onscreen framebuffer before
swapping.

Other backends (X11 CM and native/KMS) are adapted to manage a
full-stage view. The X11 CM backend will continue to use this method,
while the native/KMS backend will be adopted to use multiple view
drawing.

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

src/backends/meta-backend-private.h

@@ -106,6 +106,8 @@ struct _MetaBackendClass
 
 void meta_init_backend (MetaBackendType backend_type);
 
+ClutterBackend * meta_backend_get_clutter_backend (MetaBackend *backend);
+
 MetaIdleMonitor * meta_backend_get_idle_monitor (MetaBackend *backend,
                                                  int          device_id);
 MetaMonitorManager * meta_backend_get_monitor_manager (MetaBackend *backend);

src/backends/meta-renderer-view.c

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2016 Red Hat Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "backends/meta-renderer-view.h"
+
+#include "backends/meta-renderer.h"
+#include "clutter/clutter-mutter.h"
+
+struct _MetaRendererView
+{
+  ClutterStageView parent;
+
+  MetaMonitorInfo *monitor_info;
+};
+
+G_DEFINE_TYPE (MetaRendererView, meta_renderer_view,
+               CLUTTER_TYPE_STAGE_VIEW_COGL)
+
+static void
+meta_renderer_view_init (MetaRendererView *view)
+{
+}
+
+static void
+meta_renderer_view_class_init (MetaRendererViewClass *klass)
+{
+}

src/backends/meta-renderer-view.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2016 Red Hat Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef META_RENDERER_VIEW_H
+#define META_RENDERER_VIEW_H
+
+#include "backends/meta-monitor-manager-private.h"
+#include "clutter/clutter-mutter.h"
+
+#define META_TYPE_RENDERER_VIEW (meta_renderer_view_get_type ())
+G_DECLARE_FINAL_TYPE (MetaRendererView, meta_renderer_view,
+                      META, RENDERER_VIEW,
+                      ClutterStageViewCogl)
+
+#endif /* META_RENDERER_VIEW_H */

src/backends/meta-renderer.c

@@ -26,9 +26,15 @@
 
 #include <glib-object.h>
 
+#include "backends/meta-backend-private.h"
 #include "backends/meta-renderer.h"
 
-G_DEFINE_TYPE (MetaRenderer, meta_renderer, G_TYPE_OBJECT)
+typedef struct _MetaRendererPrivate
+{
+  GList *views;
+} MetaRendererPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (MetaRenderer, meta_renderer, G_TYPE_OBJECT)
 
 CoglRenderer *
 meta_renderer_create_cogl_renderer (MetaRenderer *renderer)
@@ -36,6 +42,69 @@ meta_renderer_create_cogl_renderer (MetaRenderer *renderer)
   return META_RENDERER_GET_CLASS (renderer)->create_cogl_renderer (renderer);
 }
 
+static MetaRendererView *
+meta_renderer_create_view (MetaRenderer    *renderer,
+                           MetaMonitorInfo *monitor_info)
+{
+  return META_RENDERER_GET_CLASS (renderer)->create_view (renderer,
+                                                          monitor_info);
+}
+
+void
+meta_renderer_rebuild_views (MetaRenderer *renderer)
+{
+  MetaRendererPrivate *priv = meta_renderer_get_instance_private (renderer);
+  MetaBackend *backend = meta_get_backend ();
+  MetaMonitorManager *monitor_manager =
+    meta_backend_get_monitor_manager (backend);
+  MetaMonitorInfo *monitor_infos;
+  unsigned int num_monitor_infos;
+  unsigned int i;
+
+  g_list_free_full (priv->views, g_object_unref);
+  priv->views = NULL;
+
+  monitor_infos = meta_monitor_manager_get_monitor_infos (monitor_manager,
+                                                          &num_monitor_infos);
+
+  for (i = 0; i < num_monitor_infos; i++)
+    {
+      MetaRendererView *view;
+
+      view = meta_renderer_create_view (renderer, &monitor_infos[i]);
+      priv->views = g_list_append (priv->views, view);
+    }
+}
+
+void
+meta_renderer_set_legacy_view (MetaRenderer     *renderer,
+                               MetaRendererView *legacy_view)
+{
+  MetaRendererPrivate *priv = meta_renderer_get_instance_private (renderer);
+
+  g_assert (!priv->views);
+
+  priv->views = g_list_append (priv->views, legacy_view);
+}
+
+GList *
+meta_renderer_get_views (MetaRenderer *renderer)
+{
+  MetaRendererPrivate *priv = meta_renderer_get_instance_private (renderer);
+
+  return priv->views;
+}
+
+static void
+meta_renderer_finalize (GObject *object)
+{
+  MetaRenderer *renderer = META_RENDERER (object);
+  MetaRendererPrivate *priv = meta_renderer_get_instance_private (renderer);
+
+  g_list_free_full (priv->views, g_object_unref);
+  priv->views = NULL;
+}
+
 static void
 meta_renderer_init (MetaRenderer *renderer)
 {
@@ -44,4 +113,7 @@ meta_renderer_init (MetaRenderer *renderer)
 static void
 meta_renderer_class_init (MetaRendererClass *klass)
 {
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize = meta_renderer_finalize;
 }

src/backends/meta-renderer.h

@@ -28,6 +28,9 @@
 #include <glib-object.h>
 
 #include "cogl/cogl.h"
+#include "clutter/clutter-mutter.h"
+#include "backends/meta-monitor-manager-private.h"
+#include "backends/meta-renderer-view.h"
 
 #define META_TYPE_RENDERER (meta_renderer_get_type ())
 G_DECLARE_DERIVABLE_TYPE (MetaRenderer, meta_renderer, META, RENDERER, GObject)
@@ -37,8 +40,17 @@ struct _MetaRendererClass
   GObjectClass parent_class;
 
   CoglRenderer * (* create_cogl_renderer) (MetaRenderer *renderer);
+  MetaRendererView * (* create_view) (MetaRenderer    *renderer,
+                                      MetaMonitorInfo *monitor_info);
 };
 
 CoglRenderer * meta_renderer_create_cogl_renderer (MetaRenderer *renderer);
 
+void meta_renderer_rebuild_views (MetaRenderer *renderer);
+
+void meta_renderer_set_legacy_view (MetaRenderer     *renderer,
+                                    MetaRendererView *legacy_view);
+
+GList * meta_renderer_get_views (MetaRenderer *renderer);
+
 #endif /* META_RENDERER_H */

src/backends/meta-stage.c

@@ -25,7 +25,10 @@
 #include "meta-stage.h"
 
 #include <meta/meta-backend.h>
+#include <meta/meta-monitor-manager.h>
 #include <meta/util.h>
+#include "backends/meta-backend-private.h"
+#include "clutter/clutter-mutter.h"
 
 struct _MetaOverlay {
   gboolean enabled;

src/backends/meta-stage.h

@@ -63,6 +63,9 @@ void              meta_stage_update_cursor_overlay   (MetaStage     *stage,
 
 void meta_stage_set_active (MetaStage *stage,
                             gboolean   is_active);
+
+void meta_stage_update_view_layout (MetaStage *stage);
+
 G_END_DECLS
 
 #endif /* META_STAGE_H */

src/backends/native/meta-backend-native.c

@@ -38,8 +38,10 @@
 #include "meta-launcher.h"
 #include "backends/meta-cursor-tracker-private.h"
 #include "backends/meta-pointer-constraint.h"
+#include "backends/meta-stage.h"
 #include "backends/native/meta-clutter-backend-native.h"
 #include "backends/native/meta-renderer-native.h"
+#include "backends/native/meta-stage-native.h"
 
 #include <stdlib.h>
 
@@ -383,8 +385,13 @@ static void
 meta_backend_native_update_screen_size (MetaBackend *backend,
                                         int width, int height)
 {
+  ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
+  MetaStageNative *stage_native;
   ClutterActor *stage = meta_backend_get_stage (backend);
 
+  stage_native = meta_clutter_backend_native_get_stage_native (clutter_backend);
+  meta_stage_native_legacy_set_size (stage_native, width, height);
+
   clutter_actor_set_size (stage, width, height);
 }
 

src/backends/native/meta-clutter-backend-native.c

@@ -36,11 +36,22 @@
 struct _MetaClutterBackendNative
 {
   ClutterBackendEglNative parent;
+
+  MetaStageNative *stage_native;
 };
 
 G_DEFINE_TYPE (MetaClutterBackendNative, meta_clutter_backend_native,
                CLUTTER_TYPE_BACKEND_EGL_NATIVE)
 
+MetaStageNative *
+meta_clutter_backend_native_get_stage_native (ClutterBackend *backend)
+{
+  MetaClutterBackendNative *clutter_backend_native =
+    META_CLUTTER_BACKEND_NATIVE (backend);
+
+  return clutter_backend_native->stage_native;
+}
+
 static CoglRenderer *
 meta_clutter_backend_native_get_renderer (ClutterBackend  *clutter_backend,
                                           GError         **error)
@@ -56,10 +67,16 @@ meta_clutter_backend_native_create_stage (ClutterBackend  *backend,
                                           ClutterStage    *wrapper,
                                           GError         **error)
 {
-  return g_object_new (META_TYPE_STAGE_NATIVE,
-                       "backend", backend,
-                       "wrapper", wrapper,
-                       NULL);
+  MetaClutterBackendNative *clutter_backend_native =
+    META_CLUTTER_BACKEND_NATIVE (backend);
+
+  g_assert (!clutter_backend_native->stage_native);
+
+  clutter_backend_native->stage_native = g_object_new (META_TYPE_STAGE_NATIVE,
+                                                       "backend", backend,
+                                                       "wrapper", wrapper,
+                                                       NULL);
+  return CLUTTER_STAGE_WINDOW (clutter_backend_native->stage_native);
 }
 
 static void

src/backends/native/meta-clutter-backend-native.h

@@ -29,10 +29,13 @@
 
 #include "clutter/clutter.h"
 #include "clutter/egl/clutter-backend-eglnative.h"
+#include "backends/native/meta-stage-native.h"
 
 #define META_TYPE_CLUTTER_BACKEND_NATIVE (meta_clutter_backend_native_get_type ())
 G_DECLARE_FINAL_TYPE (MetaClutterBackendNative, meta_clutter_backend_native,
                       META, CLUTTER_BACKEND_NATIVE,
                       ClutterBackendEglNative)
 
+MetaStageNative * meta_clutter_backend_native_get_stage_native (ClutterBackend *backend);
+
 #endif /* META_CLUTTER_BACKEND_NATIVE_H */

src/backends/native/meta-stage-native.c

@@ -35,7 +35,7 @@ struct _MetaStageNative
 {
   ClutterStageCogl parent;
 
-  CoglOnscreen *onscreen;
+  CoglOnscreen *pending_onscreen;
 };
 
 static ClutterStageWindowIface *clutter_stage_window_parent_iface = NULL;
@@ -47,19 +47,79 @@ G_DEFINE_TYPE_WITH_CODE (MetaStageNative, meta_stage_native,
                          CLUTTER_TYPE_STAGE_COGL,
                          G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_STAGE_WINDOW,
                                                 clutter_stage_window_iface_init))
+
+static MetaRendererView *
+get_legacy_view (MetaRenderer *renderer)
+{
+  GList *views;
+
+  views = meta_renderer_get_views (renderer);
+  g_assert (g_list_length (views) <= 1);
+
+  if (views)
+    return views->data;
+  else
+    return NULL;
+}
+
+static CoglOnscreen *
+get_legacy_onscreen (MetaStageNative *stage_native)
+{
+  if (stage_native->pending_onscreen)
+    {
+      return stage_native->pending_onscreen;
+    }
+  else
+    {
+      MetaBackend *backend = meta_get_backend ();
+      MetaRenderer *renderer = meta_backend_get_renderer (backend);
+      ClutterStageView *stage_view;
+      CoglFramebuffer *framebuffer;
+
+      stage_view = CLUTTER_STAGE_VIEW (get_legacy_view (renderer));
+      framebuffer = clutter_stage_view_get_framebuffer (stage_view);
+
+      return COGL_ONSCREEN (framebuffer);
+    }
+}
+
+void
+meta_stage_native_legacy_set_size (MetaStageNative *stage_native,
+                                   int              width,
+                                   int              height)
+{
+  MetaBackend *backend = meta_get_backend ();
+  MetaRenderer *renderer = meta_backend_get_renderer (backend);
+  MetaRendererView *legacy_view;
+  cairo_rectangle_int_t view_layout;
+
+  legacy_view = get_legacy_view (renderer);
+  if (!legacy_view)
+    return;
+
+  view_layout = (cairo_rectangle_int_t) {
+    .width = width,
+    .height = height
+  };
+  g_object_set (G_OBJECT (legacy_view),
+                "layout", &view_layout,
+                NULL);
+}
+
 static gboolean
 meta_stage_native_realize (ClutterStageWindow *stage_window)
 {
   MetaStageNative *stage_native = META_STAGE_NATIVE (stage_window);
-  ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_window);
-  ClutterBackend *clutter_backend = CLUTTER_BACKEND (stage_cogl->backend);
+  MetaBackend *backend = meta_get_backend ();
+  ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
+  CoglFramebuffer *framebuffer;
   GError *error = NULL;
 
-  stage_native->onscreen = cogl_onscreen_new (clutter_backend->cogl_context,
-                                              1, 1);
+  stage_native->pending_onscreen =
+    cogl_onscreen_new (clutter_backend->cogl_context, 1, 1);
 
-  if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (stage_native->onscreen),
-                                  &error))
+  framebuffer = COGL_FRAMEBUFFER (stage_native->pending_onscreen);
+  if (!cogl_framebuffer_allocate (framebuffer, &error))
     meta_fatal ("Failed to allocate onscreen framebuffer: %s\n",
                 error->message);
 
@@ -76,7 +136,7 @@ meta_stage_native_unrealize (ClutterStageWindow *stage_window)
 
   clutter_stage_window_parent_iface->unrealize (stage_window);
 
-  g_clear_pointer (&stage_native->onscreen, cogl_object_unref);
+  g_clear_pointer (&stage_native->pending_onscreen, cogl_object_unref);
 }
 
 static gboolean
@@ -89,15 +149,15 @@ static void
 meta_stage_native_get_geometry (ClutterStageWindow    *stage_window,
                                 cairo_rectangle_int_t *geometry)
 {
-  MetaStageNative *stage_native = META_STAGE_NATIVE (stage_window);
-  CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (stage_native->onscreen);
+  MetaBackend *backend = meta_get_backend ();
+  MetaRenderer *renderer = meta_backend_get_renderer (backend);
+  MetaRendererView *legacy_view;
 
-  if (framebuffer)
+  legacy_view = get_legacy_view (renderer);
+  if (legacy_view)
     {
-      *geometry = (cairo_rectangle_int_t) {
-        .width = cogl_framebuffer_get_width (framebuffer),
-        .height = cogl_framebuffer_get_height (framebuffer)
-      };
+      clutter_stage_view_get_layout (CLUTTER_STAGE_VIEW (legacy_view),
+                                     geometry);
     }
   else
     {
@@ -108,12 +168,44 @@ meta_stage_native_get_geometry (ClutterStageWindow    *stage_window,
     }
 }
 
-static CoglFramebuffer *
-meta_stage_native_get_legacy_onscreen (ClutterStageWindow *stage_window)
+static void
+ensure_legacy_view (ClutterStageWindow *stage_window)
 {
   MetaStageNative *stage_native = META_STAGE_NATIVE (stage_window);
+  MetaBackend *backend = meta_get_backend ();
+  MetaRenderer *renderer = meta_backend_get_renderer (backend);
+  MetaMonitorManager *monitor_manager =
+    meta_backend_get_monitor_manager (backend);
+  MetaRendererView *legacy_view;
+  cairo_rectangle_int_t view_layout = { 0 };
+  CoglFramebuffer *framebuffer;
 
-  return COGL_FRAMEBUFFER (stage_native->onscreen);
+  legacy_view = get_legacy_view (renderer);
+  if (legacy_view)
+    return;
+
+  if (!monitor_manager)
+    return;
+
+  meta_monitor_manager_get_screen_size (monitor_manager,
+                                        &view_layout.width,
+                                        &view_layout.height);
+  framebuffer = g_steal_pointer (&stage_native->pending_onscreen);
+  legacy_view = g_object_new (META_TYPE_RENDERER_VIEW,
+                              "layout", &view_layout,
+                              "framebuffer", framebuffer,
+                              NULL);
+  meta_renderer_set_legacy_view (renderer, legacy_view);
+}
+
+static GList *
+meta_stage_native_get_views (ClutterStageWindow *stage_window)
+{
+  MetaBackend *backend = meta_get_backend ();
+  MetaRenderer *renderer = meta_backend_get_renderer (backend);
+
+  ensure_legacy_view (stage_window);
+  return meta_renderer_get_views (renderer);
 }
 
 static CoglClosure *
@@ -122,11 +214,13 @@ meta_stage_native_set_frame_callback (ClutterStageWindow *stage_window,
                                       gpointer            user_data)
 {
   MetaStageNative *stage_native = META_STAGE_NATIVE (stage_window);
+  CoglOnscreen *legacy_onscreen;
 
-  cogl_onscreen_set_swap_throttled (stage_native->onscreen,
+  legacy_onscreen = get_legacy_onscreen (stage_native);
+  cogl_onscreen_set_swap_throttled (legacy_onscreen,
                                     _clutter_get_sync_to_vblank ());
 
-  return cogl_onscreen_add_frame_callback (stage_native->onscreen,
+  return cogl_onscreen_add_frame_callback (legacy_onscreen,
                                            callback,
                                            user_data,
                                            NULL);
@@ -137,16 +231,22 @@ meta_stage_native_remove_frame_callback (ClutterStageWindow *stage_window,
                                          CoglFrameClosure   *closure)
 {
   MetaStageNative *stage_native = META_STAGE_NATIVE (stage_window);
+  CoglOnscreen *legacy_onscreen;
 
-  cogl_onscreen_remove_frame_callback (stage_native->onscreen, closure);
+  legacy_onscreen = get_legacy_onscreen (stage_native);
+
+  cogl_onscreen_remove_frame_callback (legacy_onscreen, closure);
 }
 
 static int64_t
 meta_stage_native_get_frame_counter (ClutterStageWindow *stage_window)
 {
   MetaStageNative *stage_native = META_STAGE_NATIVE (stage_window);
+  CoglOnscreen *legacy_onscreen;
 
-  return cogl_onscreen_get_frame_counter (stage_native->onscreen);
+  legacy_onscreen = get_legacy_onscreen (stage_native);
+
+  return cogl_onscreen_get_frame_counter (legacy_onscreen);
 }
 
 static void
@@ -168,7 +268,7 @@ clutter_stage_window_iface_init (ClutterStageWindowIface *iface)
   iface->unrealize = meta_stage_native_unrealize;
   iface->can_clip_redraws = meta_stage_native_can_clip_redraws;
   iface->get_geometry = meta_stage_native_get_geometry;
-  iface->get_legacy_onscreen = meta_stage_native_get_legacy_onscreen;
+  iface->get_views = meta_stage_native_get_views;
   iface->set_frame_callback = meta_stage_native_set_frame_callback;
   iface->remove_frame_callback = meta_stage_native_remove_frame_callback;
   iface->get_frame_counter = meta_stage_native_get_frame_counter;

src/backends/native/meta-stage-native.h

@@ -31,4 +31,8 @@
 G_DECLARE_FINAL_TYPE (MetaStageNative, meta_stage_native,
                       META, STAGE_NATIVE, ClutterStageCogl)
 
+void meta_stage_native_legacy_set_size (MetaStageNative *stage_native,
+                                        int              width,
+                                        int              height);
+
 #endif /* META_STAGE_NATIVE_H */

src/backends/x11/meta-backend-x11.c

@@ -41,6 +41,7 @@
 #include "meta-idle-monitor-xsync.h"
 #include "meta-monitor-manager-xrandr.h"
 #include "backends/meta-monitor-manager-dummy.h"
+#include "backends/meta-stage.h"
 #include "backends/x11/nested/meta-cursor-renderer-x11-nested.h"
 #include "backends/x11/meta-clutter-backend-x11.h"
 #include "backends/x11/meta-renderer-x11.h"
@@ -814,7 +815,9 @@ meta_backend_x11_update_screen_size (MetaBackend *backend,
   if (priv->mode == META_BACKEND_X11_MODE_NESTED)
     {
       ClutterActor *stage = meta_backend_get_stage (backend);
+      MetaRenderer *renderer = meta_backend_get_renderer (backend);
 
+      meta_renderer_rebuild_views (renderer);
       clutter_actor_set_size (stage, width, height);
     }
   else

src/backends/x11/meta-renderer-x11.c

@@ -31,8 +31,12 @@
 #include "cogl/cogl-xlib.h"
 #include "cogl/winsys/cogl-winsys-glx-private.h"
 #include "cogl/winsys/cogl-winsys-egl-x11-private.h"
+#include "backends/meta-backend-private.h"
 #include "backends/meta-renderer.h"
+#include "backends/meta-renderer-view.h"
 #include "backends/x11/meta-renderer-x11.h"
+#include "core/boxes-private.h"
+#include "meta/meta-backend.h"
 #include "meta/util.h"
 
 struct _MetaRendererX11
@@ -64,6 +68,32 @@ meta_renderer_x11_create_cogl_renderer (MetaRenderer *renderer)
   return cogl_renderer;
 }
 
+static MetaRendererView *
+meta_renderer_x11_create_view (MetaRenderer    *renderer,
+                               MetaMonitorInfo *monitor_info)
+{
+  MetaBackend *backend = meta_get_backend ();
+  ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
+  CoglContext *cogl_context = clutter_backend_get_cogl_context (clutter_backend);
+  int width, height;
+  cairo_rectangle_int_t view_layout;
+  CoglTexture2D *texture_2d;
+  CoglOffscreen *offscreen;
+
+  g_assert (meta_is_wayland_compositor ());
+
+  width = monitor_info->rect.width;
+  height = monitor_info->rect.height;
+  texture_2d = cogl_texture_2d_new_with_size (cogl_context, width, height);
+  offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (texture_2d));
+  view_layout = meta_rectangle_to_cairo_rectangle (&monitor_info->rect);
+
+  return g_object_new (META_TYPE_RENDERER_VIEW,
+                       "layout", &view_layout,
+                       "framebuffer", COGL_FRAMEBUFFER (offscreen),
+                       NULL);
+}
+
 static void
 meta_renderer_x11_init (MetaRendererX11 *renderer_x11)
 {
@@ -75,4 +105,5 @@ meta_renderer_x11_class_init (MetaRendererX11Class *klass)
   MetaRendererClass *renderer_class = META_RENDERER_CLASS (klass);
 
   renderer_class->create_cogl_renderer = meta_renderer_x11_create_cogl_renderer;
+  renderer_class->create_view = meta_renderer_x11_create_view;
 }

src/backends/x11/meta-stage-x11-nested.c

@@ -26,13 +26,127 @@
 
 #include "backends/x11/meta-stage-x11-nested.h"
 
+#include "backends/meta-backend-private.h"
+#include "backends/meta-renderer.h"
+#include "clutter/clutter-mutter.h"
+
+static ClutterStageWindowIface *clutter_stage_window_parent_iface = NULL;
+
 struct _MetaStageX11Nested
 {
   ClutterStageX11 parent;
+
+  CoglPipeline *pipeline;
+  GList *views;
 };
 
-G_DEFINE_TYPE (MetaStageX11Nested, meta_stage_x11_nested,
-               CLUTTER_TYPE_STAGE_X11)
+static void
+clutter_stage_window_iface_init (ClutterStageWindowIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (MetaStageX11Nested, meta_stage_x11_nested,
+                         CLUTTER_TYPE_STAGE_X11,
+                         G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_STAGE_WINDOW,
+                                                clutter_stage_window_iface_init))
+
+typedef struct _ClutterStageX11View
+{
+  CoglTexture *texture;
+  ClutterStageViewCogl *view;
+} MetaStageX11NestedView;
+
+static gboolean
+meta_stage_x11_nested_can_clip_redraws (ClutterStageWindow *stage_window)
+{
+  return FALSE;
+}
+
+static GList *
+meta_stage_x11_nested_get_views (ClutterStageWindow *stage_window)
+{
+  MetaBackend *backend = meta_get_backend ();
+  MetaRenderer *renderer = meta_backend_get_renderer (backend);
+
+  return meta_renderer_get_views (renderer);
+}
+
+static void
+meta_stage_x11_nested_finish_frame (ClutterStageWindow *stage_window)
+{
+  MetaStageX11Nested *stage_nested = META_STAGE_X11_NESTED (stage_window);
+  ClutterStageX11 *stage_x11 = CLUTTER_STAGE_X11 (stage_window);
+  MetaBackend *backend = meta_get_backend ();
+  MetaRenderer *renderer = meta_backend_get_renderer (backend);
+  ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
+  CoglFramebuffer *onscreen = COGL_FRAMEBUFFER (stage_x11->onscreen);
+  GList *l;
+
+  if (!stage_nested->pipeline)
+    stage_nested->pipeline = cogl_pipeline_new (clutter_backend->cogl_context);
+
+  cogl_framebuffer_clear4f (onscreen,
+                            COGL_BUFFER_BIT_COLOR,
+                            0.0f, 0.0f, 0.0f, 1.0f);
+
+  for (l = meta_renderer_get_views (renderer); l; l = l->next)
+    {
+      ClutterStageView *view = l->data;
+      cairo_rectangle_int_t view_layout;
+      CoglFramebuffer *framebuffer;
+      CoglTexture *texture;
+
+      clutter_stage_view_get_layout (view, &view_layout);
+
+      framebuffer = clutter_stage_view_get_framebuffer (view);
+      texture = cogl_offscreen_get_texture (COGL_OFFSCREEN (framebuffer));
+      cogl_framebuffer_set_viewport (onscreen,
+                                     view_layout.x,
+                                     view_layout.y,
+                                     view_layout.width,
+                                     view_layout.height);
+      cogl_pipeline_set_layer_texture (stage_nested->pipeline, 0, texture);
+      cogl_framebuffer_draw_rectangle (onscreen,
+                                       stage_nested->pipeline,
+                                       -1, 1, 1, -1);
+    }
+
+  cogl_onscreen_swap_buffers (stage_x11->onscreen);
+}
+
+static void
+meta_stage_x11_nested_unrealize (ClutterStageWindow *stage_window)
+{
+  MetaStageX11Nested *stage_nested = META_STAGE_X11_NESTED (stage_window);
+  ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_window);
+  MetaBackend *backend = meta_get_backend ();
+  MetaRenderer *renderer = meta_backend_get_renderer (backend);
+  GList *l;
+
+  /* Clutter still uses part of the deprecated stateful API of Cogl
+   * (in particulart cogl_set_framebuffer). It means Cogl can keep an
+   * internal reference to the onscreen object we rendered to. In the
+   * case of foreign window, we want to avoid this, as we don't know
+   * what's going to happen to that window.
+   *
+   * The following call sets the current Cogl framebuffer to a dummy
+   * 1x1 one if we're unrealizing the current one, so Cogl doesn't
+   * keep any reference to the foreign window.
+   */
+  for (l = meta_renderer_get_views (renderer); l ;l = l->next)
+    {
+      ClutterStageView *view = l->data;
+      CoglFramebuffer *framebuffer = clutter_stage_view_get_framebuffer (view);
+
+      if (cogl_get_draw_framebuffer () == framebuffer)
+        {
+          _clutter_backend_reset_cogl_framebuffer (stage_cogl->backend);
+          break;
+        }
+    }
+
+  g_clear_pointer (&stage_nested->pipeline, cogl_object_unref);
+
+  clutter_stage_window_parent_iface->unrealize (stage_window);
+}
 
 static void
 meta_stage_x11_nested_init (MetaStageX11Nested *stage_x11_nested)
@@ -43,3 +157,15 @@ static void
 meta_stage_x11_nested_class_init (MetaStageX11NestedClass *klass)
 {
 }
+
+static void
+clutter_stage_window_iface_init (ClutterStageWindowIface *iface)
+{
+  clutter_stage_window_parent_iface = g_type_interface_peek_parent (iface);
+
+  iface->can_clip_redraws = meta_stage_x11_nested_can_clip_redraws;
+  iface->unrealize = meta_stage_x11_nested_unrealize;
+  iface->get_views = meta_stage_x11_nested_get_views;
+  iface->finish_frame = meta_stage_x11_nested_finish_frame;
+}
+