Merge lp:~compiz-team/compiz/compiz.fix_1119608 into lp:compiz/0.9.9

[Sam Spilsbury]

Redesign the optional pixmap deletion protocol to make the consumer responsible for deleting the pixmaps.

The previous optional protocol had the consumer send a message back to the producer when a pixmap was ready to be deleted, and then the producer would take it from its pool of pixmaps marked for deletion and delete it there. That protocol did not really work out in practise though, because of a race condition where the consumer would never become aware of a new pixmap (because the new pixmap value was read synchronously instead of delivered asynchronously) and then that pixmap would just sit there in the consumer's memory and never be deleted. The new optional protocol makes the consumer responsible for freeing the pixmap once the producer has marked it ready for deletion. That way the consumer can keep on using the pixmap until it needs to delete it. This is important on drivers that use loose binding, because the texture contents are undefined as soon as the pixmap is freed on the server side.

In order to represent that, there were a few new objects added. The first is a "communicator" object which handles all of the requests that come from the decorator through ClientMessage events and dispatch to the right place. The next are the individual message handlers, which determine whether or not the pixmap can be deleted immediately or if it should go into the pixmap release pool. The final is the release pool, which stores in-use pixmaps in a list which can then be marked for deletion when the texture they are bound to goes away.

Unit and Integration tests were added to demonstrate the code and protocol behaviour.

(LP: #1119608)

Redesign the optional pixmap deletion protocol to make the consumer responsible for deleting the pixmaps.

The previous optional protocol had the consumer send a message back to the producer when a pixmap was ready to be deleted, and then the producer would take it from its pool of pixmaps marked for deletion and delete it there. That protocol did not really work out in practise though, because of a race condition where the consumer would never become aware of a new pixmap (because the new pixmap value was read synchronously instead of delivered asynchronously) and then that pixmap would just sit there in the consumer's memory and never be deleted. The new optional protocol makes the consumer responsible for freeing the pixmap once the producer has marked it ready for deletion. That way the consumer can keep on using the pixmap until it needs to delete it. This is important on drivers that use loose binding, because the texture contents are undefined as soon as the pixmap is freed on the server side.

In order to represent that, there were a few new objects added. The first is a "communicator" object which handles all of the requests that come from the decorator through ClientMessage events and dispatch to the right place. The next are the individual message handlers, which determine whether or not the pixmap can be deleted immediately or if it should go into the pixmap release pool. The final is the release pool, which stores in-use pixmaps in a list which can then be marked for deletion when the texture they are bound to goes away.

Unit and Integration tests were added to demonstrate the code and protocol behaviour.

(LP: #1119608)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3624
http://jenkins.qa.ubuntu.com/job/compiz-ci/5/
Executed test runs:
    None: http://jenkins.qa.ubuntu.com/job/compiz-clang-ci/./build=pbuilder,distribution=quantal,flavor=amd64/43/console
    None: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=quantal,flavor=amd64/42/console
    None: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=quantal,flavor=amd64/394/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/5//rebuild/?

review: Needs Fixing (continuous-integration)

[Martin Mrazik (mrazik)]

Sorry. I had to abort the build due to some jenkins issues we are experiencing. Will re-trigger it later.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3624
http://jenkins.qa.ubuntu.com/job/compiz-ci/17/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-clang-ci/./build=pbuilder,distribution=quantal,flavor=amd64/55/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=quantal,flavor=amd64/54/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=quantal,flavor=amd64/406/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/17//rebuild/?

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3624
http://jenkins.qa.ubuntu.com/job/compiz-ci/62/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/99/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/451/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/62//rebuild/?

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3625
http://jenkins.qa.ubuntu.com/job/compiz-ci/64/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/101/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/453/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/64//rebuild/?

review: Needs Fixing (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

Overall looks good, a few things:

Some warning when compiling:
http://paste.ubuntu.com/1683356/

CI had some test seg fault (which I don't get here), so possibly taking a look into that.

Just some minor things here:

78 - default_frames[i].d->pixmap = create_pixmap (default_frames[i].d->width, default_frames[i].d->height, frame->style_window_rgba);
79 + default_frames[i].d->pixmap = create_native_pixmap_and_wrap (default_frames[i].d->width, default_frames[i].d->height, frame->style_window_rgba);

Just looks like a small indentation error.

119 + if (w == 0 || h == 0)
120 + abort ();

I've seen w or h on windows get to -1 before, should we possibly change it to w <= 0 || h <= 0?

446 + foreach (const Decoration::Ptr &d, mList)

Though I do love this macro, I would love a range for loop but compiz doesn't use c++0x :(. (just a comment)

622 +#include <boost/noncopyable.hpp>

I don't see you inherit from this noncopyable class, do we need this header?

695 + int destroyUnusedPixmap (Pixmap pixmap) { return decor_post_delete_pixmap (mDisplay,
696 + 0,
697 + pixmap); }

Just needs little bit of lining up of the params :).

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

> Overall looks good, a few things:
>

Thanks for the quick feedback.

> Some warning when compiling:
> http://paste.ubuntu.com/1683356/

Fixed.

>
> CI had some test seg fault (which I don't get here), so possibly taking a look
> into that.

I think that should be fixed now. I wasn't running the tests through the wrapper.

>
> Just some minor things here:
>
> 78 - default_frames[i].d->pixmap = create_pixmap
> (default_frames[i].d->width, default_frames[i].d->height,
> frame->style_window_rgba);
> 79 + default_frames[i].d->pixmap = create_native_pixmap_and_wrap
> (default_frames[i].d->width, default_frames[i].d->height,
> frame->style_window_rgba);
>
> Just looks like a small indentation error.

Fixed.

>
>
> 119 + if (w == 0 || h == 0)
> 120 + abort ();
>
> I've seen w or h on windows get to -1 before, should we possibly change it to
> w <= 0 || h <= 0?

Fixed.

>
> 446 + foreach (const Decoration::Ptr &d, mList)
>
> Though I do love this macro, I would love a range for loop but compiz doesn't
> use c++0x :(. (just a comment)

Likewise, but we should do them all in one go. Its just BOOST_FOREACH.

>
> 622 +#include <boost/noncopyable.hpp>
>
> I don't see you inherit from this noncopyable class, do we need this header?

Nice catch, forgot to do it.

>
> 695 + int destroyUnusedPixmap (Pixmap pixmap) { return
> decor_post_delete_pixmap (mDisplay,
> 696 + 0,
> 697 + pixmap); }
>
> Just needs little bit of lining up of the params :).

The class was unused anyways so I got rid of it.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3627
http://jenkins.qa.ubuntu.com/job/compiz-ci/65/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/102/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/454/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/65//rebuild/?

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3627
http://jenkins.qa.ubuntu.com/job/compiz-ci/66/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/103/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/455/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/66//rebuild/?

review: Needs Fixing (continuous-integration)

[lp:~compiz-team/compiz/compiz.fix_1119608]

3628. By Sam Spilsbury on 2013-02-20

Add xorg-gtest env

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3628
http://jenkins.qa.ubuntu.com/job/compiz-ci/69/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/106/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/458/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/69//rebuild/?

review: Approve (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

Everything looks good to me, im approving this but waiting for CI to give the green light for a merge.

review: Approve

[Brandon Schaefer (brandontschaefer)]

opps wrong MP, looks like CI did its job :)

review: Approve

=== modified file 'gtk/window-decorator/cairo.c'
--- gtk/window-decorator/cairo.c	2012-09-18 11:32:20 +0000
+++ gtk/window-decorator/cairo.c	2013-02-20 07:34:20 +0000
@@ -317,19 +317,10 @@
     color.g = style->bg[GTK_STATE_NORMAL].green / 65535.0;
     color.b = style->bg[GTK_STATE_NORMAL].blue  / 65535.0;
 
-    if (d->frame_window)
-    {
-	GdkColormap *cmap;
-
-	cmap = get_colormap_for_drawable (GDK_DRAWABLE (d->pixmap));
-	gdk_drawable_set_colormap (GDK_DRAWABLE (d->pixmap), cmap);
-	gdk_drawable_set_colormap (GDK_DRAWABLE (d->buffer_pixmap), cmap);
-	drawable = GDK_DRAWABLE (d->buffer_pixmap);
-    }
-    else if (d->buffer_pixmap)
-	drawable = GDK_DRAWABLE (d->buffer_pixmap);
+    if (d->buffer_pixmap)
+	drawable = d->buffer_pixmap;
     else
-	drawable = GDK_DRAWABLE (d->pixmap);
+	drawable = d->pixmap;
 
     cr = gdk_cairo_create (GDK_DRAWABLE (drawable));
     if (!cr)

=== modified file 'gtk/window-decorator/decorator.c'
--- gtk/window-decorator/decorator.c	2012-11-20 08:11:44 +0000
+++ gtk/window-decorator/decorator.c	2013-02-20 07:34:20 +0000
@@ -649,9 +649,9 @@
     /* Get the correct depth for the frame window in reparenting mode, otherwise
      * enforce 32 */
     if (d->frame_window)
-	pixmap = create_pixmap (d->width, d->height, d->frame->style_window_rgb);
+	pixmap = create_native_pixmap_and_wrap (d->width, d->height, d->frame->style_window_rgb);
     else
-	pixmap = create_pixmap (d->width, d->height, d->frame->style_window_rgba);
+	pixmap = create_native_pixmap_and_wrap (d->width, d->height, d->frame->style_window_rgba);
 
     gdk_flush ();
 
@@ -686,16 +686,12 @@
 
     /* Destroy the old pixmaps and pictures */
     if (d->pixmap)
-    {
-	gpointer key = GINT_TO_POINTER (GDK_PIXMAP_XID (d->pixmap));
-
-	if (d->old_pixmaps == NULL)
-	    d->old_pixmaps = g_hash_table_new_full (NULL, NULL, NULL,
-	                                            g_object_unref);
-
-	g_hash_table_insert (destroyed_pixmaps_table, key, d);
-	g_hash_table_insert (d->old_pixmaps, key, d->pixmap);
-    }
+	g_object_unref (d->pixmap);
+
+    if (d->x11Pixmap)
+	decor_post_delete_pixmap (xdisplay,
+				  wnck_window_get_xid (d->win),
+				  d->x11Pixmap);
 
     if (d->buffer_pixmap)
 	g_object_unref (G_OBJECT (d->buffer_pixmap));
@@ -708,6 +704,7 @@
 
     /* Assign new pixmaps and pictures */
     d->pixmap	     = pixmap;
+    d->x11Pixmap     = GDK_PIXMAP_XID (d->pixmap);
     d->buffer_pixmap = buffer_pixmap;
     d->cr	     = gdk_cairo_create (pixmap);
 
@@ -1435,7 +1432,9 @@
         extents.top += frame->titlebar_height;
 
         default_frames[i].d->draw = theme_draw_window_decoration;
-        default_frames[i].d->pixmap = create_pixmap (default_frames[i].d->width, default_frames[i].d->height, frame->style_window_rgba);
+	default_frames[i].d->pixmap = create_native_pixmap_and_wrap (default_frames[i].d->width,
+								     default_frames[i].d->height,
+								     frame->style_window_rgba);
 
 	unsigned int j, k;
 

=== modified file 'gtk/window-decorator/events.c'
--- gtk/window-decorator/events.c	2012-10-06 16:11:05 +0000
+++ gtk/window-decorator/events.c	2013-02-20 07:34:20 +0000
@@ -1093,17 +1093,6 @@
 	    if (win)
 		update_window_decoration_size (win);
 	}
-	else if (xevent->xclient.message_type == decor_delete_pixmap_atom)
-	{
-	    gconstpointer key = GINT_TO_POINTER (xevent->xclient.data.l[0]);
-	    decor_t *d = g_hash_table_lookup (destroyed_pixmaps_table, key);
-
-	    if (d != NULL)
-	    {
-		g_hash_table_remove (d->old_pixmaps, key);
-		g_hash_table_remove (destroyed_pixmaps_table, key);
-	    }
-	}
     default:
 	break;
     }

=== modified file 'gtk/window-decorator/gdk.c'
--- gtk/window-decorator/gdk.c	2012-05-27 04:32:55 +0000
+++ gtk/window-decorator/gdk.c	2013-02-20 07:34:20 +0000
@@ -92,6 +92,26 @@
 }
 
 GdkPixmap *
+create_native_pixmap_and_wrap (int	  w,
+			       int	  h,
+			       GtkWidget *parent_style_window)
+{
+    GdkWindow *window;
+
+    if (w <= 0 || h <= 0)
+	abort ();
+
+    window = gtk_widget_get_window (parent_style_window);
+    GdkPixmap *pixmap =
+	   gdk_pixmap_foreign_new (XCreatePixmap (gdk_x11_display_get_xdisplay (gdk_display_get_default ()),
+						  GDK_WINDOW_XID (window), w, h,
+						  gdk_drawable_get_depth (window)));
+    GdkColormap *cmap = get_colormap_for_drawable (GDK_DRAWABLE (pixmap));
+    gdk_drawable_set_colormap (GDK_DRAWABLE (pixmap), cmap);
+    return pixmap;
+}
+
+GdkPixmap *
 create_pixmap (int	  w,
 	       int	  h,
 	       GtkWidget *parent_style_window)
@@ -102,5 +122,9 @@
 	abort ();
 
     window = gtk_widget_get_window (parent_style_window);
-    return gdk_pixmap_new (GDK_DRAWABLE (window), w, h, -1 /* CopyFromParent */);
+    GdkPixmap *pixmap = gdk_pixmap_new (GDK_DRAWABLE (window), w, h, -1 /* CopyFromParent */);
+
+    GdkColormap *cmap = get_colormap_for_drawable (GDK_DRAWABLE (pixmap));
+    gdk_drawable_set_colormap (GDK_DRAWABLE (pixmap), cmap);
+    return pixmap;
 }

=== modified file 'gtk/window-decorator/gtk-window-decorator.c'
--- gtk/window-decorator/gtk-window-decorator.c	2012-10-06 16:11:05 +0000
+++ gtk/window-decorator/gtk-window-decorator.c	2013-02-20 07:34:20 +0000
@@ -136,7 +136,6 @@
 GtkWidget     *switcher_label;
 
 GHashTable    *frame_table;
-GHashTable    *destroyed_pixmaps_table;
 GtkWidget     *action_menu = NULL;
 gboolean      action_menu_mapped = FALSE;
 decor_color_t _title_color[2];
@@ -267,9 +266,9 @@
     net_wm_state_atom = XInternAtom (xdisplay,"_NET_WM_STATE", 0);
     net_wm_state_modal_atom = XInternAtom (xdisplay, "_NET_WM_STATE_MODAL", 0);
 
-    decor_request_atom = XInternAtom (xdisplay, "_COMPIZ_DECOR_REQUEST", 0);
-    decor_pending_atom = XInternAtom (xdisplay, "_COMPIZ_DECOR_PENDING", 0);
-    decor_delete_pixmap_atom = XInternAtom (xdisplay, "_COMPIZ_DECOR_DELETE_PIXMAP", 0);
+    decor_request_atom = XInternAtom (xdisplay, DECOR_REQUEST_PIXMAP_ATOM_NAME, 0);
+    decor_pending_atom = XInternAtom (xdisplay, DECOR_PIXMAP_PENDING_ATOM_NAME, 0);
+    decor_delete_pixmap_atom = XInternAtom (xdisplay, DECOR_DELETE_PIXMAP_ATOM_NAME, 0);
 
     status = decor_acquire_dm_session (xdisplay,
 				       gdk_screen_get_number (gdkscreen),
@@ -343,7 +342,6 @@
     xformat_rgb  = XRenderFindStandardFormat (xdisplay, PictStandardRGB24);
 
     frame_table = g_hash_table_new (NULL, NULL);
-    destroyed_pixmaps_table = g_hash_table_new (NULL, NULL);
 
     if (!create_tooltip_window ())
     {

=== modified file 'gtk/window-decorator/gtk-window-decorator.h'
--- gtk/window-decorator/gtk-window-decorator.h	2012-10-06 16:11:05 +0000
+++ gtk/window-decorator/gtk-window-decorator.h	2013-02-20 07:34:20 +0000
@@ -392,13 +392,13 @@
     event_window      button_windows[BUTTON_NUM];
     Box		      *last_pos_entered;
     guint	      button_states[BUTTON_NUM];
+    Pixmap            x11Pixmap;
     GdkPixmap	      *pixmap;
     GdkPixmap	      *buffer_pixmap;
     GdkWindow	      *frame_window;
     GtkWidget         *decor_window;
     GtkWidget	      *decor_event_box;
     GtkWidget         *decor_image;
-    GHashTable        *old_pixmaps;
     cairo_t	      *cr;
     decor_layout_t    border_layout;
     decor_context_t   *context;
@@ -470,7 +470,6 @@
 
 /* list of all decorations */
 extern GHashTable    *frame_table;
-extern GHashTable    *destroyed_pixmaps_table;
 
 /* action menu */
 extern GtkWidget     *action_menu;
@@ -801,6 +800,11 @@
 	       GtkWidget *parent_style_window);
 
 GdkPixmap *
+create_native_pixmap_and_wrap (int	  w,
+			       int	  h,
+			       GtkWidget *parent_style_window);
+
+GdkPixmap *
 pixmap_new_from_pixbuf (GdkPixbuf *pixbuf, GtkWidget *parent);
 
 /* metacity.c */

=== modified file 'gtk/window-decorator/metacity.c'
--- gtk/window-decorator/metacity.c	2012-09-10 12:59:17 +0000
+++ gtk/window-decorator/metacity.c	2013-02-20 07:34:20 +0000
@@ -616,15 +616,6 @@
     if (!d->pixmap || !d->picture)
 	return;
 
-    if (d->frame_window)
-    {
-	GdkColormap *cmap;
-	
-	cmap = get_colormap_for_drawable (GDK_DRAWABLE (d->pixmap));
-	gdk_drawable_set_colormap (GDK_DRAWABLE (d->pixmap), cmap);
-	gdk_drawable_set_colormap (GDK_DRAWABLE (d->buffer_pixmap), cmap);
-    }
-
     if (decoration_alpha == 1.0)
 	alpha = 1.0;
 
@@ -692,13 +683,7 @@
 	XRenderPictFormat *format;
 
 	if (d->frame_window)
-	{
-	    GdkColormap *cmap;
-
-	    cmap   = get_colormap_for_drawable (GDK_DRAWABLE (d->pixmap));
 	    pixmap = create_pixmap (rect.width, size, d->frame->style_window_rgb);
-	    gdk_drawable_set_colormap (GDK_DRAWABLE (pixmap), cmap);
-	}
 	else
 	    pixmap = create_pixmap (rect.width, size, d->frame->style_window_rgba);
 

=== modified file 'gtk/window-decorator/switcher.c'
--- gtk/window-decorator/switcher.c	2011-10-13 12:07:34 +0000
+++ gtk/window-decorator/switcher.c	2013-02-20 07:34:20 +0000
@@ -472,7 +472,7 @@
 	switcher_selected_window = selected;
     }
 
-    pixmap = create_pixmap (width, height, d->frame->style_window_rgba);
+    pixmap = create_native_pixmap_and_wrap (width, height, d->frame->style_window_rgba);
     if (!pixmap)
 	return FALSE;
 
@@ -486,6 +486,11 @@
     if (d->pixmap)
 	g_object_unref (G_OBJECT (d->pixmap));
 
+    if (d->x11Pixmap)
+	decor_post_delete_pixmap (xdisplay,
+				  wnck_window_get_xid (d->win),
+				  d->x11Pixmap);
+
     if (d->buffer_pixmap)
 	g_object_unref (G_OBJECT (d->buffer_pixmap));
 
@@ -496,6 +501,7 @@
 	XRenderFreePicture (xdisplay, d->picture);
 
     d->pixmap	     = pixmap;
+    d->x11Pixmap     = GDK_PIXMAP_XID (d->pixmap);
     d->buffer_pixmap = buffer_pixmap;
     d->cr	     = gdk_cairo_create (pixmap);
 

=== modified file 'gtk/window-decorator/wnck.c'
--- gtk/window-decorator/wnck.c	2012-11-05 20:50:59 +0000
+++ gtk/window-decorator/wnck.c	2013-02-20 07:34:20 +0000
@@ -455,22 +455,12 @@
     d->created = TRUE;
 }
 
-gboolean
-clean_destroyed_pixmaps (gpointer key, gpointer value, gpointer d)
-{
-    return value == d;
-}
-
 void
 remove_frame_window (WnckWindow *win)
 {
     decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
     Display *xdisplay;
 
-    g_hash_table_foreach_remove (destroyed_pixmaps_table,
-                                 clean_destroyed_pixmaps,
-                                 d);
-
     xdisplay = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
 
     if (!d->frame_window)
@@ -507,12 +497,6 @@
 	d->buffer_pixmap = NULL;
     }
 
-    if (d->old_pixmaps)
-    {
-	g_hash_table_destroy (d->old_pixmaps);
-	d->old_pixmaps = NULL;
-    }
-
     if (d->cr)
     {
 	cairo_destroy (d->cr);

=== modified file 'include/decoration.h'
--- include/decoration.h	2012-09-05 14:25:35 +0000
+++ include/decoration.h	2013-02-20 07:34:20 +0000
@@ -50,6 +50,10 @@
 #define DECOR_TYPE_PIXMAP_ATOM_NAME             "_COMPIZ_WINDOW_DECOR_TYPE_PIXMAP"
 #define DECOR_TYPE_WINDOW_ATOM_NAME             "_COMPIZ_WINDOW_DECOR_TYPE_WINDOW"
 
+#define DECOR_REQUEST_PIXMAP_ATOM_NAME          "_COMPIZ_DECOR_REQUEST"
+#define DECOR_PIXMAP_PENDING_ATOM_NAME          "_COMPIZ_DECOR_PENDING"
+#define DECOR_DELETE_PIXMAP_ATOM_NAME           "_COMPIZ_DECOR_DELETE_PIXMAP"
+
 #define WINDOW_DECORATION_TYPE_PIXMAP (1 << 0)
 #define WINDOW_DECORATION_TYPE_WINDOW (1 << 1)
 
@@ -495,12 +499,13 @@
 int
 decor_post_pending (Display *xdisplay,
 		    Window  client,
+		    unsigned int frame_type,
 		    unsigned int frame_state,
-		    unsigned int frame_type,
 		    unsigned int frame_actions);
 
 int
 decor_post_delete_pixmap (Display *xdisplay,
+			  Window  window,
 			  Pixmap  pixmap);
 
 int

=== modified file 'libdecoration/decoration.c'
--- libdecoration/decoration.c	2013-01-28 20:52:39 +0000
+++ libdecoration/decoration.c	2013-02-20 07:34:20 +0000
@@ -2890,13 +2890,13 @@
 int
 decor_post_pending (Display *xdisplay,
 		    Window  client,
+		    unsigned int frame_type,
 		    unsigned int frame_state,
-		    unsigned int frame_type,
 		    unsigned int frame_actions)
 {
     XEvent event;
 
-    Atom   decor_pending  = XInternAtom (xdisplay, "_COMPIZ_DECOR_PENDING", FALSE);
+    Atom   decor_pending  = XInternAtom (xdisplay, DECOR_PIXMAP_PENDING_ATOM_NAME, FALSE);
 
     /* Send a client message indicating that a new
      * decoration can be generated for this window
@@ -2926,7 +2926,7 @@
 {
     XEvent event;
 
-    Atom   decor_request  = XInternAtom (xdisplay, "_COMPIZ_DECOR_REQUEST", FALSE);
+    Atom   decor_request  = XInternAtom (xdisplay, DECOR_REQUEST_PIXMAP_ATOM_NAME, FALSE);
 
     /* Send a client message indicating that a new
      * decoration can be generated for this window
@@ -2949,17 +2949,18 @@
 
 int
 decor_post_delete_pixmap (Display *xdisplay,
+			  Window window,
 			  Pixmap  pixmap)
 {
     XEvent event;
 
-    Atom   decor_delete_pixmap  = XInternAtom (xdisplay, "_COMPIZ_DECOR_DELETE_PIXMAP", FALSE);
+    Atom   decor_delete_pixmap  = XInternAtom (xdisplay, DECOR_DELETE_PIXMAP_ATOM_NAME, FALSE);
 
-    /* Send a client message indicating that a new
-     * decoration can be generated for this window
+    /* Send a client message indicating that this
+     * pixmap is no longer in use and can be removed
      */
     event.xclient.type	       = ClientMessage;
-    event.xclient.window       = DefaultRootWindow (xdisplay);
+    event.xclient.window       = window;
     event.xclient.message_type = decor_delete_pixmap;
     event.xclient.format       = 32;
     event.xclient.data.l[0]    = pixmap;
@@ -2973,6 +2974,7 @@
 
     return 1;
 }
+
 int
 decor_acquire_dm_session (Display    *xdisplay,
 			  int	     screen,

=== modified file 'plugins/decor/src/decor.cpp'
--- plugins/decor/src/decor.cpp	2013-02-19 20:38:17 +0000
+++ plugins/decor/src/decor.cpp	2013-02-20 07:34:20 +0000
@@ -391,8 +391,7 @@
 	    return t;
 	}
 
-    X11PixmapDeletor::Ptr dl = boost::make_shared <X11PixmapDeletor> (screen->dpy ());
-    DecorPixmap::Ptr pm = boost::make_shared <DecorPixmap> (pixmap, dl);
+    DecorPixmap::Ptr pm = boost::make_shared <DecorPixmap> (pixmap, mReleasePool);
 
     DecorTexture *texture = new DecorTexture (boost::shared_static_cast <DecorPixmapInterface> (pm));
 
@@ -1285,7 +1284,7 @@
 DecorationInterface::Ptr
 DecorationList::findMatchingDecoration (unsigned int frameType,
 					unsigned int frameState,
-					unsigned int frameActions)
+					unsigned int frameActions) const
 {
     foreach (const Decoration::Ptr &d, mList)
     {
@@ -1298,6 +1297,18 @@
     return DecorationInterface::Ptr ();
 }
 
+DecorationInterface::Ptr
+DecorationList::findMatchingDecoration (Pixmap p) const
+{
+    foreach (const Decoration::Ptr &d, mList)
+    {
+	if (d->texture->pixmap->getPixmap () == p)
+	    return d;
+    }
+
+    return DecorationInterface::Ptr ();
+}
+
 /*
  * DecorationList::findMatchingDecoration
  *
@@ -2334,6 +2345,42 @@
     isSwitcher = false;
 }
 
+DecorPixmapRequestorInterface *
+DecorScreen::findWindowRequestor (Window window)
+{
+    if (window == screen->root ())
+    {
+	return &mRequestor;
+    }
+    else
+    {
+	CompWindow *w = screen->findWindow (window);
+
+	if (w)
+	    return &(DecorWindow::get (w)->mRequestor);
+
+	return NULL;
+    }
+}
+
+DecorationListFindMatchingInterface *
+DecorScreen::findWindowDecorations (Window window)
+{
+    if (window == screen->root ())
+    {
+	return &decor[DECOR_ACTIVE];
+    }
+    else
+    {
+	CompWindow *w = screen->findWindow (window);
+
+	if (w)
+	    return &(DecorWindow::get (w)->decor);
+
+	return NULL;
+    }
+}
+
 
 /*
  * DecorScreen::handleEvent
@@ -2376,18 +2423,8 @@
 		    dw->update (true);
 		}
 	    }
-	    /* A decoration is pending creation, allow it to be created */
-	    if (event->xclient.message_type == decorPendingAtom)
-	    {
-		CompWindow *w = screen->findWindow (event->xclient.window);
-
-		if (w)
-		{
-		    DecorWindow *dw = DecorWindow::get (w);
-
-		    dw->mRequestor.handlePending (event->xclient.data.l);
-		}
-	    }
+
+	    mCommunicator.handleClientMessage (event->xclient);
 	    break;
 	default:
 	    /* Check for damage events. If the output or input window
@@ -3010,7 +3047,31 @@
 				   screen->root (),
 				   NULL)),
     mMenusClipGroup (CompMatch ("type=Dock | type=DropdownMenu | type=PopupMenu")),
-    mRequestor (screen->dpy (), screen->root (), &(decor[DECOR_ACTIVE]))
+    mRequestor (screen->dpy (), screen->root (), &(decor[DECOR_ACTIVE])),
+    mReleasePool (new PixmapReleasePool (
+		      boost::bind (XFreePixmap,
+				   screen->dpy (),
+				   _1))),
+    mPendingHandler (boost::bind (&DecorScreen::findWindowRequestor,
+				  this,
+				  _1)),
+    mUnusedHandler (boost::bind (&DecorScreen::findWindowDecorations,
+				 this,
+				 _1),
+		    mReleasePool,
+		    boost::bind (XFreePixmap,
+				 screen->dpy (),
+				 _1)),
+    mCommunicator (XInternAtom (screen->dpy (), DECOR_PIXMAP_PENDING_ATOM_NAME, FALSE),
+		   XInternAtom (screen->dpy (), DECOR_DELETE_PIXMAP_ATOM_NAME, FALSE),
+		   boost::bind (&PendingHandler::handleMessage,
+				&mPendingHandler,
+				_1,
+				_2),
+		   boost::bind (&UnusedHandler::handleMessage,
+				&mUnusedHandler,
+				_1,
+				_2))
 {
     supportingDmCheckAtom =
 	XInternAtom (s->dpy (), DECOR_SUPPORTING_DM_CHECK_ATOM_NAME, 0);
@@ -3033,9 +3094,9 @@
     decorSwitchWindowAtom =
 	XInternAtom (s->dpy (), DECOR_SWITCH_WINDOW_ATOM_NAME, 0);
     decorPendingAtom =
-	XInternAtom (s->dpy (), "_COMPIZ_DECOR_PENDING", 0);
+	XInternAtom (s->dpy (), DECOR_PIXMAP_PENDING_ATOM_NAME, 0);
     decorRequestAtom =
-	XInternAtom (s->dpy (), "_COMPIZ_DECOR_REQUEST", 0);
+	XInternAtom (s->dpy (), DECOR_REQUEST_PIXMAP_ATOM_NAME, 0);
     requestFrameExtentsAtom =
         XInternAtom (s->dpy (), "_NET_REQUEST_FRAME_EXTENTS", 0);
     shadowColorAtom =

=== modified file 'plugins/decor/src/decor.h'
--- plugins/decor/src/decor.h	2012-09-07 22:37:20 +0000
+++ plugins/decor/src/decor.h	2013-02-20 07:34:20 +0000
@@ -159,9 +159,10 @@
 {
     public:
 	bool updateDecoration  (Window id, Atom decorAtom, DecorPixmapRequestorInterface *requestor);
-	DecorationInterface::Ptr findMatchingDecoration(unsigned int frameType,
-								 unsigned int frameState,
-								 unsigned int frameActions);
+	DecorationInterface::Ptr findMatchingDecoration (unsigned int frameType,
+							 unsigned int frameState,
+							 unsigned int frameActions) const;
+	DecorationInterface::Ptr findMatchingDecoration (Pixmap p) const;
 	const Decoration::Ptr & findMatchingDecoration (CompWindow *w, bool sizeCheck);
         void clear ()
         {
@@ -220,6 +221,11 @@
 	bool registerPaintHandler (compiz::composite::PaintHandler *pHnd);
 	void unregisterPaintHandler ();
 
+    private:
+
+	DecorPixmapRequestorInterface * findWindowRequestor (Window);
+	DecorationListFindMatchingInterface * findWindowDecorations (Window);
+
     public:
 
 	CompositeScreen *cScreen;
@@ -255,6 +261,10 @@
 
 	MatchedDecorClipGroup mMenusClipGroup;
 	X11DecorPixmapRequestor   mRequestor;
+	PixmapReleasePool::Ptr    mReleasePool;
+	PendingHandler            mPendingHandler;
+	UnusedHandler             mUnusedHandler;
+	protocol::Communicator    mCommunicator;
 };
 
 class DecorWindow :

=== modified file 'plugins/decor/src/pixmap-requests/include/pixmap-requests.h'
--- plugins/decor/src/pixmap-requests/include/pixmap-requests.h	2012-05-10 15:40:25 +0000
+++ plugins/decor/src/pixmap-requests/include/pixmap-requests.h	2013-02-20 07:34:20 +0000
@@ -26,14 +26,19 @@
 #ifndef _COMPIZ_DECOR_PIXMAP_REQUESTS_H
 #define _COMPIZ_DECOR_PIXMAP_REQUESTS_H
 
+#include <list>
+
 #include <boost/shared_ptr.hpp>
 #include <boost/shared_array.hpp>
 #include <boost/make_shared.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/function.hpp>
 #include <decoration.h>
 
 #include <X11/Xlib.h>
 
-class DecorPixmapInterface
+class DecorPixmapInterface :
+    boost::noncopyable
 {
     public:
 
@@ -44,7 +49,8 @@
 	virtual Pixmap getPixmap () = 0;
 };
 
-class DecorPixmapReceiverInterface
+class DecorPixmapReceiverInterface :
+    boost::noncopyable
 {
     public:
 
@@ -57,7 +63,8 @@
 /* So far, nothing particularly interesting here
  * we just need a way to pass around pointers for
  * testing */
-class DecorationInterface
+class DecorationInterface :
+    boost::noncopyable
 {
     public:
 
@@ -71,34 +78,50 @@
 	virtual unsigned int getFrameActions () const = 0;
 };
 
-class DecorPixmapDeletionInterface
-{
-    public:
-
-	typedef boost::shared_ptr <DecorPixmapDeletionInterface> Ptr;
-
-	virtual ~DecorPixmapDeletionInterface () {}
-
-	virtual int postDeletePixmap (Pixmap pixmap) = 0;
-};
-
-class X11PixmapDeletor :
-    public DecorPixmapDeletionInterface
-{
-    public:
-
-	typedef boost::shared_ptr <X11PixmapDeletor> Ptr;
-
-	X11PixmapDeletor (Display *dpy) :
-	    mDisplay (dpy)
-	{
-	}
-
-	int postDeletePixmap (Pixmap pixmap) { return decor_post_delete_pixmap (mDisplay, pixmap); }
+class PixmapDestroyQueue :
+    boost::noncopyable
+{
+    public:
+
+	typedef boost::shared_ptr <PixmapDestroyQueue> Ptr;
+
+	virtual ~PixmapDestroyQueue () {}
+
+	virtual int destroyUnusedPixmap (Pixmap pixmap) = 0;
+};
+
+class UnusedPixmapQueue :
+    boost::noncopyable
+{
+    public:
+
+	typedef boost::shared_ptr <UnusedPixmapQueue> Ptr;
+
+	virtual ~UnusedPixmapQueue () {}
+
+	virtual void markUnused (Pixmap pixmap) = 0;
+};
+
+class PixmapReleasePool :
+    public PixmapDestroyQueue,
+    public UnusedPixmapQueue
+{
+    public:
+
+	typedef boost::function <int (Pixmap)> FreePixmapFunc;
+
+	typedef boost::shared_ptr <PixmapReleasePool> Ptr;
+
+	PixmapReleasePool (const FreePixmapFunc &freePixmap);
+
+	void markUnused (Pixmap pixmap);
+	int destroyUnusedPixmap (Pixmap pixmap);
 
     private:
 
-	Display *mDisplay;
+	std::list <Pixmap> mPendingUnusedNotificationPixmaps;
+	FreePixmapFunc     mFreePixmap;
+
 };
 
 class DecorPixmap :
@@ -108,7 +131,7 @@
 
 	typedef boost::shared_ptr <DecorPixmap> Ptr;
 
-	DecorPixmap (Pixmap p, DecorPixmapDeletionInterface::Ptr deletor);
+	DecorPixmap (Pixmap p, PixmapDestroyQueue::Ptr deletor);
 	~DecorPixmap ();
 
 	Pixmap getPixmap ();
@@ -116,10 +139,11 @@
     private:
 
 	Pixmap mPixmap;
-	DecorPixmapDeletionInterface::Ptr mDeletor;
+	PixmapDestroyQueue::Ptr mDeletor;
 };
 
-class DecorPixmapRequestorInterface
+class DecorPixmapRequestorInterface :
+    boost::noncopyable
 {
     public:
 
@@ -129,7 +153,7 @@
 					 unsigned int frameState,
 					 unsigned int frameActions) = 0;
 
-	virtual void handlePending (long *data) = 0;
+	virtual void handlePending (const long *data) = 0;
 };
 
 class DecorationListFindMatchingInterface
@@ -140,8 +164,76 @@
 
 	virtual DecorationInterface::Ptr findMatchingDecoration (unsigned int frameType,
 								 unsigned int frameState,
-								 unsigned int frameActions) = 0;
-};
+								 unsigned int frameActions) const = 0;
+	virtual DecorationInterface::Ptr findMatchingDecoration (Pixmap pixmap) const = 0;
+};
+
+namespace compiz
+{
+namespace decor
+{
+typedef boost::function <DecorationListFindMatchingInterface * (Window)> DecorListForWindow;
+typedef boost::function <DecorPixmapRequestorInterface * (Window)> RequestorForWindow;
+
+class PendingHandler :
+    virtual boost::noncopyable
+{
+    public:
+
+	PendingHandler (const RequestorForWindow &);
+
+	void handleMessage (Window window, const long *data);
+
+    private:
+
+	RequestorForWindow     mRequestorForWindow;
+};
+
+class UnusedHandler :
+    virtual boost::noncopyable
+{
+    public:
+
+	UnusedHandler (const DecorListForWindow &,
+		       const UnusedPixmapQueue::Ptr &,
+		       const PixmapReleasePool::FreePixmapFunc &);
+
+	void handleMessage (Window, Pixmap);
+
+    private:
+
+	DecorListForWindow mListForWindow;
+	UnusedPixmapQueue::Ptr mQueue;
+	PixmapReleasePool::FreePixmapFunc mFreePixmap;
+};
+
+namespace protocol
+{
+typedef boost::function <void (Window, const long *)> PendingMessage;
+typedef boost::function <void (Window, Pixmap)> PixmapUnusedMessage;
+
+class Communicator :
+    virtual boost::noncopyable
+{
+    public:
+
+	Communicator (Atom pendingMsg,
+		      Atom unusedMsg,
+		      const PendingMessage &,
+		      const PixmapUnusedMessage &);
+
+	void handleClientMessage (const XClientMessageEvent &);
+
+    private:
+
+	Atom           mPendingMsgAtom;
+	Atom           mUnusedMsgAtom;
+	PendingMessage mPendingHandler;
+	PixmapUnusedMessage mPixmapUnusedHander;
+};
+}
+}
+}
 
 class X11DecorPixmapRequestor :
     public DecorPixmapRequestorInterface
@@ -156,7 +248,7 @@
 				 unsigned int frameState,
 				 unsigned int frameActions);
 
-	void handlePending (long *data);
+	void handlePending (const long *data);
 
     private:
 

=== modified file 'plugins/decor/src/pixmap-requests/src/pixmap-requests.cpp'
--- plugins/decor/src/pixmap-requests/src/pixmap-requests.cpp	2012-05-10 15:40:25 +0000
+++ plugins/decor/src/pixmap-requests/src/pixmap-requests.cpp	2013-02-20 07:34:20 +0000
@@ -6,7 +6,10 @@
 #define foreach BOOST_FOREACH
 #endif
 
-DecorPixmap::DecorPixmap (Pixmap pixmap, DecorPixmapDeletionInterface::Ptr d) :
+namespace cd = compiz::decor;
+namespace cdp = compiz::decor::protocol;
+
+DecorPixmap::DecorPixmap (Pixmap pixmap, PixmapDestroyQueue::Ptr d) :
     mPixmap (pixmap),
     mDeletor (d)
 {
@@ -14,7 +17,7 @@
 
 DecorPixmap::~DecorPixmap ()
 {
-    mDeletor->postDeletePixmap (mPixmap);
+    mDeletor->destroyUnusedPixmap (mPixmap);
 }
 
 Pixmap
@@ -78,7 +81,7 @@
 }
 
 void
-X11DecorPixmapRequestor::handlePending (long *data)
+X11DecorPixmapRequestor::handlePending (const long *data)
 {
     DecorationInterface::Ptr d = mListFinder->findMatchingDecoration (static_cast <unsigned int> (data[0]),
 								      static_cast <unsigned int> (data[1]),
@@ -91,3 +94,103 @@
 			     static_cast <unsigned int> (data[1]),
 			     static_cast <unsigned int> (data[2]));
 }
+
+namespace
+{
+typedef PixmapReleasePool::FreePixmapFunc FreePixmapFunc;
+}
+
+PixmapReleasePool::PixmapReleasePool (const FreePixmapFunc &freePixmap) :
+    mFreePixmap (freePixmap)
+{
+}
+
+void
+PixmapReleasePool::markUnused (Pixmap pixmap)
+{
+    mPendingUnusedNotificationPixmaps.push_back (pixmap);
+    mPendingUnusedNotificationPixmaps.unique ();
+}
+
+int
+PixmapReleasePool::destroyUnusedPixmap (Pixmap pixmap)
+{
+    std::list <Pixmap>::iterator it =
+	std::find (mPendingUnusedNotificationPixmaps.begin (),
+		   mPendingUnusedNotificationPixmaps.end (),
+		   pixmap);
+
+    if (it != mPendingUnusedNotificationPixmaps.end ())
+    {
+	Pixmap pixmap (*it);
+	mPendingUnusedNotificationPixmaps.erase (it);
+
+	mFreePixmap (pixmap);
+    }
+
+    return 0;
+}
+
+cd::PendingHandler::PendingHandler (const cd::RequestorForWindow &requestorForWindow) :
+    mRequestorForWindow (requestorForWindow)
+{
+}
+
+void
+cd::PendingHandler::handleMessage (Window window, const long *data)
+{
+    DecorPixmapRequestorInterface *requestor = mRequestorForWindow (window);
+
+    if (requestor)
+	requestor->handlePending (data);
+}
+
+cd::UnusedHandler::UnusedHandler (const cd::DecorListForWindow &listForWindow,
+				  const UnusedPixmapQueue::Ptr &queue,
+				  const FreePixmapFunc         &freePixmap) :
+    mListForWindow (listForWindow),
+    mQueue (queue),
+    mFreePixmap (freePixmap)
+{
+}
+
+void
+cd::UnusedHandler::handleMessage (Window window, Pixmap pixmap)
+{
+    DecorationListFindMatchingInterface *findMatching = mListForWindow (window);
+
+    if (findMatching)
+    {
+	DecorationInterface::Ptr decoration (findMatching->findMatchingDecoration (pixmap));
+
+	if (decoration)
+	{
+	    mQueue->markUnused (pixmap);
+	    return;
+	}
+    }
+
+   /* If a decoration was not found, then this pixmap is no longer in use
+    * and we should free it */
+    mFreePixmap (pixmap);
+}
+
+cdp::Communicator::Communicator (Atom                           pendingMsg,
+				 Atom                           unusedMsg,
+				 const cdp::PendingMessage      &pending,
+				 const cdp::PixmapUnusedMessage &pixmapUnused) :
+    mPendingMsgAtom (pendingMsg),
+    mUnusedMsgAtom (unusedMsg),
+    mPendingHandler (pending),
+    mPixmapUnusedHander (pixmapUnused)
+{
+}
+
+void
+cdp::Communicator::handleClientMessage (const XClientMessageEvent &xce)
+{
+    if (xce.message_type == mPendingMsgAtom)
+	mPendingHandler (xce.window, xce.data.l);
+    else if (xce.message_type == mUnusedMsgAtom)
+	mPixmapUnusedHander (xce.window, xce.data.l[0]);
+}

=== modified file 'plugins/decor/src/pixmap-requests/tests/CMakeLists.txt'
--- plugins/decor/src/pixmap-requests/tests/CMakeLists.txt	2012-08-01 00:42:38 +0000
+++ plugins/decor/src/pixmap-requests/tests/CMakeLists.txt	2013-02-20 07:34:20 +0000
@@ -1,10 +1,17 @@
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
+add_library (compiz_decor_pixmap_requests_mock STATIC
+             ${CMAKE_CURRENT_SOURCE_DIR}/compiz_decor_pixmap_requests_mock.cpp)
+
+target_link_libraries (compiz_decor_pixmap_requests_mock
+                       compiz_decor_pixmap_requests)
+
 add_executable (compiz_test_decor_pixmap_requests
-                ${CMAKE_CURRENT_SOURCE_DIR}/pixmap-requests/src/test-decor-pixmap-requests.cpp)
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-decor-pixmap-requests.cpp)
 
 target_link_libraries (compiz_test_decor_pixmap_requests
 		       compiz_decor_pixmap_requests
+                       compiz_decor_pixmap_requests_mock
 		       decoration
                        ${GTEST_BOTH_LIBRARIES}
 		       ${GMOCK_LIBRARY}
@@ -13,3 +20,5 @@
                        )
 
 compiz_discover_tests (compiz_test_decor_pixmap_requests COVERAGE compiz_decor_pixmap_requests)
+
+add_subdirectory (integration)

=== added file 'plugins/decor/src/pixmap-requests/tests/compiz_decor_pixmap_requests_mock.cpp'
--- plugins/decor/src/pixmap-requests/tests/compiz_decor_pixmap_requests_mock.cpp	1970-01-01 00:00:00 +0000
+++ plugins/decor/src/pixmap-requests/tests/compiz_decor_pixmap_requests_mock.cpp	2013-02-20 07:34:20 +0000
@@ -0,0 +1,113 @@
+/*
+ * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2013 Sam Spilsbury <[e-mail]>
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include "compiz_decor_pixmap_requests_mock.h"
+
+/* These exist purely because the implicit details of the
+ * constructors of the MOCK_METHODs are quite complex. We can
+ * save compilation time by generating those constructors once,
+ * and linking, rather than generating multiple definitions and
+ * having the linker eliminate them */
+
+MockDecorPixmapDeletor::MockDecorPixmapDeletor ()
+{
+}
+
+MockDecorPixmapDeletor::~MockDecorPixmapDeletor ()
+{
+}
+
+MockDecorPixmapReceiver::MockDecorPixmapReceiver ()
+{
+}
+
+MockDecorPixmapReceiver::~MockDecorPixmapReceiver ()
+{
+}
+
+MockDecoration::MockDecoration ()
+{
+}
+
+MockDecoration::~MockDecoration ()
+{
+}
+
+MockDecorationListFindMatching::MockDecorationListFindMatching ()
+{
+}
+
+MockDecorationListFindMatching::~MockDecorationListFindMatching ()
+{
+}
+
+MockDecorPixmapRequestor::MockDecorPixmapRequestor ()
+{
+}
+
+MockDecorPixmapRequestor::~MockDecorPixmapRequestor ()
+{
+}
+
+XlibPixmapMock::XlibPixmapMock ()
+{
+}
+
+XlibPixmapMock::~XlibPixmapMock ()
+{
+}
+
+MockFindRequestor::MockFindRequestor ()
+{
+}
+
+MockFindRequestor::~MockFindRequestor ()
+{
+}
+
+MockFindList::MockFindList ()
+{
+}
+
+MockFindList::~MockFindList ()
+{
+}
+
+MockUnusedPixmapQueue::MockUnusedPixmapQueue ()
+{
+}
+
+MockUnusedPixmapQueue::~MockUnusedPixmapQueue ()
+{
+}
+
+MockProtocolDispatchFuncs::MockProtocolDispatchFuncs ()
+{
+}
+
+MockProtocolDispatchFuncs::~MockProtocolDispatchFuncs ()
+{
+}

=== added file 'plugins/decor/src/pixmap-requests/tests/compiz_decor_pixmap_requests_mock.h'
--- plugins/decor/src/pixmap-requests/tests/compiz_decor_pixmap_requests_mock.h	1970-01-01 00:00:00 +0000
+++ plugins/decor/src/pixmap-requests/tests/compiz_decor_pixmap_requests_mock.h	2013-02-20 07:34:20 +0000
@@ -0,0 +1,179 @@
+/*
+ * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2013 Sam Spilsbury <[e-mail]>
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#ifndef _COMPIZ_DECOR_PIXMAP_REQUESTS_MOCK_H
+#define _COMPIZ_DECOR_PIXMAP_REQUESTS_MOCK_H
+
+#include <gmock/gmock.h>
+#include <boost/bind.hpp>
+
+#include <X11/Xlib.h>
+#include "pixmap-requests.h"
+
+class MockDecorPixmapDeletor :
+    public PixmapDestroyQueue
+{
+    public:
+
+	MockDecorPixmapDeletor ();
+	~MockDecorPixmapDeletor ();
+
+	MOCK_METHOD1 (destroyUnusedPixmap, int (Pixmap p));
+};
+
+class MockDecorPixmapReceiver :
+    public DecorPixmapReceiverInterface
+{
+    public:
+
+	MockDecorPixmapReceiver ();
+	~MockDecorPixmapReceiver ();
+
+	MOCK_METHOD0 (pending, void ());
+	MOCK_METHOD0 (update, void ());
+};
+
+class MockDecoration :
+    public DecorationInterface
+{
+    public:
+
+	MockDecoration ();
+	~MockDecoration ();
+
+	MOCK_METHOD0 (receiverInterface, DecorPixmapReceiverInterface & ());
+	MOCK_CONST_METHOD0 (getFrameType, unsigned int ());
+	MOCK_CONST_METHOD0 (getFrameState, unsigned int ());
+	MOCK_CONST_METHOD0 (getFrameActions, unsigned int ());
+};
+
+class MockDecorationListFindMatching :
+    public DecorationListFindMatchingInterface
+{
+    public:
+
+	MockDecorationListFindMatching ();
+	~MockDecorationListFindMatching ();
+
+	MOCK_CONST_METHOD3 (findMatchingDecoration, DecorationInterface::Ptr (unsigned int, unsigned int, unsigned int));
+	MOCK_CONST_METHOD1 (findMatchingDecoration, DecorationInterface::Ptr (Pixmap));
+};
+
+class MockDecorPixmapRequestor :
+    public DecorPixmapRequestorInterface
+{
+    public:
+
+	MockDecorPixmapRequestor ();
+	~MockDecorPixmapRequestor ();
+
+	MOCK_METHOD3 (postGenerateRequest, int (unsigned int, unsigned int, unsigned int));
+	MOCK_METHOD1 (handlePending, void (const long *));
+};
+
+class XlibPixmapMock
+{
+    public:
+
+	XlibPixmapMock ();
+	~XlibPixmapMock ();
+
+	MOCK_METHOD1(freePixmap, int (Pixmap));
+};
+
+class MockFindRequestor
+{
+    public:
+
+	MockFindRequestor ();
+	~MockFindRequestor ();
+
+	MOCK_METHOD1 (findRequestor, DecorPixmapRequestorInterface * (Window));
+};
+
+class MockFindList
+{
+    public:
+
+	MockFindList ();
+	~MockFindList ();
+
+	MOCK_METHOD1 (findList, DecorationListFindMatchingInterface * (Window));
+};
+
+class MockUnusedPixmapQueue :
+    public UnusedPixmapQueue
+{
+    public:
+
+	MockUnusedPixmapQueue ();
+	~MockUnusedPixmapQueue ();
+
+	typedef boost::shared_ptr <MockUnusedPixmapQueue> Ptr;
+
+	MOCK_METHOD1 (markUnused, void (Pixmap));
+};
+
+class StubReceiver :
+    public DecorPixmapReceiverInterface
+{
+    public:
+
+	void pending () {}
+	void update () {}
+};
+
+class StubDecoration :
+    public DecorationInterface
+{
+    public:
+
+	DecorPixmapReceiverInterface & receiverInterface ()
+	{
+	    return mReceiver;
+	}
+
+	unsigned int getFrameType  () const { return 0; }
+	unsigned int getFrameState () const { return 0; }
+	unsigned int getFrameActions () const { return 0; }
+
+    private:
+
+	StubReceiver mReceiver;
+};
+
+class MockProtocolDispatchFuncs
+{
+    public:
+
+	MockProtocolDispatchFuncs ();
+	~MockProtocolDispatchFuncs ();
+
+	MOCK_METHOD2 (handlePending, void (Window, const long *));
+	MOCK_METHOD2 (handleUnused, void (Window, Pixmap));
+};
+
+#endif

=== added directory 'plugins/decor/src/pixmap-requests/tests/integration'
=== added file 'plugins/decor/src/pixmap-requests/tests/integration/CMakeLists.txt'
--- plugins/decor/src/pixmap-requests/tests/integration/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/decor/src/pixmap-requests/tests/integration/CMakeLists.txt	2013-02-20 07:34:20 +0000
@@ -0,0 +1,1 @@
+add_subdirectory (xorg-gtest)

=== added directory 'plugins/decor/src/pixmap-requests/tests/integration/xorg-gtest'
=== added file 'plugins/decor/src/pixmap-requests/tests/integration/xorg-gtest/CMakeLists.txt'
--- plugins/decor/src/pixmap-requests/tests/integration/xorg-gtest/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/decor/src/pixmap-requests/tests/integration/xorg-gtest/CMakeLists.txt	2013-02-20 07:34:20 +0000
@@ -0,0 +1,41 @@
+include (FindPkgConfig)
+
+if (BUILD_XORG_GTEST)
+
+    include_directories (${compiz_SOURCE_DIR}/tests/shared
+                         ${COMPIZ_XORG_SYSTEM_TEST_INCLUDE_DIR}
+                         ${X11_INCLUDE_DIRS}
+                         ${XORG_SERVER_INCLUDE_XORG_GTEST}
+                         ${XORG_SERVER_GTEST_SRC}
+                         ${GTEST_INCLUDE_DIRS}
+                         ${COMPIZ_DECOR_PIXMAP_PROTOCOL_INTEGRATION_INCLUDE_DIRS})
+
+    link_directories (${X11_XI_LIBRARY_DIRS}
+                      ${COMPIZ_COMPOSITE_DAMAGETRACKING_INTEGRATION_LIBRARY_DIRS})
+
+    add_executable (compiz_test_decor_pixmap_protocol_integration
+                    ${CMAKE_CURRENT_SOURCE_DIR}/compiz_test_decor_pixmap_protocol_integration.cpp)
+
+    set (COMPIZ_DECOR_PIXMAP_PROTOCOL_XORG_INTEGRATION_TEST_LIBRARIES
+         xorg_gtest_all
+         xorg_gtest_main
+         compiz_xorg_gtest_system_test
+         compiz_decor_pixmap_requests
+         compiz_decor_pixmap_requests_mock
+         decoration
+         ${GMOCK_LIBRARY}
+         ${GMOCK_MAIN_LIBRARY}
+         ${GTEST_BOTH_LIBRARIES}
+         ${CMAKE_THREAD_LIBS_INIT}
+         ${XORG_SERVER_LIBRARIES}
+         ${X11_XI_LIBRARIES}
+         ${COMPIZ_DECOR_PIXMAP_PROTOCOL_INTEGRATION_LIBRARIES})
+
+    target_link_libraries (compiz_test_decor_pixmap_protocol_integration
+                           ${COMPIZ_DECOR_PIXMAP_PROTOCOL_XORG_INTEGRATION_TEST_LIBRARIES})
+
+    compiz_discover_tests (compiz_test_decor_pixmap_protocol_integration WITH_XORG_GTEST COVERAGE
+                           compiz_decor_pixmap_requests)
+
+endif (BUILD_XORG_GTEST)
+

=== added file 'plugins/decor/src/pixmap-requests/tests/integration/xorg-gtest/compiz_test_decor_pixmap_protocol_integration.cpp'
--- plugins/decor/src/pixmap-requests/tests/integration/xorg-gtest/compiz_test_decor_pixmap_protocol_integration.cpp	1970-01-01 00:00:00 +0000
+++ plugins/decor/src/pixmap-requests/tests/integration/xorg-gtest/compiz_test_decor_pixmap_protocol_integration.cpp	2013-02-20 07:34:20 +0000
@@ -0,0 +1,483 @@
+/*
+ * Compiz XOrg GTest Decoration Pixmap Protocol Integration Tests
+ *
+ * Copyright (C) 2013 Sam Spilsbury.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Authored By:
+ * Sam Spilsbury <[e-mail]>
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+
+#include <boost/shared_ptr.hpp>
+#include <boost/make_shared.hpp>
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+
+#include "decoration.h"
+
+#include <xorg/gtest/xorg-gtest.h>
+#include <compiz-xorg-gtest.h>
+
+#include "pixmap-requests.h"
+#include "compiz_decor_pixmap_requests_mock.h"
+
+namespace xt = xorg::testing;
+namespace ct = compiz::testing;
+namespace cd = compiz::decor;
+namespace cdp = compiz::decor::protocol;
+
+using ::testing::AtLeast;
+using ::testing::ReturnNull;
+using ::testing::Return;
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+using ::testing::_;
+
+class DecorPixmapProtocol :
+    public xorg::testing::Test
+{
+    public:
+
+	typedef boost::function <void (const XClientMessageEvent &)> ClientMessageReceiver;
+
+	void SetUp ();
+
+	void WaitForClientMessageOnAndDeliverTo (Window client,
+						 Atom   message,
+						 const ClientMessageReceiver &receiver);
+
+    protected:
+
+	Atom deletePixmapMessage;
+	Atom pendingMessage;
+};
+
+namespace
+{
+bool Advance (Display *d, bool result)
+{
+    return ct::AdvanceToNextEventOnSuccess (d, result);
+}
+
+Window MOCK_WINDOW = 1;
+Pixmap MOCK_PIXMAP = 2;
+
+class MockClientMessageReceiver
+{
+    public:
+
+	MOCK_METHOD1 (receiveMsg, void (const XClientMessageEvent &));
+};
+
+class DisplayFetch
+{
+    public:
+
+	virtual ~DisplayFetch () {}
+
+	virtual ::Display * Display () const = 0;
+};
+
+class XFreePixmapWrapper
+{
+    public:
+
+	XFreePixmapWrapper (const DisplayFetch &df) :
+	    mDisplayFetch (df)
+	{
+	}
+
+	int FreePixmap (Pixmap pixmap)
+	{
+	    return XFreePixmap (mDisplayFetch.Display (), pixmap);
+	}
+
+    private:
+
+	const DisplayFetch &mDisplayFetch;
+};
+
+class XErrorTracker
+{
+    public:
+
+	XErrorTracker ();
+	~XErrorTracker ();
+
+	MOCK_METHOD1 (errorHandler, void (int));
+
+    private:
+
+	XErrorHandler handler;
+
+	static int handleXError (Display *dpy, XErrorEvent *ev);
+	static XErrorTracker *tracker;
+};
+
+XErrorTracker * XErrorTracker::tracker = NULL;
+
+XErrorTracker::XErrorTracker ()
+{
+    tracker = this;
+    handler = XSetErrorHandler (handleXError);
+}
+
+XErrorTracker::~XErrorTracker ()
+{
+    tracker = NULL;
+    XSetErrorHandler (handler);
+}
+
+int
+XErrorTracker::handleXError (Display *dpy, XErrorEvent *ev)
+{
+    tracker->errorHandler (ev->error_code);
+    return 0;
+}
+
+bool PixmapValid (Display *d, Pixmap p)
+{
+    Window root;
+    unsigned int width, height, border, depth;
+    int x, y;
+
+    XErrorTracker tracker;
+
+    EXPECT_CALL (tracker, errorHandler (BadDrawable)).Times (AtLeast (0));
+
+    bool success = XGetGeometry (d, p, &root, &x, &y,
+				 &width, &height, &border, &depth);
+
+    return success;
+}
+}
+
+void
+DecorPixmapProtocol::SetUp ()
+{
+    xorg::testing::Test::SetUp ();
+
+    XSelectInput (Display (),
+		  DefaultRootWindow (Display ()),
+		  StructureNotifyMask);
+
+    deletePixmapMessage = XInternAtom (Display (), DECOR_DELETE_PIXMAP_ATOM_NAME, 0);
+    pendingMessage = XInternAtom (Display (), DECOR_PIXMAP_PENDING_ATOM_NAME, 0);
+}
+
+class DeliveryMatcher :
+    public ct::XEventMatcher
+{
+    public:
+
+	DeliveryMatcher (Atom message,
+			 const DecorPixmapProtocol::ClientMessageReceiver &receiver) :
+	    mMessage (message),
+	    mReceiver (receiver)
+	{
+	}
+
+	bool MatchAndExplain (const XEvent &xce,
+			      MatchResultListener *listener) const
+	{
+	    if (xce.xclient.message_type == mMessage)
+	    {
+		mReceiver (reinterpret_cast <const XClientMessageEvent &> (xce));
+		return true;
+	    }
+	    else
+		return false;
+	}
+
+	void DescribeTo (std::ostream *os) const
+	{
+	    *os << "Message delivered";
+	}
+
+    private:
+
+	Atom mMessage;
+	DecorPixmapProtocol::ClientMessageReceiver mReceiver;
+};
+
+void
+DecorPixmapProtocol::WaitForClientMessageOnAndDeliverTo (Window client,
+							 Atom   message,
+							 const ClientMessageReceiver &receiver)
+{
+    ::Display *d = Display ();
+
+    DeliveryMatcher delivery (message, receiver);
+    ASSERT_TRUE (Advance (d, ct::WaitForEventOfTypeOnWindowMatching (d,
+								     client,
+								     ClientMessage,
+								     -1,
+								     -1,
+								     delivery)));
+}
+
+TEST_F (DecorPixmapProtocol, PostDeleteCausesClientMessage)
+{
+    MockClientMessageReceiver receiver;
+    ::Display *d = Display ();
+
+    decor_post_delete_pixmap (d,
+			      MOCK_WINDOW,
+			      MOCK_PIXMAP);
+
+    EXPECT_CALL (receiver, receiveMsg (_)).Times (1);
+
+    WaitForClientMessageOnAndDeliverTo (MOCK_WINDOW,
+					deletePixmapMessage,
+					boost::bind (&MockClientMessageReceiver::receiveMsg,
+						     &receiver,
+						     _1));
+}
+
+TEST_F (DecorPixmapProtocol, PostDeleteDispatchesClientMessageToReceiver)
+{
+    MockProtocolDispatchFuncs dispatch;
+    cdp::Communicator         communicator (pendingMessage,
+					    deletePixmapMessage,
+					    boost::bind (&MockProtocolDispatchFuncs::handlePending,
+							 &dispatch,
+							 _1,
+							 _2),
+					    boost::bind (&MockProtocolDispatchFuncs::handleUnused,
+							 &dispatch,
+							 _1,
+							 _2));
+
+    decor_post_delete_pixmap (Display (),
+			      MOCK_WINDOW,
+			      MOCK_PIXMAP);
+
+    EXPECT_CALL (dispatch, handleUnused (MOCK_WINDOW, MOCK_PIXMAP)).Times (1);
+
+    WaitForClientMessageOnAndDeliverTo (MOCK_WINDOW,
+					deletePixmapMessage,
+					boost::bind (&cdp::Communicator::handleClientMessage,
+						     &communicator,
+						     _1));
+}
+
+/* Test end to end. Post the delete message and cause the pixmap to be freed */
+
+class DecorPixmapProtocolEndToEnd :
+    public DecorPixmapProtocol,
+    public DisplayFetch
+{
+    public:
+
+	DecorPixmapProtocolEndToEnd () :
+	    freePixmap (*this),
+	    releasePool (new PixmapReleasePool (
+			     boost::bind (&XFreePixmapWrapper::FreePixmap,
+				      &freePixmap,
+				      _1))),
+	    pendingHandler (boost::bind (&MockFindRequestor::findRequestor,
+					 &mockFindRequestor,
+					 _1)),
+	    unusedHandler (boost::bind (&MockFindList::findList,
+					&mockFindList,
+					_1),
+			   releasePool,
+			   boost::bind (&XFreePixmapWrapper::FreePixmap,
+					&freePixmap,
+					_1)),
+	    stubDecoration (new StubDecoration ())
+	{
+	}
+
+	void SetUp ()
+	{
+	    DecorPixmapProtocol::SetUp ();
+
+	    communicator.reset (new cdp::Communicator (
+				    pendingMessage,
+				    deletePixmapMessage,
+				    boost::bind (&cd::PendingHandler::handleMessage,
+						 &pendingHandler,
+						 _1,
+						 _2),
+				    boost::bind (&cd::UnusedHandler::handleMessage,
+						 &unusedHandler,
+						 _1,
+						 _2)));
+	}
+
+	::Display *
+	Display () const
+	{
+	    return DecorPixmapProtocol::Display ();
+	}
+
+	XFreePixmapWrapper       freePixmap;
+	PixmapReleasePool::Ptr   releasePool;
+	cd::PendingHandler       pendingHandler;
+	cd::UnusedHandler        unusedHandler;
+	boost::shared_ptr <cdp::Communicator> communicator;
+	MockFindList             mockFindList;
+	MockFindRequestor        mockFindRequestor;
+	StubDecoration::Ptr      stubDecoration;
+	MockDecorPixmapRequestor mockRequestor;
+	MockDecorationListFindMatching mockFindMatching;
+
+};
+
+class DecorPixmapProtocolDeleteEndToEnd :
+    public DecorPixmapProtocolEndToEnd
+{
+    public:
+
+	void SetUp ()
+	{
+	    DecorPixmapProtocolEndToEnd::SetUp ();
+
+	    ::Display *d = Display ();
+
+	    pixmap = XCreatePixmap (d,
+				   DefaultRootWindow (d),
+				   1,
+				   1,
+				   DefaultDepth (d,
+						 DefaultScreen (d)));
+
+	    decor_post_delete_pixmap (d,
+				      MOCK_WINDOW,
+				      pixmap);
+	}
+
+	void TearDown ()
+	{
+	    if (PixmapValid (Display (), pixmap))
+		XFreePixmap (Display (), pixmap);
+	}
+
+    protected:
+
+	Pixmap                   pixmap;
+};
+
+TEST_F (DecorPixmapProtocolDeleteEndToEnd, TestFreeNotFoundWindowPixmapImmediately)
+{
+    ::Display *d = Display ();
+
+    EXPECT_CALL (mockFindList, findList (MOCK_WINDOW)).WillOnce (ReturnNull ());
+
+    /* Deliver it to the communicator */
+    WaitForClientMessageOnAndDeliverTo (MOCK_WINDOW,
+					deletePixmapMessage,
+					boost::bind (&cdp::Communicator::handleClientMessage,
+						     communicator.get (),
+						     _1));
+
+    /* Check if the pixmap is still valid */
+    EXPECT_FALSE (PixmapValid (d, pixmap));
+}
+
+TEST_F (DecorPixmapProtocolDeleteEndToEnd, TestFreeUnusedPixmapImmediately)
+{
+    ::Display *d = Display ();
+
+    EXPECT_CALL (mockFindMatching, findMatchingDecoration (pixmap)).WillOnce (Return (DecorationInterface::Ptr ()));
+    EXPECT_CALL (mockFindList, findList (MOCK_WINDOW)).WillOnce (Return (&mockFindMatching));
+    /* Deliver it to the communicator */
+    WaitForClientMessageOnAndDeliverTo (MOCK_WINDOW,
+					deletePixmapMessage,
+					boost::bind (&cdp::Communicator::handleClientMessage,
+						     communicator.get (),
+						     _1));
+
+    /* Check if the pixmap is still valid */
+    EXPECT_FALSE (PixmapValid (d, pixmap));
+}
+
+TEST_F (DecorPixmapProtocolDeleteEndToEnd, TestQueuePixmapIfUsed)
+{
+    ::Display *d = Display ();
+
+    EXPECT_CALL (mockFindMatching, findMatchingDecoration (pixmap)).WillOnce (Return (stubDecoration));
+    EXPECT_CALL (mockFindList, findList (MOCK_WINDOW)).WillOnce (Return (&mockFindMatching));
+    /* Deliver it to the communicator */
+    WaitForClientMessageOnAndDeliverTo (MOCK_WINDOW,
+					deletePixmapMessage,
+					boost::bind (&cdp::Communicator::handleClientMessage,
+						     communicator.get (),
+						     _1));
+
+    /* Check if the pixmap is still valid */
+    EXPECT_TRUE (PixmapValid (d, pixmap));
+
+    /* Call destroyUnusedPixmap on the release pool, it should release
+     * the pixmap which was otherwise unused */
+    releasePool->destroyUnusedPixmap (pixmap);
+
+    /* Pixmap should now be invalid */
+    EXPECT_FALSE (PixmapValid (d, pixmap));
+}
+
+class DecorPixmapProtocolPendingEndToEnd :
+    public DecorPixmapProtocolEndToEnd
+{
+    public:
+
+	DecorPixmapProtocolPendingEndToEnd () :
+	    frameType (1),
+	    frameState (2),
+	    frameActions (3)
+	{
+	}
+
+	void SetUp ()
+	{
+	    DecorPixmapProtocolEndToEnd::SetUp ();
+
+	    ::Display *d = Display ();
+
+	    decor_post_pending (d, MOCK_WINDOW, frameType, frameState, frameActions);
+	}
+
+    protected:
+
+	unsigned int frameType, frameState, frameActions;
+};
+
+MATCHER_P3 (MatchArrayValues3, v1, v2, v3, "Matches three array values")
+{
+    return static_cast <unsigned int> (arg[0]) == v1 &&
+	   static_cast <unsigned int> (arg[1]) == v2 &&
+	   static_cast <unsigned int> (arg[2]) == v3;
+}
+
+TEST_F (DecorPixmapProtocolPendingEndToEnd, TestPostPendingMarksAsPendingOnClient)
+{
+    EXPECT_CALL (mockFindRequestor, findRequestor (MOCK_WINDOW)).WillOnce (Return (&mockRequestor));
+    EXPECT_CALL (mockRequestor, handlePending (MatchArrayValues3 (frameType, frameState, frameActions)));
+
+    /* Deliver it to the communicator */
+    WaitForClientMessageOnAndDeliverTo (MOCK_WINDOW,
+					pendingMessage,
+					boost::bind (&cdp::Communicator::handleClientMessage,
+						     communicator.get (),
+						     _1));
+}

=== renamed file 'plugins/decor/src/pixmap-requests/tests/pixmap-requests/src/test-decor-pixmap-requests.cpp' => 'plugins/decor/src/pixmap-requests/tests/test-decor-pixmap-requests.cpp'
--- plugins/decor/src/pixmap-requests/tests/pixmap-requests/src/test-decor-pixmap-requests.cpp	2012-05-10 15:40:25 +0000
+++ plugins/decor/src/pixmap-requests/tests/test-decor-pixmap-requests.cpp	2013-02-20 07:34:20 +0000
@@ -25,67 +25,29 @@
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
+#include <boost/bind.hpp>
 #include <iostream>
+
+#include <X11/Xlib.h>
 #include "pixmap-requests.h"
+#include "compiz_decor_pixmap_requests_mock.h"
 
+using ::testing::AtLeast;
+using ::testing::Pointee;
 using ::testing::Return;
-
-class DecorPixmapRequestsTest :
-    public ::testing::Test
-{
-};
-
-class MockDecorPixmapDeletor :
-    public DecorPixmapDeletionInterface
-{
-    public:
-
-	MOCK_METHOD1 (postDeletePixmap, int (Pixmap p));
-};
-
-class MockDecorPixmapReceiver :
-    public DecorPixmapReceiverInterface
-{
-    public:
-
-	MOCK_METHOD0 (pending, void ());
-	MOCK_METHOD0 (update, void ());
-};
-
-class MockDecoration :
-    public DecorationInterface
-{
-    public:
-
-	MOCK_METHOD0 (receiverInterface, DecorPixmapReceiverInterface & ());
-	MOCK_CONST_METHOD0 (getFrameType, unsigned int ());
-	MOCK_CONST_METHOD0 (getFrameState, unsigned int ());
-	MOCK_CONST_METHOD0 (getFrameActions, unsigned int ());
-};
-
-class MockDecorationListFindMatching :
-    public DecorationListFindMatchingInterface
-{
-    public:
-
-	MOCK_METHOD3 (findMatchingDecoration, DecorationInterface::Ptr (unsigned int, unsigned int, unsigned int));
-};
-
-class MockDecorPixmapRequestor :
-    public DecorPixmapRequestorInterface
-{
-    public:
-
-	MOCK_METHOD3 (postGenerateRequest, int (unsigned int, unsigned int, unsigned int));
-	MOCK_METHOD1 (handlePending, void (long *));
-};
+using ::testing::ReturnNull;
+using ::testing::IsNull;
+using ::testing::_;
+
+namespace cd = compiz::decor;
+namespace cdp = compiz::decor::protocol;
 
 TEST(DecorPixmapRequestsTest, TestDestroyPixmapDeletes)
 {
     boost::shared_ptr <MockDecorPixmapDeletor> mockDeletor = boost::make_shared <MockDecorPixmapDeletor> ();
-    DecorPixmap pm (1, boost::shared_static_cast<DecorPixmapDeletionInterface> (mockDeletor));
+    DecorPixmap pm (1, boost::shared_static_cast<PixmapDestroyQueue> (mockDeletor));
 
-    EXPECT_CALL (*(mockDeletor.get ()), postDeletePixmap (1)).WillOnce (Return (1));
+    EXPECT_CALL (*(mockDeletor.get ()), destroyUnusedPixmap (1)).WillOnce (Return (1));
 }
 
 TEST(DecorPixmapRequestsTest, TestPendingGeneratesRequest)
@@ -158,3 +120,284 @@
     receiver.pending ();
     receiver.update ();
 }
+
+class DecorPixmapReleasePool :
+    public ::testing::Test
+{
+    public:
+
+	DecorPixmapReleasePool () :
+	    mockFreeFunc (boost::bind (&XlibPixmapMock::freePixmap,
+				       &xlibPixmapMock,
+				       _1)),
+	    releasePool (mockFreeFunc)
+	{
+	}
+
+	XlibPixmapMock xlibPixmapMock;
+	PixmapReleasePool::FreePixmapFunc mockFreeFunc;
+
+	PixmapReleasePool releasePool;
+};
+
+TEST_F (DecorPixmapReleasePool, MarkUnusedNoFree)
+{
+    /* Never free pixmaps on markUnused */
+
+    EXPECT_CALL (xlibPixmapMock, freePixmap (_)).Times (0);
+
+    releasePool.markUnused (static_cast <Pixmap> (1));
+}
+
+TEST_F (DecorPixmapReleasePool, NoFreeOnPostDeleteIfNotInList)
+{
+    EXPECT_CALL (xlibPixmapMock, freePixmap (_)).Times (0);
+
+    releasePool.destroyUnusedPixmap (static_cast <Pixmap> (1));
+}
+
+TEST_F (DecorPixmapReleasePool, FreeOnPostDeleteIfMarkedUnused)
+{
+    EXPECT_CALL (xlibPixmapMock, freePixmap (1)).Times (1);
+
+    releasePool.markUnused (static_cast <Pixmap> (1));
+    releasePool.destroyUnusedPixmap (static_cast <Pixmap> (1));
+}
+
+TEST_F (DecorPixmapReleasePool, FreeOnPostDeleteIfMarkedUnusedOnceOnly)
+{
+    EXPECT_CALL (xlibPixmapMock, freePixmap (1)).Times (1);
+
+    releasePool.markUnused (static_cast <Pixmap> (1));
+    releasePool.destroyUnusedPixmap (static_cast <Pixmap> (1));
+    releasePool.destroyUnusedPixmap (static_cast <Pixmap> (1));
+}
+
+TEST_F (DecorPixmapReleasePool, UnusedUniqueness)
+{
+    EXPECT_CALL (xlibPixmapMock, freePixmap (1)).Times (1);
+
+    releasePool.markUnused (static_cast <Pixmap> (1));
+    releasePool.markUnused (static_cast <Pixmap> (1));
+    releasePool.destroyUnusedPixmap (static_cast <Pixmap> (1));
+    releasePool.destroyUnusedPixmap (static_cast <Pixmap> (1));
+}
+
+class DecorPendingMessageHandler :
+    public ::testing::Test
+{
+    public:
+
+	DecorPendingMessageHandler () :
+	    pendingHandler (boost::bind (&MockFindRequestor::findRequestor,
+					 &mockRequestorFind,
+					 _1))
+	{
+	}
+
+	MockFindRequestor              mockRequestorFind;
+	MockDecorPixmapRequestor       mockRequestor;
+
+	cd::PendingHandler             pendingHandler;
+};
+
+namespace
+{
+Window mockWindow = 1;
+}
+
+TEST_F (DecorPendingMessageHandler, NoPendingIfNotFound)
+{
+    EXPECT_CALL (mockRequestor, handlePending (_)).Times (0);
+    EXPECT_CALL (mockRequestorFind, findRequestor (mockWindow)).WillOnce (ReturnNull ());
+
+    long data = 1;
+    pendingHandler.handleMessage (mockWindow, &data);
+}
+
+TEST_F (DecorPendingMessageHandler, PendingIfFound)
+{
+    long data = 1;
+
+    EXPECT_CALL (mockRequestor, handlePending (Pointee (data)));
+    EXPECT_CALL (mockRequestorFind, findRequestor (mockWindow)).WillOnce (Return (&mockRequestor));
+
+    pendingHandler.handleMessage (mockWindow, &data);
+}
+
+class DecorUnusedMessageHandler :
+    public ::testing::Test
+{
+    public:
+
+	DecorUnusedMessageHandler () :
+	    mockUnusedPixmapQueue (new MockUnusedPixmapQueue ()),
+	    unusedHandler (boost::bind (&MockFindList::findList,
+					&mockListFind,
+					_1),
+			   mockUnusedPixmapQueue,
+			   boost::bind (&XlibPixmapMock::freePixmap,
+					&xlibPixmapMock,
+					_1))
+	{
+	}
+
+	MockFindList mockListFind;
+	MockDecorationListFindMatching mockListFinder;
+	MockUnusedPixmapQueue::Ptr     mockUnusedPixmapQueue;
+	XlibPixmapMock                 xlibPixmapMock;
+
+	cd::UnusedHandler unusedHandler;
+};
+
+namespace
+{
+Pixmap mockPixmap = 2;
+}
+
+TEST_F (DecorUnusedMessageHandler, FreeImmediatelyWindowNotFound)
+{
+    /* Don't verify calls to mockListFind */
+    EXPECT_CALL (mockListFind, findList (_)).Times (AtLeast (0));
+
+    /* Just free the pixmap immediately if no window was found */
+    EXPECT_CALL (xlibPixmapMock, freePixmap (mockPixmap)).Times (1);
+
+    ON_CALL (mockListFind, findList (mockWindow)).WillByDefault (ReturnNull ());
+    unusedHandler.handleMessage (mockWindow, mockPixmap);
+}
+
+TEST_F (DecorUnusedMessageHandler, FreeImmediatelyIfNoDecorationFound)
+{
+    /* Don't verify calls to mockListFind or mockListFinder */
+    EXPECT_CALL (mockListFind, findList (_)).Times (AtLeast (0));
+    EXPECT_CALL (mockListFinder, findMatchingDecoration (_)).Times (AtLeast (0));
+
+    EXPECT_CALL (xlibPixmapMock, freePixmap (mockPixmap)).Times (1);
+
+    ON_CALL (mockListFind, findList (mockWindow))
+	.WillByDefault (Return (&mockListFinder));
+    ON_CALL (mockListFinder, findMatchingDecoration (mockPixmap))
+	.WillByDefault (Return (DecorationInterface::Ptr ()));
+
+    unusedHandler.handleMessage (mockWindow, mockPixmap);
+}
+
+TEST_F (DecorUnusedMessageHandler, AddToQueueIfInUse)
+{
+    /* Don't verify calls to mockListFind or mockListFinder */
+    EXPECT_CALL (mockListFind, findList (_)).Times (AtLeast (0));
+    EXPECT_CALL (mockListFinder, findMatchingDecoration (_)).Times (AtLeast (0));
+
+    DecorationInterface::Ptr mockDecoration (new StubDecoration ());
+
+    /* Do not immediately free the pixmap */
+    EXPECT_CALL (xlibPixmapMock, freePixmap (mockPixmap)).Times (0);
+    EXPECT_CALL (*mockUnusedPixmapQueue, markUnused (mockPixmap)).Times (1);
+
+    ON_CALL (mockListFind, findList (mockWindow))
+	.WillByDefault (Return (&mockListFinder));
+    ON_CALL (mockListFinder, findMatchingDecoration (mockPixmap))
+	.WillByDefault (Return (mockDecoration));
+
+    unusedHandler.handleMessage (mockWindow, mockPixmap);
+}
+
+namespace
+{
+Atom pendingMsg = 3;
+Atom unusedMsg = 4;
+}
+
+class DecorProtocolCommunicator :
+    public ::testing::Test
+{
+    public:
+
+	DecorProtocolCommunicator () :
+	    handlePendingFunc (boost::bind (&MockProtocolDispatchFuncs::handlePending,
+					    &mockProtoDispatch,
+					    _1,
+					    _2)),
+	    handleUnusedFunc (boost::bind (&MockProtocolDispatchFuncs::handleUnused,
+					   &mockProtoDispatch,
+					   _1,
+					   _2)),
+	    protocolCommunicator (pendingMsg,
+				  unusedMsg,
+				  handlePendingFunc,
+				  handleUnusedFunc)
+	{
+	}
+
+	void ClientMessageData (XClientMessageEvent &msg,
+				Window              window,
+				Atom                atom,
+				long                l1,
+				long                l2,
+				long                l3,
+				long                l4)
+	{
+	    msg.window = window;
+	    msg.message_type = atom;
+	    msg.data.l[0] = l1;
+	    msg.data.l[1] = l2;
+	    msg.data.l[2] = l3;
+	    msg.data.l[3] = l4;
+	}
+
+	MockProtocolDispatchFuncs mockProtoDispatch;
+	cdp::PendingMessage       handlePendingFunc;
+	cdp::PixmapUnusedMessage  handleUnusedFunc;
+
+	cdp::Communicator protocolCommunicator;
+};
+
+MATCHER_P (MatchArray3, v, "Contains values")
+{
+    return arg[0] == v[0] &&
+	    arg[1] == v[1] &&
+	    arg[2] == v[2];
+}
+
+TEST_F (DecorProtocolCommunicator, TestDispatchToPendingHandler)
+{
+    long data[3];
+
+    data[0] = 1;
+    data[1] = 2;
+    data[2] = 3;
+
+    XClientMessageEvent ev;
+    ClientMessageData (ev,
+		       mockWindow,
+		       pendingMsg,
+		       data[0],
+		       data[1],
+		       data[2],
+		       0);
+
+    EXPECT_CALL (mockProtoDispatch, handlePending (mockWindow,
+						   MatchArray3 (data)))
+	.Times (1);
+
+    protocolCommunicator.handleClientMessage (ev);
+}
+
+TEST_F (DecorProtocolCommunicator, TestDispatchToUnusedHandler)
+{
+    XClientMessageEvent ev;
+    ClientMessageData (ev,
+		       mockWindow,
+		       unusedMsg,
+		       mockPixmap,
+		       0,
+		       0,
+		       0);
+
+    EXPECT_CALL (mockProtoDispatch, handleUnused (mockWindow,
+						  mockPixmap))
+	.Times (1);
+
+    protocolCommunicator.handleClientMessage (ev);
+}

=== modified file 'tests/system/xorg-gtest/tests/CMakeLists.txt'
--- tests/system/xorg-gtest/tests/CMakeLists.txt	2013-02-19 12:00:19 +0000
+++ tests/system/xorg-gtest/tests/CMakeLists.txt	2013-02-20 07:34:20 +0000
@@ -52,6 +52,6 @@
     target_link_libraries (compiz_xorg_gtest_test_shape_handling
 			   ${COMPIZ_XORG_GTEST_LIBRARIES})
 
-    compiz_discover_tests (compiz_xorg_gtest_test_shape_handling)
+    compiz_discover_tests (compiz_xorg_gtest_test_shape_handling WITH_XORG_GTEST)
 
 endif (BUILD_XORG_GTEST AND X11_XI_FOUND)