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)

[lp:~compiz-team/compiz/compiz.performance_1027211.2]

3535. By Sam Spilsbury on 2012-12-07

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

3536. By Sam Spilsbury on 2012-12-07

Fix assertion failures

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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 17:16:21 +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 */