[mutter/wip/nielsdg/more-declarable-types: 16/16] Use G_DECLARE_DERIVABLE/FINAL_TYPE on some types



commit 262acf560621717f036d2cb64f19c2b1b084bef7
Author: Niels De Graef <Niels DeGraef barco com>
Date:   Wed Oct 31 11:47:17 2018 +0100

    Use G_DECLARE_DERIVABLE/FINAL_TYPE on some types
    
    This is only for types in the `Meta` namespace.
    
    * Clears up a lot of boilerplate
    * We get `g_autoptr` support for free

 src/backends/meta-barrier-private.h          |  21 +-
 src/backends/meta-cursor-tracker-private.h   |   4 -
 src/backends/native/meta-barrier-native.c    |  95 ++---
 src/backends/native/meta-barrier-native.h    |  26 +-
 src/backends/x11/meta-barrier-x11.c          |  39 +-
 src/backends/x11/meta-barrier-x11.h          |  27 +-
 src/compositor/meta-background-actor.c       | 261 ++++++------
 src/compositor/meta-background-group.c       |   5 +
 src/compositor/meta-background-image.c       |  22 +-
 src/compositor/meta-background.c             | 203 ++++-----
 src/compositor/meta-cullable.h               |  11 +-
 src/compositor/meta-dnd-actor-private.h      |  26 +-
 src/compositor/meta-dnd-actor.c              |  32 +-
 src/compositor/meta-feedback-actor-private.h |  19 +-
 src/compositor/meta-shadow-factory.c         |   8 +
 src/compositor/meta-shaped-texture.c         | 355 +++++++---------
 src/compositor/meta-surface-actor-wayland.c  |  50 +--
 src/compositor/meta-surface-actor-wayland.h  |  26 +-
 src/compositor/meta-surface-actor-x11.c      | 149 +++----
 src/compositor/meta-surface-actor-x11.h      |  26 +-
 src/compositor/meta-surface-actor.c          |  60 ++-
 src/compositor/meta-surface-actor.h          |  24 +-
 src/compositor/meta-window-actor.c           | 591 ++++++++++++---------------
 src/meta/meta-background-actor.h             |  29 +-
 src/meta/meta-background-group.h             |  31 +-
 src/meta/meta-background-image.h             |  43 +-
 src/meta/meta-background.h                   |  29 +-
 src/meta/meta-cursor-tracker.h               |  14 +-
 src/meta/meta-shadow-factory.h               |  23 +-
 src/meta/meta-shaped-texture.h               |  36 +-
 src/meta/meta-window-actor.h                 |  32 +-
 src/meta/meta-window-group.h                 |   5 +-
 src/meta/meta-workspace-manager.h            |   5 +-
 33 files changed, 927 insertions(+), 1400 deletions(-)
---
diff --git a/src/backends/meta-barrier-private.h b/src/backends/meta-barrier-private.h
index e5022ef16..d0483e43c 100644
--- a/src/backends/meta-barrier-private.h
+++ b/src/backends/meta-barrier-private.h
@@ -31,20 +31,11 @@
 
 G_BEGIN_DECLS
 
-#define META_TYPE_BARRIER_IMPL            (meta_barrier_impl_get_type ())
-#define META_BARRIER_IMPL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_BARRIER_IMPL, 
MetaBarrierImpl))
-#define META_BARRIER_IMPL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_BARRIER_IMPL, 
MetaBarrierImplClass))
-#define META_IS_BARRIER_IMPL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_BARRIER_IMPL))
-#define META_IS_BARRIER_IMPL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_BARRIER_IMPL))
-#define META_BARRIER_IMPL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_BARRIER_IMPL, 
MetaBarrierImplClass))
-
-typedef struct _MetaBarrierImpl        MetaBarrierImpl;
-typedef struct _MetaBarrierImplClass   MetaBarrierImplClass;
-
-struct _MetaBarrierImpl
-{
-  GObject parent;
-};
+#define META_TYPE_BARRIER_IMPL (meta_barrier_impl_get_type ())
+G_DECLARE_DERIVABLE_TYPE (MetaBarrierImpl,
+                          meta_barrier_impl,
+                          META, BARRIER_IMPL,
+                          GObject)
 
 struct _MetaBarrierImplClass
 {
@@ -56,8 +47,6 @@ struct _MetaBarrierImplClass
   void (*destroy) (MetaBarrierImpl *barrier);
 };
 
-GType meta_barrier_impl_get_type (void) G_GNUC_CONST;
-
 void _meta_barrier_emit_hit_signal (MetaBarrier      *barrier,
                                     MetaBarrierEvent *event);
 void _meta_barrier_emit_left_signal (MetaBarrier      *barrier,
diff --git a/src/backends/meta-cursor-tracker-private.h b/src/backends/meta-cursor-tracker-private.h
index 95ff6d740..29ee94044 100644
--- a/src/backends/meta-cursor-tracker-private.h
+++ b/src/backends/meta-cursor-tracker-private.h
@@ -49,10 +49,6 @@ struct _MetaCursorTracker {
   MetaCursorSpriteXfixes *xfixes_cursor;
 };
 
-struct _MetaCursorTrackerClass {
-  GObjectClass parent_class;
-};
-
 gboolean meta_cursor_tracker_handle_xevent (MetaCursorTracker *tracker,
                                            XEvent            *xevent);
 
diff --git a/src/backends/native/meta-barrier-native.c b/src/backends/native/meta-barrier-native.c
index d335cbc17..b030921f9 100644
--- a/src/backends/native/meta-barrier-native.c
+++ b/src/backends/native/meta-barrier-native.c
@@ -65,8 +65,10 @@ typedef enum {
   META_BARRIER_STATE_LEFT,
 } MetaBarrierState;
 
-struct _MetaBarrierImplNativePrivate
+struct _MetaBarrierImplNative
 {
+  MetaBarrierImpl parent;
+
   MetaBarrier              *barrier;
   MetaBarrierManagerNative *manager;
 
@@ -77,8 +79,9 @@ struct _MetaBarrierImplNativePrivate
   MetaBarrierDirection      blocked_dir;
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (MetaBarrierImplNative, meta_barrier_impl_native,
-                            META_TYPE_BARRIER_IMPL)
+G_DEFINE_TYPE (MetaBarrierImplNative,
+               meta_barrier_impl_native,
+               META_TYPE_BARRIER_IMPL)
 
 static int
 next_serial (void)
@@ -111,10 +114,7 @@ is_barrier_blocking_directions (MetaBarrier         *barrier,
 static void
 dismiss_pointer (MetaBarrierImplNative *self)
 {
-  MetaBarrierImplNativePrivate *priv =
-    meta_barrier_impl_native_get_instance_private (self);
-
-  priv->state = META_BARRIER_STATE_LEFT;
+  self->state = META_BARRIER_STATE_LEFT;
 }
 
 /*
@@ -164,13 +164,11 @@ maybe_release_barrier (gpointer key,
                        gpointer user_data)
 {
   MetaBarrierImplNative *self = key;
-  MetaBarrierImplNativePrivate *priv =
-    meta_barrier_impl_native_get_instance_private (self);
-  MetaBarrier *barrier = priv->barrier;
+  MetaBarrier *barrier = self->barrier;
   MetaLine2 *motion = user_data;
   MetaLine2 hit_box;
 
-  if (priv->state != META_BARRIER_STATE_HELD)
+  if (self->state != META_BARRIER_STATE_HELD)
     return;
 
   /* Release if we end up outside barrier end points. */
@@ -250,9 +248,7 @@ update_closest_barrier (gpointer key,
                         gpointer user_data)
 {
   MetaBarrierImplNative *self = key;
-  MetaBarrierImplNativePrivate *priv =
-    meta_barrier_impl_native_get_instance_private (self);
-  MetaBarrier *barrier = priv->barrier;
+  MetaBarrier *barrier = self->barrier;
   MetaClosestBarrierData *data = user_data;
   MetaVector2 intersection;
   float dx, dy;
@@ -263,12 +259,12 @@ update_closest_barrier (gpointer key,
     return;
 
   /* Ignore if the barrier released the pointer. */
-  if (priv->state == META_BARRIER_STATE_RELEASE)
+  if (self->state == META_BARRIER_STATE_RELEASE)
     return;
 
   /* Ignore if we are moving away from barrier. */
-  if (priv->state == META_BARRIER_STATE_HELD &&
-      (data->in.directions & priv->blocked_dir) == 0)
+  if (self->state == META_BARRIER_STATE_HELD &&
+      (data->in.directions & self->blocked_dir) == 0)
     return;
 
   /* Check if the motion intersects with the barrier, and retrieve the
@@ -354,27 +350,25 @@ emit_barrier_event (MetaBarrierImplNative *self,
                     float                  dx,
                     float                  dy)
 {
-  MetaBarrierImplNativePrivate *priv =
-    meta_barrier_impl_native_get_instance_private (self);
-  MetaBarrier *barrier = priv->barrier;
+  MetaBarrier *barrier = self->barrier;
   MetaBarrierEvent *event = g_slice_new0 (MetaBarrierEvent);
-  MetaBarrierState old_state = priv->state;
+  MetaBarrierState old_state = self->state;
 
-  switch (priv->state)
+  switch (self->state)
     {
     case META_BARRIER_STATE_HIT:
-      priv->state = META_BARRIER_STATE_HELD;
-      priv->trigger_serial = next_serial ();
+      self->state = META_BARRIER_STATE_HELD;
+      self->trigger_serial = next_serial ();
       event->dt = 0;
 
       break;
     case META_BARRIER_STATE_RELEASE:
     case META_BARRIER_STATE_LEFT:
-      priv->state = META_BARRIER_STATE_ACTIVE;
+      self->state = META_BARRIER_STATE_ACTIVE;
 
       /* Intentional fall-through. */
     case META_BARRIER_STATE_HELD:
-      event->dt = time - priv->last_event_time;
+      event->dt = time - self->last_event_time;
 
       break;
     case META_BARRIER_STATE_ACTIVE:
@@ -382,7 +376,7 @@ emit_barrier_event (MetaBarrierImplNative *self,
     }
 
   event->ref_count = 1;
-  event->event_id = priv->trigger_serial;
+  event->event_id = self->trigger_serial;
   event->time = time;
 
   event->x = x;
@@ -390,12 +384,12 @@ emit_barrier_event (MetaBarrierImplNative *self,
   event->dx = dx;
   event->dy = dy;
 
-  event->grabbed = priv->state == META_BARRIER_STATE_HELD;
+  event->grabbed = self->state == META_BARRIER_STATE_HELD;
   event->released = old_state == META_BARRIER_STATE_RELEASE;
 
-  priv->last_event_time = time;
+  self->last_event_time = time;
 
-  if (priv->state == META_BARRIER_STATE_HELD)
+  if (self->state == META_BARRIER_STATE_HELD)
     _meta_barrier_emit_hit_signal (barrier, event);
   else
     _meta_barrier_emit_left_signal (barrier, event);
@@ -407,11 +401,10 @@ static void
 maybe_emit_barrier_event (gpointer key, gpointer value, gpointer user_data)
 {
   MetaBarrierImplNative *self = key;
-  MetaBarrierImplNativePrivate *priv =
-    meta_barrier_impl_native_get_instance_private (self);
   MetaBarrierEventData *data = user_data;
 
-  switch (priv->state) {
+  switch (self->state)
+    {
     case META_BARRIER_STATE_ACTIVE:
       break;
     case META_BARRIER_STATE_HIT:
@@ -437,9 +430,7 @@ clamp_to_barrier (MetaBarrierImplNative *self,
                   float *x,
                   float *y)
 {
-  MetaBarrierImplNativePrivate *priv =
-    meta_barrier_impl_native_get_instance_private (self);
-  MetaBarrier *barrier = priv->barrier;
+  MetaBarrier *barrier = self->barrier;
 
   if (is_barrier_horizontal (barrier))
     {
@@ -448,7 +439,7 @@ clamp_to_barrier (MetaBarrierImplNative *self,
       else if (*motion_dir & META_BARRIER_DIRECTION_NEGATIVE_Y)
         *y = barrier->priv->border.line.a.y;
 
-      priv->blocked_dir = *motion_dir & (META_BARRIER_DIRECTION_POSITIVE_Y |
+      self->blocked_dir = *motion_dir & (META_BARRIER_DIRECTION_POSITIVE_Y |
                                          META_BARRIER_DIRECTION_NEGATIVE_Y);
       *motion_dir &= ~(META_BARRIER_DIRECTION_POSITIVE_Y |
                        META_BARRIER_DIRECTION_NEGATIVE_Y);
@@ -460,13 +451,13 @@ clamp_to_barrier (MetaBarrierImplNative *self,
       else if (*motion_dir & META_BARRIER_DIRECTION_NEGATIVE_X)
         *x = barrier->priv->border.line.a.x;
 
-      priv->blocked_dir = *motion_dir & (META_BARRIER_DIRECTION_POSITIVE_X |
+      self->blocked_dir = *motion_dir & (META_BARRIER_DIRECTION_POSITIVE_X |
                                          META_BARRIER_DIRECTION_NEGATIVE_X);
       *motion_dir &= ~(META_BARRIER_DIRECTION_POSITIVE_X |
                        META_BARRIER_DIRECTION_NEGATIVE_X);
     }
 
-  priv->state = META_BARRIER_STATE_HIT;
+  self->state = META_BARRIER_STATE_HIT;
 }
 
 void
@@ -538,10 +529,8 @@ static gboolean
 _meta_barrier_impl_native_is_active (MetaBarrierImpl *impl)
 {
   MetaBarrierImplNative *self = META_BARRIER_IMPL_NATIVE (impl);
-  MetaBarrierImplNativePrivate *priv =
-    meta_barrier_impl_native_get_instance_private (self);
 
-  return priv->is_active;
+  return self->is_active;
 }
 
 static void
@@ -549,42 +538,36 @@ _meta_barrier_impl_native_release (MetaBarrierImpl  *impl,
                                    MetaBarrierEvent *event)
 {
   MetaBarrierImplNative *self = META_BARRIER_IMPL_NATIVE (impl);
-  MetaBarrierImplNativePrivate *priv =
-    meta_barrier_impl_native_get_instance_private (self);
 
-  if (priv->state == META_BARRIER_STATE_HELD &&
-      event->event_id == priv->trigger_serial)
-    priv->state = META_BARRIER_STATE_RELEASE;
+  if (self->state == META_BARRIER_STATE_HELD &&
+      event->event_id == self->trigger_serial)
+    self->state = META_BARRIER_STATE_RELEASE;
 }
 
 static void
 _meta_barrier_impl_native_destroy (MetaBarrierImpl *impl)
 {
   MetaBarrierImplNative *self = META_BARRIER_IMPL_NATIVE (impl);
-  MetaBarrierImplNativePrivate *priv =
-    meta_barrier_impl_native_get_instance_private (self);
 
-  g_hash_table_remove (priv->manager->barriers, self);
-  priv->is_active = FALSE;
+  g_hash_table_remove (self->manager->barriers, self);
+  self->is_active = FALSE;
 }
 
 MetaBarrierImpl *
 meta_barrier_impl_native_new (MetaBarrier *barrier)
 {
   MetaBarrierImplNative *self;
-  MetaBarrierImplNativePrivate *priv;
   MetaBackendNative *native;
   MetaBarrierManagerNative *manager;
 
   self = g_object_new (META_TYPE_BARRIER_IMPL_NATIVE, NULL);
-  priv = meta_barrier_impl_native_get_instance_private (self);
 
-  priv->barrier = barrier;
-  priv->is_active = TRUE;
+  self->barrier = barrier;
+  self->is_active = TRUE;
 
   native = META_BACKEND_NATIVE (meta_get_backend ());
   manager = meta_backend_native_get_barrier_manager (native);
-  priv->manager = manager;
+  self->manager = manager;
   g_hash_table_add (manager->barriers, self);
 
   return META_BARRIER_IMPL (self);
diff --git a/src/backends/native/meta-barrier-native.h b/src/backends/native/meta-barrier-native.h
index 0fc414a16..2853cfa80 100644
--- a/src/backends/native/meta-barrier-native.h
+++ b/src/backends/native/meta-barrier-native.h
@@ -29,30 +29,14 @@
 
 G_BEGIN_DECLS
 
-#define META_TYPE_BARRIER_IMPL_NATIVE            (meta_barrier_impl_native_get_type ())
-#define META_BARRIER_IMPL_NATIVE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
META_TYPE_BARRIER_IMPL_NATIVE, MetaBarrierImplNative))
-#define META_BARRIER_IMPL_NATIVE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  
META_TYPE_BARRIER_IMPL_NATIVE, MetaBarrierImplNativeClass))
-#define META_IS_BARRIER_IMPL_NATIVE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
META_TYPE_BARRIER_IMPL_NATIVE))
-#define META_IS_BARRIER_IMPL_NATIVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  
META_TYPE_BARRIER_IMPL_NATIVE))
-#define META_BARRIER_IMPL_NATIVE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  
META_TYPE_BARRIER_IMPL_NATIVE, MetaBarrierImplNativeClass))
-
-typedef struct _MetaBarrierImplNative        MetaBarrierImplNative;
-typedef struct _MetaBarrierImplNativeClass   MetaBarrierImplNativeClass;
-typedef struct _MetaBarrierImplNativePrivate MetaBarrierImplNativePrivate;
+#define META_TYPE_BARRIER_IMPL_NATIVE (meta_barrier_impl_native_get_type ())
+G_DECLARE_FINAL_TYPE (MetaBarrierImplNative,
+                      meta_barrier_impl_native,
+                      META, BARRIER_IMPL_NATIVE,
+                      MetaBarrierImpl)
 
 typedef struct _MetaBarrierManagerNative     MetaBarrierManagerNative;
 
-struct _MetaBarrierImplNative
-{
-  MetaBarrierImpl parent;
-};
-
-struct _MetaBarrierImplNativeClass
-{
-  MetaBarrierImplClass parent_class;
-};
-
-GType meta_barrier_impl_native_get_type (void) G_GNUC_CONST;
 
 MetaBarrierImpl *meta_barrier_impl_native_new (MetaBarrier *barrier);
 
diff --git a/src/backends/x11/meta-barrier-x11.c b/src/backends/x11/meta-barrier-x11.c
index d8231b607..4cf58a81a 100644
--- a/src/backends/x11/meta-barrier-x11.c
+++ b/src/backends/x11/meta-barrier-x11.c
@@ -40,23 +40,24 @@
 #include "meta/barrier.h"
 #include "x11/meta-x11-display-private.h"
 
-struct _MetaBarrierImplX11Private
+struct _MetaBarrierImplX11
 {
+  MetaBarrierImpl parent;
+
   MetaBarrier *barrier;
   PointerBarrier xbarrier;
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (MetaBarrierImplX11, meta_barrier_impl_x11,
-                            META_TYPE_BARRIER_IMPL)
+G_DEFINE_TYPE (MetaBarrierImplX11,
+               meta_barrier_impl_x11,
+               META_TYPE_BARRIER_IMPL)
 
 static gboolean
 _meta_barrier_impl_x11_is_active (MetaBarrierImpl *impl)
 {
   MetaBarrierImplX11 *self = META_BARRIER_IMPL_X11 (impl);
-  MetaBarrierImplX11Private *priv =
-    meta_barrier_impl_x11_get_instance_private (self);
 
-  return priv->xbarrier != 0;
+  return self->xbarrier != 0;
 }
 
 static void
@@ -64,16 +65,14 @@ _meta_barrier_impl_x11_release (MetaBarrierImpl  *impl,
                                 MetaBarrierEvent *event)
 {
   MetaBarrierImplX11 *self = META_BARRIER_IMPL_X11 (impl);
-  MetaBarrierImplX11Private *priv =
-    meta_barrier_impl_x11_get_instance_private (self);
-  MetaDisplay *display = priv->barrier->priv->display;
+  MetaDisplay *display = self->barrier->priv->display;
   Display *dpy = meta_x11_display_get_xdisplay (display->x11_display);
 
   if (META_X11_DISPLAY_HAS_XINPUT_23 (display->x11_display))
     {
       XIBarrierReleasePointer (dpy,
                                META_VIRTUAL_CORE_POINTER_ID,
-                               priv->xbarrier, event->event_id);
+                               self->xbarrier, event->event_id);
     }
 }
 
@@ -81,9 +80,7 @@ static void
 _meta_barrier_impl_x11_destroy (MetaBarrierImpl *impl)
 {
   MetaBarrierImplX11 *self = META_BARRIER_IMPL_X11 (impl);
-  MetaBarrierImplX11Private *priv =
-    meta_barrier_impl_x11_get_instance_private (self);
-  MetaDisplay *display = priv->barrier->priv->display;
+  MetaDisplay *display = self->barrier->priv->display;
   Display *dpy;
 
   if (display == NULL)
@@ -91,19 +88,18 @@ _meta_barrier_impl_x11_destroy (MetaBarrierImpl *impl)
 
   dpy = meta_x11_display_get_xdisplay (display->x11_display);
 
-  if (!meta_barrier_is_active (priv->barrier))
+  if (!meta_barrier_is_active (self->barrier))
     return;
 
-  XFixesDestroyPointerBarrier (dpy, priv->xbarrier);
-  g_hash_table_remove (display->x11_display->xids, &priv->xbarrier);
-  priv->xbarrier = 0;
+  XFixesDestroyPointerBarrier (dpy, self->xbarrier);
+  g_hash_table_remove (display->x11_display->xids, &self->xbarrier);
+  self->xbarrier = 0;
 }
 
 MetaBarrierImpl *
 meta_barrier_impl_x11_new (MetaBarrier *barrier)
 {
   MetaBarrierImplX11 *self;
-  MetaBarrierImplX11Private *priv;
   MetaDisplay *display = barrier->priv->display;
   Display *dpy;
   Window root;
@@ -116,15 +112,14 @@ meta_barrier_impl_x11_new (MetaBarrier *barrier)
     }
 
   self = g_object_new (META_TYPE_BARRIER_IMPL_X11, NULL);
-  priv = meta_barrier_impl_x11_get_instance_private (self);
-  priv->barrier = barrier;
+  self->barrier = barrier;
 
   dpy = meta_x11_display_get_xdisplay (display->x11_display);
   root = DefaultRootWindow (dpy);
 
   allowed_motion_dirs =
     meta_border_get_allows_directions (&barrier->priv->border);
-  priv->xbarrier = XFixesCreatePointerBarrier (dpy, root,
+  self->xbarrier = XFixesCreatePointerBarrier (dpy, root,
                                                barrier->priv->border.line.a.x,
                                                barrier->priv->border.line.a.y,
                                                barrier->priv->border.line.b.x,
@@ -132,7 +127,7 @@ meta_barrier_impl_x11_new (MetaBarrier *barrier)
                                                allowed_motion_dirs,
                                                0, NULL);
 
-  g_hash_table_insert (display->x11_display->xids, &priv->xbarrier, barrier);
+  g_hash_table_insert (display->x11_display->xids, &self->xbarrier, barrier);
 
   return META_BARRIER_IMPL (self);
 }
diff --git a/src/backends/x11/meta-barrier-x11.h b/src/backends/x11/meta-barrier-x11.h
index 59e5fa4a7..3562d106f 100644
--- a/src/backends/x11/meta-barrier-x11.h
+++ b/src/backends/x11/meta-barrier-x11.h
@@ -29,28 +29,11 @@
 
 G_BEGIN_DECLS
 
-#define META_TYPE_BARRIER_IMPL_X11            (meta_barrier_impl_x11_get_type ())
-#define META_BARRIER_IMPL_X11(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
META_TYPE_BARRIER_IMPL_X11, MetaBarrierImplX11))
-#define META_BARRIER_IMPL_X11_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  
META_TYPE_BARRIER_IMPL_X11, MetaBarrierImplX11Class))
-#define META_IS_BARRIER_IMPL_X11(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
META_TYPE_BARRIER_IMPL_X11))
-#define META_IS_BARRIER_IMPL_X11_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  
META_TYPE_BARRIER_IMPL_X11))
-#define META_BARRIER_IMPL_X11_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  
META_TYPE_BARRIER_IMPL_X11, MetaBarrierImplX11Class))
-
-typedef struct _MetaBarrierImplX11        MetaBarrierImplX11;
-typedef struct _MetaBarrierImplX11Class   MetaBarrierImplX11Class;
-typedef struct _MetaBarrierImplX11Private MetaBarrierImplX11Private;
-
-struct _MetaBarrierImplX11
-{
-  MetaBarrierImpl parent;
-};
-
-struct _MetaBarrierImplX11Class
-{
-  MetaBarrierImplClass parent_class;
-};
-
-GType meta_barrier_impl_x11_get_type (void) G_GNUC_CONST;
+#define META_TYPE_BARRIER_IMPL_X11 (meta_barrier_impl_x11_get_type ())
+G_DECLARE_FINAL_TYPE (MetaBarrierImplX11,
+                      meta_barrier_impl_x11,
+                      META, BARRIER_IMPL_X11,
+                      MetaBarrierImpl)
 
 MetaBarrierImpl *meta_barrier_impl_x11_new (MetaBarrier *barrier);
 
diff --git a/src/compositor/meta-background-actor.c b/src/compositor/meta-background-actor.c
index 756b29e72..5c18e81a8 100644
--- a/src/compositor/meta-background-actor.c
+++ b/src/compositor/meta-background-actor.c
@@ -153,8 +153,10 @@ typedef enum {
   PIPELINE_GRADIENT = (1 << 2),
 } PipelineFlags;
 
-struct _MetaBackgroundActorPrivate
+struct _MetaBackgroundActor
 {
+  ClutterActor parent;
+
   MetaDisplay *display;
   int monitor;
 
@@ -180,32 +182,28 @@ struct _MetaBackgroundActorPrivate
 static void cullable_iface_init (MetaCullableInterface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (MetaBackgroundActor, meta_background_actor, CLUTTER_TYPE_ACTOR,
-                         G_ADD_PRIVATE (MetaBackgroundActor)
                          G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
 
 static void
 set_clip_region (MetaBackgroundActor *self,
                  cairo_region_t      *clip_region)
 {
-  MetaBackgroundActorPrivate *priv = self->priv;
-
-  g_clear_pointer (&priv->clip_region, cairo_region_destroy);
+  g_clear_pointer (&self->clip_region, cairo_region_destroy);
   if (clip_region)
-    priv->clip_region = cairo_region_copy (clip_region);
+    self->clip_region = cairo_region_copy (clip_region);
 }
 
 static void
 meta_background_actor_dispose (GObject *object)
 {
   MetaBackgroundActor *self = META_BACKGROUND_ACTOR (object);
-  MetaBackgroundActorPrivate *priv = self->priv;
 
   set_clip_region (self, NULL);
   meta_background_actor_set_background (self, NULL);
-  if (priv->pipeline)
+  if (self->pipeline)
     {
-      cogl_object_unref (priv->pipeline);
-      priv->pipeline = NULL;
+      cogl_object_unref (self->pipeline);
+      self->pipeline = NULL;
     }
 
   G_OBJECT_CLASS (meta_background_actor_parent_class)->dispose (object);
@@ -216,11 +214,10 @@ get_preferred_size (MetaBackgroundActor *self,
                     gfloat              *width,
                     gfloat              *height)
 {
-  MetaBackgroundActorPrivate *priv = META_BACKGROUND_ACTOR (self)->priv;
   MetaRectangle monitor_geometry;
 
-  meta_display_get_monitor_geometry (priv->display,
-                                     priv->monitor,
+  meta_display_get_monitor_geometry (self->display,
+                                     self->monitor,
                                      &monitor_geometry);
 
   if (width != NULL)
@@ -329,7 +326,6 @@ static void
 setup_pipeline (MetaBackgroundActor   *self,
                 cairo_rectangle_int_t *actor_pixel_rect)
 {
-  MetaBackgroundActorPrivate *priv = self->priv;
   PipelineFlags pipeline_flags = 0;
   guint8 opacity;
   float color_component;
@@ -338,75 +334,75 @@ setup_pipeline (MetaBackgroundActor   *self,
   opacity = clutter_actor_get_paint_opacity (CLUTTER_ACTOR (self));
   if (opacity < 255)
     pipeline_flags |= PIPELINE_BLEND;
-  if (priv->vignette && clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
+  if (self->vignette && clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
     pipeline_flags |= PIPELINE_VIGNETTE;
-  if (priv->gradient && clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
+  if (self->gradient && clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
     pipeline_flags |= PIPELINE_GRADIENT;
 
-  if (priv->pipeline &&
-      pipeline_flags != priv->pipeline_flags)
+  if (self->pipeline &&
+      pipeline_flags != self->pipeline_flags)
     {
-      cogl_object_unref (priv->pipeline);
-      priv->pipeline = NULL;
+      cogl_object_unref (self->pipeline);
+      self->pipeline = NULL;
     }
 
-  if (priv->pipeline == NULL)
+  if (self->pipeline == NULL)
     {
-      priv->pipeline_flags = pipeline_flags;
-      priv->pipeline = make_pipeline (pipeline_flags);
-      priv->changed = CHANGED_ALL;
+      self->pipeline_flags = pipeline_flags;
+      self->pipeline = make_pipeline (pipeline_flags);
+      self->changed = CHANGED_ALL;
     }
 
-  if ((priv->changed & CHANGED_BACKGROUND) != 0)
+  if ((self->changed & CHANGED_BACKGROUND) != 0)
     {
       CoglPipelineWrapMode wrap_mode;
-      CoglTexture *texture = meta_background_get_texture (priv->background,
-                                                          priv->monitor,
-                                                          &priv->texture_area,
+      CoglTexture *texture = meta_background_get_texture (self->background,
+                                                          self->monitor,
+                                                          &self->texture_area,
                                                           &wrap_mode);
-      priv->force_bilinear = texture &&
-        (priv->texture_area.width != (int)cogl_texture_get_width (texture) ||
-         priv->texture_area.height != (int)cogl_texture_get_height (texture));
+      self->force_bilinear = texture &&
+        (self->texture_area.width != (int)cogl_texture_get_width (texture) ||
+         self->texture_area.height != (int)cogl_texture_get_height (texture));
 
-      cogl_pipeline_set_layer_texture (priv->pipeline, 0, texture);
-      cogl_pipeline_set_layer_wrap_mode (priv->pipeline, 0, wrap_mode);
+      cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
+      cogl_pipeline_set_layer_wrap_mode (self->pipeline, 0, wrap_mode);
 
-      priv->changed &= ~CHANGED_BACKGROUND;
+      self->changed &= ~CHANGED_BACKGROUND;
     }
 
-  if ((priv->changed & CHANGED_VIGNETTE_PARAMETERS) != 0)
+  if ((self->changed & CHANGED_VIGNETTE_PARAMETERS) != 0)
     {
-      cogl_pipeline_set_uniform_1f (priv->pipeline,
-                                    cogl_pipeline_get_uniform_location (priv->pipeline,
+      cogl_pipeline_set_uniform_1f (self->pipeline,
+                                    cogl_pipeline_get_uniform_location (self->pipeline,
                                                                         "vignette_sharpness"),
-                                    priv->vignette_sharpness);
+                                    self->vignette_sharpness);
 
-      priv->changed &= ~CHANGED_VIGNETTE_PARAMETERS;
+      self->changed &= ~CHANGED_VIGNETTE_PARAMETERS;
     }
 
-  if ((priv->changed & CHANGED_GRADIENT_PARAMETERS) != 0)
+  if ((self->changed & CHANGED_GRADIENT_PARAMETERS) != 0)
     {
       MetaRectangle monitor_geometry;
       float gradient_height_perc;
 
-      meta_display_get_monitor_geometry (priv->display,
-                                         priv->monitor, &monitor_geometry);
-      gradient_height_perc = MAX (0.0001, priv->gradient_height / (float)monitor_geometry.height);
-      cogl_pipeline_set_uniform_1f (priv->pipeline,
-                                    cogl_pipeline_get_uniform_location (priv->pipeline,
+      meta_display_get_monitor_geometry (self->display,
+                                         self->monitor, &monitor_geometry);
+      gradient_height_perc = MAX (0.0001, self->gradient_height / (float)monitor_geometry.height);
+      cogl_pipeline_set_uniform_1f (self->pipeline,
+                                    cogl_pipeline_get_uniform_location (self->pipeline,
                                                                         "gradient_height_perc"),
                                     gradient_height_perc);
-      cogl_pipeline_set_uniform_1f (priv->pipeline,
-                                    cogl_pipeline_get_uniform_location (priv->pipeline,
+      cogl_pipeline_set_uniform_1f (self->pipeline,
+                                    cogl_pipeline_get_uniform_location (self->pipeline,
                                                                         "gradient_max_darkness"),
-                                    priv->gradient_max_darkness);
+                                    self->gradient_max_darkness);
 
-      priv->changed &= ~CHANGED_GRADIENT_PARAMETERS;
+      self->changed &= ~CHANGED_GRADIENT_PARAMETERS;
     }
 
-  if (priv->vignette)
+  if (self->vignette)
     {
-      color_component = priv->vignette_brightness * opacity / 255.;
+      color_component = self->vignette_brightness * opacity / 255.;
 
       if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
         {
@@ -414,50 +410,49 @@ setup_pipeline (MetaBackgroundActor   *self,
            * be there if we were drawing the vignette, which is
            * (1 - (pi/12.) * vignette_sharpness) [exercise for the reader :]
            */
-          color_component *= (1 - 0.74 * priv->vignette_sharpness);
+          color_component *= (1 - 0.74 * self->vignette_sharpness);
         }
     }
   else
     color_component = opacity / 255.;
 
-  cogl_pipeline_set_color4f (priv->pipeline,
+  cogl_pipeline_set_color4f (self->pipeline,
                              color_component,
                              color_component,
                              color_component,
                              opacity / 255.);
 
-  if (!priv->force_bilinear &&
+  if (!self->force_bilinear &&
       meta_actor_painting_untransformed (actor_pixel_rect->width, actor_pixel_rect->height, NULL, NULL))
     filter = COGL_PIPELINE_FILTER_NEAREST;
   else
     filter = COGL_PIPELINE_FILTER_LINEAR;
 
-  cogl_pipeline_set_layer_filters (priv->pipeline, 0, filter, filter);
+  cogl_pipeline_set_layer_filters (self->pipeline, 0, filter, filter);
 }
 
 static void
 set_glsl_parameters (MetaBackgroundActor   *self,
                      cairo_rectangle_int_t *actor_pixel_rect)
 {
-  MetaBackgroundActorPrivate *priv = self->priv;
   float scale[2];
   float offset[2];
 
   /* Compute a scale and offset for transforming texture coordinates to the
    * coordinate system from [-0.5 to 0.5] across the area of the actor
    */
-  scale[0] = priv->texture_area.width / (float)actor_pixel_rect->width;
-  scale[1] = priv->texture_area.height / (float)actor_pixel_rect->height;
-  offset[0] = priv->texture_area.x / (float)actor_pixel_rect->width - 0.5;
-  offset[1] = priv->texture_area.y / (float)actor_pixel_rect->height - 0.5;
+  scale[0] = self->texture_area.width / (float)actor_pixel_rect->width;
+  scale[1] = self->texture_area.height / (float)actor_pixel_rect->height;
+  offset[0] = self->texture_area.x / (float)actor_pixel_rect->width - 0.5;
+  offset[1] = self->texture_area.y / (float)actor_pixel_rect->height - 0.5;
 
-  cogl_pipeline_set_uniform_float (priv->pipeline,
-                                   cogl_pipeline_get_uniform_location (priv->pipeline,
+  cogl_pipeline_set_uniform_float (self->pipeline,
+                                   cogl_pipeline_get_uniform_location (self->pipeline,
                                                                        "scale"),
                                    2, 1, scale);
 
-  cogl_pipeline_set_uniform_float (priv->pipeline,
-                                   cogl_pipeline_get_uniform_location (priv->pipeline,
+  cogl_pipeline_set_uniform_float (self->pipeline,
+                                   cogl_pipeline_get_uniform_location (self->pipeline,
                                                                        "offset"),
                                    2, 1, offset);
 }
@@ -497,13 +492,12 @@ static void
 meta_background_actor_paint (ClutterActor *actor)
 {
   MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
-  MetaBackgroundActorPrivate *priv = self->priv;
   ClutterActorBox actor_box;
   cairo_rectangle_int_t actor_pixel_rect;
   CoglFramebuffer *fb;
   int i;
 
-  if ((priv->clip_region && cairo_region_is_empty (priv->clip_region)))
+  if ((self->clip_region && cairo_region_is_empty (self->clip_region)))
     return;
 
   clutter_actor_get_content_box (actor, &actor_box);
@@ -523,27 +517,27 @@ meta_background_actor_paint (ClutterActor *actor)
 
   /* Now figure out what to actually paint.
    */
-  if (priv->clip_region != NULL)
+  if (self->clip_region != NULL)
     {
-      int n_rects = cairo_region_num_rectangles (priv->clip_region);
+      int n_rects = cairo_region_num_rectangles (self->clip_region);
       if (n_rects <= MAX_RECTS)
         {
            for (i = 0; i < n_rects; i++)
              {
                cairo_rectangle_int_t rect;
-               cairo_region_get_rectangle (priv->clip_region, i, &rect);
+               cairo_region_get_rectangle (self->clip_region, i, &rect);
 
                if (!gdk_rectangle_intersect (&actor_pixel_rect, &rect, &rect))
                  continue;
 
-               paint_clipped_rectangle (fb, priv->pipeline, &rect, &priv->texture_area);
+               paint_clipped_rectangle (fb, self->pipeline, &rect, &self->texture_area);
              }
 
            return;
         }
     }
 
-  paint_clipped_rectangle (fb, priv->pipeline, &actor_pixel_rect, &priv->texture_area);
+  paint_clipped_rectangle (fb, self->pipeline, &actor_pixel_rect, &self->texture_area);
 }
 
 static void
@@ -553,12 +547,11 @@ meta_background_actor_set_property (GObject      *object,
                                     GParamSpec   *pspec)
 {
   MetaBackgroundActor *self = META_BACKGROUND_ACTOR (object);
-  MetaBackgroundActorPrivate *priv = self->priv;
 
   switch (prop_id)
     {
     case PROP_META_DISPLAY:
-      priv->display = g_value_get_object (value);
+      self->display = g_value_get_object (value);
       break;
     case PROP_MONITOR:
       meta_background_actor_set_monitor (self, g_value_get_int (value));
@@ -569,38 +562,38 @@ meta_background_actor_set_property (GObject      *object,
     case PROP_GRADIENT:
       meta_background_actor_set_gradient (self,
                                           g_value_get_boolean (value),
-                                          priv->gradient_height,
-                                          priv->gradient_max_darkness);
+                                          self->gradient_height,
+                                          self->gradient_max_darkness);
       break;
     case PROP_GRADIENT_HEIGHT:
       meta_background_actor_set_gradient (self,
-                                          priv->gradient,
+                                          self->gradient,
                                           g_value_get_int (value),
-                                          priv->gradient_max_darkness);
+                                          self->gradient_max_darkness);
       break;
     case PROP_GRADIENT_MAX_DARKNESS:
       meta_background_actor_set_gradient (self,
-                                          priv->gradient,
-                                          priv->gradient_height,
+                                          self->gradient,
+                                          self->gradient_height,
                                           g_value_get_double (value));
       break;
     case PROP_VIGNETTE:
       meta_background_actor_set_vignette (self,
                                           g_value_get_boolean (value),
-                                          priv->vignette_brightness,
-                                          priv->vignette_sharpness);
+                                          self->vignette_brightness,
+                                          self->vignette_sharpness);
       break;
     case PROP_VIGNETTE_SHARPNESS:
       meta_background_actor_set_vignette (self,
-                                          priv->vignette,
-                                          priv->vignette_brightness,
+                                          self->vignette,
+                                          self->vignette_brightness,
                                           g_value_get_double (value));
       break;
     case PROP_VIGNETTE_BRIGHTNESS:
       meta_background_actor_set_vignette (self,
-                                          priv->vignette,
+                                          self->vignette,
                                           g_value_get_double (value),
-                                          priv->vignette_sharpness);
+                                          self->vignette_sharpness);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -614,36 +607,36 @@ meta_background_actor_get_property (GObject      *object,
                                     GValue       *value,
                                     GParamSpec   *pspec)
 {
-  MetaBackgroundActorPrivate *priv = META_BACKGROUND_ACTOR (object)->priv;
+  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (object);
 
   switch (prop_id)
     {
     case PROP_META_DISPLAY:
-      g_value_set_object (value, priv->display);
+      g_value_set_object (value, self->display);
       break;
     case PROP_MONITOR:
-      g_value_set_int (value, priv->monitor);
+      g_value_set_int (value, self->monitor);
       break;
     case PROP_BACKGROUND:
-      g_value_set_object (value, priv->background);
+      g_value_set_object (value, self->background);
       break;
     case PROP_GRADIENT:
-      g_value_set_boolean (value, priv->gradient);
+      g_value_set_boolean (value, self->gradient);
       break;
     case PROP_GRADIENT_HEIGHT:
-      g_value_set_int (value, priv->gradient_height);
+      g_value_set_int (value, self->gradient_height);
       break;
     case PROP_GRADIENT_MAX_DARKNESS:
-      g_value_set_double (value, priv->gradient_max_darkness);
+      g_value_set_double (value, self->gradient_max_darkness);
       break;
     case PROP_VIGNETTE:
-      g_value_set_boolean (value, priv->vignette);
+      g_value_set_boolean (value, self->vignette);
       break;
     case PROP_VIGNETTE_BRIGHTNESS:
-      g_value_set_double (value, priv->vignette_brightness);
+      g_value_set_double (value, self->vignette_brightness);
       break;
     case PROP_VIGNETTE_SHARPNESS:
-      g_value_set_double (value, priv->vignette_sharpness);
+      g_value_set_double (value, self->vignette_sharpness);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -761,19 +754,13 @@ meta_background_actor_class_init (MetaBackgroundActorClass *klass)
 static void
 meta_background_actor_init (MetaBackgroundActor *self)
 {
-  MetaBackgroundActorPrivate *priv;
-
-  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-                                                   META_TYPE_BACKGROUND_ACTOR,
-                                                   MetaBackgroundActorPrivate);
-
-  priv->gradient = FALSE;
-  priv->gradient_height = 0;
-  priv->gradient_max_darkness = 0.0;
+  self->gradient = FALSE;
+  self->gradient_height = 0;
+  self->gradient_max_darkness = 0.0;
 
-  priv->vignette = FALSE;
-  priv->vignette_brightness = 1.0;
-  priv->vignette_sharpness = 0.0;
+  self->vignette = FALSE;
+  self->vignette_brightness = 1.0;
+  self->vignette_sharpness = 0.0;
 }
 
 /**
@@ -832,17 +819,14 @@ cullable_iface_init (MetaCullableInterface *iface)
 cairo_region_t *
 meta_background_actor_get_clip_region (MetaBackgroundActor *self)
 {
-  MetaBackgroundActorPrivate *priv = self->priv;
-  return priv->clip_region;
+  return self->clip_region;
 }
 
 static void
 invalidate_pipeline (MetaBackgroundActor *self,
                      ChangedFlags         changed)
 {
-  MetaBackgroundActorPrivate *priv = self->priv;
-
-  priv->changed |= changed;
+  self->changed |= changed;
 }
 
 static void
@@ -857,29 +841,25 @@ void
 meta_background_actor_set_background (MetaBackgroundActor *self,
                                       MetaBackground      *background)
 {
-  MetaBackgroundActorPrivate *priv;
-
   g_return_if_fail (META_IS_BACKGROUND_ACTOR (self));
   g_return_if_fail (background == NULL || META_IS_BACKGROUND (background));
 
-  priv = self->priv;
-
-  if (background == priv->background)
+  if (background == self->background)
     return;
 
-  if (priv->background)
+  if (self->background)
     {
-      g_signal_handlers_disconnect_by_func (priv->background,
+      g_signal_handlers_disconnect_by_func (self->background,
                                             (gpointer)on_background_changed,
                                             self);
-      g_object_unref (priv->background);
-      priv->background = NULL;
+      g_object_unref (self->background);
+      self->background = NULL;
     }
 
   if (background)
     {
-      priv->background = g_object_ref (background);
-      g_signal_connect (priv->background, "changed",
+      self->background = g_object_ref (background);
+      g_signal_connect (self->background, "changed",
                         G_CALLBACK (on_background_changed), self);
     }
 
@@ -893,28 +873,25 @@ meta_background_actor_set_gradient (MetaBackgroundActor *self,
                                     int                  height,
                                     double               max_darkness)
 {
-  MetaBackgroundActorPrivate *priv;
   gboolean changed = FALSE;
 
   g_return_if_fail (META_IS_BACKGROUND_ACTOR (self));
   g_return_if_fail (height >= 0);
   g_return_if_fail (max_darkness >= 0. && max_darkness <= 1.);
 
-  priv = self->priv;
-
   enabled = enabled != FALSE && height != 0;
 
-  if (enabled != priv->gradient)
+  if (enabled != self->gradient)
     {
-      priv->gradient = enabled;
+      self->gradient = enabled;
       invalidate_pipeline (self, CHANGED_EFFECTS);
       changed = TRUE;
     }
 
-  if (height != priv->gradient_height || max_darkness != priv->gradient_max_darkness)
+  if (height != self->gradient_height || max_darkness != self->gradient_max_darkness)
     {
-      priv->gradient_height = height;
-      priv->gradient_max_darkness = max_darkness;
+      self->gradient_height = height;
+      self->gradient_max_darkness = max_darkness;
       invalidate_pipeline (self, CHANGED_GRADIENT_PARAMETERS);
       changed = TRUE;
     }
@@ -927,20 +904,19 @@ void
 meta_background_actor_set_monitor (MetaBackgroundActor *self,
                                    int                  monitor)
 {
-  MetaBackgroundActorPrivate *priv = self->priv;
   MetaRectangle old_monitor_geometry;
   MetaRectangle new_monitor_geometry;
-  MetaDisplay *display = priv->display;
+  MetaDisplay *display = self->display;
 
-  if(priv->monitor == monitor)
+  if(self->monitor == monitor)
       return;
 
-  meta_display_get_monitor_geometry (display, priv->monitor, &old_monitor_geometry);
+  meta_display_get_monitor_geometry (display, self->monitor, &old_monitor_geometry);
   meta_display_get_monitor_geometry (display, monitor, &new_monitor_geometry);
   if(old_monitor_geometry.height != new_monitor_geometry.height)
       invalidate_pipeline (self, CHANGED_GRADIENT_PARAMETERS);
 
-  priv->monitor = monitor;
+  self->monitor = monitor;
 }
 
 void
@@ -949,28 +925,25 @@ meta_background_actor_set_vignette (MetaBackgroundActor *self,
                                     double               brightness,
                                     double               sharpness)
 {
-  MetaBackgroundActorPrivate *priv;
   gboolean changed = FALSE;
 
   g_return_if_fail (META_IS_BACKGROUND_ACTOR (self));
   g_return_if_fail (brightness >= 0. && brightness <= 1.);
   g_return_if_fail (sharpness >= 0.);
 
-  priv = self->priv;
-
   enabled = enabled != FALSE;
 
-  if (enabled != priv->vignette)
+  if (enabled != self->vignette)
     {
-      priv->vignette = enabled;
+      self->vignette = enabled;
       invalidate_pipeline (self, CHANGED_EFFECTS);
       changed = TRUE;
     }
 
-  if (brightness != priv->vignette_brightness || sharpness != priv->vignette_sharpness)
+  if (brightness != self->vignette_brightness || sharpness != self->vignette_sharpness)
     {
-      priv->vignette_brightness = brightness;
-      priv->vignette_sharpness = sharpness;
+      self->vignette_brightness = brightness;
+      self->vignette_sharpness = sharpness;
       invalidate_pipeline (self, CHANGED_VIGNETTE_PARAMETERS);
       changed = TRUE;
     }
diff --git a/src/compositor/meta-background-group.c b/src/compositor/meta-background-group.c
index e30b8af4c..f3c125ab0 100644
--- a/src/compositor/meta-background-group.c
+++ b/src/compositor/meta-background-group.c
@@ -19,6 +19,11 @@
 #include "compositor/meta-cullable.h"
 #include "meta/meta-background-group.h"
 
+struct _MetaBackgroundGroup
+{
+  ClutterActor parent;
+};
+
 static void cullable_iface_init (MetaCullableInterface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (MetaBackgroundGroup, meta_background_group, CLUTTER_TYPE_ACTOR,
diff --git a/src/compositor/meta-background-image.c b/src/compositor/meta-background-image.c
index 802c10c76..14d3baf57 100644
--- a/src/compositor/meta-background-image.c
+++ b/src/compositor/meta-background-image.c
@@ -40,6 +40,13 @@ enum
 
 static guint signals[LAST_SIGNAL] = { 0 };
 
+/**
+ * MetaBackgroundImageCache:
+ *
+ * #MetaBackgroundImageCache caches loading of textures for backgrounds; there's actually
+ * nothing background specific about it, other than it is tuned to work well for
+ * large images as typically are used for backgrounds.
+ */
 struct _MetaBackgroundImageCache
 {
   GObject parent_instance;
@@ -47,11 +54,11 @@ struct _MetaBackgroundImageCache
   GHashTable *images;
 };
 
-struct _MetaBackgroundImageCacheClass
-{
-  GObjectClass parent_class;
-};
-
+/**
+ * MetaBackgroundImage:
+ *
+ * #MetaBackgroundImage is an object that represents a loaded or loading background image.
+ */
 struct _MetaBackgroundImage
 {
   GObject parent_instance;
@@ -62,11 +69,6 @@ struct _MetaBackgroundImage
   CoglTexture *texture;
 };
 
-struct _MetaBackgroundImageClass
-{
-  GObjectClass parent_class;
-};
-
 G_DEFINE_TYPE (MetaBackgroundImageCache, meta_background_image_cache, G_TYPE_OBJECT);
 
 static void
diff --git a/src/compositor/meta-background.c b/src/compositor/meta-background.c
index 4670409aa..7d74d2f23 100644
--- a/src/compositor/meta-background.c
+++ b/src/compositor/meta-background.c
@@ -47,8 +47,10 @@ struct _MetaBackgroundMonitor
   CoglFramebuffer *fbo;
 };
 
-struct _MetaBackgroundPrivate
+struct _MetaBackground
 {
+  GObject parent;
+
   MetaDisplay *display;
   MetaBackgroundMonitor *monitors;
   int n_monitors;
@@ -77,7 +79,7 @@ enum
   PROP_MONITOR,
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (MetaBackground, meta_background, G_TYPE_OBJECT)
+G_DEFINE_TYPE (MetaBackground, meta_background, G_TYPE_OBJECT)
 
 static gboolean texture_has_alpha (CoglTexture *texture);
 
@@ -86,13 +88,11 @@ static GSList *all_backgrounds = NULL;
 static void
 free_fbos (MetaBackground *self)
 {
-  MetaBackgroundPrivate *priv = self->priv;
-
   int i;
 
-  for (i = 0; i < priv->n_monitors; i++)
+  for (i = 0; i < self->n_monitors; i++)
     {
-      MetaBackgroundMonitor *monitor = &priv->monitors[i];
+      MetaBackgroundMonitor *monitor = &self->monitors[i];
       if (monitor->fbo)
         {
           cogl_object_unref (monitor->fbo);
@@ -109,48 +109,42 @@ free_fbos (MetaBackground *self)
 static void
 free_color_texture (MetaBackground *self)
 {
-  MetaBackgroundPrivate *priv = self->priv;
-
-  if (priv->color_texture != NULL)
+  if (self->color_texture != NULL)
     {
-      cogl_object_unref (priv->color_texture);
-      priv->color_texture = NULL;
+      cogl_object_unref (self->color_texture);
+      self->color_texture = NULL;
     }
 }
 
 static void
 free_wallpaper_texture (MetaBackground *self)
 {
-  MetaBackgroundPrivate *priv = self->priv;
-
-  if (priv->wallpaper_texture != NULL)
+  if (self->wallpaper_texture != NULL)
     {
-      cogl_object_unref (priv->wallpaper_texture);
-      priv->wallpaper_texture = NULL;
+      cogl_object_unref (self->wallpaper_texture);
+      self->wallpaper_texture = NULL;
     }
 
-  priv->wallpaper_allocation_failed = FALSE;
+  self->wallpaper_allocation_failed = FALSE;
 }
 
 static void
 invalidate_monitor_backgrounds (MetaBackground *self)
 {
-  MetaBackgroundPrivate *priv = self->priv;
-
   free_fbos (self);
-  g_free (priv->monitors);
-  priv->monitors = NULL;
-  priv->n_monitors = 0;
+  g_free (self->monitors);
+  self->monitors = NULL;
+  self->n_monitors = 0;
 
-  if (priv->display)
+  if (self->display)
     {
       int i;
 
-      priv->n_monitors = meta_display_get_n_monitors (priv->display);
-      priv->monitors = g_new0 (MetaBackgroundMonitor, priv->n_monitors);
+      self->n_monitors = meta_display_get_n_monitors (self->display);
+      self->monitors = g_new0 (MetaBackgroundMonitor, self->n_monitors);
 
-      for (i = 0; i < priv->n_monitors; i++)
-        priv->monitors[i].dirty = TRUE;
+      for (i = 0; i < self->n_monitors; i++)
+        self->monitors[i].dirty = TRUE;
     }
 }
 
@@ -164,9 +158,7 @@ static void
 set_display (MetaBackground *self,
              MetaDisplay    *display)
 {
-  MetaBackgroundPrivate *priv = self->priv;
-
-  g_set_object (&priv->display, display);
+  g_set_object (&self->display, display);
 
   invalidate_monitor_backgrounds (self);
 }
@@ -194,12 +186,12 @@ meta_background_get_property (GObject      *object,
                               GValue       *value,
                               GParamSpec   *pspec)
 {
-  MetaBackgroundPrivate *priv = META_BACKGROUND (object)->priv;
+  MetaBackground *self = META_BACKGROUND (object);
 
   switch (prop_id)
     {
     case PROP_META_DISPLAY:
-      g_value_set_object (value, priv->display);
+      g_value_set_object (value, self->display);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -210,14 +202,13 @@ meta_background_get_property (GObject      *object,
 static gboolean
 need_prerender (MetaBackground *self)
 {
-  MetaBackgroundPrivate *priv = self->priv;
-  CoglTexture *texture1 = priv->background_image1 ? meta_background_image_get_texture 
(priv->background_image1) : NULL;
-  CoglTexture *texture2 = priv->background_image2 ? meta_background_image_get_texture 
(priv->background_image2) : NULL;
+  CoglTexture *texture1 = self->background_image1 ? meta_background_image_get_texture 
(self->background_image1) : NULL;
+  CoglTexture *texture2 = self->background_image2 ? meta_background_image_get_texture 
(self->background_image2) : NULL;
 
   if (texture1 == NULL && texture2 == NULL)
     return FALSE;
 
-  if (texture2 == NULL && priv->style == G_DESKTOP_BACKGROUND_STYLE_WALLPAPER)
+  if (texture2 == NULL && self->style == G_DESKTOP_BACKGROUND_STYLE_WALLPAPER)
     return FALSE;
 
   return TRUE;
@@ -226,14 +217,13 @@ need_prerender (MetaBackground *self)
 static void
 mark_changed (MetaBackground *self)
 {
-  MetaBackgroundPrivate *priv = self->priv;
   int i;
 
   if (!need_prerender (self))
     free_fbos (self);
 
-  for (i = 0; i < priv->n_monitors; i++)
-    priv->monitors[i].dirty = TRUE;
+  for (i = 0; i < self->n_monitors; i++)
+    self->monitors[i].dirty = TRUE;
 
   g_signal_emit (self, signals[CHANGED], 0);
 }
@@ -293,13 +283,12 @@ static void
 meta_background_dispose (GObject *object)
 {
   MetaBackground        *self = META_BACKGROUND (object);
-  MetaBackgroundPrivate *priv = self->priv;
 
   free_color_texture (self);
   free_wallpaper_texture (self);
 
-  set_file (self, &priv->file1, &priv->background_image1, NULL);
-  set_file (self, &priv->file2, &priv->background_image2, NULL);
+  set_file (self, &self->file1, &self->background_image1, NULL);
+  set_file (self, &self->file2, &self->background_image2, NULL);
 
   set_display (self, NULL);
 
@@ -318,12 +307,11 @@ static void
 meta_background_constructed (GObject *object)
 {
   MetaBackground        *self = META_BACKGROUND (object);
-  MetaBackgroundPrivate *priv = self->priv;
   MetaMonitorManager *monitor_manager = meta_monitor_manager_get ();
 
   G_OBJECT_CLASS (meta_background_parent_class)->constructed (object);
 
-  g_signal_connect_object (priv->display, "gl-video-memory-purged",
+  g_signal_connect_object (self->display, "gl-video-memory-purged",
                            G_CALLBACK (mark_changed), object, G_CONNECT_SWAPPED);
 
   g_signal_connect_object (monitor_manager, "monitors-changed",
@@ -366,9 +354,6 @@ meta_background_class_init (MetaBackgroundClass *klass)
 static void
 meta_background_init (MetaBackground *self)
 {
-  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-                                            META_TYPE_BACKGROUND,
-                                            MetaBackgroundPrivate);
   all_backgrounds = g_slist_prepend (all_backgrounds, self);
 }
 
@@ -388,7 +373,6 @@ get_texture_area (MetaBackground          *self,
                   CoglTexture             *texture,
                   cairo_rectangle_int_t   *texture_area)
 {
-  MetaBackgroundPrivate *priv = self->priv;
   cairo_rectangle_int_t image_area;
   int screen_width, screen_height;
   float texture_width, texture_height;
@@ -397,7 +381,7 @@ get_texture_area (MetaBackground          *self,
   texture_width = cogl_texture_get_width (texture);
   texture_height = cogl_texture_get_height (texture);
 
-  switch (priv->style)
+  switch (self->style)
     {
     case G_DESKTOP_BACKGROUND_STYLE_STRETCHED:
     default:
@@ -407,7 +391,7 @@ get_texture_area (MetaBackground          *self,
       set_texture_area_from_monitor_area (monitor_rect, texture_area);
       break;
     case G_DESKTOP_BACKGROUND_STYLE_WALLPAPER:
-      meta_display_get_size (priv->display, &screen_width, &screen_height);
+      meta_display_get_size (self->display, &screen_width, &screen_height);
 
       /* Start off by centering a tile in the middle of the
        * total screen area.
@@ -444,9 +428,9 @@ get_texture_area (MetaBackground          *self,
       monitor_x_scale = monitor_rect->width / texture_width;
       monitor_y_scale = monitor_rect->height / texture_height;
 
-      if ((priv->style == G_DESKTOP_BACKGROUND_STYLE_SCALED &&
+      if ((self->style == G_DESKTOP_BACKGROUND_STYLE_SCALED &&
            (monitor_x_scale < monitor_y_scale)) ||
-          (priv->style == G_DESKTOP_BACKGROUND_STYLE_ZOOM &&
+          (self->style == G_DESKTOP_BACKGROUND_STYLE_ZOOM &&
            (monitor_x_scale > monitor_y_scale)))
         {
           /* Fill image to exactly fit actor horizontally */
@@ -476,7 +460,7 @@ get_texture_area (MetaBackground          *self,
         /* paint region is the union of all monitors, with the origin
          * of the region set to align with monitor associated with the background.
          */
-        meta_display_get_size (priv->display, &screen_width, &screen_height);
+        meta_display_get_size (self->display, &screen_width, &screen_height);
 
         /* unclipped texture area is whole screen */
         image_area.width = screen_width;
@@ -499,13 +483,12 @@ draw_texture (MetaBackground        *self,
               CoglTexture           *texture,
               cairo_rectangle_int_t *monitor_area)
 {
-  MetaBackgroundPrivate *priv = self->priv;
   cairo_rectangle_int_t texture_area;
   gboolean bare_region_visible;
 
   get_texture_area (self, monitor_area, texture, &texture_area);
 
-  switch (priv->style)
+  switch (self->style)
     {
     case G_DESKTOP_BACKGROUND_STYLE_STRETCHED:
     case G_DESKTOP_BACKGROUND_STYLE_WALLPAPER:
@@ -550,9 +533,7 @@ draw_texture (MetaBackground        *self,
 static void
 ensure_color_texture (MetaBackground *self)
 {
-  MetaBackgroundPrivate *priv = self->priv;
-
-  if (priv->color_texture == NULL)
+  if (self->color_texture == NULL)
     {
       ClutterBackend *backend = clutter_get_default_backend ();
       CoglContext *ctx = clutter_backend_get_cogl_context (backend);
@@ -560,18 +541,18 @@ ensure_color_texture (MetaBackground *self)
       uint8_t pixels[6];
       int width, height;
 
-      if (priv->shading_direction == G_DESKTOP_BACKGROUND_SHADING_SOLID)
+      if (self->shading_direction == G_DESKTOP_BACKGROUND_SHADING_SOLID)
         {
           width = 1;
           height = 1;
 
-          pixels[0] = priv->color.red;
-          pixels[1] = priv->color.green;
-          pixels[2] = priv->color.blue;
+          pixels[0] = self->color.red;
+          pixels[1] = self->color.green;
+          pixels[2] = self->color.blue;
         }
       else
         {
-          switch (priv->shading_direction)
+          switch (self->shading_direction)
             {
             case G_DESKTOP_BACKGROUND_SHADING_VERTICAL:
               width = 1;
@@ -585,15 +566,15 @@ ensure_color_texture (MetaBackground *self)
               g_return_if_reached ();
             }
 
-          pixels[0] = priv->color.red;
-          pixels[1] = priv->color.green;
-          pixels[2] = priv->color.blue;
-          pixels[3] = priv->second_color.red;
-          pixels[4] = priv->second_color.green;
-          pixels[5] = priv->second_color.blue;
+          pixels[0] = self->color.red;
+          pixels[1] = self->color.green;
+          pixels[2] = self->color.blue;
+          pixels[3] = self->second_color.red;
+          pixels[4] = self->second_color.green;
+          pixels[5] = self->second_color.blue;
         }
 
-      priv->color_texture = COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx, width, height,
+      self->color_texture = COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx, width, height,
                                                                          COGL_PIXEL_FORMAT_RGB_888,
                                                                          width * 3,
                                                                          pixels,
@@ -661,9 +642,7 @@ static gboolean
 ensure_wallpaper_texture (MetaBackground *self,
                           CoglTexture    *texture)
 {
-  MetaBackgroundPrivate *priv = self->priv;
-
-  if (priv->wallpaper_texture == NULL && !priv->wallpaper_allocation_failed)
+  if (self->wallpaper_texture == NULL && !self->wallpaper_allocation_failed)
     {
       int width = cogl_texture_get_width (texture);
       int height = cogl_texture_get_height (texture);
@@ -672,10 +651,10 @@ ensure_wallpaper_texture (MetaBackground *self,
       CoglError *catch_error = NULL;
       CoglPipeline *pipeline;
 
-      priv->wallpaper_texture = meta_create_texture (width, height,
+      self->wallpaper_texture = meta_create_texture (width, height,
                                                      COGL_TEXTURE_COMPONENTS_RGBA,
                                                      META_TEXTURE_FLAGS_NONE);
-      offscreen = cogl_offscreen_new_with_texture (priv->wallpaper_texture);
+      offscreen = cogl_offscreen_new_with_texture (self->wallpaper_texture);
       fbo = COGL_FRAMEBUFFER (offscreen);
 
       if (!cogl_framebuffer_allocate (fbo, &catch_error))
@@ -686,11 +665,11 @@ ensure_wallpaper_texture (MetaBackground *self,
            */
           cogl_error_free (catch_error);
 
-          cogl_object_unref (priv->wallpaper_texture);
-          priv->wallpaper_texture = NULL;
+          cogl_object_unref (self->wallpaper_texture);
+          self->wallpaper_texture = NULL;
           cogl_object_unref (fbo);
 
-          priv->wallpaper_allocation_failed = TRUE;
+          self->wallpaper_allocation_failed = TRUE;
           return FALSE;
         }
 
@@ -708,7 +687,7 @@ ensure_wallpaper_texture (MetaBackground *self,
           ensure_color_texture (self);
 
           pipeline = create_pipeline (PIPELINE_OVER_REVERSE);
-          cogl_pipeline_set_layer_texture (pipeline, 0, priv->color_texture);
+          cogl_pipeline_set_layer_texture (pipeline, 0, self->color_texture);
           cogl_framebuffer_draw_rectangle (fbo, pipeline, 0, 0, width, height);
           cogl_object_unref (pipeline);
         }
@@ -716,7 +695,7 @@ ensure_wallpaper_texture (MetaBackground *self,
       cogl_object_unref (fbo);
     }
 
-  return priv->wallpaper_texture != NULL;
+  return self->wallpaper_texture != NULL;
 }
 
 static CoglPipelineWrapMode
@@ -743,26 +722,24 @@ meta_background_get_texture (MetaBackground         *self,
                              cairo_rectangle_int_t  *texture_area,
                              CoglPipelineWrapMode   *wrap_mode)
 {
-  MetaBackgroundPrivate *priv;
   MetaBackgroundMonitor *monitor;
   MetaRectangle geometry;
   cairo_rectangle_int_t monitor_area;
   CoglTexture *texture1, *texture2;
 
   g_return_val_if_fail (META_IS_BACKGROUND (self), NULL);
-  priv = self->priv;
-  g_return_val_if_fail (monitor_index >= 0 && monitor_index < priv->n_monitors, NULL);
+  g_return_val_if_fail (monitor_index >= 0 && monitor_index < self->n_monitors, NULL);
 
-  monitor = &priv->monitors[monitor_index];
+  monitor = &self->monitors[monitor_index];
 
-  meta_display_get_monitor_geometry (priv->display, monitor_index, &geometry);
+  meta_display_get_monitor_geometry (self->display, monitor_index, &geometry);
   monitor_area.x = geometry.x;
   monitor_area.y = geometry.y;
   monitor_area.width = geometry.width;
   monitor_area.height = geometry.height;
 
-  texture1 = priv->background_image1 ? meta_background_image_get_texture (priv->background_image1) : NULL;
-  texture2 = priv->background_image2 ? meta_background_image_get_texture (priv->background_image2) : NULL;
+  texture1 = self->background_image1 ? meta_background_image_get_texture (self->background_image1) : NULL;
+  texture2 = self->background_image2 ? meta_background_image_get_texture (self->background_image2) : NULL;
 
   if (texture1 == NULL && texture2 == NULL)
     {
@@ -771,19 +748,19 @@ meta_background_get_texture (MetaBackground         *self,
         set_texture_area_from_monitor_area (&monitor_area, texture_area);
       if (wrap_mode)
         *wrap_mode = COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
-      return priv->color_texture;
+      return self->color_texture;
     }
 
-  if (texture2 == NULL && priv->style == G_DESKTOP_BACKGROUND_STYLE_WALLPAPER &&
-      priv->shading_direction == G_DESKTOP_BACKGROUND_SHADING_SOLID &&
+  if (texture2 == NULL && self->style == G_DESKTOP_BACKGROUND_STYLE_WALLPAPER &&
+      self->shading_direction == G_DESKTOP_BACKGROUND_SHADING_SOLID &&
       ensure_wallpaper_texture (self, texture1))
     {
       if (texture_area)
-        get_texture_area (self, &monitor_area, priv->wallpaper_texture,
+        get_texture_area (self, &monitor_area, self->wallpaper_texture,
                           texture_area);
       if (wrap_mode)
         *wrap_mode = COGL_PIPELINE_WRAP_MODE_REPEAT;
-      return priv->wallpaper_texture;
+      return self->wallpaper_texture;
     }
 
   if (monitor->dirty)
@@ -820,13 +797,13 @@ meta_background_get_texture (MetaBackground         *self,
       cogl_framebuffer_orthographic (monitor->fbo, 0, 0,
                                      monitor_area.width, monitor_area.height, -1., 1.);
 
-      if (texture2 != NULL && priv->blend_factor != 0.0)
+      if (texture2 != NULL && self->blend_factor != 0.0)
         {
           CoglPipeline *pipeline = create_pipeline (PIPELINE_REPLACE);
           cogl_pipeline_set_color4f (pipeline,
-                                      priv->blend_factor, priv->blend_factor, priv->blend_factor, 
priv->blend_factor);
+                                      self->blend_factor, self->blend_factor, self->blend_factor, 
self->blend_factor);
           cogl_pipeline_set_layer_texture (pipeline, 0, texture2);
-          cogl_pipeline_set_layer_wrap_mode (pipeline, 0, get_wrap_mode (priv->style));
+          cogl_pipeline_set_layer_wrap_mode (pipeline, 0, get_wrap_mode (self->style));
 
           bare_region_visible = draw_texture (self,
                                               monitor->fbo, pipeline,
@@ -841,16 +818,16 @@ meta_background_get_texture (MetaBackground         *self,
                                     0.0, 0.0, 0.0, 0.0);
         }
 
-      if (texture1 != NULL && priv->blend_factor != 1.0)
+      if (texture1 != NULL && self->blend_factor != 1.0)
         {
           CoglPipeline *pipeline = create_pipeline (PIPELINE_ADD);
           cogl_pipeline_set_color4f (pipeline,
-                                     (1 - priv->blend_factor),
-                                     (1 - priv->blend_factor),
-                                     (1 - priv->blend_factor),
-                                     (1 - priv->blend_factor));;
+                                     (1 - self->blend_factor),
+                                     (1 - self->blend_factor),
+                                     (1 - self->blend_factor),
+                                     (1 - self->blend_factor));;
           cogl_pipeline_set_layer_texture (pipeline, 0, texture1);
-          cogl_pipeline_set_layer_wrap_mode (pipeline, 0, get_wrap_mode (priv->style));
+          cogl_pipeline_set_layer_wrap_mode (pipeline, 0, get_wrap_mode (self->style));
 
           bare_region_visible = bare_region_visible || draw_texture (self,
                                                                      monitor->fbo, pipeline,
@@ -864,7 +841,7 @@ meta_background_get_texture (MetaBackground         *self,
           CoglPipeline *pipeline = create_pipeline (PIPELINE_OVER_REVERSE);
 
           ensure_color_texture (self);
-          cogl_pipeline_set_layer_texture (pipeline, 0, priv->color_texture);
+          cogl_pipeline_set_layer_texture (pipeline, 0, self->color_texture);
           cogl_framebuffer_draw_rectangle (monitor->fbo,
                                            pipeline,
                                            0, 0,
@@ -911,17 +888,13 @@ meta_background_set_gradient (MetaBackground            *self,
                               ClutterColor              *color,
                               ClutterColor              *second_color)
 {
-  MetaBackgroundPrivate *priv;
-
   g_return_if_fail (META_IS_BACKGROUND (self));
   g_return_if_fail (color != NULL);
   g_return_if_fail (second_color != NULL);
 
-  priv = self->priv;
-
-  priv->shading_direction = shading_direction;
-  priv->color = *color;
-  priv->second_color = *second_color;
+  self->shading_direction = shading_direction;
+  self->color = *color;
+  self->second_color = *second_color;
 
   free_color_texture (self);
   free_wallpaper_texture (self);
@@ -945,18 +918,14 @@ meta_background_set_blend (MetaBackground          *self,
                            double                   blend_factor,
                            GDesktopBackgroundStyle  style)
 {
-  MetaBackgroundPrivate *priv;
-
   g_return_if_fail (META_IS_BACKGROUND (self));
   g_return_if_fail (blend_factor >= 0.0 && blend_factor <= 1.0);
 
-  priv = self->priv;
-
-  set_file (self, &priv->file1, &priv->background_image1, file1);
-  set_file (self, &priv->file2, &priv->background_image2, file2);
+  set_file (self, &self->file1, &self->background_image1, file1);
+  set_file (self, &self->file2, &self->background_image2, file2);
 
-  priv->blend_factor = blend_factor;
-  priv->style = style;
+  self->blend_factor = blend_factor;
+  self->style = style;
 
   free_wallpaper_texture (self);
   mark_changed (self);
diff --git a/src/compositor/meta-cullable.h b/src/compositor/meta-cullable.h
index d7fe6e483..fc1720c8d 100644
--- a/src/compositor/meta-cullable.h
+++ b/src/compositor/meta-cullable.h
@@ -29,13 +29,8 @@
 
 G_BEGIN_DECLS
 
-#define META_TYPE_CULLABLE             (meta_cullable_get_type ())
-#define META_CULLABLE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_CULLABLE, MetaCullable))
-#define META_IS_CULLABLE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_CULLABLE))
-#define META_CULLABLE_GET_IFACE(obj)   (G_TYPE_INSTANCE_GET_INTERFACE ((obj),  META_TYPE_CULLABLE, 
MetaCullableInterface))
-
-typedef struct _MetaCullable MetaCullable;
-typedef struct _MetaCullableInterface MetaCullableInterface;
+#define META_TYPE_CULLABLE (meta_cullable_get_type ())
+G_DECLARE_INTERFACE (MetaCullable, meta_cullable, META, CULLABLE, ClutterActor)
 
 struct _MetaCullableInterface
 {
@@ -47,8 +42,6 @@ struct _MetaCullableInterface
   void (* reset_culling) (MetaCullable  *cullable);
 };
 
-GType meta_cullable_get_type (void);
-
 void meta_cullable_cull_out (MetaCullable   *cullable,
                              cairo_region_t *unobscured_region,
                              cairo_region_t *clip_region);
diff --git a/src/compositor/meta-dnd-actor-private.h b/src/compositor/meta-dnd-actor-private.h
index f7ad91acc..20be369eb 100644
--- a/src/compositor/meta-dnd-actor-private.h
+++ b/src/compositor/meta-dnd-actor-private.h
@@ -31,28 +31,12 @@
  * This class handles the rendering of the DnD surface
  */
 
-#define META_TYPE_DND_ACTOR            (meta_dnd_actor_get_type ())
-#define META_DND_ACTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_DND_ACTOR, 
MetaDnDActor))
-#define META_DND_ACTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_DND_ACTOR, 
MetaDnDActorClass))
-#define META_IS_DND_ACTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_DND_ACTOR))
-#define META_IS_DND_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_DND_ACTOR))
-#define META_DND_ACTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_DND_ACTOR, 
MetaDnDActorClass))
+#define META_TYPE_DND_ACTOR (meta_dnd_actor_get_type ())
+G_DECLARE_FINAL_TYPE (MetaDnDActor,
+                      meta_dnd_actor,
+                      META, DND_ACTOR,
+                      MetaFeedbackActor)
 
-typedef struct _MetaDnDActor        MetaDnDActor;
-typedef struct _MetaDnDActorClass   MetaDnDActorClass;
-
-struct _MetaDnDActorClass
-{
-  /*< private >*/
-  MetaFeedbackActorClass parent_class;
-};
-
-struct _MetaDnDActor
-{
-  MetaFeedbackActor parent;
-};
-
-GType         meta_dnd_actor_get_type (void);
 
 ClutterActor *meta_dnd_actor_new (ClutterActor *drag_origin,
                                   int           start_x,
diff --git a/src/compositor/meta-dnd-actor.c b/src/compositor/meta-dnd-actor.c
index 24f578be1..d1e3c60ac 100644
--- a/src/compositor/meta-dnd-actor.c
+++ b/src/compositor/meta-dnd-actor.c
@@ -39,16 +39,16 @@ enum {
   PROP_DRAG_START_Y
 };
 
-typedef struct _MetaDnDActorPrivate MetaDnDActorPrivate;
-
-struct _MetaDnDActorPrivate
+struct _MetaDnDActor
 {
+  MetaFeedbackActor parent;
+
   ClutterActor *drag_origin;
   int drag_start_x;
   int drag_start_y;
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (MetaDnDActor, meta_dnd_actor, META_TYPE_FEEDBACK_ACTOR)
+G_DEFINE_TYPE (MetaDnDActor, meta_dnd_actor, META_TYPE_FEEDBACK_ACTOR)
 
 static void
 meta_dnd_actor_set_property (GObject      *object,
@@ -57,18 +57,17 @@ meta_dnd_actor_set_property (GObject      *object,
                              GParamSpec   *pspec)
 {
   MetaDnDActor *self = META_DND_ACTOR (object);
-  MetaDnDActorPrivate *priv = meta_dnd_actor_get_instance_private (self);
 
   switch (prop_id)
     {
     case PROP_DRAG_ORIGIN:
-      priv->drag_origin = g_value_get_object (value);
+      self->drag_origin = g_value_get_object (value);
       break;
     case PROP_DRAG_START_X:
-      priv->drag_start_x = g_value_get_int (value);
+      self->drag_start_x = g_value_get_int (value);
       break;
     case PROP_DRAG_START_Y:
-      priv->drag_start_y = g_value_get_int (value);
+      self->drag_start_y = g_value_get_int (value);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -83,18 +82,17 @@ meta_dnd_actor_get_property (GObject      *object,
                              GParamSpec   *pspec)
 {
   MetaDnDActor *self = META_DND_ACTOR (object);
-  MetaDnDActorPrivate *priv = meta_dnd_actor_get_instance_private (self);
 
   switch (prop_id)
     {
     case PROP_DRAG_ORIGIN:
-      g_value_set_object (value, priv->drag_origin);
+      g_value_set_object (value, self->drag_origin);
       break;
     case PROP_DRAG_START_X:
-      g_value_set_int (value, priv->drag_start_x);
+      g_value_set_int (value, self->drag_start_x);
       break;
     case PROP_DRAG_START_Y:
-      g_value_set_int (value, priv->drag_start_y);
+      g_value_set_int (value, self->drag_start_y);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -185,13 +183,11 @@ void
 meta_dnd_actor_drag_finish (MetaDnDActor *self,
                             gboolean      success)
 {
-  MetaDnDActorPrivate *priv;
   ClutterActor *actor;
 
   g_return_if_fail (META_IS_DND_ACTOR (self));
 
   actor = CLUTTER_ACTOR (self);
-  priv = meta_dnd_actor_get_instance_private (self);
 
   if (success)
     {
@@ -207,18 +203,18 @@ meta_dnd_actor_drag_finish (MetaDnDActor *self,
       clutter_actor_set_easing_duration (actor, DRAG_FAILED_DURATION);
       clutter_actor_set_opacity (actor, 0);
 
-      if (CLUTTER_ACTOR_IS_VISIBLE (priv->drag_origin))
+      if (CLUTTER_ACTOR_IS_VISIBLE (self->drag_origin))
         {
           int anchor_x, anchor_y;
           ClutterPoint dest;
 
-          clutter_actor_get_transformed_position (priv->drag_origin,
+          clutter_actor_get_transformed_position (self->drag_origin,
                                                   &dest.x, &dest.y);
           meta_feedback_actor_get_anchor (META_FEEDBACK_ACTOR (self),
                                           &anchor_x, &anchor_y);
 
-          dest.x += priv->drag_start_x - anchor_x;
-          dest.y += priv->drag_start_y - anchor_y;
+          dest.x += self->drag_start_x - anchor_x;
+          dest.y += self->drag_start_y - anchor_y;
           clutter_actor_set_position (actor, dest.x, dest.y);
         }
 
diff --git a/src/compositor/meta-feedback-actor-private.h b/src/compositor/meta-feedback-actor-private.h
index 6bccefd0c..6b1d2c8fc 100644
--- a/src/compositor/meta-feedback-actor-private.h
+++ b/src/compositor/meta-feedback-actor-private.h
@@ -31,15 +31,12 @@
  * This class handles the rendering of user interaction feedback
  */
 
-#define META_TYPE_FEEDBACK_ACTOR            (meta_feedback_actor_get_type ())
-#define META_FEEDBACK_ACTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_FEEDBACK_ACTOR, 
MetaFeedbackActor))
-#define META_FEEDBACK_ACTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_FEEDBACK_ACTOR, 
MetaFeedbackActorClass))
-#define META_IS_FEEDBACK_ACTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_FEEDBACK_ACTOR))
-#define META_IS_FEEDBACK_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_FEEDBACK_ACTOR))
-#define META_FEEDBACK_ACTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_FEEDBACK_ACTOR, 
MetaFeedbackActorClass))
+#define META_TYPE_FEEDBACK_ACTOR (meta_feedback_actor_get_type ())
+G_DECLARE_DERIVABLE_TYPE (MetaFeedbackActor,
+                          meta_feedback_actor,
+                          META, FEEDBACK_ACTOR,
+                          ClutterActor)
 
-typedef struct _MetaFeedbackActor        MetaFeedbackActor;
-typedef struct _MetaFeedbackActorClass   MetaFeedbackActorClass;
 
 struct _MetaFeedbackActorClass
 {
@@ -47,12 +44,6 @@ struct _MetaFeedbackActorClass
   ClutterActorClass parent_class;
 };
 
-struct _MetaFeedbackActor
-{
-  ClutterActor parent;
-};
-
-GType meta_feedback_actor_get_type (void);
 
 ClutterActor *meta_feedback_actor_new (int anchor_x,
                                        int anchor_y);
diff --git a/src/compositor/meta-shadow-factory.c b/src/compositor/meta-shadow-factory.c
index ab358dd6d..f254af602 100644
--- a/src/compositor/meta-shadow-factory.c
+++ b/src/compositor/meta-shadow-factory.c
@@ -22,6 +22,14 @@
  * @short_description: Create and cache shadow textures for abritrary window shapes
  */
 
+/**
+ * MetaShadowFactory:
+ *
+ * #MetaShadowFactory is used to create window shadows. It caches shadows internally
+ * so that multiple shadows created for the same shape with the same radius will
+ * share the same MetaShadow.
+ */
+
 #include "config.h"
 
 #include <math.h>
diff --git a/src/compositor/meta-shaped-texture.c b/src/compositor/meta-shaped-texture.c
index 3a7710301..e1aaf1528 100644
--- a/src/compositor/meta-shaped-texture.c
+++ b/src/compositor/meta-shaped-texture.c
@@ -70,10 +70,6 @@ static gboolean meta_shaped_texture_get_paint_volume (ClutterActor *self, Clutte
 
 static void cullable_iface_init (MetaCullableInterface *iface);
 
-#define META_SHAPED_TEXTURE_GET_PRIVATE(obj) \
-  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), META_TYPE_SHAPED_TEXTURE, \
-                                MetaShapedTexturePrivate))
-
 enum {
   SIZE_CHANGED,
 
@@ -82,8 +78,10 @@ enum {
 
 static guint signals[LAST_SIGNAL];
 
-struct _MetaShapedTexturePrivate
+struct _MetaShapedTexture
 {
+  ClutterActor parent;
+
   MetaTextureTower *paint_tower;
 
   CoglTexture *texture;
@@ -119,7 +117,6 @@ struct _MetaShapedTexturePrivate
 };
 
 G_DEFINE_TYPE_WITH_CODE (MetaShapedTexture, meta_shaped_texture, CLUTTER_TYPE_ACTOR,
-                         G_ADD_PRIVATE (MetaShapedTexture)
                          G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
 
 static void
@@ -146,73 +143,66 @@ meta_shaped_texture_class_init (MetaShapedTextureClass *klass)
 static void
 invalidate_size (MetaShapedTexture *stex)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
-
-  priv->size_invalid = TRUE;
+  stex->size_invalid = TRUE;
 }
 
 static void
-meta_shaped_texture_init (MetaShapedTexture *self)
+meta_shaped_texture_init (MetaShapedTexture *stex)
 {
-  MetaShapedTexturePrivate *priv;
+  stex->paint_tower = meta_texture_tower_new ();
 
-  priv = self->priv = META_SHAPED_TEXTURE_GET_PRIVATE (self);
+  stex->texture = NULL;
+  stex->mask_texture = NULL;
+  stex->create_mipmaps = TRUE;
+  stex->is_y_inverted = TRUE;
+  stex->transform = META_MONITOR_TRANSFORM_NORMAL;
 
-  priv->paint_tower = meta_texture_tower_new ();
-
-  priv->texture = NULL;
-  priv->mask_texture = NULL;
-  priv->create_mipmaps = TRUE;
-  priv->is_y_inverted = TRUE;
-  priv->transform = META_MONITOR_TRANSFORM_NORMAL;
-
-  g_signal_connect (self,
+  g_signal_connect (stex,
                     "notify::scale-x",
                     G_CALLBACK (invalidate_size),
-                    self);
+                    stex);
 }
 
 static void
 update_size (MetaShapedTexture *stex)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
   int dst_width;
   int dst_height;
 
-  if (meta_monitor_transform_is_rotated (priv->transform))
+  if (meta_monitor_transform_is_rotated (stex->transform))
     {
-      if (priv->texture)
+      if (stex->texture)
         {
-          dst_width = priv->tex_height;
-          dst_height = priv->tex_width;
+          dst_width = stex->tex_height;
+          dst_height = stex->tex_width;
         }
       else
         {
-          dst_width = priv->fallback_height;
-          dst_height = priv->fallback_width;
+          dst_width = stex->fallback_height;
+          dst_height = stex->fallback_width;
         }
     }
   else
     {
-      if (priv->texture)
+      if (stex->texture)
         {
-          dst_width = priv->tex_width;
-          dst_height = priv->tex_height;
+          dst_width = stex->tex_width;
+          dst_height = stex->tex_height;
         }
       else
         {
-          dst_width = priv->fallback_width;
-          dst_height = priv->fallback_height;
+          dst_width = stex->fallback_width;
+          dst_height = stex->fallback_height;
         }
     }
 
-  priv->size_invalid = FALSE;
+  stex->size_invalid = FALSE;
 
-  if (priv->dst_width != dst_width ||
-      priv->dst_height != dst_height)
+  if (stex->dst_width != dst_width ||
+      stex->dst_height != dst_height)
     {
-      priv->dst_width = dst_width;
-      priv->dst_height = dst_height;
+      stex->dst_width = dst_width;
+      stex->dst_height = dst_height;
       meta_shaped_texture_set_mask_texture (stex, NULL);
       clutter_actor_queue_relayout (CLUTTER_ACTOR (stex));
       g_signal_emit (stex, signals[SIZE_CHANGED], 0);
@@ -222,80 +212,71 @@ update_size (MetaShapedTexture *stex)
 static void
 ensure_size_valid (MetaShapedTexture *stex)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
-
-  if (priv->size_invalid)
+  if (stex->size_invalid)
     update_size (stex);
 }
 
 static void
-set_unobscured_region (MetaShapedTexture *self,
+set_unobscured_region (MetaShapedTexture *stex,
                        cairo_region_t    *unobscured_region)
 {
-  MetaShapedTexturePrivate *priv = self->priv;
-
-  g_clear_pointer (&priv->unobscured_region, cairo_region_destroy);
+  g_clear_pointer (&stex->unobscured_region, cairo_region_destroy);
   if (unobscured_region)
     {
       int width, height;
 
-      ensure_size_valid (self);
-      width = priv->dst_width;
-      height = priv->dst_height;
+      ensure_size_valid (stex);
+      width = stex->dst_width;
+      height = stex->dst_height;
 
       cairo_rectangle_int_t bounds = { 0, 0, width, height };
-      priv->unobscured_region = cairo_region_copy (unobscured_region);
-      cairo_region_intersect_rectangle (priv->unobscured_region, &bounds);
+      stex->unobscured_region = cairo_region_copy (unobscured_region);
+      cairo_region_intersect_rectangle (stex->unobscured_region, &bounds);
     }
 }
 
 static void
-set_clip_region (MetaShapedTexture *self,
+set_clip_region (MetaShapedTexture *stex,
                  cairo_region_t    *clip_region)
 {
-  MetaShapedTexturePrivate *priv = self->priv;
-
-  g_clear_pointer (&priv->clip_region, cairo_region_destroy);
+  g_clear_pointer (&stex->clip_region, cairo_region_destroy);
   if (clip_region)
-    priv->clip_region = cairo_region_copy (clip_region);
+    stex->clip_region = cairo_region_copy (clip_region);
 }
 
 static void
 meta_shaped_texture_reset_pipelines (MetaShapedTexture *stex)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
-
-  g_clear_pointer (&priv->base_pipeline, cogl_object_unref);
-  g_clear_pointer (&priv->masked_pipeline, cogl_object_unref);
-  g_clear_pointer (&priv->unblended_pipeline, cogl_object_unref);
+  g_clear_pointer (&stex->base_pipeline, cogl_object_unref);
+  g_clear_pointer (&stex->masked_pipeline, cogl_object_unref);
+  g_clear_pointer (&stex->unblended_pipeline, cogl_object_unref);
 }
 
 static void
 meta_shaped_texture_dispose (GObject *object)
 {
-  MetaShapedTexture *self = (MetaShapedTexture *) object;
-  MetaShapedTexturePrivate *priv = self->priv;
+  MetaShapedTexture *stex = (MetaShapedTexture *) object;
 
-  if (priv->remipmap_timeout_id)
+  if (stex->remipmap_timeout_id)
     {
-      g_source_remove (priv->remipmap_timeout_id);
-      priv->remipmap_timeout_id = 0;
+      g_source_remove (stex->remipmap_timeout_id);
+      stex->remipmap_timeout_id = 0;
     }
 
-  if (priv->paint_tower)
-    meta_texture_tower_free (priv->paint_tower);
-  priv->paint_tower = NULL;
+  if (stex->paint_tower)
+    meta_texture_tower_free (stex->paint_tower);
+  stex->paint_tower = NULL;
 
-  g_clear_pointer (&priv->texture, cogl_object_unref);
-  g_clear_pointer (&priv->opaque_region, cairo_region_destroy);
+  g_clear_pointer (&stex->texture, cogl_object_unref);
+  g_clear_pointer (&stex->opaque_region, cairo_region_destroy);
 
-  meta_shaped_texture_set_mask_texture (self, NULL);
-  set_unobscured_region (self, NULL);
-  set_clip_region (self, NULL);
+  meta_shaped_texture_set_mask_texture (stex, NULL);
+  set_unobscured_region (stex, NULL);
+  set_clip_region (stex, NULL);
 
-  meta_shaped_texture_reset_pipelines (self);
+  meta_shaped_texture_reset_pipelines (stex);
 
-  g_clear_pointer (&priv->snippet, cogl_object_unref);
+  g_clear_pointer (&stex->snippet, cogl_object_unref);
 
   G_OBJECT_CLASS (meta_shaped_texture_parent_class)->dispose (object);
 }
@@ -304,11 +285,10 @@ static CoglPipeline *
 get_base_pipeline (MetaShapedTexture *stex,
                    CoglContext       *ctx)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
   CoglPipeline *pipeline;
 
-  if (priv->base_pipeline)
-    return priv->base_pipeline;
+  if (stex->base_pipeline)
+    return stex->base_pipeline;
 
   pipeline = cogl_pipeline_new (ctx);
   cogl_pipeline_set_layer_wrap_mode_s (pipeline, 0,
@@ -319,7 +299,7 @@ get_base_pipeline (MetaShapedTexture *stex,
                                        COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE);
   cogl_pipeline_set_layer_wrap_mode_t (pipeline, 1,
                                        COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE);
-  if (!priv->is_y_inverted)
+  if (!stex->is_y_inverted)
     {
       CoglMatrix matrix;
 
@@ -329,13 +309,13 @@ get_base_pipeline (MetaShapedTexture *stex,
       cogl_pipeline_set_layer_matrix (pipeline, 0, &matrix);
     }
 
-  if (priv->transform != META_MONITOR_TRANSFORM_NORMAL)
+  if (stex->transform != META_MONITOR_TRANSFORM_NORMAL)
     {
       CoglMatrix matrix;
       CoglEuler euler;
 
       cogl_matrix_init_translation (&matrix, 0.5, 0.5, 0.0);
-      switch (priv->transform)
+      switch (stex->transform)
         {
         case META_MONITOR_TRANSFORM_90:
           cogl_euler_init (&euler, 0.0, 0.0, 90.0);
@@ -368,12 +348,12 @@ get_base_pipeline (MetaShapedTexture *stex,
       cogl_pipeline_set_layer_matrix (pipeline, 1, &matrix);
     }
 
-  if (priv->snippet)
-    cogl_pipeline_add_layer_snippet (pipeline, 0, priv->snippet);
+  if (stex->snippet)
+    cogl_pipeline_add_layer_snippet (pipeline, 0, stex->snippet);
 
-  priv->base_pipeline = pipeline;
+  stex->base_pipeline = pipeline;
 
-  return priv->base_pipeline;
+  return stex->base_pipeline;
 }
 
 static CoglPipeline *
@@ -387,18 +367,17 @@ static CoglPipeline *
 get_masked_pipeline (MetaShapedTexture *stex,
                      CoglContext       *ctx)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
   CoglPipeline *pipeline;
 
-  if (priv->masked_pipeline)
-    return priv->masked_pipeline;
+  if (stex->masked_pipeline)
+    return stex->masked_pipeline;
 
   pipeline = cogl_pipeline_copy (get_base_pipeline (stex, ctx));
   cogl_pipeline_set_layer_combine (pipeline, 1,
                                    "RGBA = MODULATE (PREVIOUS, TEXTURE[A])",
                                    NULL);
 
-  priv->masked_pipeline = pipeline;
+  stex->masked_pipeline = pipeline;
 
   return pipeline;
 }
@@ -407,12 +386,11 @@ static CoglPipeline *
 get_unblended_pipeline (MetaShapedTexture *stex,
                         CoglContext       *ctx)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
   CoglPipeline *pipeline;
   CoglColor color;
 
-  if (priv->unblended_pipeline)
-    return priv->unblended_pipeline;
+  if (stex->unblended_pipeline)
+    return stex->unblended_pipeline;
 
   pipeline = cogl_pipeline_copy (get_base_pipeline (stex, ctx));
   cogl_color_init_from_4ub (&color, 255, 255, 255, 255);
@@ -421,7 +399,7 @@ get_unblended_pipeline (MetaShapedTexture *stex,
                            NULL);
   cogl_pipeline_set_color (pipeline, &color);
 
-  priv->unblended_pipeline = pipeline;
+  stex->unblended_pipeline = pipeline;
 
   return pipeline;
 }
@@ -459,17 +437,14 @@ static void
 set_cogl_texture (MetaShapedTexture *stex,
                   CoglTexture       *cogl_tex)
 {
-  MetaShapedTexturePrivate *priv;
   int width, height;
 
   g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
 
-  priv = stex->priv;
-
-  if (priv->texture)
-    cogl_object_unref (priv->texture);
+  if (stex->texture)
+    cogl_object_unref (stex->texture);
 
-  priv->texture = cogl_tex;
+  stex->texture = cogl_tex;
 
   if (cogl_tex != NULL)
     {
@@ -483,11 +458,11 @@ set_cogl_texture (MetaShapedTexture *stex,
       height = 0;
     }
 
-  if (priv->tex_width != width ||
-      priv->tex_height != height)
+  if (stex->tex_width != width ||
+      stex->tex_height != height)
     {
-      priv->tex_width = width;
-      priv->tex_height = height;
+      stex->tex_width = width;
+      stex->tex_height = height;
       update_size (stex);
     }
 
@@ -496,21 +471,20 @@ set_cogl_texture (MetaShapedTexture *stex,
    * previous buffer. We only queue a redraw in response to surface
    * damage. */
 
-  if (priv->create_mipmaps)
-    meta_texture_tower_set_base_texture (priv->paint_tower, cogl_tex);
+  if (stex->create_mipmaps)
+    meta_texture_tower_set_base_texture (stex->paint_tower, cogl_tex);
 }
 
 static gboolean
 texture_is_idle_and_not_mipmapped (gpointer user_data)
 {
   MetaShapedTexture *stex = META_SHAPED_TEXTURE (user_data);
-  MetaShapedTexturePrivate *priv = stex->priv;
 
-  if ((g_get_monotonic_time () - priv->earliest_remipmap) < 0)
+  if ((g_get_monotonic_time () - stex->earliest_remipmap) < 0)
     return G_SOURCE_CONTINUE;
 
   clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
-  priv->remipmap_timeout_id = 0;
+  stex->remipmap_timeout_id = 0;
 
   return G_SOURCE_REMOVE;
 }
@@ -519,7 +493,6 @@ static void
 meta_shaped_texture_paint (ClutterActor *actor)
 {
   MetaShapedTexture *stex = (MetaShapedTexture *) actor;
-  MetaShapedTexturePrivate *priv = stex->priv;
   double tex_scale;
   int dst_width, dst_height;
   cairo_rectangle_int_t tex_rect;
@@ -535,7 +508,7 @@ meta_shaped_texture_paint (ClutterActor *actor)
   CoglPipelineFilter filter;
   gint64 now = g_get_monotonic_time ();
 
-  if (priv->clip_region && cairo_region_is_empty (priv->clip_region))
+  if (stex->clip_region && cairo_region_is_empty (stex->clip_region))
     return;
 
   if (!CLUTTER_ACTOR_IS_REALIZED (CLUTTER_ACTOR (stex)))
@@ -556,29 +529,29 @@ meta_shaped_texture_paint (ClutterActor *actor)
    * Setting the texture quality to high without SGIS_generate_mipmap
    * support for TFP textures will result in fallbacks to XGetImage.
    */
-  if (priv->create_mipmaps && priv->last_invalidation)
+  if (stex->create_mipmaps && stex->last_invalidation)
     {
-      gint64 age = now - priv->last_invalidation;
+      gint64 age = now - stex->last_invalidation;
 
       if (age >= MIN_MIPMAP_AGE_USEC ||
-          priv->fast_updates < MIN_FAST_UPDATES_BEFORE_UNMIPMAP)
-        paint_tex = meta_texture_tower_get_paint_texture (priv->paint_tower);
+          stex->fast_updates < MIN_FAST_UPDATES_BEFORE_UNMIPMAP)
+        paint_tex = meta_texture_tower_get_paint_texture (stex->paint_tower);
     }
 
   if (paint_tex == NULL)
     {
-      paint_tex = COGL_TEXTURE (priv->texture);
+      paint_tex = COGL_TEXTURE (stex->texture);
 
       if (paint_tex == NULL)
         return;
 
-      if (priv->create_mipmaps)
+      if (stex->create_mipmaps)
         {
           /* Minus 1000 to ensure we don't fail the age test in timeout */
-          priv->earliest_remipmap = now + MIN_MIPMAP_AGE_USEC - 1000;
+          stex->earliest_remipmap = now + MIN_MIPMAP_AGE_USEC - 1000;
 
-          if (!priv->remipmap_timeout_id)
-            priv->remipmap_timeout_id =
+          if (!stex->remipmap_timeout_id)
+            stex->remipmap_timeout_id =
               g_timeout_add (MIN_MIPMAP_AGE_USEC / 1000,
                              texture_is_idle_and_not_mipmapped,
                              stex);
@@ -587,9 +560,9 @@ meta_shaped_texture_paint (ClutterActor *actor)
 
   clutter_actor_get_scale (actor, &tex_scale, NULL);
   ensure_size_valid (stex);
-  dst_width = priv->dst_width;
-  dst_height = priv->dst_height;
+  dst_width = stex->dst_width;
 
+  dst_height = stex->dst_height;
   if (dst_width == 0 || dst_height == 0) /* no contents yet */
     return;
 
@@ -610,10 +583,10 @@ meta_shaped_texture_paint (ClutterActor *actor)
   opacity = clutter_actor_get_paint_opacity (actor);
   clutter_actor_get_allocation_box (actor, &alloc);
 
-  if (priv->opaque_region && opacity == 255)
+  if (stex->opaque_region && opacity == 255)
     {
       opaque_tex_region =
-        meta_region_scale_double (priv->opaque_region,
+        meta_region_scale_double (stex->opaque_region,
                                   1.0 / tex_scale,
                                   META_ROUNDING_STRATEGY_SHRINK);
       use_opaque_region = TRUE;
@@ -624,10 +597,10 @@ meta_shaped_texture_paint (ClutterActor *actor)
       use_opaque_region = FALSE;
     }
 
-  if (priv->clip_region)
+  if (stex->clip_region)
     {
       clip_tex_region =
-        meta_region_scale_double (priv->clip_region,
+        meta_region_scale_double (stex->clip_region,
                                   1.0 / tex_scale,
                                   META_ROUNDING_STRATEGY_GROW);
     }
@@ -719,14 +692,14 @@ meta_shaped_texture_paint (ClutterActor *actor)
     {
       CoglPipeline *blended_pipeline;
 
-      if (priv->mask_texture == NULL)
+      if (stex->mask_texture == NULL)
         {
           blended_pipeline = get_unmasked_pipeline (stex, ctx);
         }
       else
         {
           blended_pipeline = get_masked_pipeline (stex, ctx);
-          cogl_pipeline_set_layer_texture (blended_pipeline, 1, priv->mask_texture);
+          cogl_pipeline_set_layer_texture (blended_pipeline, 1, stex->mask_texture);
           cogl_pipeline_set_layer_filters (blended_pipeline, 1, filter, filter);
         }
 
@@ -776,14 +749,13 @@ meta_shaped_texture_get_preferred_width (ClutterActor *self,
                                          gfloat       *natural_width_p)
 {
   MetaShapedTexture *stex = META_SHAPED_TEXTURE (self);
-  MetaShapedTexturePrivate *priv = stex->priv;
 
   ensure_size_valid (stex);
 
   if (min_width_p)
-    *min_width_p = priv->dst_width;
+    *min_width_p = stex->dst_width;
   if (natural_width_p)
-    *natural_width_p = priv->dst_width;
+    *natural_width_p = stex->dst_width;
 }
 
 static void
@@ -793,24 +765,22 @@ meta_shaped_texture_get_preferred_height (ClutterActor *self,
                                           gfloat       *natural_height_p)
 {
   MetaShapedTexture *stex = META_SHAPED_TEXTURE (self);
-  MetaShapedTexturePrivate *priv = stex->priv;
 
   ensure_size_valid (stex);
 
   if (min_height_p)
-    *min_height_p = priv->dst_height;
+    *min_height_p = stex->dst_height;
   if (natural_height_p)
-    *natural_height_p = priv->dst_height;
+    *natural_height_p = stex->dst_height;
 }
 
 static cairo_region_t *
-effective_unobscured_region (MetaShapedTexture *self)
+effective_unobscured_region (MetaShapedTexture *stex)
 {
-  MetaShapedTexturePrivate *priv = self->priv;
   ClutterActor *actor;
 
   /* Fail if we have any mapped clones. */
-  actor = CLUTTER_ACTOR (self);
+  actor = CLUTTER_ACTOR (stex);
   do
     {
       if (clutter_actor_has_mapped_clones (actor))
@@ -819,7 +789,7 @@ effective_unobscured_region (MetaShapedTexture *self)
     }
   while (actor != NULL);
 
-  return priv->unobscured_region;
+  return stex->unobscured_region;
 }
 
 static gboolean
@@ -833,20 +803,16 @@ void
 meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex,
                                        gboolean           create_mipmaps)
 {
-  MetaShapedTexturePrivate *priv;
-
   g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
 
-  priv = stex->priv;
-
   create_mipmaps = create_mipmaps != FALSE;
 
-  if (create_mipmaps != priv->create_mipmaps)
+  if (create_mipmaps != stex->create_mipmaps)
     {
       CoglTexture *base_texture;
-      priv->create_mipmaps = create_mipmaps;
-      base_texture = create_mipmaps ? priv->texture : NULL;
-      meta_texture_tower_set_base_texture (priv->paint_tower, base_texture);
+      stex->create_mipmaps = create_mipmaps;
+      base_texture = create_mipmaps ? stex->texture : NULL;
+      meta_texture_tower_set_base_texture (stex->paint_tower, base_texture);
     }
 }
 
@@ -854,27 +820,23 @@ void
 meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
                                       CoglTexture       *mask_texture)
 {
-  MetaShapedTexturePrivate *priv;
-
   g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
 
-  priv = stex->priv;
-
-  g_clear_pointer (&priv->mask_texture, cogl_object_unref);
+  g_clear_pointer (&stex->mask_texture, cogl_object_unref);
 
   if (mask_texture != NULL)
     {
-      priv->mask_texture = mask_texture;
-      cogl_object_ref (priv->mask_texture);
+      stex->mask_texture = mask_texture;
+      cogl_object_ref (stex->mask_texture);
     }
 
   clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }
 
 gboolean
-meta_shaped_texture_is_obscured (MetaShapedTexture *self)
+meta_shaped_texture_is_obscured (MetaShapedTexture *stex)
 {
-  cairo_region_t *unobscured_region = effective_unobscured_region (self);
+  cairo_region_t *unobscured_region = effective_unobscured_region (stex);
 
   if (unobscured_region)
     return cairo_region_is_empty (unobscured_region);
@@ -902,29 +864,26 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
                                 int                width,
                                 int                height)
 {
-  MetaShapedTexturePrivate *priv;
   cairo_region_t *unobscured_region;
   const cairo_rectangle_int_t clip = { x, y, width, height };
 
-  priv = stex->priv;
-
-  if (priv->texture == NULL)
+  if (stex->texture == NULL)
     return FALSE;
 
-  meta_texture_tower_update_area (priv->paint_tower, x, y, width, height);
+  meta_texture_tower_update_area (stex->paint_tower, x, y, width, height);
 
-  priv->prev_invalidation = priv->last_invalidation;
-  priv->last_invalidation = g_get_monotonic_time ();
+  stex->prev_invalidation = stex->last_invalidation;
+  stex->last_invalidation = g_get_monotonic_time ();
 
-  if (priv->prev_invalidation)
+  if (stex->prev_invalidation)
     {
-      gint64 interval = priv->last_invalidation - priv->prev_invalidation;
+      gint64 interval = stex->last_invalidation - stex->prev_invalidation;
       gboolean fast_update = interval < MIN_MIPMAP_AGE_USEC;
 
       if (!fast_update)
-        priv->fast_updates = 0;
-      else if (priv->fast_updates < MIN_FAST_UPDATES_BEFORE_UNMIPMAP)
-        priv->fast_updates++;
+        stex->fast_updates = 0;
+      else if (stex->fast_updates < MIN_FAST_UPDATES_BEFORE_UNMIPMAP)
+        stex->fast_updates++;
     }
 
   unobscured_region = effective_unobscured_region (stex);
@@ -978,14 +937,12 @@ void
 meta_shaped_texture_set_is_y_inverted (MetaShapedTexture *stex,
                                        gboolean           is_y_inverted)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
-
-  if (priv->is_y_inverted == is_y_inverted)
+  if (stex->is_y_inverted == is_y_inverted)
     return;
 
   meta_shaped_texture_reset_pipelines (stex);
 
-  priv->is_y_inverted = is_y_inverted;
+  stex->is_y_inverted = is_y_inverted;
 }
 
 /**
@@ -995,16 +952,14 @@ void
 meta_shaped_texture_set_snippet (MetaShapedTexture *stex,
                                  CoglSnippet       *snippet)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
-
-  if (priv->snippet == snippet)
+  if (stex->snippet == snippet)
     return;
 
   meta_shaped_texture_reset_pipelines (stex);
 
-  g_clear_pointer (&priv->snippet, cogl_object_unref);
+  g_clear_pointer (&stex->snippet, cogl_object_unref);
   if (snippet)
-    priv->snippet = cogl_object_ref (snippet);
+    stex->snippet = cogl_object_ref (snippet);
 }
 
 /**
@@ -1017,7 +972,7 @@ CoglTexture *
 meta_shaped_texture_get_texture (MetaShapedTexture *stex)
 {
   g_return_val_if_fail (META_IS_SHAPED_TEXTURE (stex), NULL);
-  return COGL_TEXTURE (stex->priv->texture);
+  return COGL_TEXTURE (stex->texture);
 }
 
 /**
@@ -1035,38 +990,31 @@ void
 meta_shaped_texture_set_opaque_region (MetaShapedTexture *stex,
                                        cairo_region_t    *opaque_region)
 {
-  MetaShapedTexturePrivate *priv;
-
   g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
 
-  priv = stex->priv;
-
-  if (priv->opaque_region)
-    cairo_region_destroy (priv->opaque_region);
+  if (stex->opaque_region)
+    cairo_region_destroy (stex->opaque_region);
 
   if (opaque_region)
-    priv->opaque_region = cairo_region_reference (opaque_region);
+    stex->opaque_region = cairo_region_reference (opaque_region);
   else
-    priv->opaque_region = NULL;
+    stex->opaque_region = NULL;
 }
 
 cairo_region_t *
 meta_shaped_texture_get_opaque_region (MetaShapedTexture *stex)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
-  return priv->opaque_region;
+  return stex->opaque_region;
 }
 
 void
 meta_shaped_texture_set_transform (MetaShapedTexture    *stex,
                                    MetaMonitorTransform  transform)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
-
-  if (priv->transform == transform)
+  if (stex->transform == transform)
     return;
 
-  priv->transform = transform;
+  stex->transform = transform;
 
   meta_shaped_texture_reset_pipelines (stex);
   invalidate_size (stex);
@@ -1096,7 +1044,7 @@ meta_shaped_texture_get_image (MetaShapedTexture     *stex,
 
   g_return_val_if_fail (META_IS_SHAPED_TEXTURE (stex), NULL);
 
-  texture = COGL_TEXTURE (stex->priv->texture);
+  texture = COGL_TEXTURE (stex->texture);
 
   if (texture == NULL)
     return NULL;
@@ -1132,7 +1080,7 @@ meta_shaped_texture_get_image (MetaShapedTexture     *stex,
   if (clip != NULL)
     cogl_object_unref (texture);
 
-  mask_texture = stex->priv->mask_texture;
+  mask_texture = stex->mask_texture;
   if (mask_texture != NULL)
     {
       cairo_t *cr;
@@ -1175,10 +1123,8 @@ meta_shaped_texture_set_fallback_size (MetaShapedTexture *stex,
                                        int                fallback_width,
                                        int                fallback_height)
 {
-  MetaShapedTexturePrivate *priv = stex->priv;
-
-  priv->fallback_width = fallback_width;
-  priv->fallback_height = fallback_height;
+  stex->fallback_width = fallback_width;
+  stex->fallback_height = fallback_height;
 
   invalidate_size (stex);
 }
@@ -1188,20 +1134,19 @@ meta_shaped_texture_cull_out (MetaCullable   *cullable,
                               cairo_region_t *unobscured_region,
                               cairo_region_t *clip_region)
 {
-  MetaShapedTexture *self = META_SHAPED_TEXTURE (cullable);
-  MetaShapedTexturePrivate *priv = self->priv;
+  MetaShapedTexture *stex = META_SHAPED_TEXTURE (cullable);
 
-  set_unobscured_region (self, unobscured_region);
-  set_clip_region (self, clip_region);
+  set_unobscured_region (stex, unobscured_region);
+  set_clip_region (stex, clip_region);
 
-  if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (self)) == 0xff)
+  if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (stex)) == 0xff)
     {
-      if (priv->opaque_region)
+      if (stex->opaque_region)
         {
           if (unobscured_region)
-            cairo_region_subtract (unobscured_region, priv->opaque_region);
+            cairo_region_subtract (unobscured_region, stex->opaque_region);
           if (clip_region)
-            cairo_region_subtract (clip_region, priv->opaque_region);
+            cairo_region_subtract (clip_region, stex->opaque_region);
         }
     }
 }
diff --git a/src/compositor/meta-surface-actor-wayland.c b/src/compositor/meta-surface-actor-wayland.c
index a099cef72..f8d6c32b7 100644
--- a/src/compositor/meta-surface-actor-wayland.c
+++ b/src/compositor/meta-surface-actor-wayland.c
@@ -37,15 +37,17 @@
 #include "wayland/meta-wayland-private.h"
 #include "wayland/meta-window-wayland.h"
 
-typedef struct _MetaSurfaceActorWaylandPrivate
+struct _MetaSurfaceActorWayland
 {
+  MetaSurfaceActor parent;
+
   MetaWaylandSurface *surface;
   struct wl_list frame_callback_list;
-} MetaSurfaceActorWaylandPrivate;
+};
 
-G_DEFINE_TYPE_WITH_PRIVATE (MetaSurfaceActorWayland,
-                            meta_surface_actor_wayland,
-                            META_TYPE_SURFACE_ACTOR)
+G_DEFINE_TYPE (MetaSurfaceActorWayland,
+               meta_surface_actor_wayland,
+               META_TYPE_SURFACE_ACTOR)
 
 static void
 meta_surface_actor_wayland_process_damage (MetaSurfaceActor *actor,
@@ -93,9 +95,7 @@ void
 meta_surface_actor_wayland_add_frame_callbacks (MetaSurfaceActorWayland *self,
                                                 struct wl_list *frame_callbacks)
 {
-  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
-
-  wl_list_insert_list (&priv->frame_callback_list, frame_callbacks);
+  wl_list_insert_list (&self->frame_callback_list, frame_callbacks);
 }
 
 static MetaWindow *
@@ -162,15 +162,13 @@ static void
 meta_surface_actor_wayland_paint (ClutterActor *actor)
 {
   MetaSurfaceActorWayland *self = META_SURFACE_ACTOR_WAYLAND (actor);
-  MetaSurfaceActorWaylandPrivate *priv =
-    meta_surface_actor_wayland_get_instance_private (self);
 
-  if (priv->surface)
+  if (self->surface)
     {
-      MetaWaylandCompositor *compositor = priv->surface->compositor;
+      MetaWaylandCompositor *compositor = self->surface->compositor;
 
-      wl_list_insert_list (&compositor->frame_callbacks, &priv->frame_callback_list);
-      wl_list_init (&priv->frame_callback_list);
+      wl_list_insert_list (&compositor->frame_callbacks, &self->frame_callback_list);
+      wl_list_init (&self->frame_callback_list);
     }
 
   CLUTTER_ACTOR_CLASS (meta_surface_actor_wayland_parent_class)->paint (actor);
@@ -180,21 +178,19 @@ static void
 meta_surface_actor_wayland_dispose (GObject *object)
 {
   MetaSurfaceActorWayland *self = META_SURFACE_ACTOR_WAYLAND (object);
-  MetaSurfaceActorWaylandPrivate *priv =
-    meta_surface_actor_wayland_get_instance_private (self);
   MetaWaylandFrameCallback *cb, *next;
   MetaShapedTexture *stex =
     meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
 
   meta_shaped_texture_set_texture (stex, NULL);
-  if (priv->surface)
+  if (self->surface)
     {
-      g_object_remove_weak_pointer (G_OBJECT (priv->surface),
-                                    (gpointer *) &priv->surface);
-      priv->surface = NULL;
+      g_object_remove_weak_pointer (G_OBJECT (self->surface),
+                                    (gpointer *) &self->surface);
+      self->surface = NULL;
     }
 
-  wl_list_for_each_safe (cb, next, &priv->frame_callback_list, link)
+  wl_list_for_each_safe (cb, next, &self->frame_callback_list, link)
     wl_resource_destroy (cb->resource);
 
   G_OBJECT_CLASS (meta_surface_actor_wayland_parent_class)->dispose (object);
@@ -233,14 +229,13 @@ 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 ());
 
-  wl_list_init (&priv->frame_callback_list);
-  priv->surface = surface;
-  g_object_add_weak_pointer (G_OBJECT (priv->surface),
-                             (gpointer *) &priv->surface);
+  wl_list_init (&self->frame_callback_list);
+  self->surface = surface;
+  g_object_add_weak_pointer (G_OBJECT (self->surface),
+                             (gpointer *) &self->surface);
 
   return META_SURFACE_ACTOR (self);
 }
@@ -248,6 +243,5 @@ meta_surface_actor_wayland_new (MetaWaylandSurface *surface)
 MetaWaylandSurface *
 meta_surface_actor_wayland_get_surface (MetaSurfaceActorWayland *self)
 {
-  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
-  return priv->surface;
+  return self->surface;
 }
diff --git a/src/compositor/meta-surface-actor-wayland.h b/src/compositor/meta-surface-actor-wayland.h
index a037941e1..e1ad843f7 100644
--- a/src/compositor/meta-surface-actor-wayland.h
+++ b/src/compositor/meta-surface-actor-wayland.h
@@ -34,27 +34,11 @@
 
 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);
+#define META_TYPE_SURFACE_ACTOR_WAYLAND (meta_surface_actor_wayland_get_type ())
+G_DECLARE_FINAL_TYPE (MetaSurfaceActorWayland,
+                      meta_surface_actor_wayland,
+                      META, SURFACE_ACTOR_WAYLAND,
+                      MetaSurfaceActor)
 
 MetaSurfaceActor * meta_surface_actor_wayland_new (MetaWaylandSurface *surface);
 MetaWaylandSurface * meta_surface_actor_wayland_get_surface (MetaSurfaceActorWayland *self);
diff --git a/src/compositor/meta-surface-actor-x11.c b/src/compositor/meta-surface-actor-x11.c
index 1f897be3f..244b1e885 100644
--- a/src/compositor/meta-surface-actor-x11.c
+++ b/src/compositor/meta-surface-actor-x11.c
@@ -37,8 +37,10 @@
 #include "x11/meta-x11-display-private.h"
 #include "x11/window-x11.h"
 
-struct _MetaSurfaceActorX11Private
+struct _MetaSurfaceActorX11
 {
+  MetaSurfaceActor parent;
+
   MetaWindow *window;
 
   MetaDisplay *display;
@@ -60,35 +62,34 @@ struct _MetaSurfaceActorX11Private
 
   guint unredirected   : 1;
 };
-typedef struct _MetaSurfaceActorX11Private MetaSurfaceActorX11Private;
 
-G_DEFINE_TYPE_WITH_PRIVATE (MetaSurfaceActorX11, meta_surface_actor_x11, META_TYPE_SURFACE_ACTOR)
+G_DEFINE_TYPE (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;
+  MetaDisplay *display = self->display;
   Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display);
 
-  if (priv->damage == None)
+  if (self->damage == None)
     return;
 
   meta_x11_error_trap_push (display->x11_display);
-  XDamageDestroy (xdisplay, priv->damage);
-  priv->damage = None;
+  XDamageDestroy (xdisplay, self->damage);
+  self->damage = None;
   meta_x11_error_trap_pop (display->x11_display);
 }
 
 static void
 detach_pixmap (MetaSurfaceActorX11 *self)
 {
-  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
-  MetaDisplay *display = priv->display;
+  MetaDisplay *display = self->display;
   Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display);
   MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
 
-  if (priv->pixmap == None)
+  if (self->pixmap == None)
     return;
 
   /* Get rid of all references to the pixmap before freeing it; it's unclear whether
@@ -99,28 +100,26 @@ detach_pixmap (MetaSurfaceActorX11 *self)
   cogl_flush ();
 
   meta_x11_error_trap_push (display->x11_display);
-  XFreePixmap (xdisplay, priv->pixmap);
-  priv->pixmap = None;
+  XFreePixmap (xdisplay, self->pixmap);
+  self->pixmap = None;
   meta_x11_error_trap_pop (display->x11_display);
 
-  g_clear_pointer (&priv->texture, cogl_object_unref);
+  g_clear_pointer (&self->texture, cogl_object_unref);
 }
 
 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));
   CoglError *error = NULL;
   CoglTexture *texture;
 
-  g_assert (priv->pixmap == None);
-  priv->pixmap = pixmap;
+  g_assert (self->pixmap == None);
+  self->pixmap = pixmap;
 
-  texture = COGL_TEXTURE (cogl_texture_pixmap_x11_new (ctx, priv->pixmap, FALSE, &error));
+  texture = COGL_TEXTURE (cogl_texture_pixmap_x11_new (ctx, self->pixmap, FALSE, &error));
 
   if (error != NULL)
     {
@@ -130,27 +129,26 @@ set_pixmap (MetaSurfaceActorX11 *self,
   else 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;
+  self->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;
+  MetaDisplay *display = self->display;
   Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display);
 
-  if (priv->size_changed)
+  if (self->size_changed)
     {
       detach_pixmap (self);
-      priv->size_changed = FALSE;
+      self->size_changed = FALSE;
     }
 
-  if (priv->pixmap == None)
+  if (self->pixmap == None)
     {
       Pixmap new_pixmap;
-      Window xwindow = meta_window_x11_get_toplevel_xwindow (priv->window);
+      Window xwindow = meta_window_x11_get_toplevel_xwindow (self->window);
 
       meta_x11_error_trap_push (display->x11_display);
       new_pixmap = XCompositeNameWindowPixmap (xdisplay, xwindow);
@@ -170,7 +168,7 @@ update_pixmap (MetaSurfaceActorX11 *self)
       if (new_pixmap == None)
         {
           meta_verbose ("Unable to get named pixmap for %s\n",
-                        meta_window_get_description (priv->window));
+                        meta_window_get_description (self->window));
           return;
         }
 
@@ -181,8 +179,7 @@ update_pixmap (MetaSurfaceActorX11 *self)
 static gboolean
 is_visible (MetaSurfaceActorX11 *self)
 {
-  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
-  return (priv->pixmap != None) && !priv->unredirected;
+  return (self->pixmap != None) && !self->unredirected;
 }
 
 static void
@@ -190,31 +187,30 @@ 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;
+  self->received_damage = TRUE;
 
-  if (meta_window_is_fullscreen (priv->window) && !priv->unredirected && !priv->does_full_damage)
+  if (meta_window_is_fullscreen (self->window) && !self->unredirected && !self->does_full_damage)
     {
       MetaRectangle window_rect;
-      meta_window_get_frame_rect (priv->window, &window_rect);
+      meta_window_get_frame_rect (self->window, &window_rect);
 
       if (x == 0 &&
           y == 0 &&
           window_rect.width == width &&
           window_rect.height == height)
-        priv->full_damage_frames_count++;
+        self->full_damage_frames_count++;
       else
-        priv->full_damage_frames_count = 0;
+        self->full_damage_frames_count = 0;
 
-      if (priv->full_damage_frames_count >= 100)
-        priv->does_full_damage = TRUE;
+      if (self->full_damage_frames_count >= 100)
+        self->does_full_damage = TRUE;
     }
 
   if (!is_visible (self))
     return;
 
-  cogl_texture_pixmap_x11_update_area (COGL_TEXTURE_PIXMAP_X11 (priv->texture),
+  cogl_texture_pixmap_x11_update_area (COGL_TEXTURE_PIXMAP_X11 (self->texture),
                                        x, y, width, height);
 }
 
@@ -222,17 +218,16 @@ 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;
+  MetaDisplay *display = self->display;
   Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display);
 
-  if (priv->received_damage)
+  if (self->received_damage)
     {
       meta_x11_error_trap_push (display->x11_display);
-      XDamageSubtract (xdisplay, priv->damage, None, None);
+      XDamageSubtract (xdisplay, self->damage, None, None);
       meta_x11_error_trap_pop (display->x11_display);
 
-      priv->received_damage = FALSE;
+      self->received_damage = FALSE;
     }
 
   update_pixmap (self);
@@ -249,7 +244,6 @@ static gboolean
 meta_surface_actor_x11_is_opaque (MetaSurfaceActor *actor)
 {
   MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
-  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
 
   /* If we're not ARGB32, then we're opaque. */
   if (!meta_surface_actor_is_argb32 (actor))
@@ -261,7 +255,7 @@ meta_surface_actor_x11_is_opaque (MetaSurfaceActor *actor)
   if (!opaque_region)
     return FALSE;
 
-  MetaWindow *window = priv->window;
+  MetaWindow *window = self->window;
   cairo_rectangle_int_t client_area;
   meta_window_get_client_area_rect (window, &client_area);
 
@@ -276,9 +270,8 @@ 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;
+  MetaWindow *window = self->window;
 
   if (meta_window_requested_dont_bypass_compositor (window))
     return FALSE;
@@ -301,7 +294,7 @@ meta_surface_actor_x11_should_unredirect (MetaSurfaceActor *actor)
   if (meta_window_is_override_redirect (window))
     return TRUE;
 
-  if (priv->does_full_damage)
+  if (self->does_full_damage)
     return TRUE;
 
   return FALSE;
@@ -310,14 +303,13 @@ meta_surface_actor_x11_should_unredirect (MetaSurfaceActor *actor)
 static void
 sync_unredirected (MetaSurfaceActorX11 *self)
 {
-  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
-  MetaDisplay *display = priv->display;
+  MetaDisplay *display = self->display;
   Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display);
-  Window xwindow = meta_window_x11_get_toplevel_xwindow (priv->window);
+  Window xwindow = meta_window_x11_get_toplevel_xwindow (self->window);
 
   meta_x11_error_trap_push (display->x11_display);
 
-  if (priv->unredirected)
+  if (self->unredirected)
     {
       detach_pixmap (self);
       XCompositeUnredirectWindow (xdisplay, xwindow, CompositeRedirectManual);
@@ -335,12 +327,11 @@ 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)
+  if (self->unredirected == unredirected)
     return;
 
-  priv->unredirected = unredirected;
+  self->unredirected = unredirected;
   sync_unredirected (self);
 }
 
@@ -348,9 +339,8 @@ 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;
+  return self->unredirected;
 }
 
 static void
@@ -367,9 +357,8 @@ meta_surface_actor_x11_dispose (GObject *object)
 static MetaWindow *
 meta_surface_actor_x11_get_window (MetaSurfaceActor *actor)
 {
-  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (META_SURFACE_ACTOR_X11 
(actor));
-
-  return priv->window;
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  return self->window;
 }
 
 static void
@@ -394,20 +383,17 @@ meta_surface_actor_x11_class_init (MetaSurfaceActorX11Class *klass)
 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;
+  self->last_width = -1;
+  self->last_height = -1;
 }
 
 static void
 create_damage (MetaSurfaceActorX11 *self)
 {
-  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
-  Display *xdisplay = meta_x11_display_get_xdisplay (priv->display->x11_display);
-  Window xwindow = meta_window_x11_get_toplevel_xwindow (priv->window);
+  Display *xdisplay = meta_x11_display_get_xdisplay (self->display->x11_display);
+  Window xwindow = meta_window_x11_get_toplevel_xwindow (self->window);
 
-  priv->damage = XDamageCreate (xdisplay, xwindow, XDamageReportBoundingBox);
+  self->damage = XDamageCreate (xdisplay, xwindow, XDamageReportBoundingBox);
 }
 
 static void
@@ -425,39 +411,37 @@ window_decorated_notify (MetaWindow *window,
 static void
 reset_texture (MetaSurfaceActorX11 *self)
 {
-  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
   MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
 
-  if (!priv->texture)
+  if (!self->texture)
     return;
 
   /* Setting the texture to NULL will cause all the FBO's cached by the
    * shaped texture's MetaTextureTower to be discarded and recreated.
    */
   meta_shaped_texture_set_texture (stex, NULL);
-  meta_shaped_texture_set_texture (stex, priv->texture);
+  meta_shaped_texture_set_texture (stex, self->texture);
 }
 
 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);
 
   g_assert (!meta_is_wayland_compositor ());
 
-  priv->window = window;
-  priv->display = display;
+  self->window = window;
+  self->display = display;
 
-  g_signal_connect_object (priv->display, "gl-video-memory-purged",
+  g_signal_connect_object (self->display, "gl-video-memory-purged",
                            G_CALLBACK (reset_texture), self, G_CONNECT_SWAPPED);
 
   create_damage (self);
-  g_signal_connect_object (priv->window, "notify::decorated",
+  g_signal_connect_object (self->window, "notify::decorated",
                            G_CALLBACK (window_decorated_notify), self, 0);
 
-  priv->unredirected = FALSE;
+  self->unredirected = FALSE;
   sync_unredirected (self);
 
   clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
@@ -468,15 +452,14 @@ void
 meta_surface_actor_x11_set_size (MetaSurfaceActorX11 *self,
                                  int width, int height)
 {
-  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
   MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
 
-  if (priv->last_width == width &&
-      priv->last_height == height)
+  if (self->last_width == width &&
+      self->last_height == height)
     return;
 
-  priv->size_changed = TRUE;
-  priv->last_width = width;
-  priv->last_height = height;
+  self->size_changed = TRUE;
+  self->last_width = width;
+  self->last_height = height;
   meta_shaped_texture_set_fallback_size (stex, width, height);
 }
diff --git a/src/compositor/meta-surface-actor-x11.h b/src/compositor/meta-surface-actor-x11.h
index e1b2014a0..2c4ed4dd6 100644
--- a/src/compositor/meta-surface-actor-x11.h
+++ b/src/compositor/meta-surface-actor-x11.h
@@ -36,27 +36,11 @@
 
 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);
+#define META_TYPE_SURFACE_ACTOR_X11 (meta_surface_actor_x11_get_type ())
+G_DECLARE_FINAL_TYPE (MetaSurfaceActorX11,
+                      meta_surface_actor_x11,
+                      META, SURFACE_ACTOR_X11,
+                      MetaSurfaceActor)
 
 MetaSurfaceActor * meta_surface_actor_x11_new (MetaWindow *window);
 
diff --git a/src/compositor/meta-surface-actor.c b/src/compositor/meta-surface-actor.c
index 823c1ac12..7add47b3a 100644
--- a/src/compositor/meta-surface-actor.c
+++ b/src/compositor/meta-surface-actor.c
@@ -18,7 +18,7 @@
 #include "compositor/meta-shaped-texture-private.h"
 #include "meta/meta-shaped-texture.h"
 
-struct _MetaSurfaceActorPrivate
+typedef struct _MetaSurfaceActorPrivate
 {
   MetaShapedTexture *texture;
 
@@ -27,7 +27,7 @@ struct _MetaSurfaceActorPrivate
   /* Freeze/thaw accounting */
   cairo_region_t *pending_damage;
   guint frozen : 1;
-};
+} MetaSurfaceActorPrivate;
 
 static void cullable_iface_init (MetaCullableInterface *iface);
 
@@ -49,7 +49,8 @@ meta_surface_actor_pick (ClutterActor       *actor,
                          const ClutterColor *color)
 {
   MetaSurfaceActor *self = META_SURFACE_ACTOR (actor);
-  MetaSurfaceActorPrivate *priv = self->priv;
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
   ClutterActorIter iter;
   ClutterActor *child;
 
@@ -113,7 +114,8 @@ static void
 meta_surface_actor_dispose (GObject *object)
 {
   MetaSurfaceActor *self = META_SURFACE_ACTOR (object);
-  MetaSurfaceActorPrivate *priv = self->priv;
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
 
   g_clear_pointer (&priv->input_region, cairo_region_destroy);
 
@@ -177,11 +179,8 @@ texture_size_changed (MetaShapedTexture *texture,
 static void
 meta_surface_actor_init (MetaSurfaceActor *self)
 {
-  MetaSurfaceActorPrivate *priv;
-
-  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-                                                   META_TYPE_SURFACE_ACTOR,
-                                                   MetaSurfaceActorPrivate);
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
 
   priv->texture = META_SHAPED_TEXTURE (meta_shaped_texture_new ());
   g_signal_connect_object (priv->texture, "size-changed",
@@ -193,20 +192,27 @@ cairo_surface_t *
 meta_surface_actor_get_image (MetaSurfaceActor      *self,
                               cairo_rectangle_int_t *clip)
 {
-  return meta_shaped_texture_get_image (self->priv->texture, clip);
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
+
+  return meta_shaped_texture_get_image (priv->texture, clip);
 }
 
 MetaShapedTexture *
 meta_surface_actor_get_texture (MetaSurfaceActor *self)
 {
-  return self->priv->texture;
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
+
+  return priv->texture;
 }
 
 static void
 meta_surface_actor_update_area (MetaSurfaceActor *self,
                                 int x, int y, int width, int height)
 {
-  MetaSurfaceActorPrivate *priv = self->priv;
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
 
   if (meta_shaped_texture_update_area (priv->texture, x, y, width, height))
     g_signal_emit (self, signals[REPAINT_SCHEDULED], 0);
@@ -215,7 +221,9 @@ meta_surface_actor_update_area (MetaSurfaceActor *self,
 gboolean
 meta_surface_actor_is_obscured (MetaSurfaceActor *self)
 {
-  MetaSurfaceActorPrivate *priv = self->priv;
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
+
   return meta_shaped_texture_is_obscured (priv->texture);
 }
 
@@ -223,7 +231,8 @@ void
 meta_surface_actor_set_input_region (MetaSurfaceActor *self,
                                      cairo_region_t   *region)
 {
-  MetaSurfaceActorPrivate *priv = self->priv;
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
 
   if (priv->input_region)
     cairo_region_destroy (priv->input_region);
@@ -238,21 +247,27 @@ void
 meta_surface_actor_set_opaque_region (MetaSurfaceActor *self,
                                       cairo_region_t   *region)
 {
-  MetaSurfaceActorPrivate *priv = self->priv;
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
+
   meta_shaped_texture_set_opaque_region (priv->texture, region);
 }
 
 cairo_region_t *
-meta_surface_actor_get_opaque_region (MetaSurfaceActor *actor)
+meta_surface_actor_get_opaque_region (MetaSurfaceActor *self)
 {
-  MetaSurfaceActorPrivate *priv = actor->priv;
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
+
   return meta_shaped_texture_get_opaque_region (priv->texture);
 }
 
 static gboolean
 is_frozen (MetaSurfaceActor *self)
 {
-  MetaSurfaceActorPrivate *priv = self->priv;
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
+
   return priv->frozen;
 }
 
@@ -260,7 +275,8 @@ void
 meta_surface_actor_process_damage (MetaSurfaceActor *self,
                                    int x, int y, int width, int height)
 {
-  MetaSurfaceActorPrivate *priv = self->priv;
+  MetaSurfaceActorPrivate *priv =
+      meta_surface_actor_get_instance_private (self);
 
   if (is_frozen (self))
     {
@@ -339,7 +355,8 @@ void
 meta_surface_actor_set_frozen (MetaSurfaceActor *self,
                                gboolean          frozen)
 {
-  MetaSurfaceActorPrivate *priv = self->priv;
+  MetaSurfaceActorPrivate *priv =
+      meta_surface_actor_get_instance_private (self);
 
   priv->frozen = frozen;
 
@@ -390,7 +407,8 @@ void
 meta_surface_actor_set_transform (MetaSurfaceActor     *self,
                                   MetaMonitorTransform  transform)
 {
-  MetaSurfaceActorPrivate *priv = self->priv;
+  MetaSurfaceActorPrivate *priv =
+    meta_surface_actor_get_instance_private (self);
 
   meta_shaped_texture_set_transform (priv->texture, transform);
 }
diff --git a/src/compositor/meta-surface-actor.h b/src/compositor/meta-surface-actor.h
index 102b67083..bf60ac462 100644
--- a/src/compositor/meta-surface-actor.h
+++ b/src/compositor/meta-surface-actor.h
@@ -11,16 +11,11 @@
 
 G_BEGIN_DECLS
 
-#define META_TYPE_SURFACE_ACTOR            (meta_surface_actor_get_type())
-#define META_SURFACE_ACTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SURFACE_ACTOR, 
MetaSurfaceActor))
-#define META_SURFACE_ACTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_SURFACE_ACTOR, 
MetaSurfaceActorClass))
-#define META_IS_SURFACE_ACTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SURFACE_ACTOR))
-#define META_IS_SURFACE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_SURFACE_ACTOR))
-#define META_SURFACE_ACTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_SURFACE_ACTOR, 
MetaSurfaceActorClass))
-
-typedef struct _MetaSurfaceActor        MetaSurfaceActor;
-typedef struct _MetaSurfaceActorClass   MetaSurfaceActorClass;
-typedef struct _MetaSurfaceActorPrivate MetaSurfaceActorPrivate;
+#define META_TYPE_SURFACE_ACTOR (meta_surface_actor_get_type ())
+G_DECLARE_DERIVABLE_TYPE (MetaSurfaceActor,
+                          meta_surface_actor,
+                          META, SURFACE_ACTOR,
+                          ClutterActor)
 
 struct _MetaSurfaceActorClass
 {
@@ -40,15 +35,6 @@ struct _MetaSurfaceActorClass
   MetaWindow *(* get_window)      (MetaSurfaceActor *actor);
 };
 
-struct _MetaSurfaceActor
-{
-  ClutterActor            parent;
-
-  MetaSurfaceActorPrivate *priv;
-};
-
-GType meta_surface_actor_get_type (void);
-
 cairo_surface_t *meta_surface_actor_get_image (MetaSurfaceActor      *self,
                                                cairo_rectangle_int_t *clip);
 
diff --git a/src/compositor/meta-window-actor.c b/src/compositor/meta-window-actor.c
index 8368049d0..237aa3c6c 100644
--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@@ -47,8 +47,10 @@ typedef enum {
   EMITTED_FIRST_FRAME
 } FirstFrameState;
 
-struct _MetaWindowActorPrivate
+struct _MetaWindowActor
 {
+  ClutterActor           parent;
+
   MetaWindow *window;
   MetaCompositor *compositor;
 
@@ -190,7 +192,6 @@ static void cullable_iface_init (MetaCullableInterface *iface);
 static void screen_cast_window_iface_init (MetaScreenCastWindowInterface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (MetaWindowActor, meta_window_actor, CLUTTER_TYPE_ACTOR,
-                         G_ADD_PRIVATE (MetaWindowActor)
                          G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init)
                          G_IMPLEMENT_INTERFACE (META_TYPE_SCREEN_CAST_WINDOW, 
screen_cast_window_iface_init));
 
@@ -291,12 +292,7 @@ meta_window_actor_class_init (MetaWindowActorClass *klass)
 static void
 meta_window_actor_init (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv;
-
-  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-                                                  META_TYPE_WINDOW_ACTOR,
-                                                  MetaWindowActorPrivate);
-  priv->shadow_class = NULL;
+  self->shadow_class = NULL;
 }
 
 static void
@@ -321,22 +317,19 @@ surface_repaint_scheduled (MetaSurfaceActor *actor,
                            gpointer          user_data)
 {
   MetaWindowActor *self = META_WINDOW_ACTOR (user_data);
-  MetaWindowActorPrivate *priv = self->priv;
 
-  priv->repaint_scheduled = TRUE;
+  self->repaint_scheduled = TRUE;
 }
 
 static gboolean
 is_argb32 (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
   /* assume we're argb until we get the window (because
      in practice we're drawing nothing, so we're fully
      transparent)
   */
-  if (priv->surface)
-    return meta_surface_actor_is_argb32 (priv->surface);
+  if (self->surface)
+    return meta_surface_actor_is_argb32 (self->surface);
   else
     return TRUE;
 }
@@ -344,8 +337,7 @@ is_argb32 (MetaWindowActor *self)
 static gboolean
 is_non_opaque (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaWindow *window = priv->window;
+  MetaWindow *window = self->window;
 
   return is_argb32 (self) || (window->opacity != 0xFF);
 }
@@ -353,32 +345,26 @@ is_non_opaque (MetaWindowActor *self)
 static gboolean
 is_frozen (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  return priv->surface == NULL || priv->freeze_count > 0;
+  return self->surface == NULL || self->freeze_count > 0;
 }
 
 static void
 meta_window_actor_freeze (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
+  if (self->freeze_count == 0 && self->surface)
+    meta_surface_actor_set_frozen (self->surface, TRUE);
 
-  if (priv->freeze_count == 0 && priv->surface)
-    meta_surface_actor_set_frozen (priv->surface, TRUE);
-
-  priv->freeze_count ++;
+  self->freeze_count ++;
 }
 
 static void
 meta_window_actor_sync_thawed_state (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (priv->first_frame_state == INITIALLY_FROZEN)
-    priv->first_frame_state = DRAWING_FIRST_FRAME;
+  if (self->first_frame_state == INITIALLY_FROZEN)
+    self->first_frame_state = DRAWING_FIRST_FRAME;
 
-  if (priv->surface)
-    meta_surface_actor_set_frozen (priv->surface, FALSE);
+  if (self->surface)
+    meta_surface_actor_set_frozen (self->surface, FALSE);
 
   /* We sometimes ignore moves and resizes on frozen windows */
   meta_window_actor_sync_actor_geometry (self, FALSE);
@@ -387,13 +373,11 @@ meta_window_actor_sync_thawed_state (MetaWindowActor *self)
 static void
 meta_window_actor_thaw (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (priv->freeze_count <= 0)
+  if (self->freeze_count <= 0)
     g_error ("Error in freeze/thaw accounting");
 
-  priv->freeze_count--;
-  if (priv->freeze_count > 0)
+  self->freeze_count--;
+  if (self->freeze_count > 0)
     return;
 
   /* We still might be frozen due to lack of a MetaSurfaceActor */
@@ -411,32 +395,30 @@ static void
 set_surface (MetaWindowActor  *self,
              MetaSurfaceActor *surface)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (priv->surface)
+  if (self->surface)
     {
-      g_signal_handler_disconnect (priv->surface, priv->repaint_scheduled_id);
-      g_signal_handler_disconnect (priv->surface, priv->size_changed_id);
-      priv->repaint_scheduled_id = 0;
-      clutter_actor_remove_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (priv->surface));
-      g_object_unref (priv->surface);
+      g_signal_handler_disconnect (self->surface, self->repaint_scheduled_id);
+      g_signal_handler_disconnect (self->surface, self->size_changed_id);
+      self->repaint_scheduled_id = 0;
+      clutter_actor_remove_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (self->surface));
+      g_object_unref (self->surface);
     }
 
-  priv->surface = surface;
+  self->surface = surface;
 
-  if (priv->surface)
+  if (self->surface)
     {
-      g_object_ref_sink (priv->surface);
-      priv->repaint_scheduled_id = g_signal_connect (priv->surface, "repaint-scheduled",
+      g_object_ref_sink (self->surface);
+      self->repaint_scheduled_id = g_signal_connect (self->surface, "repaint-scheduled",
                                                      G_CALLBACK (surface_repaint_scheduled), self);
-      priv->size_changed_id = g_signal_connect (priv->surface, "size-changed",
+      self->size_changed_id = g_signal_connect (self->surface, "size-changed",
                                                 G_CALLBACK (surface_size_changed), self);
-      clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (priv->surface));
+      clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (self->surface));
 
       meta_window_actor_update_shape (self);
 
       if (is_frozen (self))
-        meta_surface_actor_set_frozen (priv->surface, TRUE);
+        meta_surface_actor_set_frozen (self->surface, TRUE);
       else
         meta_window_actor_sync_thawed_state (self);
     }
@@ -445,8 +427,7 @@ set_surface (MetaWindowActor  *self,
 void
 meta_window_actor_update_surface (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaWindow *window = priv->window;
+  MetaWindow *window = self->window;
   MetaSurfaceActor *surface_actor;
 
 #ifdef HAVE_WAYLAND
@@ -466,10 +447,9 @@ static void
 meta_window_actor_constructed (GObject *object)
 {
   MetaWindowActor *self = META_WINDOW_ACTOR (object);
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaWindow *window = priv->window;
+  MetaWindow *window = self->window;
 
-  priv->compositor = window->display->compositor;
+  self->compositor = window->display->compositor;
 
   meta_window_actor_update_surface (self);
 
@@ -477,38 +457,37 @@ meta_window_actor_constructed (GObject *object)
 
   /* Start off with an empty shape region to maintain the invariant
    * that it's always set */
-  priv->shape_region = cairo_region_create ();
+  self->shape_region = cairo_region_create ();
 }
 
 static void
 meta_window_actor_dispose (GObject *object)
 {
   MetaWindowActor *self = META_WINDOW_ACTOR (object);
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaCompositor *compositor = priv->compositor;
+  MetaCompositor *compositor = self->compositor;
 
-  if (priv->disposed)
+  if (self->disposed)
     return;
 
-  priv->disposed = TRUE;
+  self->disposed = TRUE;
 
-  if (priv->send_frame_messages_timer != 0)
+  if (self->send_frame_messages_timer != 0)
     {
-      g_source_remove (priv->send_frame_messages_timer);
-      priv->send_frame_messages_timer = 0;
+      g_source_remove (self->send_frame_messages_timer);
+      self->send_frame_messages_timer = 0;
     }
 
-  g_clear_pointer (&priv->shape_region, cairo_region_destroy);
-  g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);
+  g_clear_pointer (&self->shape_region, cairo_region_destroy);
+  g_clear_pointer (&self->shadow_clip, cairo_region_destroy);
 
-  g_clear_pointer (&priv->shadow_class, g_free);
-  g_clear_pointer (&priv->focused_shadow, meta_shadow_unref);
-  g_clear_pointer (&priv->unfocused_shadow, meta_shadow_unref);
-  g_clear_pointer (&priv->shadow_shape, meta_window_shape_unref);
+  g_clear_pointer (&self->shadow_class, g_free);
+  g_clear_pointer (&self->focused_shadow, meta_shadow_unref);
+  g_clear_pointer (&self->unfocused_shadow, meta_shadow_unref);
+  g_clear_pointer (&self->shadow_shape, meta_window_shape_unref);
 
   compositor->windows = g_list_remove (compositor->windows, (gconstpointer) self);
 
-  g_clear_object (&priv->window);
+  g_clear_object (&self->window);
 
   set_surface (self, NULL);
 
@@ -519,9 +498,8 @@ static void
 meta_window_actor_finalize (GObject *object)
 {
   MetaWindowActor        *self = META_WINDOW_ACTOR (object);
-  MetaWindowActorPrivate *priv = self->priv;
 
-  g_list_free_full (priv->frames, (GDestroyNotify) frame_data_free);
+  g_list_free_full (self->frames, (GDestroyNotify) frame_data_free);
 
   G_OBJECT_CLASS (meta_window_actor_parent_class)->finalize (object);
 }
@@ -532,24 +510,23 @@ meta_window_actor_set_property (GObject      *object,
                                 const GValue *value,
                                 GParamSpec   *pspec)
 {
-  MetaWindowActor        *self   = META_WINDOW_ACTOR (object);
-  MetaWindowActorPrivate *priv = self->priv;
+  MetaWindowActor *self = META_WINDOW_ACTOR (object);
 
   switch (prop_id)
     {
     case PROP_META_WINDOW:
-      priv->window = g_value_dup_object (value);
-      g_signal_connect_object (priv->window, "notify::appears-focused",
+      self->window = g_value_dup_object (value);
+      g_signal_connect_object (self->window, "notify::appears-focused",
                                G_CALLBACK (window_appears_focused_notify), self, 0);
       break;
     case PROP_SHADOW_MODE:
       {
         MetaShadowMode newv = g_value_get_enum (value);
 
-        if (newv == priv->shadow_mode)
+        if (newv == self->shadow_mode)
           return;
 
-        priv->shadow_mode = newv;
+        self->shadow_mode = newv;
 
         meta_window_actor_invalidate_shadow (self);
       }
@@ -558,11 +535,11 @@ meta_window_actor_set_property (GObject      *object,
       {
         const char *newv = g_value_get_string (value);
 
-        if (g_strcmp0 (newv, priv->shadow_class) == 0)
+        if (g_strcmp0 (newv, self->shadow_class) == 0)
           return;
 
-        g_free (priv->shadow_class);
-        priv->shadow_class = g_strdup (newv);
+        g_free (self->shadow_class);
+        self->shadow_class = g_strdup (newv);
 
         meta_window_actor_invalidate_shadow (self);
       }
@@ -579,18 +556,18 @@ meta_window_actor_get_property (GObject      *object,
                                 GValue       *value,
                                 GParamSpec   *pspec)
 {
-  MetaWindowActorPrivate *priv = META_WINDOW_ACTOR (object)->priv;
+  MetaWindowActor *self = META_WINDOW_ACTOR (object);
 
   switch (prop_id)
     {
     case PROP_META_WINDOW:
-      g_value_set_object (value, priv->window);
+      g_value_set_object (value, self->window);
       break;
     case PROP_SHADOW_MODE:
-      g_value_set_enum (value, priv->shadow_mode);
+      g_value_set_enum (value, self->shadow_mode);
       break;
     case PROP_SHADOW_CLASS:
-      g_value_set_string (value, priv->shadow_class);
+      g_value_set_string (value, self->shadow_class);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -601,13 +578,11 @@ meta_window_actor_get_property (GObject      *object,
 static const char *
 meta_window_actor_get_shadow_class (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (priv->shadow_class != NULL)
-    return priv->shadow_class;
+  if (self->shadow_class != NULL)
+    return self->shadow_class;
   else
     {
-      MetaWindowType window_type = meta_window_get_window_type (priv->window);
+      MetaWindowType window_type = meta_window_get_window_type (self->window);
 
       switch (window_type)
         {
@@ -618,7 +593,7 @@ meta_window_actor_get_shadow_class (MetaWindowActor *self)
           return "popup-menu";
         default:
           {
-            MetaFrameType frame_type = meta_window_get_frame_type (priv->window);
+            MetaFrameType frame_type = meta_window_get_frame_type (self->window);
             return meta_frame_type_to_string (frame_type);
           }
         }
@@ -641,9 +616,7 @@ void
 meta_window_actor_get_shape_bounds (MetaWindowActor       *self,
                                     cairo_rectangle_int_t *bounds)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  cairo_region_get_extents (priv->shape_region, bounds);
+  cairo_region_get_extents (self->shape_region, bounds);
 }
 
 static void
@@ -651,11 +624,12 @@ meta_window_actor_get_shadow_bounds (MetaWindowActor       *self,
                                      gboolean               appears_focused,
                                      cairo_rectangle_int_t *bounds)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaShadow *shadow = appears_focused ? priv->focused_shadow : priv->unfocused_shadow;
+  MetaShadow *shadow;
   cairo_rectangle_int_t shape_bounds;
   MetaShadowParams params;
 
+  shadow = appears_focused ? self->focused_shadow : self->unfocused_shadow;
+
   meta_window_actor_get_shape_bounds (self, &shape_bounds);
   meta_window_actor_get_shadow_params (self, appears_focused, &params);
 
@@ -682,26 +656,23 @@ meta_window_actor_get_shadow_bounds (MetaWindowActor       *self,
 static gboolean
 clip_shadow_under_window (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  return is_non_opaque (self) && priv->window->frame;
+  return is_non_opaque (self) && self->window->frame;
 }
 
 static void
 assign_frame_counter_to_frames (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaCompositor *compositor = priv->compositor;
+  MetaCompositor *compositor = self->compositor;
   ClutterStage *stage = CLUTTER_STAGE (compositor->stage);
   GList *l;
 
   /* If the window is obscured, then we're expecting to deal with sending
    * frame messages in a timeout, rather than in this paint cycle.
    */
-  if (priv->send_frame_messages_timer != 0)
+  if (self->send_frame_messages_timer != 0)
     return;
 
-  for (l = priv->frames; l; l = l->next)
+  for (l = self->frames; l; l = l->next)
     {
       FrameData *frame = l->data;
 
@@ -714,19 +685,20 @@ static void
 meta_window_actor_paint (ClutterActor *actor)
 {
   MetaWindowActor *self = META_WINDOW_ACTOR (actor);
-  MetaWindowActorPrivate *priv = self->priv;
-  gboolean appears_focused = meta_window_appears_focused (priv->window);
-  MetaShadow *shadow = appears_focused ? priv->focused_shadow : priv->unfocused_shadow;
+  gboolean appears_focused = meta_window_appears_focused (self->window);
+  MetaShadow *shadow;
   CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
 
+  shadow = appears_focused ? self->focused_shadow : self->unfocused_shadow;
+
  /* This window got damage when obscured; we set up a timer
   * to send frame completion events, but since we're drawing
   * the window now (for some other reason) cancel the timer
   * and send the completion events normally */
-  if (priv->send_frame_messages_timer != 0)
+  if (self->send_frame_messages_timer != 0)
     {
-      g_source_remove (priv->send_frame_messages_timer);
-      priv->send_frame_messages_timer = 0;
+      g_source_remove (self->send_frame_messages_timer);
+      self->send_frame_messages_timer = 0;
 
       assign_frame_counter_to_frames (self);
     }
@@ -735,18 +707,18 @@ meta_window_actor_paint (ClutterActor *actor)
     {
       MetaShadowParams params;
       cairo_rectangle_int_t shape_bounds;
-      cairo_region_t *clip = priv->shadow_clip;
-      MetaWindow *window = priv->window;
+      cairo_region_t *clip = self->shadow_clip;
+      MetaWindow *window = self->window;
 
       meta_window_actor_get_shape_bounds (self, &shape_bounds);
       meta_window_actor_get_shadow_params (self, appears_focused, &params);
 
-      /* The frame bounds are already subtracted from priv->shadow_clip
+      /* The frame bounds are already subtracted from self->shadow_clip
        * if that exists.
        */
       if (!clip && clip_shadow_under_window (self))
         {
-          cairo_region_t *frame_bounds = meta_window_get_frame_bounds (priv->window);
+          cairo_region_t *frame_bounds = meta_window_get_frame_bounds (self->window);
           cairo_rectangle_int_t bounds;
 
           meta_window_actor_get_shadow_bounds (self, appears_focused, &bounds);
@@ -765,7 +737,7 @@ meta_window_actor_paint (ClutterActor *actor)
                          clip,
                          clip_shadow_under_window (self)); /* clip_strictly - not just as an optimization */
 
-      if (clip && clip != priv->shadow_clip)
+      if (clip && clip != self->shadow_clip)
         cairo_region_destroy (clip);
     }
 
@@ -777,14 +749,13 @@ meta_window_actor_get_paint_volume (ClutterActor       *actor,
                                     ClutterPaintVolume *volume)
 {
   MetaWindowActor *self = META_WINDOW_ACTOR (actor);
-  MetaWindowActorPrivate *priv = self->priv;
-  gboolean appears_focused = meta_window_appears_focused (priv->window);
+  gboolean appears_focused = meta_window_appears_focused (self->window);
 
   /* The paint volume is computed before paint functions are called
    * so our bounds might not be updated yet. Force an update. */
   meta_window_actor_handle_updates (self);
 
-  if (appears_focused ? priv->focused_shadow : priv->unfocused_shadow)
+  if (appears_focused ? self->focused_shadow : self->unfocused_shadow)
     {
       cairo_rectangle_int_t shadow_bounds;
       ClutterActorBox shadow_box;
@@ -805,11 +776,11 @@ meta_window_actor_get_paint_volume (ClutterActor       *actor,
       clutter_paint_volume_union_box (volume, &shadow_box);
     }
 
-  if (priv->surface)
+  if (self->surface)
     {
       const ClutterPaintVolume *child_volume;
 
-      child_volume = clutter_actor_get_transformed_paint_volume (CLUTTER_ACTOR (priv->surface), actor);
+      child_volume = clutter_actor_get_transformed_paint_volume (CLUTTER_ACTOR (self->surface), actor);
       if (!child_volume)
         return FALSE;
 
@@ -822,32 +793,30 @@ meta_window_actor_get_paint_volume (ClutterActor       *actor,
 static gboolean
 meta_window_actor_has_shadow (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (priv->shadow_mode == META_SHADOW_MODE_FORCED_OFF)
+  if (self->shadow_mode == META_SHADOW_MODE_FORCED_OFF)
     return FALSE;
-  if (priv->shadow_mode == META_SHADOW_MODE_FORCED_ON)
+  if (self->shadow_mode == META_SHADOW_MODE_FORCED_ON)
     return TRUE;
 
   /* Leaving out shadows for maximized and fullscreen windows is an effeciency
    * win and also prevents the unsightly effect of the shadow of maximized
    * window appearing on an adjacent window */
-  if ((meta_window_get_maximized (priv->window) == META_MAXIMIZE_BOTH) ||
-      meta_window_is_fullscreen (priv->window))
+  if ((meta_window_get_maximized (self->window) == META_MAXIMIZE_BOTH) ||
+      meta_window_is_fullscreen (self->window))
     return FALSE;
 
   /*
    * If we have two snap-tiled windows, we don't want the shadow to obstruct
    * the other window.
    */
-  if (meta_window_get_tile_match (priv->window))
+  if (meta_window_get_tile_match (self->window))
     return FALSE;
 
   /*
    * Always put a shadow around windows with a frame - This should override
    * the restriction about not putting a shadow around ARGB windows.
    */
-  if (meta_window_get_frame (priv->window))
+  if (meta_window_get_frame (self->window))
     return TRUE;
 
   /*
@@ -861,7 +830,7 @@ meta_window_actor_has_shadow (MetaWindowActor *self)
    * If a window specifies that it has custom frame extents, that likely
    * means that it is drawing a shadow itself. Don't draw our own.
    */
-  if (priv->window->has_custom_frame_extents)
+  if (self->window->has_custom_frame_extents)
     return FALSE;
 
   /*
@@ -881,7 +850,7 @@ meta_window_actor_has_shadow (MetaWindowActor *self)
 MetaWindow *
 meta_window_actor_get_meta_window (MetaWindowActor *self)
 {
-  return self->priv->window;
+  return self->window;
 }
 
 /**
@@ -896,8 +865,8 @@ meta_window_actor_get_meta_window (MetaWindowActor *self)
 ClutterActor *
 meta_window_actor_get_texture (MetaWindowActor *self)
 {
-  if (self->priv->surface)
-    return CLUTTER_ACTOR (meta_surface_actor_get_texture (self->priv->surface));
+  if (self->surface)
+    return CLUTTER_ACTOR (meta_surface_actor_get_texture (self->surface));
   else
     return NULL;
 }
@@ -914,7 +883,7 @@ meta_window_actor_get_texture (MetaWindowActor *self)
 MetaSurfaceActor *
 meta_window_actor_get_surface (MetaWindowActor *self)
 {
-  return self->priv->surface;
+  return self->surface;
 }
 
 /**
@@ -928,17 +897,16 @@ meta_window_actor_get_surface (MetaWindowActor *self)
 gboolean
 meta_window_actor_is_destroyed (MetaWindowActor *self)
 {
-  return self->priv->disposed || self->priv->needs_destroy;
+  return self->disposed || self->needs_destroy;
 }
 
 static gboolean
 send_frame_messages_timeout (gpointer data)
 {
   MetaWindowActor *self = (MetaWindowActor *) data;
-  MetaWindowActorPrivate *priv = self->priv;
   GList *l;
 
-  for (l = priv->frames; l;)
+  for (l = self->frames; l;)
     {
       GList *l_next = l->next;
       FrameData *frame = l->data;
@@ -948,15 +916,15 @@ send_frame_messages_timeout (gpointer data)
           do_send_frame_drawn (self, frame);
           do_send_frame_timings (self, frame, 0, 0);
 
-          priv->frames = g_list_delete_link (priv->frames, l);
+          self->frames = g_list_delete_link (self->frames, l);
           frame_data_free (frame);
         }
 
       l = l_next;
     }
 
-  priv->needs_frame_drawn = FALSE;
-  priv->send_frame_messages_timer = 0;
+  self->needs_frame_drawn = FALSE;
+  self->send_frame_messages_timer = 0;
 
   return FALSE;
 }
@@ -964,15 +932,14 @@ send_frame_messages_timeout (gpointer data)
 static void
 queue_send_frame_messages_timeout (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaWindow *window = priv->window;
-  MetaDisplay *display = meta_window_get_display (priv->window);
+  MetaWindow *window = self->window;
+  MetaDisplay *display = meta_window_get_display (self->window);
   MetaLogicalMonitor *logical_monitor;
   int64_t current_time;
   float refresh_rate;
   int interval, offset;
 
-  if (priv->send_frame_messages_timer != 0)
+  if (self->send_frame_messages_timer != 0)
     return;
 
   logical_monitor = meta_window_get_main_logical_monitor (window);
@@ -996,21 +963,20 @@ queue_send_frame_messages_timeout (MetaWindowActor *self)
     meta_compositor_monotonic_time_to_server_time (display,
                                                    g_get_monotonic_time ());
   interval = (int)(1000000 / refresh_rate) * 6;
-  offset = MAX (0, priv->frame_drawn_time + interval - current_time) / 1000;
+  offset = MAX (0, self->frame_drawn_time + interval - current_time) / 1000;
 
  /* The clutter master clock source has already been added with META_PRIORITY_REDRAW,
   * so the timer will run *after* the clutter frame handling, if a frame is ready
   * to be drawn when the timer expires.
   */
-  priv->send_frame_messages_timer = g_timeout_add_full (META_PRIORITY_REDRAW, offset, 
send_frame_messages_timeout, self, NULL);
-  g_source_set_name_by_id (priv->send_frame_messages_timer, "[mutter] send_frame_messages_timeout");
+  self->send_frame_messages_timer = g_timeout_add_full (META_PRIORITY_REDRAW, offset, 
send_frame_messages_timeout, self, NULL);
+  g_source_set_name_by_id (self->send_frame_messages_timer, "[mutter] send_frame_messages_timeout");
 }
 
 void
 meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
                                      gboolean         no_delay_frame)
 {
-  MetaWindowActorPrivate *priv = self->priv;
   FrameData *frame;
 
   if (meta_window_actor_is_destroyed (self))
@@ -1019,11 +985,11 @@ meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
   frame = g_slice_new0 (FrameData);
   frame->frame_counter = -1;
 
-  priv->needs_frame_drawn = TRUE;
+  self->needs_frame_drawn = TRUE;
 
-  frame->sync_request_serial = priv->window->sync_request_serial;
+  frame->sync_request_serial = self->window->sync_request_serial;
 
-  priv->frames = g_list_prepend (priv->frames, frame);
+  self->frames = g_list_prepend (self->frames, frame);
 
   if (no_delay_frame)
     {
@@ -1031,12 +997,12 @@ meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
       clutter_stage_skip_sync_delay (CLUTTER_STAGE (stage));
     }
 
-  if (!priv->repaint_scheduled)
+  if (!self->repaint_scheduled)
     {
       gboolean is_obscured;
 
-      if (priv->surface)
-        is_obscured = meta_surface_actor_is_obscured (priv->surface);
+      if (self->surface)
+        is_obscured = meta_surface_actor_is_obscured (self->surface);
       else
         is_obscured = FALSE;
 
@@ -1054,11 +1020,11 @@ meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
         }
       else
         {
-          if (priv->surface)
+          if (self->surface)
             {
               const cairo_rectangle_int_t clip = { 0, 0, 1, 1 };
-              clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (priv->surface), &clip);
-              priv->repaint_scheduled = TRUE;
+              clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (self->surface), &clip);
+              self->repaint_scheduled = TRUE;
             }
         }
     }
@@ -1067,10 +1033,10 @@ meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
 gboolean
 meta_window_actor_effect_in_progress (MetaWindowActor *self)
 {
-  return (self->priv->minimize_in_progress ||
-         self->priv->size_change_in_progress ||
-         self->priv->map_in_progress ||
-         self->priv->destroy_in_progress);
+  return (self->minimize_in_progress ||
+          self->size_change_in_progress ||
+          self->map_in_progress ||
+          self->destroy_in_progress);
 }
 
 static gboolean
@@ -1091,8 +1057,7 @@ static gboolean
 start_simple_effect (MetaWindowActor  *self,
                      MetaPluginEffect  event)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaCompositor *compositor = priv->compositor;
+  MetaCompositor *compositor = self->compositor;
   gint *counter = NULL;
   gboolean use_freeze_thaw = FALSE;
 
@@ -1103,16 +1068,16 @@ start_simple_effect (MetaWindowActor  *self,
   case META_PLUGIN_NONE:
     return FALSE;
   case META_PLUGIN_MINIMIZE:
-    counter = &priv->minimize_in_progress;
+    counter = &self->minimize_in_progress;
     break;
   case META_PLUGIN_UNMINIMIZE:
-    counter = &priv->unminimize_in_progress;
+    counter = &self->unminimize_in_progress;
     break;
   case META_PLUGIN_MAP:
-    counter = &priv->map_in_progress;
+    counter = &self->map_in_progress;
     break;
   case META_PLUGIN_DESTROY:
-    counter = &priv->destroy_in_progress;
+    counter = &self->destroy_in_progress;
     break;
   case META_PLUGIN_SIZE_CHANGE:
   case META_PLUGIN_SWITCH_WORKSPACE:
@@ -1143,9 +1108,7 @@ start_simple_effect (MetaWindowActor  *self,
 static void
 meta_window_actor_after_effects (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (priv->needs_destroy)
+  if (self->needs_destroy)
     {
       clutter_actor_destroy (CLUTTER_ACTOR (self));
       return;
@@ -1160,12 +1123,11 @@ void
 meta_window_actor_effect_completed (MetaWindowActor  *self,
                                     MetaPluginEffect  event)
 {
-  MetaWindowActorPrivate *priv   = self->priv;
   gboolean inconsistent = FALSE;
 
   /* NB: Keep in mind that when effects get completed it possible
    * that the corresponding MetaWindow may have be been destroyed.
-   * In this case priv->window will == NULL */
+   * In this case self->window will == NULL */
 
   switch (event)
   {
@@ -1173,22 +1135,22 @@ meta_window_actor_effect_completed (MetaWindowActor  *self,
     break;
   case META_PLUGIN_MINIMIZE:
     {
-      priv->minimize_in_progress--;
-      if (priv->minimize_in_progress < 0)
-       {
-         g_warning ("Error in minimize accounting.");
-         priv->minimize_in_progress = 0;
+      self->minimize_in_progress--;
+      if (self->minimize_in_progress < 0)
+        {
+          g_warning ("Error in minimize accounting.");
+          self->minimize_in_progress = 0;
           inconsistent = TRUE;
-       }
+        }
     }
     break;
   case META_PLUGIN_UNMINIMIZE:
     {
-      priv->unminimize_in_progress--;
-      if (priv->unminimize_in_progress < 0)
+      self->unminimize_in_progress--;
+      if (self->unminimize_in_progress < 0)
        {
          g_warning ("Error in unminimize accounting.");
-         priv->unminimize_in_progress = 0;
+         self->unminimize_in_progress = 0;
          inconsistent = TRUE;
        }
     }
@@ -1198,31 +1160,31 @@ meta_window_actor_effect_completed (MetaWindowActor  *self,
      * Make sure that the actor is at the correct place in case
      * the plugin fscked.
      */
-    priv->map_in_progress--;
+    self->map_in_progress--;
 
-    if (priv->map_in_progress < 0)
+    if (self->map_in_progress < 0)
       {
-       g_warning ("Error in map accounting.");
-       priv->map_in_progress = 0;
+        g_warning ("Error in map accounting.");
+        self->map_in_progress = 0;
         inconsistent = TRUE;
       }
     break;
   case META_PLUGIN_DESTROY:
-    priv->destroy_in_progress--;
+    self->destroy_in_progress--;
 
-    if (priv->destroy_in_progress < 0)
+    if (self->destroy_in_progress < 0)
       {
-       g_warning ("Error in destroy accounting.");
-       priv->destroy_in_progress = 0;
+        g_warning ("Error in destroy accounting.");
+        self->destroy_in_progress = 0;
         inconsistent = TRUE;
       }
     break;
   case META_PLUGIN_SIZE_CHANGE:
-    priv->size_change_in_progress--;
-    if (priv->size_change_in_progress < 0)
+    self->size_change_in_progress--;
+    if (self->size_change_in_progress < 0)
       {
-       g_warning ("Error in size change accounting.");
-       priv->size_change_in_progress = 0;
+        g_warning ("Error in size change accounting.");
+        self->size_change_in_progress = 0;
         inconsistent = TRUE;
       }
     break;
@@ -1241,9 +1203,8 @@ meta_window_actor_effect_completed (MetaWindowActor  *self,
 gboolean
 meta_window_actor_should_unredirect (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  if (!meta_window_actor_is_destroyed (self) && priv->surface)
-    return meta_surface_actor_should_unredirect (priv->surface);
+  if (!meta_window_actor_is_destroyed (self) && self->surface)
+    return meta_surface_actor_should_unredirect (self->surface);
   else
     return FALSE;
 }
@@ -1252,25 +1213,22 @@ void
 meta_window_actor_set_unredirected (MetaWindowActor *self,
                                     gboolean         unredirected)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  g_assert(priv->surface); /* because otherwise should_unredirect() is FALSE */
-  meta_surface_actor_set_unredirected (priv->surface, unredirected);
+  g_assert (self->surface); /* because otherwise should_unredirect() is FALSE */
+  meta_surface_actor_set_unredirected (self->surface, unredirected);
 }
 
 void
 meta_window_actor_queue_destroy (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaWindow *window = priv->window;
+  MetaWindow *window = self->window;
   MetaWindowType window_type = meta_window_get_window_type (window);
 
   meta_window_set_compositor_private (window, NULL);
 
-  if (priv->send_frame_messages_timer != 0)
+  if (self->send_frame_messages_timer != 0)
     {
-      g_source_remove (priv->send_frame_messages_timer);
-      priv->send_frame_messages_timer = 0;
+      g_source_remove (self->send_frame_messages_timer);
+      self->send_frame_messages_timer = 0;
     }
 
   if (window_type == META_WINDOW_DROPDOWN_MENU ||
@@ -1288,7 +1246,7 @@ meta_window_actor_queue_destroy (MetaWindowActor *self)
       return;
     }
 
-  priv->needs_destroy = TRUE;
+  self->needs_destroy = TRUE;
 
   if (!meta_window_actor_effect_in_progress (self))
     clutter_actor_destroy (CLUTTER_ACTOR (self));
@@ -1298,15 +1256,14 @@ void
 meta_window_actor_sync_actor_geometry (MetaWindowActor *self,
                                        gboolean         did_placement)
 {
-  MetaWindowActorPrivate *priv = self->priv;
   MetaRectangle window_rect;
 
-  meta_window_get_buffer_rect (priv->window, &window_rect);
+  meta_window_get_buffer_rect (self->window, &window_rect);
 
   /* 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),
+  if (META_IS_SURFACE_ACTOR_X11 (self->surface))
+    meta_surface_actor_x11_set_size (META_SURFACE_ACTOR_X11 (self->surface),
                                      window_rect.width, window_rect.height);
 
   /* Normally we want freezing a window to also freeze its position; this allows
@@ -1332,13 +1289,12 @@ void
 meta_window_actor_show (MetaWindowActor   *self,
                         MetaCompEffect     effect)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaCompositor *compositor = priv->compositor;
+  MetaCompositor *compositor = self->compositor;
   MetaPluginEffect event;
 
-  g_return_if_fail (!priv->visible);
+  g_return_if_fail (!self->visible);
 
-  self->priv->visible = TRUE;
+  self->visible = TRUE;
 
   switch (effect)
     {
@@ -1366,13 +1322,12 @@ void
 meta_window_actor_hide (MetaWindowActor *self,
                         MetaCompEffect   effect)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaCompositor *compositor = priv->compositor;
+  MetaCompositor *compositor = self->compositor;
   MetaPluginEffect event;
 
-  g_return_if_fail (priv->visible);
+  g_return_if_fail (self->visible);
 
-  priv->visible = FALSE;
+  self->visible = FALSE;
 
   /* If a plugin is animating a workspace transition, we have to
    * hold off on hiding the window, and do it after the workspace
@@ -1406,16 +1361,15 @@ meta_window_actor_size_change (MetaWindowActor    *self,
                                MetaRectangle      *old_frame_rect,
                                MetaRectangle      *old_buffer_rect)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaCompositor *compositor = priv->compositor;
+  MetaCompositor *compositor = self->compositor;
 
-  self->priv->size_change_in_progress++;
+  self->size_change_in_progress++;
   meta_window_actor_freeze (self);
 
   if (!meta_plugin_manager_event_size_change (compositor->plugin_mgr, self,
                                               which_change, old_frame_rect, old_buffer_rect))
     {
-      self->priv->size_change_in_progress--;
+      self->size_change_in_progress--;
       meta_window_actor_thaw (self);
     }
 }
@@ -1426,29 +1380,26 @@ meta_window_actor_new (MetaWindow *window)
   MetaDisplay *display = meta_window_get_display (window);
   MetaCompositor *compositor = display->compositor;
   MetaWindowActor        *self;
-  MetaWindowActorPrivate *priv;
   ClutterActor           *window_group;
 
   self = g_object_new (META_TYPE_WINDOW_ACTOR,
                        "meta-window", window,
                        NULL);
 
-  priv = self->priv;
-
   meta_window_actor_sync_updates_frozen (self);
 
   if (is_frozen (self))
-    priv->first_frame_state = INITIALLY_FROZEN;
+    self->first_frame_state = INITIALLY_FROZEN;
   else
-    priv->first_frame_state = DRAWING_FIRST_FRAME;
+    self->first_frame_state = DRAWING_FIRST_FRAME;
 
   /* 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)
+  if (self->window->extended_sync_request_counter && !self->updates_frozen)
     meta_window_actor_queue_frame_drawn (self, FALSE);
 
-  meta_window_actor_sync_actor_geometry (self, priv->window->placed);
+  meta_window_actor_sync_actor_geometry (self, self->window->placed);
 
   /* Hang our compositor window state off the MetaWindow for fast retrieval */
   meta_window_set_compositor_private (window, G_OBJECT (self));
@@ -1527,25 +1478,24 @@ static void
 meta_window_actor_set_clip_region_beneath (MetaWindowActor *self,
                                            cairo_region_t  *beneath_region)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  gboolean appears_focused = meta_window_appears_focused (priv->window);
+  gboolean appears_focused = meta_window_appears_focused (self->window);
 
-  if (appears_focused ? priv->focused_shadow : priv->unfocused_shadow)
+  if (appears_focused ? self->focused_shadow : self->unfocused_shadow)
     {
-      g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);
+      g_clear_pointer (&self->shadow_clip, cairo_region_destroy);
 
       if (beneath_region)
         {
-          priv->shadow_clip = cairo_region_copy (beneath_region);
+          self->shadow_clip = cairo_region_copy (beneath_region);
 
           if (clip_shadow_under_window (self))
             {
-              cairo_region_t *frame_bounds = meta_window_get_frame_bounds (priv->window);
-              cairo_region_subtract (priv->shadow_clip, frame_bounds);
+              cairo_region_t *frame_bounds = meta_window_get_frame_bounds (self->window);
+              cairo_region_subtract (self->shadow_clip, frame_bounds);
             }
         }
       else
-        priv->shadow_clip = NULL;
+        self->shadow_clip = NULL;
     }
 }
 
@@ -1564,9 +1514,8 @@ static void
 meta_window_actor_reset_culling (MetaCullable *cullable)
 {
   MetaWindowActor *self = META_WINDOW_ACTOR (cullable);
-  MetaWindowActorPrivate *priv = self->priv;
 
-  g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);
+  g_clear_pointer (&self->shadow_clip, cairo_region_destroy);
 
   meta_cullable_reset_culling_children (cullable);
 }
@@ -1581,7 +1530,6 @@ cullable_iface_init (MetaCullableInterface *iface)
 static void
 check_needs_shadow (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
   MetaShadow *old_shadow = NULL;
   MetaShadow **shadow_location;
   gboolean recompute_shadow;
@@ -1592,23 +1540,23 @@ check_needs_shadow (MetaWindowActor *self)
    * and avoids the need to explicitly handle window type changes, which
    * we would do if tried to keep track of when we might be adding or removing
    * a shadow more explicitly. We only keep track of changes to the *shape* of
-   * the shadow with priv->recompute_shadow.
+   * the shadow with self->recompute_shadow.
    */
 
   should_have_shadow = meta_window_actor_has_shadow (self);
-  appears_focused = meta_window_appears_focused (priv->window);
+  appears_focused = meta_window_appears_focused (self->window);
 
   if (appears_focused)
     {
-      recompute_shadow = priv->recompute_focused_shadow;
-      priv->recompute_focused_shadow = FALSE;
-      shadow_location = &priv->focused_shadow;
+      recompute_shadow = self->recompute_focused_shadow;
+      self->recompute_focused_shadow = FALSE;
+      shadow_location = &self->focused_shadow;
     }
   else
     {
-      recompute_shadow = priv->recompute_unfocused_shadow;
-      priv->recompute_unfocused_shadow = FALSE;
-      shadow_location = &priv->unfocused_shadow;
+      recompute_shadow = self->recompute_unfocused_shadow;
+      self->recompute_unfocused_shadow = FALSE;
+      shadow_location = &self->unfocused_shadow;
     }
 
   if (!should_have_shadow || recompute_shadow)
@@ -1622,8 +1570,8 @@ check_needs_shadow (MetaWindowActor *self)
 
   if (*shadow_location == NULL && should_have_shadow)
     {
-      if (priv->shadow_shape == NULL)
-        priv->shadow_shape = meta_window_shape_new (priv->shape_region);
+      if (self->shadow_shape == NULL)
+        self->shadow_shape = meta_window_shape_new (self->shape_region);
 
       MetaShadowFactory *factory = meta_shadow_factory_get_default ();
       const char *shadow_class = meta_window_actor_get_shadow_class (self);
@@ -1631,7 +1579,7 @@ check_needs_shadow (MetaWindowActor *self)
 
       meta_window_actor_get_shape_bounds (self, &shape_bounds);
       *shadow_location = meta_shadow_factory_get_shadow (factory,
-                                                         priv->shadow_shape,
+                                                         self->shadow_shape,
                                                          shape_bounds.width, shape_bounds.height,
                                                          shadow_class, appears_focused);
     }
@@ -1644,10 +1592,8 @@ void
 meta_window_actor_process_x11_damage (MetaWindowActor    *self,
                                       XDamageNotifyEvent *event)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (priv->surface)
-    meta_surface_actor_process_damage (priv->surface,
+  if (self->surface)
+    meta_surface_actor_process_damage (self->surface,
                                        event->area.x,
                                        event->area.y,
                                        event->area.width,
@@ -1657,11 +1603,9 @@ meta_window_actor_process_x11_damage (MetaWindowActor    *self,
 void
 meta_window_actor_sync_visibility (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (CLUTTER_ACTOR_IS_VISIBLE (self) != priv->visible)
+  if (CLUTTER_ACTOR_IS_VISIBLE (self) != self->visible)
     {
-      if (priv->visible)
+      if (self->visible)
         clutter_actor_show (CLUTTER_ACTOR (self));
       else
         clutter_actor_hide (CLUTTER_ACTOR (self));
@@ -1712,7 +1656,6 @@ build_and_scan_frame_mask (MetaWindowActor       *self,
 {
   ClutterBackend *backend = clutter_get_default_backend ();
   CoglContext *ctx = clutter_backend_get_cogl_context (backend);
-  MetaWindowActorPrivate *priv = self->priv;
   guchar *mask_data;
   guint tex_width, tex_height;
   MetaShapedTexture *stex;
@@ -1721,7 +1664,7 @@ build_and_scan_frame_mask (MetaWindowActor       *self,
   cairo_t *cr;
   cairo_surface_t *surface;
 
-  stex = meta_surface_actor_get_texture (priv->surface);
+  stex = meta_surface_actor_get_texture (self->surface);
   g_return_if_fail (stex);
 
   meta_shaped_texture_set_mask_texture (stex, NULL);
@@ -1748,7 +1691,7 @@ build_and_scan_frame_mask (MetaWindowActor       *self,
   gdk_cairo_region (cr, shape_region);
   cairo_fill (cr);
 
-  if (priv->window->frame != NULL)
+  if (self->window->frame != NULL)
     {
       cairo_region_t *frame_paint_region, *scanned_region;
       cairo_rectangle_int_t rect = { 0, 0, tex_width, tex_height };
@@ -1760,7 +1703,7 @@ build_and_scan_frame_mask (MetaWindowActor       *self,
       gdk_cairo_region (cr, frame_paint_region);
       cairo_clip (cr);
 
-      meta_frame_get_mask (priv->window->frame, cr);
+      meta_frame_get_mask (self->window->frame, cr);
 
       cairo_surface_flush (surface);
       scanned_region = scan_visible_region (mask_data, stride, frame_paint_region);
@@ -1809,20 +1752,19 @@ build_and_scan_frame_mask (MetaWindowActor       *self,
 static void
 meta_window_actor_update_shape_region (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
   cairo_region_t *region = NULL;
   cairo_rectangle_int_t client_area;
 
-  meta_window_get_client_area_rect (priv->window, &client_area);
+  meta_window_get_client_area_rect (self->window, &client_area);
 
-  if (priv->window->frame != NULL && priv->window->shape_region != NULL)
+  if (self->window->frame != NULL && self->window->shape_region != NULL)
     {
-      region = cairo_region_copy (priv->window->shape_region);
+      region = cairo_region_copy (self->window->shape_region);
       cairo_region_translate (region, client_area.x, client_area.y);
     }
-  else if (priv->window->shape_region != NULL)
+  else if (self->window->shape_region != NULL)
     {
-      region = cairo_region_reference (priv->window->shape_region);
+      region = cairo_region_reference (self->window->shape_region);
     }
   else
     {
@@ -1832,13 +1774,13 @@ meta_window_actor_update_shape_region (MetaWindowActor *self)
       region = cairo_region_create_rectangle (&client_area);
     }
 
-  if ((priv->window->shape_region != NULL) || (priv->window->frame != NULL))
+  if ((self->window->shape_region != NULL) || (self->window->frame != NULL))
     build_and_scan_frame_mask (self, &client_area, region);
 
-  g_clear_pointer (&priv->shape_region, cairo_region_destroy);
-  priv->shape_region = region;
+  g_clear_pointer (&self->shape_region, cairo_region_destroy);
+  self->shape_region = region;
 
-  g_clear_pointer (&priv->shadow_shape, meta_window_shape_unref);
+  g_clear_pointer (&self->shadow_shape, meta_window_shape_unref);
 
   meta_window_actor_invalidate_shadow (self);
 }
@@ -1846,8 +1788,7 @@ meta_window_actor_update_shape_region (MetaWindowActor *self)
 static void
 meta_window_actor_update_input_region (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaWindow *window = priv->window;
+  MetaWindow *window = self->window;
   cairo_region_t *region;
 
   if (window->shape_region && window->input_region)
@@ -1862,22 +1803,21 @@ meta_window_actor_update_input_region (MetaWindowActor *self)
   else
     region = NULL;
 
-  meta_surface_actor_set_input_region (priv->surface, region);
+  meta_surface_actor_set_input_region (self->surface, region);
   cairo_region_destroy (region);
 }
 
 static void
 meta_window_actor_update_opaque_region (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
   cairo_region_t *opaque_region;
   gboolean argb32 = is_argb32 (self);
 
-  if (argb32 && priv->window->opaque_region != NULL)
+  if (argb32 && self->window->opaque_region != NULL)
     {
       cairo_rectangle_int_t client_area;
 
-      meta_window_get_client_area_rect (priv->window, &client_area);
+      meta_window_get_client_area_rect (self->window, &client_area);
 
       /* The opaque region is defined to be a part of the
        * window which ARGB32 will always paint with opaque
@@ -1889,56 +1829,50 @@ meta_window_actor_update_opaque_region (MetaWindowActor *self)
        * to be undefined, and considered a client bug. In mutter's
        * case, graphical glitches will occur.
        */
-      opaque_region = cairo_region_copy (priv->window->opaque_region);
+      opaque_region = cairo_region_copy (self->window->opaque_region);
       cairo_region_translate (opaque_region, client_area.x, client_area.y);
-      cairo_region_intersect (opaque_region, priv->shape_region);
+      cairo_region_intersect (opaque_region, self->shape_region);
     }
   else if (argb32)
     opaque_region = NULL;
   else
-    opaque_region = cairo_region_reference (priv->shape_region);
+    opaque_region = cairo_region_reference (self->shape_region);
 
-  meta_surface_actor_set_opaque_region (priv->surface, opaque_region);
+  meta_surface_actor_set_opaque_region (self->surface, opaque_region);
   cairo_region_destroy (opaque_region);
 }
 
 static void
 check_needs_reshape (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (!priv->needs_reshape)
+  if (!self->needs_reshape)
     return;
 
   meta_window_actor_update_shape_region (self);
 
-  if (priv->window->client_type == META_WINDOW_CLIENT_TYPE_X11)
+  if (self->window->client_type == META_WINDOW_CLIENT_TYPE_X11)
     {
       meta_window_actor_update_input_region (self);
       meta_window_actor_update_opaque_region (self);
     }
 
-  priv->needs_reshape = FALSE;
+  self->needs_reshape = FALSE;
 }
 
 void
 meta_window_actor_update_shape (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  priv->needs_reshape = TRUE;
+  self->needs_reshape = TRUE;
 
   if (is_frozen (self))
     return;
 
-  clutter_actor_queue_redraw (CLUTTER_ACTOR (priv->surface));
+  clutter_actor_queue_redraw (CLUTTER_ACTOR (self->surface));
 }
 
 static void
 meta_window_actor_handle_updates (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
   if (is_frozen (self))
     {
       /* The window is frozen due to a pending animation: we'll wait until
@@ -1946,12 +1880,12 @@ meta_window_actor_handle_updates (MetaWindowActor *self)
       return;
     }
 
-  if (meta_surface_actor_is_unredirected (priv->surface))
+  if (meta_surface_actor_is_unredirected (self->surface))
     return;
 
-  meta_surface_actor_pre_paint (priv->surface);
+  meta_surface_actor_pre_paint (self->surface);
 
-  if (!meta_surface_actor_is_visible (priv->surface))
+  if (!meta_surface_actor_is_visible (self->surface))
     return;
 
   check_needs_reshape (self);
@@ -1972,18 +1906,17 @@ meta_window_actor_pre_paint (MetaWindowActor *self)
 static void
 do_send_frame_drawn (MetaWindowActor *self, FrameData *frame)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaDisplay *display = meta_window_get_display (priv->window);
+  MetaDisplay *display = meta_window_get_display (self->window);
   Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display);
 
   XClientMessageEvent ev = { 0, };
 
   frame->frame_drawn_time = meta_compositor_monotonic_time_to_server_time (display,
                                                                            g_get_monotonic_time ());
-  priv->frame_drawn_time = frame->frame_drawn_time;
+  self->frame_drawn_time = frame->frame_drawn_time;
 
   ev.type = ClientMessage;
-  ev.window = meta_window_get_xwindow (priv->window);
+  ev.window = meta_window_get_xwindow (self->window);
   ev.message_type = display->x11_display->atom__NET_WM_FRAME_DRAWN;
   ev.format = 32;
   ev.data.l[0] = frame->sync_request_serial & G_GUINT64_CONSTANT(0xffffffff);
@@ -2000,9 +1933,7 @@ do_send_frame_drawn (MetaWindowActor *self, FrameData *frame)
 void
 meta_window_actor_post_paint (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  priv->repaint_scheduled = FALSE;
+  self->repaint_scheduled = FALSE;
 
   if (meta_window_actor_is_destroyed (self))
     return;
@@ -2011,12 +1942,12 @@ meta_window_actor_post_paint (MetaWindowActor *self)
    * it is obscured, we should wait until timer expiration before
    * sending _NET_WM_FRAME_* messages.
    */
-  if (priv->send_frame_messages_timer == 0 &&
-      priv->needs_frame_drawn)
+  if (self->send_frame_messages_timer == 0 &&
+      self->needs_frame_drawn)
     {
       GList *l;
 
-      for (l = priv->frames; l; l = l->next)
+      for (l = self->frames; l; l = l->next)
         {
           FrameData *frame = l->data;
 
@@ -2024,12 +1955,12 @@ meta_window_actor_post_paint (MetaWindowActor *self)
             do_send_frame_drawn (self, frame);
         }
 
-      priv->needs_frame_drawn = FALSE;
+      self->needs_frame_drawn = FALSE;
     }
 
-  if (priv->first_frame_state == DRAWING_FIRST_FRAME)
+  if (self->first_frame_state == DRAWING_FIRST_FRAME)
     {
-      priv->first_frame_state = EMITTED_FIRST_FRAME;
+      self->first_frame_state = EMITTED_FIRST_FRAME;
       g_signal_emit (self, signals[FIRST_FRAME], 0);
     }
 }
@@ -2040,14 +1971,13 @@ do_send_frame_timings (MetaWindowActor  *self,
                        gint             refresh_interval,
                        gint64           presentation_time)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaDisplay *display = meta_window_get_display (priv->window);
+  MetaDisplay *display = meta_window_get_display (self->window);
   Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display);
 
   XClientMessageEvent ev = { 0, };
 
   ev.type = ClientMessage;
-  ev.window = meta_window_get_xwindow (priv->window);
+  ev.window = meta_window_get_xwindow (self->window);
   ev.message_type = display->x11_display->atom__NET_WM_FRAME_TIMINGS;
   ev.format = 32;
   ev.data.l[0] = frame->sync_request_serial & G_GUINT64_CONSTANT(0xffffffff);
@@ -2098,13 +2028,12 @@ meta_window_actor_frame_complete (MetaWindowActor  *self,
                                   ClutterFrameInfo *frame_info,
                                   gint64            presentation_time)
 {
-  MetaWindowActorPrivate *priv = self->priv;
   GList *l;
 
   if (meta_window_actor_is_destroyed (self))
     return;
 
-  for (l = priv->frames; l;)
+  for (l = self->frames; l;)
     {
       GList *l_next = l->next;
       FrameData *frame = l->data;
@@ -2114,12 +2043,12 @@ meta_window_actor_frame_complete (MetaWindowActor  *self,
         {
           if (G_UNLIKELY (frame->frame_drawn_time == 0))
             g_warning ("%s: Frame has assigned frame counter but no frame drawn time",
-                       priv->window->desc);
+                       self->window->desc);
           if (G_UNLIKELY (frame->frame_counter < frame_counter))
             g_warning ("%s: frame_complete callback never occurred for frame %" G_GINT64_FORMAT,
-                       priv->window->desc, frame->frame_counter);
+                       self->window->desc, frame->frame_counter);
 
-          priv->frames = g_list_delete_link (priv->frames, l);
+          self->frames = g_list_delete_link (self->frames, l);
           send_frame_timings (self, frame, frame_info, presentation_time);
           frame_data_free (frame);
         }
@@ -2131,10 +2060,8 @@ meta_window_actor_frame_complete (MetaWindowActor  *self,
 void
 meta_window_actor_invalidate_shadow (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  priv->recompute_focused_shadow = TRUE;
-  priv->recompute_unfocused_shadow = TRUE;
+  self->recompute_focused_shadow = TRUE;
+  self->recompute_unfocused_shadow = TRUE;
 
   if (is_frozen (self))
     return;
@@ -2145,24 +2072,21 @@ meta_window_actor_invalidate_shadow (MetaWindowActor *self)
 void
 meta_window_actor_update_opacity (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaWindow *window = priv->window;
+  MetaWindow *window = self->window;
 
-  if (priv->surface)
-    clutter_actor_set_opacity (CLUTTER_ACTOR (priv->surface), window->opacity);
+  if (self->surface)
+    clutter_actor_set_opacity (CLUTTER_ACTOR (self->surface), window->opacity);
 }
 
 static void
 meta_window_actor_set_updates_frozen (MetaWindowActor *self,
                                       gboolean         updates_frozen)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
   updates_frozen = updates_frozen != FALSE;
 
-  if (priv->updates_frozen != updates_frozen)
+  if (self->updates_frozen != updates_frozen)
     {
-      priv->updates_frozen = updates_frozen;
+      self->updates_frozen = updates_frozen;
       if (updates_frozen)
         meta_window_actor_freeze (self);
       else
@@ -2173,8 +2097,7 @@ meta_window_actor_set_updates_frozen (MetaWindowActor *self,
 void
 meta_window_actor_sync_updates_frozen (MetaWindowActor *self)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaWindow *window = priv->window;
+  MetaWindow *window = self->window;
 
   meta_window_actor_set_updates_frozen (self, meta_window_updates_are_frozen (window));
 }
@@ -2210,10 +2133,10 @@ meta_window_actor_get_frame_bounds (MetaScreenCastWindow *screen_cast_window,
   MetaRectangle frame_rect;
   double scale_x, scale_y;
 
-  stex = meta_surface_actor_get_texture (window_actor->priv->surface);
+  stex = meta_surface_actor_get_texture (window_actor->surface);
   clutter_actor_get_scale (CLUTTER_ACTOR (stex), &scale_x, &scale_y);
 
-  window = window_actor->priv->window;
+  window = window_actor->window;
   meta_window_get_buffer_rect (window, &buffer_rect);
   meta_window_get_frame_rect (window, &frame_rect);
 
@@ -2245,7 +2168,7 @@ meta_window_actor_transform_relative_position (MetaScreenCastWindow *screen_cast
                 bounds.y,
                 bounds.y + bounds.height);
 
-  stex = meta_surface_actor_get_texture (window_actor->priv->surface);
+  stex = meta_surface_actor_get_texture (window_actor->surface);
   clutter_actor_apply_transform_to_point (CLUTTER_ACTOR (stex), &v1, &v2);
 
   *x_out = (double) v2.x;
@@ -2268,7 +2191,7 @@ meta_window_actor_capture_into (MetaScreenCastWindow *screen_cast_window,
     return;
 
   clip_rect = *bounds;
-  image = meta_surface_actor_get_image (window_actor->priv->surface, &clip_rect);
+  image = meta_surface_actor_get_image (window_actor->surface, &clip_rect);
   cr_data = cairo_image_surface_get_data (image);
   cr_stride = cairo_image_surface_get_stride (image);
 
diff --git a/src/meta/meta-background-actor.h b/src/meta/meta-background-actor.h
index 6885a0ee1..ff601676f 100644
--- a/src/meta/meta-background-actor.h
+++ b/src/meta/meta-background-actor.h
@@ -34,31 +34,12 @@
  * the background that are obscured by other windows.
  */
 
-#define META_TYPE_BACKGROUND_ACTOR            (meta_background_actor_get_type ())
-#define META_BACKGROUND_ACTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
META_TYPE_BACKGROUND_ACTOR, MetaBackgroundActor))
-#define META_BACKGROUND_ACTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_BACKGROUND_ACTOR, 
MetaBackgroundActorClass))
-#define META_IS_BACKGROUND_ACTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
META_TYPE_BACKGROUND_ACTOR))
-#define META_IS_BACKGROUND_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_BACKGROUND_ACTOR))
-#define META_BACKGROUND_ACTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_BACKGROUND_ACTOR, 
MetaBackgroundActorClass))
+#define META_TYPE_BACKGROUND_ACTOR (meta_background_actor_get_type ())
+G_DECLARE_FINAL_TYPE (MetaBackgroundActor,
+                      meta_background_actor,
+                      META, BACKGROUND_ACTOR,
+                      ClutterActor)
 
-typedef struct _MetaBackgroundActor        MetaBackgroundActor;
-typedef struct _MetaBackgroundActorClass   MetaBackgroundActorClass;
-typedef struct _MetaBackgroundActorPrivate MetaBackgroundActorPrivate;
-
-struct _MetaBackgroundActorClass
-{
-  /*< private >*/
-  ClutterActorClass parent_class;
-};
-
-struct _MetaBackgroundActor
-{
-  ClutterActor parent;
-
-  MetaBackgroundActorPrivate *priv;
-};
-
-GType meta_background_actor_get_type (void);
 
 ClutterActor *meta_background_actor_new    (MetaDisplay *display,
                                             int          monitor);
diff --git a/src/meta/meta-background-group.h b/src/meta/meta-background-group.h
index 14bb0814c..7eb26b31c 100644
--- a/src/meta/meta-background-group.h
+++ b/src/meta/meta-background-group.h
@@ -5,32 +5,11 @@
 
 #include "clutter/clutter.h"
 
-#define META_TYPE_BACKGROUND_GROUP            (meta_background_group_get_type ())
-#define META_BACKGROUND_GROUP(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
META_TYPE_BACKGROUND_GROUP, MetaBackgroundGroup))
-#define META_BACKGROUND_GROUP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_BACKGROUND_GROUP, 
MetaBackgroundGroupClass))
-#define META_IS_BACKGROUND_GROUP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
META_TYPE_BACKGROUND_GROUP))
-#define META_IS_BACKGROUND_GROUP_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), 
META_TYPE_BACKGROUND_GROUP))
-#define META_BACKGROUND_GROUP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_BACKGROUND_GROUP, 
MetaBackgroundGroupClass))
-
-typedef struct _MetaBackgroundGroup        MetaBackgroundGroup;
-typedef struct _MetaBackgroundGroupClass   MetaBackgroundGroupClass;
-typedef struct _MetaBackgroundGroupPrivate MetaBackgroundGroupPrivate;
-
-struct _MetaBackgroundGroupClass
-{
-  /*< private >*/
-  ClutterActorClass parent_class;
-};
-
-struct _MetaBackgroundGroup
-{
-  /*< private >*/
-  ClutterActor parent;
-
-  MetaBackgroundGroupPrivate *priv;
-};
-
-GType meta_background_group_get_type (void);
+#define META_TYPE_BACKGROUND_GROUP (meta_background_group_get_type ())
+G_DECLARE_FINAL_TYPE (MetaBackgroundGroup,
+                      meta_background_group,
+                      META, BACKGROUND_GROUP,
+                      ClutterActor)
 
 ClutterActor *meta_background_group_new (void);
 
diff --git a/src/meta/meta-background-image.h b/src/meta/meta-background-image.h
index de018bd1e..b2e2175bd 100644
--- a/src/meta/meta-background-image.h
+++ b/src/meta/meta-background-image.h
@@ -29,48 +29,25 @@
 #include "cogl/cogl.h"
 #include "meta/display.h"
 
-#define META_TYPE_BACKGROUND_IMAGE            (meta_background_image_get_type ())
-#define META_BACKGROUND_IMAGE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
META_TYPE_BACKGROUND_IMAGE, MetaBackgroundImage))
-#define META_BACKGROUND_IMAGE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  
META_TYPE_BACKGROUND_IMAGE, MetaBackgroundImageClass))
-#define META_IS_BACKGROUND_IMAGE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
META_TYPE_BACKGROUND_IMAGE))
-#define META_IS_BACKGROUND_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  
META_TYPE_BACKGROUND_IMAGE))
-#define META_BACKGROUND_IMAGE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  
META_TYPE_BACKGROUND_IMAGE, MetaBackgroundImageClass))
-
-/**
- * MetaBackgroundImage:
- *
- * #MetaBackgroundImage is an object that represents a loaded or loading background image.
- */
-typedef struct _MetaBackgroundImage      MetaBackgroundImage;
-typedef struct _MetaBackgroundImageClass MetaBackgroundImageClass;
-
-GType meta_background_image_get_type (void);
+#define META_TYPE_BACKGROUND_IMAGE (meta_background_image_get_type ())
+G_DECLARE_FINAL_TYPE (MetaBackgroundImage,
+                      meta_background_image,
+                      META, BACKGROUND_IMAGE,
+                      GObject)
 
 gboolean     meta_background_image_is_loaded   (MetaBackgroundImage *image);
 gboolean     meta_background_image_get_success (MetaBackgroundImage *image);
 CoglTexture *meta_background_image_get_texture (MetaBackgroundImage *image);
 
-#define META_TYPE_BACKGROUND_IMAGE_CACHE            (meta_background_image_cache_get_type ())
-#define META_BACKGROUND_IMAGE_CACHE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
META_TYPE_BACKGROUND_IMAGE_CACHE, MetaBackgroundImageCache))
-#define META_BACKGROUND_IMAGE_CACHE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  
META_TYPE_BACKGROUND_IMAGE_CACHE, MetaBackgroundImageCacheClass))
-#define META_IS_BACKGROUND_IMAGE_CACHE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
META_TYPE_BACKGROUND_IMAGE_CACHE))
-#define META_IS_BACKGROUND_IMAGE_CACHE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  
META_TYPE_BACKGROUND_IMAGE_CACHE))
-#define META_BACKGROUND_IMAGE_CACHE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  
META_TYPE_BACKGROUND_IMAGE_CACHE, MetaBackgroundImageCacheClass))
 
-/**
- * MetaBackgroundImageCache:
- *
- * #MetaBackgroundImageCache caches loading of textures for backgrounds; there's actually
- * nothing background specific about it, other than it is tuned to work well for
- * large images as typically are used for backgrounds.
- */
-typedef struct _MetaBackgroundImageCache      MetaBackgroundImageCache;
-typedef struct _MetaBackgroundImageCacheClass MetaBackgroundImageCacheClass;
+#define META_TYPE_BACKGROUND_IMAGE_CACHE (meta_background_image_cache_get_type ())
+G_DECLARE_FINAL_TYPE (MetaBackgroundImageCache,
+                      meta_background_image_cache,
+                      META, BACKGROUND_IMAGE_CACHE,
+                      GObject)
 
 MetaBackgroundImageCache *meta_background_image_cache_get_default (void);
 
-GType meta_background_image_cache_get_type (void);
-
 MetaBackgroundImage *meta_background_image_cache_load  (MetaBackgroundImageCache *cache,
                                                         GFile                    *file);
 void                 meta_background_image_cache_purge (MetaBackgroundImageCache *cache,
diff --git a/src/meta/meta-background.h b/src/meta/meta-background.h
index 7c7c3c673..0a94d5e49 100644
--- a/src/meta/meta-background.h
+++ b/src/meta/meta-background.h
@@ -34,34 +34,15 @@
  * the background that are obscured by other windows.
  */
 
-#define META_TYPE_BACKGROUND            (meta_background_get_type ())
-#define META_BACKGROUND(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_BACKGROUND, 
MetaBackground))
-#define META_BACKGROUND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_BACKGROUND, 
MetaBackgroundClass))
-#define META_IS_BACKGROUND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_BACKGROUND))
-#define META_IS_BACKGROUND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_BACKGROUND))
-#define META_BACKGROUND_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_BACKGROUND, 
MetaBackgroundClass))
+#define META_TYPE_BACKGROUND (meta_background_get_type ())
+G_DECLARE_FINAL_TYPE (MetaBackground,
+                      meta_background,
+                      META, BACKGROUND,
+                      GObject)
 
-typedef struct _MetaBackground        MetaBackground;
-typedef struct _MetaBackgroundClass   MetaBackgroundClass;
-typedef struct _MetaBackgroundPrivate MetaBackgroundPrivate;
-
-struct _MetaBackgroundClass
-{
-  /*< private >*/
-  GObjectClass parent_class;
-};
-
-struct _MetaBackground
-{
-  GObject parent;
-
-  MetaBackgroundPrivate *priv;
-};
 
 void meta_background_refresh_all (void);
 
-GType meta_background_get_type (void);
-
 MetaBackground *meta_background_new (MetaDisplay *display);
 
 void meta_background_set_color    (MetaBackground            *self,
diff --git a/src/meta/meta-cursor-tracker.h b/src/meta/meta-cursor-tracker.h
index 735fa5810..8234dbbe4 100644
--- a/src/meta/meta-cursor-tracker.h
+++ b/src/meta/meta-cursor-tracker.h
@@ -29,16 +29,12 @@
 #include "meta/types.h"
 #include "meta/workspace.h"
 
-#define META_TYPE_CURSOR_TRACKER            (meta_cursor_tracker_get_type ())
-#define META_CURSOR_TRACKER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_CURSOR_TRACKER, 
MetaCursorTracker))
-#define META_CURSOR_TRACKER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_CURSOR_TRACKER, 
MetaCursorTrackerClass))
-#define META_IS_CURSOR_TRACKER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_CURSOR_TRACKER))
-#define META_IS_CURSOR_TRACKER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_CURSOR_TRACKER))
-#define META_CURSOR_TRACKER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_CURSOR_TRACKER, 
MetaCursorTrackerClass))
+#define META_TYPE_CURSOR_TRACKER (meta_cursor_tracker_get_type ())
+G_DECLARE_FINAL_TYPE (MetaCursorTracker,
+                      meta_cursor_tracker,
+                      META, CURSOR_TRACKER,
+                      GObject)
 
-typedef struct _MetaCursorTrackerClass   MetaCursorTrackerClass;
-
-GType meta_cursor_tracker_get_type (void);
 
 MetaCursorTracker *meta_cursor_tracker_get_for_display (MetaDisplay *display);
 
diff --git a/src/meta/meta-shadow-factory.h b/src/meta/meta-shadow-factory.h
index 4aa1fc386..e91af162e 100644
--- a/src/meta/meta-shadow-factory.h
+++ b/src/meta/meta-shadow-factory.h
@@ -57,27 +57,14 @@ struct _MetaShadowParams
   guint8 opacity;
 };
 
-#define META_TYPE_SHADOW_FACTORY            (meta_shadow_factory_get_type ())
-#define META_SHADOW_FACTORY(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SHADOW_FACTORY, 
MetaShadowFactory))
-#define META_SHADOW_FACTORY_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_SHADOW_FACTORY, 
MetaShadowFactoryClass))
-#define META_IS_SHADOW_FACTORY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SHADOW_FACTORY))
-#define META_IS_SHADOW_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_SHADOW_FACTORY))
-#define META_SHADOW_FACTORY_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_SHADOW_FACTORY, 
MetaShadowFactoryClass))
-
-/**
- * MetaShadowFactory:
- *
- * #MetaShadowFactory is used to create window shadows. It caches shadows internally
- * so that multiple shadows created for the same shape with the same radius will
- * share the same MetaShadow.
- */
-typedef struct _MetaShadowFactory      MetaShadowFactory;
-typedef struct _MetaShadowFactoryClass MetaShadowFactoryClass;
+#define META_TYPE_SHADOW_FACTORY (meta_shadow_factory_get_type ())
+G_DECLARE_FINAL_TYPE (MetaShadowFactory,
+                      meta_shadow_factory,
+                      META, SHADOW_FACTORY,
+                      GObject)
 
 MetaShadowFactory *meta_shadow_factory_get_default (void);
 
-GType meta_shadow_factory_get_type (void);
-
 void meta_shadow_factory_set_params (MetaShadowFactory *factory,
                                      const char        *class_name,
                                      gboolean           focused,
diff --git a/src/meta/meta-shaped-texture.h b/src/meta/meta-shaped-texture.h
index dc568a743..ca79b6521 100644
--- a/src/meta/meta-shaped-texture.h
+++ b/src/meta/meta-shaped-texture.h
@@ -30,38 +30,12 @@
 
 G_BEGIN_DECLS
 
-#define META_TYPE_SHAPED_TEXTURE            (meta_shaped_texture_get_type())
-#define META_SHAPED_TEXTURE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj),META_TYPE_SHAPED_TEXTURE, 
MetaShapedTexture))
-#define META_SHAPED_TEXTURE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_SHAPED_TEXTURE, 
MetaShapedTextureClass))
-#define META_IS_SHAPED_TEXTURE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SHAPED_TEXTURE))
-#define META_IS_SHAPED_TEXTURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_SHAPED_TEXTURE))
-#define META_SHAPED_TEXTURE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_SHAPED_TEXTURE, 
MetaShapedTextureClass))
+#define META_TYPE_SHAPED_TEXTURE (meta_shaped_texture_get_type ())
+G_DECLARE_FINAL_TYPE (MetaShapedTexture,
+                      meta_shaped_texture,
+                      META, SHAPED_TEXTURE,
+                      ClutterActor)
 
-typedef struct _MetaShapedTexture        MetaShapedTexture;
-typedef struct _MetaShapedTextureClass   MetaShapedTextureClass;
-typedef struct _MetaShapedTexturePrivate MetaShapedTexturePrivate;
-
-struct _MetaShapedTextureClass
-{
-  /*< private >*/
-  ClutterActorClass parent_class;
-};
-
-/**
- * MetaShapedTexture:
- *
- * The <structname>MetaShapedTexture</structname> structure contains
- * only private data and should be accessed using the provided API
- */
-struct _MetaShapedTexture
-{
-  /*< private >*/
-  ClutterActor parent;
-
-  MetaShapedTexturePrivate *priv;
-};
-
-GType meta_shaped_texture_get_type (void) G_GNUC_CONST;
 
 void meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex,
                                             gboolean           create_mipmaps);
diff --git a/src/meta/meta-window-actor.h b/src/meta/meta-window-actor.h
index d5862e44b..c1bc02b68 100644
--- a/src/meta/meta-window-actor.h
+++ b/src/meta/meta-window-actor.h
@@ -28,34 +28,12 @@
 #include "clutter/clutter.h"
 #include "meta/compositor.h"
 
-/*
- * MetaWindowActor object (ClutterGroup sub-class)
- */
-#define META_TYPE_WINDOW_ACTOR            (meta_window_actor_get_type ())
-#define META_WINDOW_ACTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_WINDOW_ACTOR, 
MetaWindowActor))
-#define META_WINDOW_ACTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_WINDOW_ACTOR, 
MetaWindowActorClass))
-#define META_IS_WINDOW_ACTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_WINDOW_ACTOR))
-#define META_IS_WINDOW_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_WINDOW_ACTOR))
-#define META_WINDOW_ACTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_WINDOW_ACTOR, 
MetaWindowActorClass))
-
-typedef struct _MetaWindowActor        MetaWindowActor;
-typedef struct _MetaWindowActorClass   MetaWindowActorClass;
-typedef struct _MetaWindowActorPrivate MetaWindowActorPrivate;
-
-struct _MetaWindowActorClass
-{
-  /*< private >*/
-  ClutterActorClass parent_class;
-};
-
-struct _MetaWindowActor
-{
-  ClutterActor           parent;
-
-  MetaWindowActorPrivate *priv;
-};
+#define META_TYPE_WINDOW_ACTOR (meta_window_actor_get_type ())
+G_DECLARE_FINAL_TYPE (MetaWindowActor,
+                      meta_window_actor,
+                      META, WINDOW_ACTOR,
+                      ClutterActor)
 
-GType meta_window_actor_get_type (void);
 
 Window             meta_window_actor_get_x_window         (MetaWindowActor *self);
 MetaWindow *       meta_window_actor_get_meta_window      (MetaWindowActor *self);
diff --git a/src/meta/meta-window-group.h b/src/meta/meta-window-group.h
index 624e07c9a..8dc219887 100644
--- a/src/meta/meta-window-group.h
+++ b/src/meta/meta-window-group.h
@@ -6,6 +6,9 @@
 #include "clutter/clutter.h"
 
 #define META_TYPE_WINDOW_GROUP (meta_window_group_get_type())
-G_DECLARE_FINAL_TYPE (MetaWindowGroup, meta_window_group, META, WINDOW_GROUP, ClutterActor)
+G_DECLARE_FINAL_TYPE (MetaWindowGroup,
+                      meta_window_group,
+                      META, WINDOW_GROUP,
+                      ClutterActor)
 
 #endif /* META_WINDOW_GROUP_H */
diff --git a/src/meta/meta-workspace-manager.h b/src/meta/meta-workspace-manager.h
index 52b2f0e30..da8125e49 100644
--- a/src/meta/meta-workspace-manager.h
+++ b/src/meta/meta-workspace-manager.h
@@ -30,7 +30,10 @@
 #include <meta/types.h>
 
 #define META_TYPE_WORKSPACE_MANAGER (meta_workspace_manager_get_type ())
-G_DECLARE_FINAL_TYPE (MetaWorkspaceManager, meta_workspace_manager, META, WORKSPACE_MANAGER, GObject)
+G_DECLARE_FINAL_TYPE (MetaWorkspaceManager,
+                      meta_workspace_manager,
+                      META, WORKSPACE_MANAGER,
+                      GObject)
 
 GList *meta_workspace_manager_get_workspaces (MetaWorkspaceManager *workspace_manager);
 


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]