Merge lp:~compiz-team/compiz/compiz.performance_1027211.2 into lp:compiz/0.9.9

[Sam Spilsbury]

Allow plugins to throttle delivery of ConfigureWindow requests within reason (LP: #1027211)

Allow plugins to throttle delivery of ConfigureWindow requests within reason (LP: #1027211)

(LP: #1027211) seems to be caused by vsync in the nvidia driver and posting lots of ConfigureWindow requests to the server. The driver really chokes on these for some reason. As a result, two things were happening:

1. The driver slows down quite significantly
2. We get more time to post more ConfigureWindow requests to the driver, which just slows it down even more until it grinds to a halt.

This branch does three things:
1. Introduces infrastructure for plugins to hold a "lock" on delivering ConfigureWindow requests until they choose to release it later (eg, on paint, or on ungrab), while still allowing core to override the plugin's decisions in cases where we actually need to post a ConfigureWindow request to the server in order to continue (eg, some other request is dependent on it). That code was TDD'ed into existence and has test coverage.
2. Optimizes reconfigureXWindow to only configure the frame window if the only thing that happened was that we moved the window. This means that we only buffer up one ConfigureWindow instead of three per call to reconfigureXWindow
3. Implements ConfigureRequestBuffer in both opengl and move. The default implementation in "opengl" is the "safe" version and releases its lock every time the window paints. That means that dragging around opengl rendered windows goes from a complete halt to a steady 12fps. In the move plugin, I've revived "lazy positioning" - off by default as it might be more unsafe, but this prevents all ConfigureWindow requests from being posted until the window is ungrabbed. That goes brings us from 12fps to 60fps.

One question that might arise here is whether or not this branch is fundamentally unsafe because we allow the server to get "out of sync" with us. That isn't as much of a problem these days as it used to be. Nowadays we never track the incoming positions from the server to give us a representation of our own internal state, instead that is represented by what we meant to post to the server. So the internal state can never get mucked up. In areas where we do actually need to have our internal state represent what was really last sent to the server, I've structured the code such that in order to do those things, you have to release the queued up ConfigureWindow requests first.

Again, throw this at the wall and see if it introduces any bad regressions. I haven't see any so far.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3530
http://jenkins.qa.ubuntu.com/job/compiz-ci/308/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/308/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3534
http://jenkins.qa.ubuntu.com/job/compiz-ci/309/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/309/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3536
http://jenkins.qa.ubuntu.com/job/compiz-ci/312/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/312/console

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

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

Confirmed moving windows is much improved. There is no improvement with resizing though. I still encounter exactly the same freezes as mentioned previously:
  1. XSync() inside PrivateWindow::updateRegion()
  2. XShapeGetRectangles()
So please either:
  (a) Don't touch XShape* in this proposal, and leave resize fixes for a later proposal; or
  (b) Fix XShape* properly.
Given the large size of this proposal already, and that a proper fix for XShape should be to simply call it much less often (i.e. only for shaped windows), I recommend (a).

Secondly, I do support the concept of disabling lazy positioning in theory but would have to get my test machine (Atom) for that upgraded and working again before I approve it.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

Also, without too much verbosity, why is it we need to implement window movement completely synchronously? My understanding is that waiting and locking should never be required when the user moves a window.

A window move should simply involve two events:
  1. Motion event -> move plugin -> send request to X server (XConfigureWindow I think).
and some time later (should not care when):
  2. XConfigureNotify (or whatever) -> core plugin -> compiz window position updated.

If this is lazy positioning then maybe I do support it. But historically we seem to have a lot more code than should be necessary to implement movement so I'm not sure.

[Daniel van Vugt (vanvugt)]

I mean; my understanding of lazy positioning is that we update the compiz position without waiting for the server to tell us it's done. Therefore the above method counts as non-lazy movement, but also does not require any waiting or locking. I think this is contrary to the proposed and established non-lazy algorithm that does sync for some reason.

If we want to keep lazy mode as an option and it does bypass the server as I suspect then OK. However I think at least non-lazy mode should be implemented as above, so that either way you never need to lock or sync to move a window.

[Sam Spilsbury (smspillaz)]

On Mon, Dec 10, 2012 at 2:16 PM, Daniel van Vugt
<email address hidden> wrote:
> Review: Needs Fixing
>
> Confirmed moving windows is much improved. There is no improvement with resizing though. I still encounter exactly the same freezes as mentioned previously:
> 1. XSync() inside PrivateWindow::updateRegion()
> 2. XShapeGetRectangles()
> So please either:
> (a) Don't touch XShape* in this proposal, and leave resize fixes for a later proposal; or
> (b) Fix XShape* properly.
> Given the large size of this proposal already, and that a proper fix for XShape should be to simply call it much less often (i.e. only for shaped windows), I recommend (a).

Ah, we actually need to touch it otherwise this proposal won't work
without it, though its not a very big touch, and more or less just a
wrapper around it to make sure that when it is called, we release the
geometry queue for that window.

The reason for that being that XShapeGetRectangles is dependent on us
having the most recent server size of the window actually posted to
the server by that point. If it isn't, then you'll get the wrong
client shape, and that will be incorrectly applied to the frame!

>
> Secondly, I do support the concept of disabling lazy positioning in theory but would have to get my test machine (Atom) for that upgraded and working again before I approve it.
>
> --
> https://code.launchpad.net/~compiz-team/compiz/compiz.performance_1027211.2/+merge/138800
> Your team Compiz Maintainers is subscribed to branch lp:compiz.

--
Sam Spilsbury

[Sam Spilsbury (smspillaz)]

On Mon, Dec 10, 2012 at 2:41 PM, Daniel van Vugt
<email address hidden> wrote:
> Also, without too much verbosity, why is it we need to implement window movement completely synchronously? My understanding is that waiting and locking should never be required when the user moves a window.
>
> A window move should simply involve two events:
> 1. Motion event -> move plugin -> send request to X server (XConfigureWindow I think).
> and some time later (should not care when):
> 2. XConfigureNotify (or whatever) -> core plugin -> compiz window position updated.
>
> I mean; my understanding of lazy positioning is that we update the compiz position without waiting for the server to tell us it's done. Therefore the above method counts as non-lazy movement, but also does not require any waiting or locking. I think this is contrary to the proposed and established non-lazy algorithm that does sync for some reason.
>
> If we want to keep lazy mode as an option and it does bypass the server as I suspect then OK. However I think at least non-lazy mode should be implemented as above, so that either way you never need to lock or sync to move a window.

Ah, I think there's a mixup of terminology here.

We're still completely async, both this branch and before this branch.
ConfigureWindow requests are in themselves async, you can post as many
as you want. There's absolutely no waiting for the server.

The problem is that the nvidia driver can't handle it. So instead of
sending it lots and lots of ConfigureWindow requests, we let plugins
"lock out" core from doing that until it makes sense for us to do it.
This means that:

1. In the case of "lazy positioning" being disabled, we just wait
until just before the next frame and post the request
2. In the case of "lazy positioning" enabled, we wait until the window
is ungrabbed.

Both are overridden in cases where we have to ask the server
something. But that's not too often.

> --
> https://code.launchpad.net/~compiz-team/compiz/compiz.performance_1027211.2/+merge/138800
> Your team Compiz Maintainers is subscribed to branch lp:compiz.

--
Sam Spilsbury

[Daniel van Vugt (vanvugt)]

It will take me a while to get the code compiled 32-bit and running on the Atom where I tested all the previous lazy-mode regressions. Until then, some style issues:

1. This is hard to read. I recommend (but don't require) all on one line...
48 +namespace compiz
49 +{
50 +namespace window
51 +{
52 +namespace configure_buffers
53 +{

2. MOVE_WINDOW (w) - Using macros to declare local variables via side-effect is dangerous and very hard to understand if you're new to compiz. I suggest not doing this in future code. Instead use an explicit:
    MoveWindow *mw = MoveWindow::get(w);

3. From a high-level perspective, even if the implementation turns out to be right then I think maybe more analysis was required. This fix is an example of where the medicine could be worse than the disease. It's only useful to nvidia because nvidia is buggy IMHO. And the price to pay is more abstraction and complication that hinders maintainability of the code. We might be better off not trying to "fix" window movement any further. Though resizing needs work still.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

OK, verified window movement is absolutely perfect on the Atom with this change. So no non-lazy-mode regression to worry about.

Just need (want) to reconsider the style issues and the philosophical point above.

[Daniel van Vugt (vanvugt)]

FYI, window resizing on the Atom (i915) freezes just like with Nvidia so that's another good test platform.

[Sam Spilsbury (smspillaz)]

> It will take me a while to get the code compiled 32-bit and running on the
> Atom where I tested all the previous lazy-mode regressions. Until then, some
> style issues:
>
> 1. This is hard to read. I recommend (but don't require) all on one line...
> 48 +namespace compiz
> 49 +{
> 50 +namespace window
> 51 +{
> 52 +namespace configure_buffers
> 53 +{
>
> 2. MOVE_WINDOW (w) - Using macros to declare local variables via side-effect
> is dangerous and very hard to understand if you're new to compiz. I suggest
> not doing this in future code. Instead use an explicit:
> MoveWindow *mw = MoveWindow::get(w);

+1

>
> 3. From a high-level perspective, even if the implementation turns out to be
> right then I think maybe more analysis was required. This fix is an example of
> where the medicine could be worse than the disease. It's only useful to nvidia
> because nvidia is buggy IMHO. And the price to pay is more abstraction and
> complication that hinders maintainability of the code. We might be better off
> not trying to "fix" window movement any further. Though resizing needs work
> still.

It is a little more abstract and complex, yes, however having an unusable system on nvidia is not an acceptable alternative either.

I don't think the code is "unmaintainable", I think it just works in a way that is a tad more complex and different to the way that you would expect. Its fully tested and encapsulated from the other code, so future maintainers don't need to worry about inadvertently breaking it (except for their usage of the client hooks).

In addition, if there are any problems you can just "turn it off" - just don't take a lock on the configure request queue in the opengl plugin.

Speaking of medicine worse than the disease, you just named one of my favourite pieces of music :P (http://www.youtube.com/watch?v=htGmTJNsOr0)

[Sam Spilsbury (smspillaz)]

>
> +1
>
> >
> > 3. From a high-level perspective, even if the implementation turns out to be
> > right then I think maybe more analysis was required. This fix is an example
> of
> > where the medicine could be worse than the disease. It's only useful to
> nvidia
> > because nvidia is buggy IMHO. And the price to pay is more abstraction and
> > complication that hinders maintainability of the code. We might be better
> off
> > not trying to "fix" window movement any further. Though resizing needs work
> > still.
>
> It is a little more abstract and complex, yes, however having an unusable
> system on nvidia is not an acceptable alternative either.
>
> I don't think the code is "unmaintainable", I think it just works in a way
> that is a tad more complex and different to the way that you would expect. Its
> fully tested and encapsulated from the other code, so future maintainers don't
> need to worry about inadvertently breaking it (except for their usage of the
> client hooks).
>

On the same note.

Over my many years of developing compiz, I've often found that the little quirks between drivers, opengl, the way the xserver works, the way specs are implemented etc often means the issues aren't that simple, so its means that the implementation is almost never going to be simple.

If you have a look at any window manager, they are often large and complicated beasts, doing lots of things that you wouldn't even expect a window manager to have to do.

However, window managers often start small and grow to accomadate the quirks in their surrounding environment. The best approach, in my opinion, is to encapsulate complexity into clearly defined areas of the code, so that your handing of corner cases doesn't pollute your main buisness logic or get tangled in-between it. While doing that, ensure that the corner cases are tested codepaths that future maintainers can rely upon the tests when making changes.

This is something that I think compiz really succeeds at. While our test coverage is pretty absymal at best, no other non-niche window manager I can think of is as well tested as compiz is. And its starting to pay off - I've been able to rely on the test suite alone for making some changes now, which is something that I was never able to do.

That being said, I think you're right into looking into any more workarounds for the nvidia problems with ConfigureWindow requests and simultaneous redirected GL. We've found the main cause and root of the problem now, so lets stick with this implementation and work on other things. Window movement is 60FPS here with this applied, so I doubt we can make it any faster :)

[Daniel van Vugt (vanvugt)]

OK, forget the style issues. I don't want to spend any more hours on testing more revisions.

review: Approve

[Daniel van Vugt (vanvugt)]

Sorry, I had to revert this merge in r3528. It caused too many regressions. See bug 1089279.

[Daniel van Vugt (vanvugt)]

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

Ah, I thought there might be some regressions.

Thanks, I'll get on to it.

On Thu, Dec 13, 2012 at 4:50 PM, Daniel van Vugt
<email address hidden> wrote:
> Review: Needs Fixing
>
>
> --
> https://code.launchpad.net/~compiz-team/compiz/compiz.performance_1027211.2/+merge/138800
> Your team Compiz Maintainers is subscribed to branch lp:compiz.

--
Sam Spilsbury

Unmerged revisions

3536. By Sam Spilsbury on 2012-12-07

Fix assertion failures

3535. By Sam Spilsbury on 2012-12-07

Put lock in the list before freezing the buffer to avoid an assertion failure

3534. By Sam Spilsbury on 2012-12-07

Revert an accidental change due to f'n'r

3533. By Sam Spilsbury on 2012-12-07

Update client code to take advantage of ConfigureBuffer wrapping
queryShapeRectangles

3532. By Sam Spilsbury on 2012-12-07

Fix broken assert

3531. By Sam Spilsbury on 2012-12-07

Merge lp:compiz

3530. By Sam Spilsbury on 2012-12-07

Bring back lazy positioning, make it off by default.

This basically "fixes" the various problems with nvidia being slow at
handling ConfigureWindow requests at the same time as doing synchronized
compositing, however it could come at the cost of some weird bugs. Keep
it off for now, and lets turn it on if there aren't any in testing

3529. By Sam Spilsbury on 2012-12-07

Handle XShapeQueryRectangles too and work around races with that

3528. By Sam Spilsbury on 2012-12-07

Remove const promise, be a little smarter about calling XConfigureWindow
the other times

3527. By Sam Spilsbury on 2012-12-07

Refactor the test code into test fixtures, remove lots of duplicated code

=== modified file 'include/core/CMakeLists.txt'
--- include/core/CMakeLists.txt	2012-10-17 06:25:59 +0000
+++ include/core/CMakeLists.txt	2012-12-07 18:08:24 +0000
@@ -1,6 +1,7 @@
 set (_headers
     action.h
     atoms.h
+    configurerequestbuffer.h
     core.h
     countedlist.h
     global.h

=== added file 'include/core/configurerequestbuffer.h'
--- include/core/configurerequestbuffer.h	1970-01-01 00:00:00 +0000
+++ include/core/configurerequestbuffer.h	2012-12-07 18:08:24 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2012 Sam Spilsbury
+ *
+ * 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_CONFIGURE_REQUEST_BUFFER_H
+#define _COMPIZ_CONFIGURE_REQUEST_BUFFER_H
+
+#include <boost/shared_ptr.hpp>
+#include <X11/Xlib.h>
+#include <syncserverwindow.h>
+
+namespace compiz
+{
+namespace window
+{
+namespace configure_buffers
+{
+class Releasable
+{
+    public:
+
+	typedef boost::shared_ptr <Releasable> Ptr;
+
+	virtual void release () = 0;
+};
+
+class Buffer :
+    public SyncServerWindow
+{
+    public:
+
+	typedef boost::shared_ptr <Buffer> Ptr;
+
+	virtual ~Buffer () {}
+
+	virtual void pushClientRequest (const XWindowChanges &xwc, unsigned int mask) = 0;
+	virtual void pushWrapperRequest (const XWindowChanges &xwc, unsigned int mask) = 0;
+	virtual void pushFrameRequest (const XWindowChanges &xwc, unsigned int mask) = 0;
+
+	virtual void pushSyntheticConfigureNotify () = 0;
+
+	virtual Releasable::Ptr obtainLock () = 0;
+
+	/* This API will all configure requests to be
+	 * released. It should only be used in situations
+	 * where you have a server grab and need
+	 * to have complete sync with the server */
+	virtual void forceRelease () = 0;
+};
+}
+}
+}
+#endif

=== modified file 'include/core/window.h'
--- include/core/window.h	2012-12-07 09:28:03 +0000
+++ include/core/window.h	2012-12-07 18:08:24 +0000
@@ -53,13 +53,26 @@
 class PrivateWindow;
 struct CompStartupSequence;
 
-namespace compiz { namespace private_screen {
-    class Ping;
-    class GrabManager;
-    class OutputDevices;
-    class WindowManager;
-    class StartupSequence;
-}}
+namespace compiz
+{
+namespace window
+{
+namespace configure_buffers
+{
+class Releasable;
+typedef boost::shared_ptr <Releasable> ReleasablePtr;
+}
+}
+
+namespace private_screen
+{
+class Ping;
+class GrabManager;
+class OutputDevices;
+class WindowManager;
+class StartupSequence;
+}
+}
 
 #define ROOTPARENT(x) (((x)->frame ()) ? (x)->frame () : (x)->id ())
 
@@ -524,6 +537,12 @@
 	bool updateStruts ();
 	const CompStruts *struts () const;
 
+	bool queryAttributes (XWindowAttributes &);
+	bool queryFrameAttributes (XWindowAttributes &);
+
+	compiz::window::configure_buffers::ReleasablePtr
+	obtainLockOnConfigureRequests ();
+
 	WRAPABLE_HND (0, WindowInterface, void, getOutputExtents,
 		      CompWindowExtents&);
 	WRAPABLE_HND (1, WindowInterface, void, getAllowedActions,

=== modified file 'plugins/composite/src/window.cpp'
--- plugins/composite/src/window.cpp	2012-11-18 00:16:47 +0000
+++ plugins/composite/src/window.cpp	2012-12-07 18:08:24 +0000
@@ -181,11 +181,7 @@
 bool
 PrivateCompositeWindow::getAttributes (XWindowAttributes &attr)
 {
-    if (XGetWindowAttributes (screen->dpy (),
-			      ROOTPARENT (window), &attr))
-	return true;
-
-    return false;
+    return window->queryFrameAttributes (attr);
 }
 
 bool

=== modified file 'plugins/move/move.xml.in'
--- plugins/move/move.xml.in	2012-10-15 10:31:51 +0000
+++ plugins/move/move.xml.in	2012-12-07 18:08:24 +0000
@@ -42,7 +42,7 @@
 	    <option name="lazy_positioning" type="bool">
 		<_short>Lazy Positioning</_short>
 		<_long>Do not update the server-side position of windows until finished moving</_long>
-		<default>true</default>
+                <default>false</default>
 	    </option>
 	</options>
     </plugin>

=== modified file 'plugins/move/src/move.cpp'
--- plugins/move/src/move.cpp	2012-12-05 09:38:59 +0000
+++ plugins/move/src/move.cpp	2012-12-07 18:08:24 +0000
@@ -158,6 +158,14 @@
 		if (mw->gWindow)
 		mw->gWindow->glPaintSetEnabled (mw, true);
 	    }
+
+	    if (ms->optionGetLazyPositioning ())
+	    {
+		MOVE_WINDOW (w);
+
+		if (mw->gWindow)
+		    mw->releasable = w->obtainLockOnConfigureRequests ();
+	    }
 	}
     }
 
@@ -173,6 +181,8 @@
 
     if (ms->w)
     {
+	MOVE_WINDOW (ms->w);
+
 	if (state & CompAction::StateCancel)
 	    ms->w->move (ms->savedX - ms->w->geometry ().x (),
 			 ms->savedY - ms->w->geometry ().y (), false);
@@ -194,14 +204,14 @@
 
 	if (ms->moveOpacity != OPAQUE)
 	{
-	    MOVE_WINDOW (ms->w);
-
 	    if (mw->cWindow)
 		mw->cWindow->addDamage ();
 	    if (mw->gWindow)
 		mw->gWindow->glPaintSetEnabled (mw, false);
 	}
 
+	mw->releasable.reset ();
+
 	ms->w             = 0;
 	ms->releaseButton = 0;
     }
@@ -489,9 +499,6 @@
 	    w->move (wX + dx - w->geometry ().x (),
 		     wY + dy - w->geometry ().y (), false);
 
-	    if (!ms->optionGetLazyPositioning ())
-		w->syncPosition ();
-
 	    ms->x -= dx;
 	    ms->y -= dy;
 	}

=== modified file 'plugins/move/src/move.h'
--- plugins/move/src/move.h	2012-09-07 22:48:26 +0000
+++ plugins/move/src/move.h	2012-12-07 18:08:24 +0000
@@ -27,6 +27,7 @@
 
 #include <core/screen.h>
 #include <core/pluginclasshandler.h>
+#include <core/configurerequestbuffer.h>
 
 #include <composite/composite.h>
 #include <opengl/opengl.h>
@@ -117,6 +118,7 @@
 	CompWindow      *window;
 	GLWindow        *gWindow;
 	CompositeWindow *cWindow;
+	compiz::window::configure_buffers::Releasable::Ptr releasable;
 };
 
 #define MOVE_SCREEN(s) \

=== modified file 'plugins/opengl/src/paint.cpp'
--- plugins/opengl/src/paint.cpp	2012-12-04 08:47:32 +0000
+++ plugins/opengl/src/paint.cpp	2012-12-07 18:08:24 +0000
@@ -1283,6 +1283,9 @@
 	!priv->cWindow->damaged ())
 	return true;
 
+    /* Release any queued ConfigureWindow requests now */
+    priv->configureLock->release ();
+
     if (textures ().empty () && !bind ())
 	return false;
 

=== modified file 'plugins/opengl/src/privates.h'
--- plugins/opengl/src/privates.h	2012-11-08 09:29:42 +0000
+++ plugins/opengl/src/privates.h	2012-12-07 18:08:24 +0000
@@ -33,6 +33,7 @@
 #include <composite/composite.h>
 #include <opengl/opengl.h>
 #include <core/atoms.h>
+#include <core/configurerequestbuffer.h>
 
 #ifdef USE_GLES
 #include <opengl/framebufferobject.h>
@@ -276,6 +277,8 @@
 	GLVertexBuffer::AutoProgram *autoProgram;
 
 	std::list<GLIcon> icons;
+
+	compiz::window::configure_buffers::Releasable::Ptr configureLock;
 };
 
 #endif

=== modified file 'plugins/opengl/src/window.cpp'
--- plugins/opengl/src/window.cpp	2012-10-16 04:49:19 +0000
+++ plugins/opengl/src/window.cpp	2012-12-07 18:08:24 +0000
@@ -86,7 +86,8 @@
     bindFailed (false),
     vertexBuffer (new GLVertexBuffer ()),
     autoProgram(new GLWindowAutoProgram(this)),
-    icons ()
+    icons (),
+    configureLock (w->obtainLockOnConfigureRequests ())
 {
     paint.xScale	= 1.0f;
     paint.yScale	= 1.0f;

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2012-11-26 07:13:04 +0000
+++ src/CMakeLists.txt	2012-12-07 18:08:24 +0000
@@ -160,6 +160,12 @@
     compiz_window_geometry
 )
 
+add_library (compiz_configurerequestbuffer STATIC
+             configurerequestbuffer.cpp)
+
+target_link_libraries (compiz_configurerequestbuffer
+                       compiz_window_geometry)
+
 # workaround for build race
 add_dependencies (compiz core-xml-file)
 
@@ -192,6 +198,7 @@
     compiz_servergrab
     compiz_output
     compiz_outputdevices
+    compiz_configurerequestbuffer
     -Wl,-no-whole-archive
 #    ${CORE_MOD_LIBRARIES}
 )

=== added file 'src/asyncserverwindow.h'
--- src/asyncserverwindow.h	1970-01-01 00:00:00 +0000
+++ src/asyncserverwindow.h	2012-12-07 18:08:24 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2012 Sam Spilsbury
+ *
+ * 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_ASYNC_SERVER_WINDOW_H
+#define _COMPIZ_ASYNC_SERVER_WINDOW_H
+
+#include <X11/Xlib.h>
+
+namespace compiz
+{
+namespace window
+{
+class AsyncServerWindow
+{
+    public:
+
+	virtual ~AsyncServerWindow () {};
+
+	virtual int requestConfigureOnClient (const XWindowChanges &xwc,
+					      unsigned int         valueMask) = 0;
+	virtual int requestConfigureOnWrapper (const XWindowChanges &xwc,
+					       unsigned int         valueMask) = 0;
+	virtual int requestConfigureOnFrame  (const XWindowChanges &xwc,
+					      unsigned int         valueMask) = 0;
+	virtual void sendSyntheticConfigureNotify () = 0;
+	virtual bool hasCustomShape () const = 0;
+};
+}
+}
+
+#endif

=== added file 'src/configurerequestbuffer-impl.h'
--- src/configurerequestbuffer-impl.h	1970-01-01 00:00:00 +0000
+++ src/configurerequestbuffer-impl.h	2012-12-07 18:08:24 +0000
@@ -0,0 +1,145 @@
+/*
+ * Copyright © 2012 Sam Spilsbury
+ *
+ * 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_GEOMETRY_UPDATE_QUEUE_H
+#define _COMPIZ_GEOMETRY_UPDATE_QUEUE_H
+
+#include <memory>
+#include <vector>
+#include <boost/weak_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+#include <X11/Xlib.h>
+
+#include <core/configurerequestbuffer.h>
+
+namespace compiz
+{
+namespace window
+{
+class AsyncServerWindow;
+namespace configure_buffers
+{
+
+class Lockable
+{
+    public:
+
+	typedef boost::shared_ptr <Lockable> Ptr;
+	typedef boost::weak_ptr <Lockable> Weak;
+
+	virtual ~Lockable () {}
+
+	virtual void lock () = 0;
+};
+
+class BufferLock :
+    public Lockable,
+    public Releasable
+{
+    public:
+	typedef boost::shared_ptr <BufferLock> Ptr;
+
+	virtual ~BufferLock () {}
+};
+
+class CountedFreeze
+{
+    public:
+
+	virtual ~CountedFreeze () {}
+
+	virtual void freeze () = 0;
+	virtual void release () = 0;
+
+	virtual void untrackLock (compiz::window::configure_buffers::BufferLock *lock) = 0;
+};
+
+class ConfigureRequestBuffer :
+    public CountedFreeze,
+    public Buffer
+{
+    public:
+
+	typedef boost::function <BufferLock::Ptr (CountedFreeze *)> LockFactory;
+
+	void freeze ();
+	void release ();
+
+	void untrackLock (compiz::window::configure_buffers::BufferLock *lock);
+
+	void pushClientRequest (const XWindowChanges &xwc, unsigned int mask);
+	void pushWrapperRequest (const XWindowChanges &xwc, unsigned int mask);
+	void pushFrameRequest (const XWindowChanges &xwc, unsigned int mask);
+	void pushSyntheticConfigureNotify ();
+	compiz::window::configure_buffers::Releasable::Ptr obtainLock ();
+
+	/* Implement getAttributes and require that
+	 * the queue is released before calling through
+	 * to the SyncServerWindow */
+	bool queryAttributes (XWindowAttributes &attrib);
+	bool queryFrameAttributes (XWindowAttributes &attrib);
+	XRectangle * queryShapeRectangles (int kind,
+					   int *count,
+					   int *ordering);
+
+	void forceRelease ();
+
+	static compiz::window::configure_buffers::Buffer::Ptr
+	Create (AsyncServerWindow *asyncServerWindow,
+		SyncServerWindow  *syncServerWindow,
+		const LockFactory &factory);
+
+    private:
+
+	ConfigureRequestBuffer (AsyncServerWindow *asyncServerWindow,
+				SyncServerWindow  *syncServerWindow,
+				const LockFactory &factory);
+
+	class Private;
+	std::auto_ptr <Private> priv;
+};
+
+class ConfigureBufferLock :
+    public compiz::window::configure_buffers::BufferLock
+{
+    public:
+
+	typedef boost::shared_ptr <ConfigureBufferLock> Ptr;
+
+	ConfigureBufferLock (CountedFreeze *);
+	~ConfigureBufferLock ();
+
+	void lock ();
+	void release ();
+
+    private:
+
+	class Private;
+	std::auto_ptr <Private> priv;
+};
+}
+}
+}
+#endif

=== added file 'src/configurerequestbuffer.cpp'
--- src/configurerequestbuffer.cpp	1970-01-01 00:00:00 +0000
+++ src/configurerequestbuffer.cpp	2012-12-07 18:08:24 +0000
@@ -0,0 +1,354 @@
+/*
+ * Copyright © 2012 Sam Spilsbury
+ *
+ * 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 <cassert>
+#include <boost/foreach.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/bind.hpp>
+#include "asyncserverwindow.h"
+#include "configurerequestbuffer-impl.h"
+
+#ifndef foreach
+#define foreach BOOST_FOREACH
+#endif
+
+namespace crb = compiz::window::configure_buffers;
+namespace cw = compiz::window;
+
+class crb::ConfigureRequestBuffer::Private
+{
+    public:
+
+	typedef crb::Lockable::Weak LockObserver;
+
+	Private (cw::AsyncServerWindow                          *asyncServerWindow,
+		 cw::SyncServerWindow                           *syncServerWindow,
+		 const crb::ConfigureRequestBuffer::LockFactory &lockFactory) :
+	    clientChangeMask (0),
+	    wrapperChangeMask (0),
+	    frameChangeMask (0),
+	    sendSyntheticConfigure (false),
+	    lockCount (0),
+	    asyncServerWindow (asyncServerWindow),
+	    syncServerWindow (syncServerWindow),
+	    lockFactory (lockFactory)
+	{
+	}
+
+	void dispatchConfigure (bool force = false);
+
+	XWindowChanges clientChanges;
+	unsigned int   clientChangeMask;
+
+	XWindowChanges wrapperChanges;
+	unsigned int   wrapperChangeMask;
+
+	XWindowChanges frameChanges;
+	unsigned int   frameChangeMask;
+
+	bool           sendSyntheticConfigure;
+
+	unsigned int   lockCount;
+
+	cw::AsyncServerWindow *asyncServerWindow;
+	cw::SyncServerWindow  *syncServerWindow;
+
+	crb::ConfigureRequestBuffer::LockFactory lockFactory;
+	std::vector <LockObserver>               locks;
+};
+
+void
+crb::ConfigureRequestBuffer::Private::dispatchConfigure (bool force)
+{
+    const unsigned int allEventMasks = 0x7f;
+    bool immediate = frameChangeMask & (CWStackMode | CWSibling);
+    immediate |= (frameChangeMask & (CWWidth | CWHeight)) &&
+		 asyncServerWindow->hasCustomShape ();
+    immediate |= force;
+
+    bool clientDispatch = (clientChangeMask & allEventMasks);
+    bool wrapperDispatch = (wrapperChangeMask & allEventMasks);
+    bool frameDispatch  = (frameChangeMask & allEventMasks);
+
+    bool dispatch = !lockCount && (clientDispatch ||
+				   wrapperDispatch ||
+				   frameDispatch ||
+				   sendSyntheticConfigure);
+
+    if (dispatch || immediate)
+    {
+	if (frameDispatch)
+	{
+	    asyncServerWindow->requestConfigureOnFrame (frameChanges,
+							frameChangeMask);
+	    frameChangeMask = 0;
+	}
+
+	if (wrapperDispatch)
+	{
+	    asyncServerWindow->requestConfigureOnWrapper (wrapperChanges,
+							  wrapperChangeMask);
+	    wrapperChangeMask = 0;
+	}
+
+	if (clientDispatch)
+	{
+	    asyncServerWindow->requestConfigureOnClient (clientChanges,
+							 clientChangeMask);
+	    clientChangeMask = 0;
+	}
+
+	if (sendSyntheticConfigure)
+	{
+	    asyncServerWindow->sendSyntheticConfigureNotify ();
+	    sendSyntheticConfigure = false;
+	}
+
+	foreach (const LockObserver &lock, locks)
+	{
+	    crb::Lockable::Ptr strongLock (lock.lock ());
+
+	    /* We might be in a lock's destructor so check
+	     * if this can really be re-locked, if not, its
+	     * no big deal as the lock is going away anyways
+	     */
+	    if (strongLock)
+		strongLock->lock ();
+	}
+    }
+}
+
+void
+crb::ConfigureRequestBuffer::freeze ()
+{
+    priv->lockCount++;
+
+    assert (priv->lockCount <= priv->locks.size ());
+}
+
+void
+crb::ConfigureRequestBuffer::release ()
+{
+    assert (priv->lockCount);
+
+    priv->lockCount--;
+
+    priv->dispatchConfigure ();
+}
+
+namespace
+{
+void applyChangeToXWC (const XWindowChanges &from,
+		       XWindowChanges       &to,
+		       unsigned int         mask)
+{
+    if (mask & CWX)
+	to.x = from.x;
+
+    if (mask & CWY)
+	to.y = from.y;
+
+    if (mask & CWWidth)
+	to.width = from.width;
+
+    if (mask & CWHeight)
+	to.height = from.height;
+
+    if (mask & CWBorderWidth)
+	to.border_width = from.border_width;
+
+    if (mask & CWSibling)
+	to.sibling = from.sibling;
+
+    if (mask & CWStackMode)
+	to.stack_mode = from.stack_mode;
+}
+}
+
+void
+crb::ConfigureRequestBuffer::pushClientRequest (const XWindowChanges &xwc,
+						unsigned int         mask)
+{
+    applyChangeToXWC (xwc, priv->clientChanges, mask);
+    priv->clientChangeMask |= mask;
+
+    priv->dispatchConfigure ();
+}
+
+void
+crb::ConfigureRequestBuffer::pushWrapperRequest (const XWindowChanges &xwc,
+						 unsigned int         mask)
+{
+    applyChangeToXWC (xwc, priv->wrapperChanges, mask);
+    priv->wrapperChangeMask |= mask;
+
+    priv->dispatchConfigure ();
+}
+
+void
+crb::ConfigureRequestBuffer::pushFrameRequest (const XWindowChanges &xwc,
+					       unsigned int         mask)
+{
+    applyChangeToXWC (xwc, priv->frameChanges, mask);
+    priv->frameChangeMask |= mask;
+
+    priv->dispatchConfigure ();
+}
+
+void
+crb::ConfigureRequestBuffer::pushSyntheticConfigureNotify ()
+{
+    priv->sendSyntheticConfigure = true;
+
+    priv->dispatchConfigure ();
+}
+
+crb::Releasable::Ptr
+crb::ConfigureRequestBuffer::obtainLock ()
+{
+    crb::BufferLock::Ptr lock (priv->lockFactory (this));
+
+    priv->locks.push_back (crb::Lockable::Weak (lock));
+    lock->lock ();
+
+    return lock;
+}
+
+namespace
+{
+bool isLock (const crb::Lockable::Weak &lockable,
+	     crb::BufferLock           *lock)
+{
+    crb::Lockable::Ptr strongLockable (lockable.lock ());
+
+    /* Asserting that the lock did not go away without telling
+     * us first */
+    assert (strongLockable.get ());
+
+    if (strongLockable.get () == lock)
+	return true;
+
+    return false;
+}
+}
+
+void
+crb::ConfigureRequestBuffer::untrackLock (crb::BufferLock *lock)
+{
+    std::remove_if (priv->locks.begin (),
+		    priv->locks.end (),
+		    boost::bind (isLock, _1, lock));
+}
+
+bool crb::ConfigureRequestBuffer::queryAttributes (XWindowAttributes &attrib)
+{
+    priv->dispatchConfigure (true);
+    return priv->syncServerWindow->queryAttributes (attrib);
+}
+
+bool crb::ConfigureRequestBuffer::queryFrameAttributes (XWindowAttributes &attrib)
+{
+    priv->dispatchConfigure (true);
+    return priv->syncServerWindow->queryFrameAttributes (attrib);
+}
+
+/* This is more or less of a stop-gap for the fact that
+ * when resizing window we re-query the window shape
+ * and apply that to the frame. That's a separate unit of
+ * work and should be dealt with separately. For now, force
+ * a release of the queue whenever we do that so that
+ * XShapeGetRectangles doesn't return an unexpected value
+ */
+XRectangle *
+crb::ConfigureRequestBuffer::queryShapeRectangles (int kind,
+						   int *count,
+						   int *ordering)
+{
+    priv->dispatchConfigure (true);
+    return priv->syncServerWindow->queryShapeRectangles (kind, count, ordering);
+}
+
+void crb::ConfigureRequestBuffer::forceRelease ()
+{
+    priv->dispatchConfigure (true);
+}
+
+crb::ConfigureRequestBuffer::ConfigureRequestBuffer (AsyncServerWindow                          *asyncServerWindow,
+						     SyncServerWindow                           *syncServerWindow,
+						     const crb::ConfigureRequestBuffer::LockFactory &factory) :
+    priv (new crb::ConfigureRequestBuffer::Private (asyncServerWindow, syncServerWindow, factory))
+{
+}
+
+compiz::window::configure_buffers::Buffer::Ptr
+crb::ConfigureRequestBuffer::Create (AsyncServerWindow *asyncServerWindow,
+				     SyncServerWindow  *syncServerWindow,
+				     const LockFactory &factory)
+{
+    return crb::Buffer::Ptr (new crb::ConfigureRequestBuffer (asyncServerWindow,
+							      syncServerWindow,
+							      factory));
+}
+
+class crb::ConfigureBufferLock::Private
+{
+    public:
+
+	Private (crb::CountedFreeze *freezable) :
+	    freezable (freezable),
+	    armed (false)
+	{
+	}
+
+	crb::CountedFreeze *freezable;
+	bool               armed;
+};
+
+crb::ConfigureBufferLock::ConfigureBufferLock (crb::CountedFreeze *freezable) :
+    priv (new crb::ConfigureBufferLock::Private (freezable))
+{
+}
+
+crb::ConfigureBufferLock::~ConfigureBufferLock ()
+{
+    release ();
+}
+
+void
+crb::ConfigureBufferLock::lock ()
+{
+    if (!priv->armed)
+	priv->freezable->freeze ();
+
+    priv->armed = true;
+}
+
+void
+crb::ConfigureBufferLock::release ()
+{
+    if (priv->armed)
+	priv->freezable->release ();
+
+    priv->armed = false;
+}

=== modified file 'src/event.cpp'
--- src/event.cpp	2012-12-04 15:11:42 +0000
+++ src/event.cpp	2012-12-07 18:08:24 +0000
@@ -1928,7 +1928,7 @@
 
 	    /* We should check the override_redirect flag here, because the
 	       client might have changed it while being unmapped. */
-	    if (XGetWindowAttributes (privateScreen.dpy, w->id (), &attr))
+	    if (w->queryAttributes (attr))
 		w->priv->setOverrideRedirect (attr.override_redirect != 0);
 
 	    if (w->state () & CompWindowStateHiddenMask)

=== modified file 'src/privatewindow.h'
--- src/privatewindow.h	2012-11-28 18:14:56 +0000
+++ src/privatewindow.h	2012-12-07 18:08:24 +0000
@@ -35,6 +35,11 @@
 
 #include <boost/shared_ptr.hpp>
 
+#include <core/configurerequestbuffer.h>
+
+#include "syncserverwindow.h"
+#include "asyncserverwindow.h"
+
 #define XWINDOWCHANGES_INIT {0, 0, 0, 0, 0, None, 0}
 
 namespace compiz {namespace X11
@@ -107,12 +112,47 @@
 
 typedef CompWindowExtents CompFullscreenMonitorSet;
 
-class PrivateWindow {
+class X11SyncServerWindow :
+    public compiz::window::SyncServerWindow
+{
+    public:
+
+	X11SyncServerWindow (Display      *dpy,
+			     const Window *w,
+			     const Window *frame);
+
+	bool queryAttributes (XWindowAttributes &attrib);
+	bool queryFrameAttributes (XWindowAttributes &attrib);
+	XRectangle * queryShapeRectangles(int kind, int *count, int *ordering);
+
+    private:
+
+	Display      *mDpy;
+	const Window *mWindow;
+	const Window *mFrame;
+};
+
+class PrivateWindow :
+    public compiz::window::SyncServerWindow,
+    public compiz::window::AsyncServerWindow
+{
 
     public:
 	PrivateWindow ();
 	~PrivateWindow ();
 
+	bool queryAttributes (XWindowAttributes &attrib);
+	bool queryFrameAttributes (XWindowAttributes &attrib);
+	XRectangle * queryShapeRectangles (int kind, int *count, int *ordering);
+	int  requestConfigureOnClient (const XWindowChanges &xwc,
+				       unsigned int valueMask);
+	int  requestConfigureOnWrapper (const XWindowChanges &xwc,
+					unsigned int valueMask);
+	int  requestConfigureOnFrame (const XWindowChanges &xwc,
+				      unsigned int valueMask);
+	void sendSyntheticConfigureNotify ();
+	bool hasCustomShape () const;
+
 	void recalcNormalHints ();
 
 	void updateFrameWindow ();
@@ -373,6 +413,7 @@
 
 	CompWindowExtents input;
 	CompWindowExtents serverInput;
+	CompWindowExtents lastServerInput;
 	CompWindowExtents border;
 	CompWindowExtents output;
 
@@ -398,6 +439,9 @@
 	Time lastCloseRequestTime;
 
 	bool nextMoveImmediate;
+
+	X11SyncServerWindow                            syncServerWindow;
+	compiz::window::configure_buffers::Buffer::Ptr configureBuffer;
 };
 
 #endif

=== added file 'src/serverwindow.h'
=== added file 'src/syncserverwindow.h'
--- src/syncserverwindow.h	1970-01-01 00:00:00 +0000
+++ src/syncserverwindow.h	2012-12-07 18:08:24 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2012 Sam Spilsbury
+ *
+ * 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_SYNC_SERVER_WINDOW_H
+#define _COMPIZ_SYNC_SERVER_WINDOW_H
+
+#include <X11/Xlib.h>
+
+namespace compiz
+{
+namespace window
+{
+class SyncServerWindow
+{
+    public:
+
+	virtual ~SyncServerWindow () {}
+
+	virtual bool queryAttributes (XWindowAttributes &attrib) = 0;
+	virtual bool queryFrameAttributes (XWindowAttributes &attrib) = 0;
+	virtual XRectangle * queryShapeRectangles (int kind,
+						   int *count,
+						   int *ordering) = 0;
+};
+}
+}
+
+#endif

=== modified file 'src/tests/CMakeLists.txt'
--- src/tests/CMakeLists.txt	2012-11-26 07:13:04 +0000
+++ src/tests/CMakeLists.txt	2012-12-07 18:08:24 +0000
@@ -29,3 +29,14 @@
 
 compiz_discover_tests(compiz_test_outputdevices COVERAGE compiz_core)
 
+add_executable (compiz_test_configurerequestbuffer
+                test_configurerequestbuffer.cpp)
+
+target_link_libraries (compiz_test_configurerequestbuffer
+    compiz_configurerequestbuffer
+    ${GTEST_BOTH_LIBRARIES}
+    ${GMOCK_MAIN_LIBRARY}
+    ${GMOCK_LIBRARY}
+)
+
+compiz_discover_tests(compiz_test_configurerequestbuffer COVERAGE compiz_configurerequestbuffer)

=== added file 'src/tests/test_configurerequestbuffer.cpp'
--- src/tests/test_configurerequestbuffer.cpp	1970-01-01 00:00:00 +0000
+++ src/tests/test_configurerequestbuffer.cpp	2012-12-07 18:08:24 +0000
@@ -0,0 +1,647 @@
+/*
+ * Copyright © 2012 Sam Spilsbury
+ *
+ * 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 <deque>
+#include <boost/shared_ptr.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/bind.hpp>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <X11/Xlib.h>
+
+#include "configurerequestbuffer-impl.h"
+#include "asyncserverwindow.h"
+
+namespace crb = compiz::window::configure_buffers;
+namespace cw = compiz::window;
+
+using testing::_;
+using testing::NiceMock;
+using testing::Return;
+using testing::Invoke;
+using testing::WithArgs;
+using testing::SetArgReferee;
+using testing::DoAll;
+using testing::InSequence;
+using testing::ReturnNull;
+using testing::IsNull;
+
+class MockAsyncServerWindow :
+    public cw::AsyncServerWindow
+{
+    public:
+
+	MOCK_METHOD2 (requestConfigureOnClient, int (const XWindowChanges &, unsigned int));
+	MOCK_METHOD2 (requestConfigureOnFrame, int (const XWindowChanges &, unsigned int));
+	MOCK_METHOD2 (requestConfigureOnWrapper, int (const XWindowChanges &, unsigned int));
+	MOCK_METHOD0 (sendSyntheticConfigureNotify, void ());
+	MOCK_CONST_METHOD0 (hasCustomShape, bool ());
+};
+
+class MockSyncServerWindow :
+    public cw::SyncServerWindow
+{
+    public:
+
+	MOCK_METHOD1 (queryAttributes, bool (XWindowAttributes &));
+	MOCK_METHOD1 (queryFrameAttributes, bool (XWindowAttributes &));
+	MOCK_METHOD3 (queryShapeRectangles, XRectangle * (int, int *, int *));
+};
+
+namespace
+{
+int REQUEST_X = 1;
+int REQUEST_Y = 2;
+int REQUEST_WIDTH = 3;
+int REQUEST_HEIGHT = 4;
+int REQUEST_BORDER = 5;
+
+Window REQUEST_ABOVE = 6;
+unsigned int REQUEST_MODE = 7;
+
+crb::BufferLock::Ptr
+CreateNormalLock (crb::CountedFreeze *cf)
+{
+    return boost::make_shared <crb::ConfigureBufferLock> (cf);
+}
+
+}
+
+MATCHER_P2 (MaskXWC, xwc, vm, "Matches XWindowChanges")
+{
+    if (vm & CWX)
+	if (xwc.x != arg.x)
+	    return false;
+
+    if (vm & CWY)
+	if (xwc.y != arg.y)
+	    return false;
+
+    if (vm & CWWidth)
+	if (xwc.width != arg.width)
+	    return false;
+
+    if (vm & CWHeight)
+	if (xwc.height != arg.height)
+	    return false;
+
+    if (vm & CWBorderWidth)
+	if (xwc.border_width != arg.border_width)
+	    return false;
+
+    if (vm & CWStackMode)
+	if (xwc.stack_mode != arg.stack_mode)
+	    return false;
+
+    if (vm & CWSibling)
+	if (xwc.sibling != arg.sibling)
+	    return false;
+
+    return true;
+}
+
+class ConfigureRequestBuffer :
+    public testing::Test
+{
+    public:
+
+	ConfigureRequestBuffer ()
+	{
+	    /* Initialize xwc, we control it
+	     * through the value masks */
+	    xwc.x = REQUEST_X;
+	    xwc.y = REQUEST_Y;
+	    xwc.width = REQUEST_WIDTH;
+	    xwc.height = REQUEST_HEIGHT;
+	    xwc.border_width = REQUEST_BORDER;
+	    xwc.sibling = REQUEST_ABOVE;
+	    xwc.stack_mode = REQUEST_MODE;
+	}
+
+    protected:
+
+	XWindowChanges        xwc;
+	MockAsyncServerWindow asyncServerWindow;
+	MockSyncServerWindow  syncServerWindow;
+};
+
+class ConfigureRequestBufferDispatch :
+    public ConfigureRequestBuffer
+{
+    protected:
+
+	ConfigureRequestBufferDispatch () :
+	    ConfigureRequestBuffer (),
+	    factory (boost::bind (CreateNormalLock, _1)),
+	    buffer (
+		crb::ConfigureRequestBuffer::Create (&asyncServerWindow,
+						     &syncServerWindow,
+						     factory))
+	{
+	}
+
+	crb::ConfigureRequestBuffer::LockFactory factory;
+	crb::Buffer::Ptr buffer;
+};
+
+TEST_F (ConfigureRequestBufferDispatch, PushDirectSyntheticConfigureNotify)
+{
+    EXPECT_CALL (asyncServerWindow, sendSyntheticConfigureNotify ());
+
+    buffer->pushSyntheticConfigureNotify ();
+}
+
+TEST_F (ConfigureRequestBufferDispatch, PushDirectClientUpdate)
+{
+    unsigned int   valueMask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth |
+			       CWSibling | CWStackMode;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnClient (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    buffer->pushClientRequest (xwc, valueMask);
+}
+
+TEST_F (ConfigureRequestBufferDispatch, PushDirectWrapperUpdate)
+{
+    unsigned int   valueMask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth |
+			       CWSibling | CWStackMode;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnWrapper (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    buffer->pushWrapperRequest (xwc, valueMask);
+}
+
+TEST_F (ConfigureRequestBufferDispatch, PushDirectFrameUpdate)
+{
+    unsigned int   valueMask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth |
+			       CWSibling | CWStackMode;
+
+    EXPECT_CALL (asyncServerWindow, hasCustomShape ()).WillOnce (Return (false));
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    buffer->pushFrameRequest (xwc, valueMask);
+}
+
+TEST_F (ConfigureRequestBufferDispatch, PushUpdateLocked)
+{
+    crb::Releasable::Ptr lock (buffer->obtainLock ());
+
+    unsigned int   valueMask = 0;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+}
+
+TEST_F (ConfigureRequestBufferDispatch, PushCombinedUpdateLocked)
+{
+    crb::Releasable::Ptr lock (buffer->obtainLock ());
+
+    unsigned int   valueMask = CWX | CWY;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    valueMask |= CWWidth | CWHeight;
+
+    EXPECT_CALL (asyncServerWindow, hasCustomShape ()).WillRepeatedly (Return (false));
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    lock->release ();
+}
+
+TEST_F (ConfigureRequestBufferDispatch, PushUpdateLockedReleaseInOrder)
+{
+    crb::Releasable::Ptr lock (buffer->obtainLock ());
+
+    unsigned int   valueMask = CWX | CWY;
+
+    EXPECT_CALL (asyncServerWindow, hasCustomShape ()).WillRepeatedly (Return (false));
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnWrapper (_, _)).Times (0);
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnClient (_, _)).Times (0);
+
+    buffer->pushClientRequest (xwc, valueMask);
+    buffer->pushWrapperRequest (xwc, valueMask);
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    InSequence s;
+
+    /* Always frame -> wrapper -> client */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (MaskXWC (xwc, valueMask),
+					       valueMask));
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnWrapper (MaskXWC (xwc, valueMask),
+					       valueMask));
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnClient (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    lock->release ();
+}
+
+TEST_F (ConfigureRequestBufferDispatch, UnlockBuffer)
+{
+    crb::Releasable::Ptr lock (buffer->obtainLock ());
+
+    unsigned int   valueMask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
+
+    EXPECT_CALL (asyncServerWindow, hasCustomShape ()).WillRepeatedly (Return (false));
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    lock->release ();
+}
+
+TEST_F (ConfigureRequestBufferDispatch, ImplicitUnlockBuffer)
+{
+    crb::Releasable::Ptr lock (buffer->obtainLock ());
+
+    unsigned int   valueMask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
+
+    EXPECT_CALL (asyncServerWindow, hasCustomShape ()).WillRepeatedly (Return (false));
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (MaskXWC (xwc, valueMask),
+					       valueMask));
+}
+
+TEST_F (ConfigureRequestBufferDispatch, ForceImmediateConfigureOnRestack)
+{
+    crb::Releasable::Ptr lock (buffer->obtainLock ());
+
+    unsigned int   valueMask = CWStackMode | CWSibling;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    buffer->pushFrameRequest (xwc, valueMask);
+}
+
+TEST_F (ConfigureRequestBufferDispatch, ForceImmediateConfigureOnShapedWindowSizeChange)
+{
+    crb::Releasable::Ptr lock (buffer->obtainLock ());
+
+    unsigned int   valueMask = CWWidth | CWHeight;
+
+    EXPECT_CALL (asyncServerWindow, hasCustomShape ()).WillOnce (Return (true));
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    buffer->pushFrameRequest (xwc, valueMask);
+}
+
+namespace
+{
+class MockLock :
+    public crb::BufferLock
+{
+    public:
+
+	/* We're currently importing the locks statefulness and coupling
+	 * the caller with that */
+	MockLock () :
+	    armed (false)
+	{
+	    ON_CALL (*this, lock ()).WillByDefault (
+			Invoke (this, &MockLock::FreezeIfUnarmed));
+	    ON_CALL (*this, release ()).WillByDefault (
+			Invoke (this, &MockLock::ReleaseIfArmed));
+	}
+
+	void OperateOver (crb::CountedFreeze *cf)
+	{
+	    countedFreeze = cf;
+	}
+
+	void FreezeIfUnarmed ()
+	{
+	    if (!armed)
+	    {
+		countedFreeze->freeze ();
+		armed = true;
+	    }
+	}
+
+	void ReleaseIfArmed ()
+	{
+	    if (armed)
+	    {
+		countedFreeze->release ();
+		armed = false;
+	    }
+	}
+
+	typedef boost::shared_ptr <MockLock> Ptr;
+
+	MOCK_METHOD0 (lock, void ());
+	MOCK_METHOD0 (release, void ());
+
+    private:
+
+	crb::CountedFreeze *countedFreeze;
+	bool               armed;
+};
+
+class MockLockFactory
+{
+    public:
+
+	crb::BufferLock::Ptr
+	CreateMockLock (crb::CountedFreeze  *cf)
+	{
+	    MockLock::Ptr mockLock (locks.front ());
+	    mockLock->OperateOver (cf);
+
+	    locks.pop_front ();
+
+	    return mockLock;
+	}
+
+	void
+	QueueLockForCreation (const MockLock::Ptr &lock)
+	{
+	    locks.push_back (lock);
+	}
+
+    private:
+
+	std::deque <MockLock::Ptr> locks;
+};
+}
+
+class ConfigureRequestBufferLockBehaviour :
+    public ConfigureRequestBuffer
+{
+    public:
+
+	ConfigureRequestBufferLockBehaviour () :
+	    ConfigureRequestBuffer (),
+	    lock (boost::make_shared <MockLock> ()),
+	    factory (
+		boost::bind (&MockLockFactory::CreateMockLock,
+			     &mockLockFactory,
+			     _1)),
+	    buffer (
+		crb::ConfigureRequestBuffer::Create (
+		    &asyncServerWindow,
+		    &syncServerWindow,
+		    factory))
+
+	{
+	    mockLockFactory.QueueLockForCreation (lock);
+	}
+
+    protected:
+
+	typedef NiceMock <MockAsyncServerWindow> NiceServerWindow;
+	typedef crb::ConfigureRequestBuffer::LockFactory LockFactory;
+
+	MockLock::Ptr    lock;
+	MockLockFactory  mockLockFactory;
+
+	LockFactory      factory;
+	crb::Buffer::Ptr buffer;
+};
+
+TEST_F (ConfigureRequestBufferLockBehaviour, RearmBufferLockOnRelease)
+{
+    EXPECT_CALL (*lock, lock ());
+    crb::Releasable::Ptr releasable (buffer->obtainLock ());
+
+    unsigned int   valueMask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
+
+    EXPECT_CALL (asyncServerWindow, hasCustomShape ()).WillRepeatedly (Return (false));
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    /* We are releasing this lock */
+    EXPECT_CALL (*lock, release ());
+
+    /* Now the buffer will dispatch is configure request */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _));
+
+    /* Rearm locks on release */
+    EXPECT_CALL (*lock, lock ());
+
+    /* Directly release the queue */
+    releasable->release ();
+}
+
+TEST_F (ConfigureRequestBufferLockBehaviour, NoRearmBufferLockNoReleaseRequired)
+{
+    /* Locks get armed on construction */
+    EXPECT_CALL (*lock, lock ());
+    crb::Releasable::Ptr releasable (buffer->obtainLock ());
+
+    /* No call to requestConfigureOnFrame if there's nothing to be configured */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    /* We are releasing this lock */
+    EXPECT_CALL (*lock, release ());
+
+    /* No rearm - we haven't released the whole buffer */
+    EXPECT_CALL (*lock, lock ()).Times (0);
+
+    /* Directly release the queue */
+    releasable->release ();
+}
+
+TEST_F (ConfigureRequestBufferLockBehaviour, RearmWhenPushReady)
+{
+    /* Locks get armed on construction */
+    EXPECT_CALL (*lock, lock ());
+    crb::Releasable::Ptr releasable (buffer->obtainLock ());
+
+    /* We are releasing this lock */
+    EXPECT_CALL (*lock, release ());
+
+    /* No call to requestConfigureOnFrame if there's nothing to be configured */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    /* No rearm - we haven't released it */
+    EXPECT_CALL (*lock, lock ()).Times (0);
+
+    /* Directly release the queue */
+    releasable->release ();
+
+    /* Since we're now going to push something to a queue
+     * that's effectively not locked, the locks should now
+     * be released */
+    unsigned int   valueMask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
+
+    /* Now rearm it */
+    EXPECT_CALL (asyncServerWindow, hasCustomShape ()).WillOnce (Return (false));
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _));
+    EXPECT_CALL (*lock, lock ());
+
+    buffer->pushFrameRequest (xwc, valueMask);
+}
+
+TEST_F (ConfigureRequestBufferLockBehaviour, NoRearmBufferLockOnNoRelease)
+{
+    MockLock::Ptr    second (boost::make_shared <MockLock> ());
+    mockLockFactory.QueueLockForCreation (second);
+
+    /* Locks get armed on construction */
+    EXPECT_CALL (*lock, lock ());
+    EXPECT_CALL (*second, lock ());
+
+    crb::Releasable::Ptr releasable (buffer->obtainLock ());
+    crb::Releasable::Ptr otherReleasable (buffer->obtainLock ());
+
+    /* We are releasing this lock */
+    EXPECT_CALL (*lock, release ());
+
+    /* No call to requestConfigureOnFrame if there's nothing to be configured */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    /* No rearm - we haven't released it */
+    EXPECT_CALL (*lock, lock ()).Times (0);
+
+    releasable->release ();
+}
+
+TEST_F (ConfigureRequestBufferLockBehaviour, QueryAttributesDispatchAndRearm)
+{
+    /* Locks get armed on construction */
+    EXPECT_CALL (*lock, lock ());
+
+    crb::Releasable::Ptr releasable (buffer->obtainLock ());
+
+    unsigned int valueMask = CWX | CWY;
+
+    /* Queue locked */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    /* Queue forceably unlocked, locks rearmed */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _));
+    EXPECT_CALL (*lock, lock ());
+
+    /* Expect a call to XGetWindowAttributes */
+    EXPECT_CALL (syncServerWindow, queryShapeRectangles (_, _, _))
+	    .WillOnce (
+		ReturnNull ());
+
+    int a, b;
+
+    EXPECT_THAT (buffer->queryShapeRectangles (0, &a, &b), IsNull ());
+}
+
+TEST_F (ConfigureRequestBufferLockBehaviour, QueryFrameAttributesDispatchAndRearm)
+{
+    /* Locks get armed on construction */
+    EXPECT_CALL (*lock, lock ());
+
+    crb::Releasable::Ptr releasable (buffer->obtainLock ());
+
+    unsigned int valueMask = CWX | CWY;
+
+    /* Queue locked */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    /* Queue forceably unlocked, locks rearmed */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _));
+    EXPECT_CALL (*lock, lock ());
+
+    /* Expect a call to XGetWindowAttributes */
+    XWindowAttributes xwa;
+    EXPECT_CALL (syncServerWindow, queryFrameAttributes (_))
+	    .WillOnce (
+		DoAll (
+		    SetArgReferee <0> (xwa),
+		    Return (true)));
+
+    buffer->queryFrameAttributes (xwa);
+}
+
+TEST_F (ConfigureRequestBufferLockBehaviour, QueryShapeRectanglesDispatchAndRearm)
+{
+    /* Locks get armed on construction */
+    EXPECT_CALL (*lock, lock ());
+
+    crb::Releasable::Ptr releasable (buffer->obtainLock ());
+
+    unsigned int valueMask = CWX | CWY;
+
+    /* Queue locked */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    /* Queue forceably unlocked, locks rearmed */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _));
+    EXPECT_CALL (*lock, lock ());
+
+    /* Expect a call to XGetWindowAttributes */
+    XWindowAttributes xwa;
+    EXPECT_CALL (syncServerWindow, queryFrameAttributes (_))
+	    .WillOnce (
+		DoAll (
+		    SetArgReferee <0> (xwa),
+		    Return (true)));
+
+    buffer->queryFrameAttributes (xwa);
+}
+
+TEST_F (ConfigureRequestBufferLockBehaviour, ForceReleaseDispatchAndRearm)
+{
+    /* Locks get armed on construction */
+    EXPECT_CALL (*lock, lock ());
+
+    crb::Releasable::Ptr releasable (buffer->obtainLock ());
+
+    unsigned int valueMask = CWX | CWY;
+
+    /* Queue locked */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    /* Queue forceably unlocked, locks rearmed */
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _));
+    EXPECT_CALL (*lock, lock ());
+
+    /* Force release */
+    buffer->forceRelease ();
+}
+

=== modified file 'src/window.cpp'
--- src/window.cpp	2012-12-07 09:28:03 +0000
+++ src/window.cpp	2012-12-07 18:08:24 +0000
@@ -37,6 +37,7 @@
 #include <math.h>
 
 #include <boost/bind.hpp>
+#include <boost/make_shared.hpp>
 
 #include <core/icon.h>
 #include <core/atoms.h>
@@ -45,8 +46,13 @@
 #include "privatescreen.h"
 #include "privatestackdebugger.h"
 
+#include "configurerequestbuffer-impl.h"
+
 #include <boost/scoped_array.hpp>
 
+namespace crb = compiz::window::configure_buffers;
+namespace cw = compiz::window;
+
 template class WrapableInterface<CompWindow, WindowInterface>;
 
 PluginClassStorage::Indices windowPluginClassIndices (0);
@@ -912,10 +918,12 @@
 	/* We should update the server here */
 	XSync (screen->dpy (), false);
 
-	boundingShapeRects = XShapeGetRectangles (screen->dpy (), priv->id,
-					 	  ShapeBounding, &nBounding, &order);
-	inputShapeRects = XShapeGetRectangles (screen->dpy (), priv->id,
-					       ShapeInput, &nInput, &order);
+	boundingShapeRects = priv->queryShapeRectangles (ShapeBounding,
+							 &nBounding,
+							 &order);
+	inputShapeRects = priv->queryShapeRectangles (ShapeInput,
+						      &nBounding,
+						      &order);
     }
 
     r.x      = -geom.border ();
@@ -2961,6 +2969,80 @@
     return pc->matchRequest (xwc, valueMask);
 }
 
+bool
+PrivateWindow::queryAttributes (XWindowAttributes &attrib)
+{
+    return configureBuffer->queryAttributes (attrib);
+}
+
+bool
+PrivateWindow::queryFrameAttributes (XWindowAttributes &attrib)
+{
+    return configureBuffer->queryFrameAttributes (attrib);
+}
+
+XRectangle *
+PrivateWindow::queryShapeRectangles (int kind, int *count, int *ordering)
+{
+    return configureBuffer->queryShapeRectangles (kind, count, ordering);
+}
+
+int
+PrivateWindow::requestConfigureOnClient (const XWindowChanges &xwc,
+					 unsigned int valueMask)
+{
+    int ret = XConfigureWindow (screen->dpy (),
+				id,
+				valueMask,
+				const_cast <XWindowChanges *> (&xwc));
+
+    return ret;
+}
+
+int
+PrivateWindow::requestConfigureOnWrapper (const XWindowChanges &xwc,
+					  unsigned int valueMask)
+{
+    return XConfigureWindow (screen->dpy (),
+			     wrapper,
+			     valueMask,
+			     const_cast <XWindowChanges *> (&xwc));
+}
+
+int
+PrivateWindow::requestConfigureOnFrame (const XWindowChanges &xwc,
+					unsigned int frameValueMask)
+{
+    XWindowChanges wc = xwc;
+
+    wc.x      = serverFrameGeometry.x ();
+    wc.y      = serverFrameGeometry.y ();
+    wc.width  = serverFrameGeometry.width ();
+    wc.height = serverFrameGeometry.height ();
+
+    compiz::X11::PendingEvent::Ptr pc (
+	new compiz::X11::PendingConfigureEvent (
+	    screen->dpy (),
+	    priv->serverFrame,
+	    frameValueMask, &wc));
+
+    pendingConfigures.add (pc);
+
+    return XConfigureWindow (screen->dpy (), serverFrame, frameValueMask, &wc);
+}
+
+void
+PrivateWindow::sendSyntheticConfigureNotify ()
+{
+    window->sendConfigureNotify ();
+}
+
+bool
+PrivateWindow::hasCustomShape () const
+{
+    return false;
+}
+
 void
 PrivateWindow::reconfigureXWindow (unsigned int   valueMask,
 				   XWindowChanges *xwc)
@@ -3173,47 +3255,41 @@
     if (serverFrame)
     {
 	if (frameValueMask)
-	{
-	    XWindowChanges wc = *xwc;
-
-	    wc.x      = serverFrameGeometry.x ();
-	    wc.y      = serverFrameGeometry.y ();
-	    wc.width  = serverFrameGeometry.width ();
-	    wc.height = serverFrameGeometry.height ();
-
-	    compiz::X11::PendingEvent::Ptr pc =
-		    boost::shared_static_cast<compiz::X11::PendingEvent> (compiz::X11::PendingConfigureEvent::Ptr (
-									      new compiz::X11::PendingConfigureEvent (
-										  screen->dpy (), priv->serverFrame, frameValueMask, &wc)));
-
-	    pendingConfigures.add (pc);
-
-	    XConfigureWindow (screen->dpy (), serverFrame, frameValueMask, &wc);
-	}
-
-	valueMask &= ~(CWSibling | CWStackMode);
+	    priv->configureBuffer->pushFrameRequest (*xwc, frameValueMask);
+
+	valueMask = frameValueMask & (CWWidth | CWHeight);
 
 	/* If the frame has changed position (eg, serverInput.top
 	 * or serverInput.left have changed) then we also need to
 	 * update the client and wrapper position */
-	if (!(valueMask & CWX))
-	    valueMask |= frameValueMask & CWX;
-	if (!(valueMask & CWY))
-	    valueMask |= frameValueMask & CWY;
+	if (lastServerInput.left != serverInput.left)
+	    valueMask |= CWX;
+	if (lastServerInput.top != serverInput.top)
+	    valueMask |= CWY;
+
+	if (lastServerInput.right != serverInput.right)
+	    valueMask |= CWWidth;
+	if (lastServerInput.bottom != serverInput.bottom)
+	    valueMask |= CWHeight;
 
 	if (valueMask)
 	{
 	    xwc->x = serverInput.left;
 	    xwc->y = serverInput.top;
-	    XConfigureWindow (screen->dpy (), wrapper, valueMask, xwc);
-
-	    xwc->x = 0;
-	    xwc->y = 0;
+
+	    lastServerInput = serverInput;
+
+	    priv->configureBuffer->pushWrapperRequest (*xwc, valueMask);
 	}
     }
 
+    /* Client is reparented, the only things that can change
+     * are the width, height and border width */
+    if (serverFrame)
+	valueMask &= (CWWidth | CWHeight | CWBorderWidth);
+
     if (valueMask)
-	XConfigureWindow (screen->dpy (), id, valueMask, xwc);
+	priv->configureBuffer->pushClientRequest (*xwc, valueMask);
 
     /* Send the synthetic configure notify
      * after the real configure notify arrives
@@ -5655,6 +5731,24 @@
     return priv->struts;
 }
 
+bool
+CompWindow::queryAttributes (XWindowAttributes &attrib)
+{
+    return priv->queryAttributes (attrib);
+}
+
+bool
+CompWindow::queryFrameAttributes (XWindowAttributes &attrib)
+{
+    return priv->queryFrameAttributes (attrib);
+}
+
+crb::Releasable::Ptr
+CompWindow::obtainLockOnConfigureRequests ()
+{
+    return priv->configureBuffer->obtainLock ();
+}
+
 int &
 CompWindow::saveMask () const
 {
@@ -6193,6 +6287,55 @@
     delete priv;
 }
 
+X11SyncServerWindow::X11SyncServerWindow (Display      *dpy,
+					  const Window *w,
+					  const Window *frame) :
+    mDpy (dpy),
+    mWindow (w),
+    mFrame (frame)
+{
+}
+
+bool
+X11SyncServerWindow::queryAttributes (XWindowAttributes &attrib)
+{
+    if (XGetWindowAttributes (mDpy, *mWindow, &attrib))
+	return true;
+
+    return false;
+}
+
+bool
+X11SyncServerWindow::queryFrameAttributes (XWindowAttributes &attrib)
+{
+    Window w = *mFrame ? *mFrame : *mWindow;
+
+    if (XGetWindowAttributes (mDpy, w, &attrib))
+	return true;
+
+    return false;
+}
+
+XRectangle *
+X11SyncServerWindow::queryShapeRectangles (int kind,
+					   int *count,
+					   int *ordering)
+{
+    return XShapeGetRectangles (mDpy, *mWindow,
+				kind,
+				count,
+				ordering);
+}
+
+namespace
+{
+crb::BufferLock::Ptr
+createConfigureBufferLock (crb::CountedFreeze *cf)
+{
+    return boost::make_shared <crb::ConfigureBufferLock> (cf);
+}
+}
+
 PrivateWindow::PrivateWindow () :
     priv (this),
     refcnt (1),
@@ -6264,27 +6407,27 @@
 
     syncWait (false),
     closeRequests (false),
-    lastCloseRequestTime (0)
+    lastCloseRequestTime (0),
+
+    syncServerWindow (screen->dpy (),
+		      &id,
+		      &serverFrame),
+    configureBuffer (
+	crb::ConfigureRequestBuffer::Create (
+	    this,
+	    &syncServerWindow,
+	    boost::bind (createConfigureBufferLock, _1)))
 {
     input.left   = 0;
     input.right  = 0;
     input.top    = 0;
     input.bottom = 0;
 
-    serverInput.left   = 0;
-    serverInput.right  = 0;
-    serverInput.top    = 0;
-    serverInput.bottom = 0;
-
-    border.top    = 0;
-    border.bottom = 0;
-    border.left   = 0;
-    border.right  = 0;
-
-    output.left   = 0;
-    output.right  = 0;
-    output.top    = 0;
-    output.bottom = 0;
+    /* Zero initialize */
+    serverInput = input;
+    lastServerInput = input;
+    border = input;
+    output = input;
 
     syncWaitTimer.setTimes (1000, 1200);
     syncWaitTimer.setCallback (boost::bind (&PrivateWindow::handleSyncAlarm,
@@ -6554,7 +6697,11 @@
     XSync (dpy, false);
     XGrabServer (dpy);
 
-    if (!XGetWindowAttributes (dpy, id, &wa))
+    /* We need to flush all queued up requests */
+    foreach (CompWindow *w, screen->windows ())
+	w->priv->configureBuffer->forceRelease ();
+
+    if (!window->priv->queryAttributes (wa))
     {
 	XUngrabServer (dpy);
 	XSync (dpy, false);
@@ -6841,7 +6988,7 @@
 	 * a DestroyNotify for it yet, it is possible that restacking
 	 * operations could occurr relative to it so we need to hold it
 	 * in the stack for now. Ensure that it is marked override redirect */
-	XGetWindowAttributes (screen->dpy (), serverFrame, &attrib);
+	window->priv->queryFrameAttributes (attrib);
 
 	/* Put the frame window "above" the client window
 	 * in the stack */