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

[Sam Spilsbury]

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.

Resubmitted with (LP: #1089279 fixed)

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.

Demonstrable numbers: moving opengl-rendered window around with vsync enabled in the driver goes from a constantly-diminishing 1FPS to staying consistent at around 12FPS, with 60FPS if "lazy positioning" is enabled in the move plugin (disabled by default)

I've also added some further integration testing framework around this - with a "testhelper" plugin to facilitate communication between the test and compiz for requests that aren't usually exposed over EWMH or ICCCM.

[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

[Sam Spilsbury (smspillaz)]

I've fixed (LP: #1089279) by forcing any changes to the size of the window to release the queue immediately. Also to be on the safe side, I've made it so that changes to clients or the wrapper window release the queue immediately. We can have a look into those a bit later.

I can understand if you don't want to merge this for this year and wait until later until we have more testing. I've been setting up a ppa with a bunch of performance related things at ppa:smspillaz/compiz-experimental .

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Sam Spilsbury (smspillaz)]

Somehow this was merged. It shouldn't have been, see https://lists.launchpad.net/unity-dev/msg00597.html

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3557
http://jenkins.qa.ubuntu.com/job/compiz-ci/40/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/77/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/429/console

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

review: Approve (continuous-integration)

[MC Return (mc-return)]

Tested this. Moved around and resized windows. Could not spot any obvious regressions.
+1

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3558
http://jenkins.qa.ubuntu.com/job/compiz-ci/63/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/100/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/452/console

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

review: Needs Fixing (continuous-integration)

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

3559. By Sam Spilsbury on 2013-02-20

Merge lp:compiz

3560. By Sam Spilsbury on 2013-02-20

The Find* modules might go inside the xorg-gtest build process before we get a chance to set COMPIZ_INTERNAL_INCLUDES, set it first

3561. By Sam Spilsbury on 2013-02-20

Specify whether or not the plugin should be installed

3562. By Sam Spilsbury on 2013-02-20

NOINSTALL is not a library

3563. By Sam Spilsbury on 2013-02-20

Minor indent fix

3564. By Sam Spilsbury on 2013-02-20

Also ensure we don't install any schemas, metadata, data, images etc

3565. By Sam Spilsbury on 2013-02-20

s/plugin/COMPIZ_CURRENT_PLUGIN/

3566. By Sam Spilsbury on 2013-02-21

Merge lp:compiz

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-02-15 11:28:27 +0000
+++ CMakeLists.txt	2013-02-19 15:13:21 +0000
@@ -179,6 +179,22 @@
 
 endif (COMPIZ_BUILD_TESTING)
 
+set (COMPIZ_INTERNAL_INCLUDES
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/timer/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/string/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/pluginclasshandler/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/point/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/rect/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/servergrab/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/region/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/window/geometry/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/window/geometry-saver/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/window/extents/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/window/constrainment/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/logmessage/include)
+
 # Add the rest of compiz
 add_subdirectory (cmake)
 add_subdirectory (include)

=== modified file 'include/core/CMakeLists.txt'
--- include/core/CMakeLists.txt	2012-12-13 10:12:23 +0000
+++ include/core/CMakeLists.txt	2013-02-19 15:13: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	2013-02-19 15:13: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	2013-01-03 16:06:41 +0000
+++ include/core/window.h	2013-02-19 15:13:21 +0000
@@ -54,13 +54,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 ())
 
@@ -529,6 +542,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/CMakeLists.txt'
--- plugins/CMakeLists.txt	2013-02-12 02:43:44 +0000
+++ plugins/CMakeLists.txt	2013-02-19 15:13:21 +0000
@@ -7,23 +7,7 @@
 
 add_definitions ( -DHAVE_CONFIG_H)
 
-include_directories( 
-  ${CMAKE_CURRENT_SOURCE_DIR}/../include
-  
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src/timer/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src/string/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src/pluginclasshandler/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src/point/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src/rect/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src/servergrab/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src/region/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src/window/geometry/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src/window/geometry-saver/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src/window/extents/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/../src/window/constrainment/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/../logmessage/include
-)
+include_directories (${COMPIZ_INTERNAL_INCLUDES})
 
 # temporarily disable plugins that aren't ported yet
 set (COMPIZ_DISABLE_PLUGIN_ANIMATIONADDON ON)

=== modified file 'plugins/composite/src/window.cpp'
--- plugins/composite/src/window.cpp	2012-12-13 10:12:23 +0000
+++ plugins/composite/src/window.cpp	2013-02-19 15:13: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-12-13 10:12:23 +0000
+++ plugins/move/move.xml.in	2013-02-19 15:13: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-13 10:12:23 +0000
+++ plugins/move/src/move.cpp	2013-02-19 15:13: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-12-13 10:12:23 +0000
+++ plugins/move/src/move.h	2013-02-19 15:13: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	2013-01-01 10:04:50 +0000
+++ plugins/opengl/src/paint.cpp	2013-02-19 15:13:21 +0000
@@ -418,6 +418,11 @@
 	if (w->destroyed ())
 	    continue;
 
+        gw = GLWindow::get (w);
+
+        /* Release any queued ConfigureWindow requests now */
+        gw->priv->configureLock->release ();
+
 	if (unredirected.find (w) != unredirected.end ())
 	    continue;
 
@@ -427,8 +432,6 @@
 		continue;
 	}
 
-	gw = GLWindow::get (w);
-
 	const CompRegion &clip =
 	    (!(mask & PAINT_SCREEN_NO_OCCLUSION_DETECTION_MASK)) ?
 	    gw->clip () : region;

=== modified file 'plugins/opengl/src/privates.h'
--- plugins/opengl/src/privates.h	2013-01-01 09:41:41 +0000
+++ plugins/opengl/src/privates.h	2013-02-19 15:13: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>
@@ -283,6 +284,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-12-13 10:12:23 +0000
+++ plugins/opengl/src/window.cpp	2013-02-19 15:13: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-12-13 10:12:23 +0000
+++ src/CMakeLists.txt	2013-02-19 15:13: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	2013-02-19 15:13: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	2013-02-19 15:13: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	2013-02-19 15:13:21 +0000
@@ -0,0 +1,363 @@
+/*
+ * 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 <cstdio>
+#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);
+
+    /* This is a stop-gap solution for not having a plugin API to
+     * query the window shape. Once we have that, we can safely
+     * remove these and require the queue to be unlocked when that
+     * happens. Its a separate unit of work for improving resize
+     * performance anyways.
+     */
+    immediate |= (frameChangeMask & (CWWidth | CWHeight | CWBorderWidth));
+    immediate |= (wrapperChangeMask & (CWWidth | CWHeight | CWBorderWidth | CWX | CWY));
+    immediate |= (clientChangeMask & (CWWidth | CWHeight | CWBorderWidth | CWX | CWY));
+    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	2013-01-03 16:06:41 +0000
+++ src/event.cpp	2013-02-19 15:13:21 +0000
@@ -1947,7 +1947,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/plugin.cpp'
--- src/plugin.cpp	2013-01-24 14:18:03 +0000
+++ src/plugin.cpp	2013-02-19 15:13:21 +0000
@@ -398,6 +398,7 @@
 CompPlugin *
 CompPlugin::load (const char *name)
 {
+    char *compiz_plugin_dir_override = getenv ("COMPIZ_PLUGIN_DIR");
     std::auto_ptr<CompPlugin>p(new CompPlugin ());
 
     p->devPrivate.uval = 0;
@@ -406,6 +407,12 @@
 
     compLogMessage (here, CompLogLevelInfo, "Loading plugin: %s", name);
 
+    if (compiz_plugin_dir_override)
+    {
+	if (loaderLoadPlugin (p.get (), compiz_plugin_dir_override, name))
+	    return p.release ();
+    }
+
     if (char* home = getenv ("HOME"))
     {
         boost::scoped_array<char> plugindir(new char [strlen (home) + strlen (HOME_PLUGINDIR) + 3]);

=== modified file 'src/plugin/tests/CMakeLists.txt'
--- src/plugin/tests/CMakeLists.txt	2012-08-01 00:42:38 +0000
+++ src/plugin/tests/CMakeLists.txt	2013-02-19 15:13:21 +0000
@@ -5,6 +5,7 @@
 
   ${compiz_SOURCE_DIR}/include
   ${compiz_SOURCE_DIR}/src
+  ${compiz_SOURCE_DIR}/tests/shared
 )
 
 add_definitions (

=== modified file 'src/plugin/tests/test-plugin.cpp'
--- src/plugin/tests/test-plugin.cpp	2012-06-24 09:00:27 +0000
+++ src/plugin/tests/test-plugin.cpp	2013-02-19 15:13:21 +0000
@@ -9,6 +9,7 @@
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
+#include <gtest_shared_tmpenv.h>
 
 namespace {
 
@@ -136,6 +137,34 @@
     CompPlugin::unload(cp);
 }
 
+TEST(PluginTest, load_plugin_from_COMPIZ_PLUGIN_DIR_env_succeeds)
+{
+    const char *COMPIZ_PLUGIN_DIR_VALUE = "/path/to/plugin/dir";
+    TmpEnv env ("COMPIZ_PLUGIN_DIR", COMPIZ_PLUGIN_DIR_VALUE);
+    MockPluginFilesystem mockfs;
+
+    using namespace testing;
+
+    EXPECT_CALL(mockfs, LoadPlugin(Ne((void*)0), EndsWith(COMPIZ_PLUGIN_DIR_VALUE), StrEq("dummy"))).
+	WillOnce(Return(true));
+
+    EXPECT_CALL(mockfs, LoadPlugin(Ne((void*)0), EndsWith(HOME_PLUGINDIR), StrEq("dummy"))).
+	Times(AtMost(0));
+
+    EXPECT_CALL(mockfs, LoadPlugin(Ne((void*)0), EndsWith(PLUGINDIR), StrEq("dummy"))).
+	Times(AtMost(0));
+
+    EXPECT_CALL(mockfs, LoadPlugin(Ne((void*)0), Eq((void*)0), StrEq("dummy"))).
+	    Times(AtMost(0));
+
+    EXPECT_CALL(mockfs, UnloadPlugin(_)).Times(1);
+
+    CompPlugin* cp = CompPlugin::load("dummy");
+    ASSERT_NE((void*)0, cp);
+
+    CompPlugin::unload(cp);
+}
+
 TEST(PluginTest, load_plugin_from_void_succeeds)
 {
     MockPluginFilesystem mockfs;

=== modified file 'src/privatewindow.h'
--- src/privatewindow.h	2013-01-03 16:06:41 +0000
+++ src/privatewindow.h	2013-02-19 15:13: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 ();
@@ -382,6 +422,7 @@
 
 	CompWindowExtents input;
 	CompWindowExtents serverInput;
+	CompWindowExtents lastServerInput;
 	CompWindowExtents border;
 	CompWindowExtents output;
 
@@ -407,6 +448,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	2013-02-19 15:13: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	2013-01-03 16:06:41 +0000
+++ src/tests/CMakeLists.txt	2013-02-19 15:13:21 +0000
@@ -30,3 +30,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	2013-02-19 15:13:21 +0000
@@ -0,0 +1,667 @@
+/*
+ * 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 | CWBorderWidth |
+			       CWSibling | CWStackMode;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnClient (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    buffer->pushClientRequest (xwc, valueMask);
+}
+
+TEST_F (ConfigureRequestBufferDispatch, PushDirectWrapperUpdate)
+{
+    unsigned int   valueMask = CWX | CWY | CWBorderWidth |
+			       CWSibling | CWStackMode;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnWrapper (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    buffer->pushWrapperRequest (xwc, valueMask);
+}
+
+TEST_F (ConfigureRequestBufferDispatch, PushDirectFrameUpdate)
+{
+    unsigned int   valueMask = CWX | CWY | CWBorderWidth |
+			       CWSibling | CWStackMode;
+
+    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;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    valueMask |= CWY;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (_, _)).Times (0);
+
+    buffer->pushFrameRequest (xwc, valueMask);
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    lock->release ();
+}
+
+/*
+ * This test is disabled until we can expose the QueryShapeRectangles API
+ * to plugins
+ */
+TEST_F (ConfigureRequestBufferDispatch, DISABLED_PushUpdateLockedReleaseInOrder)
+{
+    crb::Releasable::Ptr lock (buffer->obtainLock ());
+
+    unsigned int   valueMask = CWX | CWY;
+
+    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, 0);
+    buffer->pushFrameRequest (xwc, 0);
+
+    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;
+
+    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;
+
+    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, ForceImmediateConfigureOnWindowSizeChange)
+{
+    crb::Releasable::Ptr lock (buffer->obtainLock ());
+
+    unsigned int   valueMask = CWWidth | CWHeight | CWBorderWidth;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnFrame (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    buffer->pushFrameRequest (xwc, valueMask);
+}
+
+TEST_F (ConfigureRequestBufferDispatch, ForceImmediateConfigureOnClientReposition)
+{
+    crb::Releasable::Ptr lock (buffer->obtainLock ());
+
+    unsigned int   valueMask = CWX | CWY;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnClient (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    buffer->pushClientRequest (xwc, valueMask);
+}
+
+TEST_F (ConfigureRequestBufferDispatch, ForceImmediateConfigureOnWrapperReposition)
+{
+    crb::Releasable::Ptr lock (buffer->obtainLock ());
+
+    unsigned int   valueMask = CWX | CWY;
+
+    EXPECT_CALL (asyncServerWindow, requestConfigureOnWrapper (MaskXWC (xwc, valueMask),
+					       valueMask));
+
+    buffer->pushWrapperRequest (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;
+
+    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;
+
+    /* Now rearm it */
+    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	2013-02-18 22:51:33 +0000
+++ src/window.cpp	2013-02-19 15:13: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);
@@ -3028,6 +3034,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)
@@ -3240,47 +3320,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 - lastServerInput.left !=
+	    serverInput.right - serverInput.left)
+	    valueMask |= CWWidth;
+	if (lastServerInput.bottom - lastServerInput.top !=
+	    serverInput.bottom - serverInput.top)
+	    valueMask |= CWHeight;
 
 	if (valueMask)
 	{
 	    xwc->x = serverInput.left;
 	    xwc->y = serverInput.top;
-	    XConfigureWindow (screen->dpy (), wrapper, valueMask, xwc);
 
-	    xwc->x = 0;
-	    xwc->y = 0;
+	    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
@@ -5811,6 +5885,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
 {
@@ -6349,6 +6441,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),
@@ -6420,27 +6561,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,
@@ -6648,6 +6789,9 @@
 	 * whenever the frame extents update
 	 * so that plugins can re-position appropriately */
 	moveNotify (0, 0, true);
+
+	/* Once we have updated everything, re-set lastServerInput */
+	priv->lastServerInput = priv->serverInput;
     }
 
     /* Use b for _NET_WM_FRAME_EXTENTS here because
@@ -6710,7 +6854,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);
@@ -6997,7 +7145,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 */

=== modified file 'tests/acceptance-tests/xorg-gtest/tests/compiz_acceptance_replace_current_wm.cpp'
--- tests/acceptance-tests/xorg-gtest/tests/compiz_acceptance_replace_current_wm.cpp	2012-12-05 03:40:20 +0000
+++ tests/acceptance-tests/xorg-gtest/tests/compiz_acceptance_replace_current_wm.cpp	2013-02-19 15:13:21 +0000
@@ -101,6 +101,7 @@
     TmpEnv env ("XORG_GTEST_CHILD_STDOUT", "1");
     ProcessPtr compiz (boost::make_shared <ct::CompizProcess> (Display (),
 							       ct::CompizProcess::WaitForStartupMessage,
+							       ct::CompizProcess::PluginList (),
 							       3000));
 
     pid_t firstProcessPid = compiz->Pid ();
@@ -130,6 +131,7 @@
     TmpEnv env ("XORG_GTEST_CHILD_STDOUT", "1");
     ProcessPtr firstCompiz (boost::make_shared <ct::CompizProcess> (Display (),
 								    ct::CompizProcess::WaitForStartupMessage,
+								    ct::CompizProcess::PluginList (),
 								    3000));
 
     /* Expect it to exit */
@@ -142,6 +144,7 @@
 								     static_cast <ct::CompizProcess::StartupFlags> (
 									ct::CompizProcess::WaitForStartupMessage |
 									ct::CompizProcess::ReplaceCurrentWM),
+								     ct::CompizProcess::PluginList (),
 								     maximumWaitTime));
 
     if (!task->ReadMsgFromTask (PROCESS_EXITED_MSG, maximumWaitTime))
@@ -223,6 +226,7 @@
     TmpEnv env ("XORG_GTEST_CHILD_STDOUT", "1");
     ProcessPtr firstCompiz (boost::make_shared <ct::CompizProcess> (dpy,
 								    ct::CompizProcess::WaitForStartupMessage,
+								    ct::CompizProcess::PluginList (),
 								    3000));
 
     SlowDownTask::GetProcessState procState (boost::bind (&ct::CompizProcess::State,
@@ -244,6 +248,7 @@
 								     static_cast <ct::CompizProcess::StartupFlags> (
 									ct::CompizProcess::ReplaceCurrentWM |
 									ct::CompizProcess::WaitForStartupMessage),
+								     ct::CompizProcess::PluginList (),
 								     maximumWaitTime));
 
     /* Wait until the first one goes away */

=== modified file 'tests/system/xorg-gtest/CMakeLists.txt'
--- tests/system/xorg-gtest/CMakeLists.txt	2013-02-12 04:33:31 +0000
+++ tests/system/xorg-gtest/CMakeLists.txt	2013-02-19 15:13:21 +0000
@@ -1,5 +1,42 @@
+<<<<<<< TREE
 if (BUILD_XORG_GTEST)
 
+=======
+include (FindPkgConfig)
+
+pkg_check_modules (XORG_SERVER xorg-gtest xorg-server x11)
+
+option (BUILD_XORG_GTEST "Build Xorg GTest integration tests" OFF)
+
+if (XORG_SERVER_FOUND AND BUILD_XORG_GTEST)
+
+    execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=prefix xorg-gtest OUTPUT_VARIABLE _xorg_gtest_prefix)
+    execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=includedir xorg-gtest OUTPUT_VARIABLE _xorg_gtest_include_dir)
+    execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=sourcedir xorg-gtest OUTPUT_VARIABLE _xorg_gtest_source_dir)
+    execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=CPPflags xorg-gtest OUTPUT_VARIABLE _xorg_gtest_cflags)
+
+    string (STRIP ${_xorg_gtest_prefix} _xorg_gtest_prefix)
+    string (STRIP ${_xorg_gtest_include_dir} _xorg_gtest_include_dir)
+    string (STRIP ${_xorg_gtest_source_dir} _xorg_gtest_source_dir)
+    string (STRIP ${_xorg_gtest_cflags} _xorg_gtest_cflags)
+
+    set (XORG_SERVER_INCLUDE_XORG_GTEST ${_xorg_gtest_include_dir} CACHE PATH "Path to Xorg GTest Headers")
+    set (XORG_SERVER_GTEST_SRC ${_xorg_gtest_source_dir} CACHE PATH "Path to Xorg GTest Sources")
+    set (COMPIZ_XORG_SYSTEM_TEST_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include CACHE PATH "Path to Compiz Xorg GTest Headers")
+    set (COMPIZ_OVERRIDE_PLUGIN_PATH ${CMAKE_CURRENT_BINARY_DIR}/tests/plugins/testhelper CACHE PATH "Override plugin path for system tests" FORCE)
+    
+    message (STATUS "Found xorg-gtest sources at " ${XORG_SERVER_GTEST_SRC})
+
+    set (COMPIZ_XORG_GTEST_COMMUNICATOR_INCLUDE_DIR
+         ${CMAKE_CURRENT_SOURCE_DIR}/communicator/)
+    set (COMPIZ_XORG_GTEST_COMMUNICATOR_LIBRARY_DIR
+         ${CMAKE_CURRENT_BINARY_DIR}/communicator)
+    set (COMPIZ_XORG_GTEST_COMMUNICATOR_LIBRARY
+         compiz_xorg_gtest_communicator)
+
+    add_subdirectory (communicator)
+    add_subdirectory (src)
+>>>>>>> MERGE-SOURCE
     add_subdirectory (tests)
 
 endif (BUILD_XORG_GTEST)

=== added directory 'tests/system/xorg-gtest/communicator'
=== added file 'tests/system/xorg-gtest/communicator/CMakeLists.txt'
--- tests/system/xorg-gtest/communicator/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/system/xorg-gtest/communicator/CMakeLists.txt	2013-02-19 15:13:21 +0000
@@ -0,0 +1,17 @@
+include (FindPkgConfig)
+
+pkg_check_modules (COMPIZ_XORG_GTEST_COMMUNICATOR x11)
+
+if (COMPIZ_XORG_GTEST_COMMUNICATOR_FOUND)
+
+    include_directories (${COMPIZ_XORG_GTEST_COMMUNICATOR_INCLUDE_DIRS}
+			 ${CMAKE_CURRENT_SOURCE_DIR})
+    link_directories (${COMPIZ_XORG_GTEST_COMMUNICATOR_LIBRARY_DIRS})
+
+    add_library (${COMPIZ_XORG_GTEST_COMMUNICATOR_LIBRARY} STATIC
+                 ${CMAKE_CURRENT_SOURCE_DIR}/compiz_xorg_gtest_communicator.cpp)
+
+    target_link_libraries (${COMPIZ_XORG_GTEST_COMMUNICATOR_LIBRARY}
+                           ${COMPIZ_XORG_GTEST_COMMUNICATOR_LIBRARIES})
+
+endif (COMPIZ_XORG_GTEST_COMMUNICATOR_FOUND)

=== added file 'tests/system/xorg-gtest/communicator/compiz_xorg_gtest_communicator.cpp'
--- tests/system/xorg-gtest/communicator/compiz_xorg_gtest_communicator.cpp	1970-01-01 00:00:00 +0000
+++ tests/system/xorg-gtest/communicator/compiz_xorg_gtest_communicator.cpp	2013-02-19 15:13:21 +0000
@@ -0,0 +1,200 @@
+/*
+* Copyright © 2013 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
+* Novell, Inc. not be used in advertising or publicity pertaining to
+* distribution of the software without specific, written prior permission.
+* Novell, Inc. makes no representations about the suitability of this
+* software for any purpose. It is provided "as is" without express or
+* implied warranty.
+*
+* NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+* NO EVENT SHALL NOVELL, INC. 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.
+*
+* Author: Sam Spilsbury <[e-mail]>
+*/
+
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <string>
+#include <sstream>
+#include <stdexcept>
+#include <poll.h>
+#include <X11/Xlib.h>
+#include <compiz_xorg_gtest_communicator.h>
+
+namespace compiz
+{
+namespace testing
+{
+namespace messages
+{
+namespace internal
+{
+const char *messages[] =
+{
+    "_COMPIZ_TEST_HELPER_READY",
+    "_COMPIZ_TEST_HELPER_REGISTER_CLIENT",
+    "_COMPIZ_TEST_HELPER_LOCK_CONFIGURE_REQUESTS",
+    "_COMPIZ_TEST_HELPER_CHANGE_FRAME_EXTENTS",
+    "_COMPIZ_TEST_HELPER_FRAME_EXTENTS_CHANGED",
+    "_COMPIZ_TEST_HELPER_CONFIGURE_WINDOW",
+    "_COMPIZ_TEST_HELPER_WINDOW_CONFIGURE_PROCESSED",
+    "_COMPIZ_TEST_HELPER_WINDOW_READY"
+};
+}
+
+const char *TEST_HELPER_READY_MSG = internal::messages[0];
+const char *TEST_HELPER_REGISTER_CLIENT = internal::messages[1];
+const char *TEST_HELPER_LOCK_CONFIGURE_REQUESTS = internal::messages[2];
+const char *TEST_HELPER_CHANGE_FRAME_EXTENTS = internal::messages[3];
+const char *TEST_HELPER_FRAME_EXTENTS_CHANGED = internal::messages[4];
+const char *TEST_HELPER_CONFIGURE_WINDOW = internal::messages[5];
+const char *TEST_HELPER_WINDOW_CONFIGURE_PROCESSED = internal::messages[6];
+const char *TEST_HELPER_WINDOW_READY = internal::messages[7];
+}
+}
+}
+
+namespace ct = compiz::testing;
+namespace ctmi = compiz::testing::messages::internal;
+
+class ct::MessageAtoms::Private
+{
+    public:
+
+	std::map <const char *, Atom> atoms;
+};
+
+ct::MessageAtoms::MessageAtoms (Display *display) :
+    priv (new ct::MessageAtoms::Private)
+{
+    int  nAtoms = sizeof (ctmi::messages) / sizeof (const char *);
+    Atom atoms[nAtoms];
+
+    if (!XInternAtoms (display,
+		       const_cast <char **> (ctmi::messages),
+		       sizeof (ctmi::messages) / sizeof (const char *),
+		       0,
+		       atoms))
+	throw std::runtime_error ("XInternAtoms generated an error");
+
+    for (int i = 0; i < nAtoms; ++i)
+	priv->atoms[ctmi::messages[i]] = atoms[i];
+}
+
+Atom
+ct::MessageAtoms::FetchForString (const char *message)
+{
+    std::map <const char *, Atom>::iterator it (priv->atoms.find (message));
+
+    if (it == priv->atoms.end ())
+    {
+	std::stringstream ss;
+
+	ss << "Atom for message " << message << " does not exist";
+	throw std::runtime_error (ss.str ());
+    }
+
+    return it->second;
+}
+
+namespace
+{
+bool FindClientMessage (Display *display,
+			XEvent  &event,
+			Atom    message)
+{
+    while (XPending (display))
+    {
+	XNextEvent (display, &event);
+
+	if (event.type == ClientMessage)
+	{
+	    if (event.xclient.message_type == message)
+		return true;
+	}
+    }
+
+    return false;
+}
+}
+
+bool
+ct::ReceiveMessage (Display *display,
+		    Atom    message,
+		    XEvent  &event,
+		    int     timeout)
+{
+    if (FindClientMessage (display, event, message))
+	return true;
+    else
+    {
+	XSync (display, false);
+
+	struct pollfd pfd;
+	pfd.events = POLLIN | POLLHUP | POLLERR;
+	pfd.revents = 0;
+	pfd.fd = ConnectionNumber (display);
+
+	poll (&pfd, 1, timeout);
+
+	/* Make sure we get something */
+	if ((pfd.revents & POLLIN) &&
+	    !(pfd.revents & (POLLHUP | POLLERR)))
+	{
+	    return ReceiveMessage (display, message, event, timeout);
+	}
+	else
+	    return false;
+    }
+
+    return false;
+}
+
+void
+ct::SendClientMessage (Display *display,
+		       Atom    message,
+		       Window  destination,
+		       Window  target,
+		       const std::vector<long> &data)
+{
+    if (data.size () > 5)
+	throw std::runtime_error ("data size must be less than 5");
+
+    XEvent event;
+
+    memset (&event, 0, sizeof (XEvent));
+
+    event.type = ClientMessage;
+
+    event.xclient.display = display;
+    event.xclient.send_event = 1;
+    event.xclient.serial = 0;
+
+    event.xclient.message_type = message;
+    event.xclient.window = target;
+    event.xclient.format = 32;
+
+    int count = 0;
+    for (std::vector <long>::const_iterator it = data.begin ();
+	 it != data.end ();
+	 ++it)
+	event.xclient.data.l[count++] = *it;
+
+    XSendEvent (display,
+		destination,
+		0,
+		StructureNotifyMask,
+		&event);
+};

=== added file 'tests/system/xorg-gtest/communicator/compiz_xorg_gtest_communicator.h'
--- tests/system/xorg-gtest/communicator/compiz_xorg_gtest_communicator.h	1970-01-01 00:00:00 +0000
+++ tests/system/xorg-gtest/communicator/compiz_xorg_gtest_communicator.h	2013-02-19 15:13:21 +0000
@@ -0,0 +1,67 @@
+/*
+* Copyright © 2013 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
+* Novell, Inc. not be used in advertising or publicity pertaining to
+* distribution of the software without specific, written prior permission.
+* Novell, Inc. makes no representations about the suitability of this
+* software for any purpose. It is provided "as is" without express or
+* implied warranty.
+*
+* NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+* NO EVENT SHALL NOVELL, INC. 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.
+*
+* Author: Sam Spilsbury <[e-mail]>
+*/
+#ifndef _COMPIZ_XORG_GTEST_COMMUNICATOR_H
+#define _COMPIZ_XORG_GTEST_COMMUNICATOR_H
+
+#include <memory>
+#include <vector>
+
+namespace compiz
+{
+namespace testing
+{
+namespace messages
+{
+extern const char *TEST_HELPER_READY_MSG;
+extern const char *TEST_HELPER_REGISTER_CLIENT;
+extern const char *TEST_HELPER_LOCK_CONFIGURE_REQUESTS;
+extern const char *TEST_HELPER_CHANGE_FRAME_EXTENTS;
+extern const char *TEST_HELPER_FRAME_EXTENTS_CHANGED;
+extern const char *TEST_HELPER_CONFIGURE_WINDOW;
+extern const char *TEST_HELPER_WINDOW_CONFIGURE_PROCESSED;
+extern const char *TEST_HELPER_WINDOW_READY;
+}
+
+
+class MessageAtoms
+{
+    public:
+
+	MessageAtoms (Display *);
+
+	Atom FetchForString (const char *string);
+
+    private:
+
+	class Private;
+	std::auto_ptr <Private> priv;
+};
+
+bool ReceiveMessage (Display *, Atom, XEvent &, int timeout = 1000);
+void SendClientMessage (Display *, Atom, Window, Window, const std::vector <long> &data);
+}
+}
+
+#endif

=== modified file 'tests/system/xorg-gtest/tests/CMakeLists.txt'
--- tests/system/xorg-gtest/tests/CMakeLists.txt	2013-02-19 12:00:19 +0000
+++ tests/system/xorg-gtest/tests/CMakeLists.txt	2013-02-19 15:13:21 +0000
@@ -2,12 +2,15 @@
 
 if (BUILD_XORG_GTEST AND X11_XI_FOUND)
 
+    add_subdirectory (plugins)
+
     include_directories (${compiz_SOURCE_DIR}/tests/shared
                          ${COMPIZ_XORG_SYSTEM_TEST_INCLUDE_DIR}
 			 ${X11_INCLUDE_DIRS}
 			 ${XORG_SERVER_INCLUDE_XORG_GTEST}
 			 ${XORG_SERVER_GTEST_SRC}
-			 ${GTEST_INCLUDE_DIRS})
+                         ${GTEST_INCLUDE_DIRS}
+                         ${COMPIZ_XORG_GTEST_COMMUNICATOR_INCLUDE_DIR})
 
     link_directories (${X11_XI_LIBRARY_DIRS}
                       ${compiz_BINARY_DIR}/tests/shared/src)
@@ -15,6 +18,9 @@
     add_executable (compiz_xorg_gtest_test_window_stacking
 		    ${CMAKE_CURRENT_SOURCE_DIR}/compiz_xorg_gtest_test_window_stacking.cpp)
 
+    add_executable (compiz_xorg_gtest_test_configure_window
+                    ${CMAKE_CURRENT_SOURCE_DIR}/compiz_xorg_gtest_configure_window.cpp)
+
     add_executable (compiz_xorg_gtest_test_icccm
 		    ${CMAKE_CURRENT_SOURCE_DIR}/compiz_xorg_gtest_icccm.cpp)
 
@@ -54,4 +60,9 @@
 
     compiz_discover_tests (compiz_xorg_gtest_test_shape_handling)
 
+    target_link_libraries (compiz_xorg_gtest_test_configure_window
+			   ${COMPIZ_XORG_GTEST_LIBRARIES})
+
+    compiz_discover_tests (compiz_xorg_gtest_test_configure_window)
+
 endif (BUILD_XORG_GTEST AND X11_XI_FOUND)

=== added file 'tests/system/xorg-gtest/tests/compiz_xorg_gtest_configure_window.cpp'
--- tests/system/xorg-gtest/tests/compiz_xorg_gtest_configure_window.cpp	1970-01-01 00:00:00 +0000
+++ tests/system/xorg-gtest/tests/compiz_xorg_gtest_configure_window.cpp	2013-02-19 15:13:21 +0000
@@ -0,0 +1,567 @@
+/*
+ * Compiz XOrg GTest, ConfigureWindow handling
+ *
+ * Copyright (C) 2012 Sam Spilsbury ([e-mail])
+ *
+* Permission to use, copy, modify, distribute, and sell this software
+* and its documentation for any purpose is hereby granted without
+* fee, provided that the above copyright notice appear in all copies
+* and that both that copyright notice and this permission notice
+* appear in supporting documentation, and that the name of
+* Novell, Inc. not be used in advertising or publicity pertaining to
+* distribution of the software without specific, written prior permission.
+* Novell, Inc. makes no representations about the suitability of this
+* software for any purpose. It is provided "as is" without express or
+* implied warranty.
+*
+* NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+* NO EVENT SHALL NOVELL, INC. 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 <list>
+#include <string>
+#include <stdexcept>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <xorg/gtest/xorg-gtest.h>
+#include <compiz-xorg-gtest.h>
+#include <compiz_xorg_gtest_communicator.h>
+
+#include <gtest_shared_tmpenv.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+
+using ::testing::MatchResultListener;
+using ::testing::MakeMatcher;
+using ::testing::Matcher;
+
+namespace ct = compiz::testing;
+
+namespace
+{
+
+bool Advance (Display *d, bool r)
+{
+    return ct::AdvanceToNextEventOnSuccess (d, r);
+}
+
+Window GetTopParent (Display *display,
+		     Window w)
+{
+    Window rootReturn;
+    Window parentReturn = w;
+    Window *childrenReturn;
+    unsigned int nChildrenReturn;
+
+    Window lastParent = 0;
+
+    do
+    {
+	lastParent = parentReturn;
+
+	XQueryTree (display,
+		    lastParent,
+		    &rootReturn,
+		    &parentReturn,
+		    &childrenReturn,
+		    &nChildrenReturn);
+	XFree (childrenReturn);
+    } while (parentReturn != rootReturn);
+
+    return lastParent;
+}
+
+bool QueryGeometry (Display *dpy,
+		    Window w,
+		    int &x,
+		    int &y,
+		    unsigned int &width,
+		    unsigned int &height)
+{
+    Window rootRet;
+    unsigned int  depth, border;
+
+    if (!XGetGeometry (dpy,
+		       w,
+		       &rootRet,
+		       &x,
+		       &y,
+		       &width,
+		       &height,
+		       &depth,
+		       &border))
+	return false;
+
+    return true;
+}
+
+bool WaitForReparentAndMap (Display *dpy,
+			    Window w)
+{
+    bool ret = Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy,
+							     w,
+							     ReparentNotify,
+							     -1,
+							     -1));
+    EXPECT_TRUE (ret);
+    if (!ret)
+	return false;
+
+
+    ret = Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy,
+							w,
+							MapNotify,
+							-1,
+							-1));
+    EXPECT_TRUE (ret);
+    if (!ret)
+	return false;
+
+    return true;
+}
+
+struct ReparentedWindow
+{
+    Window client;
+    Window frame;
+};
+
+typedef boost::function <void (Window)> CreateWaitFunc;
+
+ReparentedWindow
+GetNewWindowAndFrame (Display *dpy, const CreateWaitFunc &waitForCreation)
+{
+    ReparentedWindow w;
+
+    w.client = ct::CreateNormalWindow (dpy);
+    waitForCreation (w.client);
+
+    XMapRaised (dpy, w.client);
+    WaitForReparentAndMap (dpy, w.client);
+
+    w.frame = GetTopParent (dpy, w.client);
+
+    XSelectInput (dpy, w.frame, StructureNotifyMask);
+
+    return w;
+}
+
+bool
+WaitForConfigureNotify (Display *dpy,
+			Window  w,
+			int     x,
+			int     y,
+			int     width,
+			int     height,
+			int     border,
+			Window  above,
+			unsigned int mask)
+{
+    ct::ConfigureNotifyXEventMatcher matcher (above, border, x, y, width, height,
+					      mask);
+
+    return Advance (dpy, ct::WaitForEventOfTypeOnWindowMatching (dpy,
+								 w,
+								 ConfigureNotify,
+								 -1,
+								 -1,
+								 matcher));
+}
+
+}
+
+class CompizXorgSystemConfigureWindowTest :
+    public ct::AutostartCompizXorgSystemTestWithTestHelper
+{
+    public:
+
+	CompizXorgSystemConfigureWindowTest () :
+	    /* See note in the acceptance tests about this */
+	    env ("XORG_GTEST_CHILD_STDOUT", "1")
+	{
+	}
+
+	void SendConfigureRequest (Window w, int x, int y, int width, int height, int mask);
+	void SendSetFrameExtentsRequest (Window w, int left, int right, int top, int bottom);
+	void SendConfigureLockRequest (Window w, bool lockRequests);
+	bool VerifyConfigureResponse (Window w, int x, int y, int width, int height);
+	bool VerifySetFrameExtentsResponse (Window w, int left, int right, int top, int bottom);
+	bool VerifyWindowSize (Window w, int x, int y, int width, int height);
+
+    protected:
+
+	ReparentedWindow CreateWindow (::Display *);
+	int GetEventMask ();
+
+    private:
+
+	TmpEnv env;
+};
+
+int
+CompizXorgSystemConfigureWindowTest::GetEventMask ()
+{
+    return ct::AutostartCompizXorgSystemTestWithTestHelper::GetEventMask () |
+	    SubstructureNotifyMask;
+}
+
+void
+CompizXorgSystemConfigureWindowTest::SendConfigureRequest (Window w,
+							   int x,
+							   int y,
+							   int width,
+							   int height,
+							   int mask)
+{
+    ::Display *dpy = Display ();
+
+    std::vector <long> data;
+    data.push_back (x);
+    data.push_back (y);
+    data.push_back (width);
+    data.push_back (height);
+    data.push_back (mask);
+
+    ct::SendClientMessage (dpy,
+			   FetchAtom (ct::messages::TEST_HELPER_CONFIGURE_WINDOW),
+			   DefaultRootWindow (dpy),
+			   w,
+			   data);
+}
+
+void
+CompizXorgSystemConfigureWindowTest::SendSetFrameExtentsRequest (Window w,
+								 int    left,
+								 int    right,
+								 int    top,
+								 int    bottom)
+{
+    ::Display *dpy = Display ();
+
+    std::vector <long> data;
+    data.push_back (left);
+    data.push_back (right);
+    data.push_back (top);
+    data.push_back (bottom);
+
+    ct::SendClientMessage (dpy,
+			   FetchAtom (ct::messages::TEST_HELPER_CHANGE_FRAME_EXTENTS),
+			   DefaultRootWindow (dpy),
+			   w,
+			   data);
+}
+
+void
+CompizXorgSystemConfigureWindowTest::SendConfigureLockRequest (Window w,
+							       bool   lockRequests)
+{
+    ::Display *dpy = Display ();
+
+    std::vector <long> data;
+    data.push_back (lockRequests ? 1 : 0);
+
+    ct::SendClientMessage (dpy,
+			   FetchAtom (ct::messages::TEST_HELPER_LOCK_CONFIGURE_REQUESTS),
+			   DefaultRootWindow (dpy),
+			   w,
+			   data);
+}
+
+bool
+CompizXorgSystemConfigureWindowTest::VerifyConfigureResponse (Window w,
+							      int x,
+							      int y,
+							      int width,
+							      int height)
+{
+    ::Display *dpy = Display ();
+    XEvent event;
+
+    while (ct::ReceiveMessage (dpy,
+			       FetchAtom (ct::messages::TEST_HELPER_WINDOW_CONFIGURE_PROCESSED),
+			       event))
+    {
+	bool requestAcknowledged =
+		x == event.xclient.data.l[0] &&
+		y == event.xclient.data.l[1] &&
+		width == event.xclient.data.l[2] &&
+		height == event.xclient.data.l[3];
+
+	if (requestAcknowledged)
+	    return true;
+
+    }
+
+    return false;
+}
+
+bool
+CompizXorgSystemConfigureWindowTest::VerifySetFrameExtentsResponse (Window w,
+								    int left,
+								    int right,
+								    int top,
+								    int bottom)
+{
+    ::Display *dpy = Display ();
+    XEvent event;
+
+    while (ct::ReceiveMessage (dpy,
+			       FetchAtom (ct::messages::TEST_HELPER_FRAME_EXTENTS_CHANGED),
+			       event))
+    {
+	bool requestAcknowledged =
+		left == event.xclient.data.l[0] &&
+		right == event.xclient.data.l[1] &&
+		top == event.xclient.data.l[2] &&
+		bottom == event.xclient.data.l[3];
+
+	if (requestAcknowledged)
+	    return true;
+
+    }
+
+    return false;
+}
+
+bool
+CompizXorgSystemConfigureWindowTest::VerifyWindowSize (Window w,
+						       int x,
+						       int y,
+						       int width,
+						       int height)
+{
+    ::Display *dpy = Display ();
+
+    int          xRet, yRet;
+    unsigned int widthRet, heightRet;
+    if (!QueryGeometry (dpy, w, xRet, yRet, widthRet, heightRet))
+	return false;
+
+    EXPECT_EQ (x, xRet);
+    EXPECT_EQ (y, yRet);
+    EXPECT_EQ (width, widthRet);
+    EXPECT_EQ (height, heightRet);
+
+    return true;
+}
+
+ReparentedWindow
+CompizXorgSystemConfigureWindowTest::CreateWindow (::Display *dpy)
+{
+    return GetNewWindowAndFrame (dpy,
+				 boost::bind (&CompizXorgSystemConfigureWindowTest::WaitForWindowCreation,
+					      this,
+					      _1));
+}
+
+TEST_F (CompizXorgSystemConfigureWindowTest, ConfigureAndReponseUnlocked)
+{
+    ::Display *dpy = Display ();
+
+    int x = 1;
+    int y = 1;
+    int width = 100;
+    int height = 200;
+    int mask = CWX | CWY | CWWidth | CWHeight;
+
+    ReparentedWindow w = CreateWindow (dpy);
+
+    SendConfigureRequest (w.client, x, y, width, height, mask);
+
+    /* Wait for a response */
+    ASSERT_TRUE (VerifyConfigureResponse (w.client, x, y, width, height));
+
+    /* Query the window size again */
+    ASSERT_TRUE (VerifyWindowSize (w.frame, x, y, width, height));
+
+}
+
+TEST_F (CompizXorgSystemConfigureWindowTest, FrameExtentsAndReponseUnlocked)
+{
+    ::Display *dpy = Display ();
+
+    int left = 1;
+    int right = 2;
+    int top = 3;
+    int bottom = 4;
+
+    ReparentedWindow w = CreateWindow (dpy);
+
+    int x, y;
+    unsigned int width, height;
+    ASSERT_TRUE (QueryGeometry (dpy, w.client, x, y, width, height));
+
+    SendSetFrameExtentsRequest (w.client, left, right, top, bottom);
+
+    /* Wait for a response */
+    ASSERT_TRUE (VerifySetFrameExtentsResponse (w.client, left, right, top, bottom));
+
+    /* Client geometry is always unchanged */
+    ASSERT_TRUE (VerifyWindowSize (w.client, x, y, width, height));
+
+    /* Frame geometry is frame geometry offset by extents */
+    x -= left;
+    y -= top;
+    width += left + right;
+    height += top + bottom;
+
+    ASSERT_TRUE (VerifyWindowSize (w.frame, x, y, width, height));
+}
+
+TEST_F (CompizXorgSystemConfigureWindowTest, MoveFrameLocked)
+{
+    ::Display *dpy = Display ();
+
+    int x = 1;
+    int y = 1;
+    int width = 0; int height = 0;
+    int mask = CWX | CWY;
+
+    ReparentedWindow w = CreateWindow (dpy);
+
+    int currentX, currentY;
+    unsigned int currentWidth, currentHeight;
+    ASSERT_TRUE (QueryGeometry (dpy,
+				w.frame,
+				currentX,
+				currentY,
+				currentWidth,
+				currentHeight));
+
+    SendConfigureLockRequest (w.client, true);
+    SendConfigureRequest (w.client, x, y, width, height, mask);
+
+    /* Wait for a response */
+    ASSERT_TRUE (VerifyConfigureResponse (w.client, x, y, width, height));
+
+    /* Query the window size again - it should be the same */
+    ASSERT_TRUE (VerifyWindowSize (w.frame,
+				   currentX,
+				   currentY,
+				   currentWidth,
+				   currentHeight));
+
+
+    SendConfigureLockRequest (w.client, false);
+
+    /* Expect buffer to be released */
+    ASSERT_TRUE (WaitForConfigureNotify (dpy,
+					 w.frame,
+					 x,
+					 y,
+					 0,
+					 0,
+					 0,
+					 0,
+					 mask));
+
+}
+
+TEST_F (CompizXorgSystemConfigureWindowTest, ResizeFrameLocked)
+{
+    ::Display *dpy = Display ();
+
+    int x = 0;
+    int y = 0;
+    int width = 200; int height = 300;
+    int mask = CWWidth | CWHeight;
+
+    ReparentedWindow w = CreateWindow (dpy);
+
+    int currentX, currentY;
+    unsigned int currentWidth, currentHeight;
+    ASSERT_TRUE (QueryGeometry (dpy,
+				w.frame,
+				currentX,
+				currentY,
+				currentWidth,
+				currentHeight));
+
+    SendConfigureLockRequest (w.client, true);
+    SendConfigureRequest (w.client, x, y, width, height, mask);
+
+    /* Expect buffer to be released immediately */
+    ASSERT_TRUE (WaitForConfigureNotify (dpy,
+					 w.frame,
+					 0,
+					 0,
+					 width,
+					 height,
+					 0,
+					 0,
+					 mask));
+
+    /* Wait for a response */
+    ASSERT_TRUE (VerifyConfigureResponse (w.client, x, y, width, height));
+
+    SendConfigureLockRequest (w.client, false);
+
+    /* Query the window size again - it should be the same */
+    ASSERT_TRUE (VerifyWindowSize (w.frame,
+				   currentX,
+				   currentY,
+				   width,
+				   height));
+}
+
+TEST_F (CompizXorgSystemConfigureWindowTest, SetFrameExtentsLocked)
+{
+    ::Display *dpy = Display ();
+
+    /* Give the client window a 1px border, this will cause
+     * the client to move within the frame window by 1, 1 ,
+     * the frame window to move by -1, -1  and resize by 2, 2 */
+    int left = 1;
+    int right = 1;
+    int top = 1;
+    int bottom = 1;
+    int frameMask = CWX | CWY | CWWidth | CWHeight;
+
+    ReparentedWindow w = CreateWindow (dpy);
+
+    int currentX, currentY;
+    unsigned int currentWidth, currentHeight;
+    ASSERT_TRUE (QueryGeometry (dpy,
+				w.frame,
+				currentX,
+				currentY,
+				currentWidth,
+				currentHeight));
+
+    SendConfigureLockRequest (w.client, true);
+    SendSetFrameExtentsRequest (w.client, left, right, top, bottom);
+
+    /* Expect buffer to be released immediately */
+    ASSERT_TRUE (WaitForConfigureNotify (dpy,
+					 w.frame,
+					 currentX - left,
+					 currentY - top,
+					 currentWidth + (left + right),
+					 currentHeight + (top + bottom),
+					 0,
+					 0,
+					 frameMask));
+
+
+    /* Wait for a response */
+    ASSERT_TRUE (VerifySetFrameExtentsResponse (w.client, left, right, top, bottom));
+
+    SendConfigureLockRequest (w.client, false);
+
+    /* Query the window size again - it should be the same */
+    ASSERT_TRUE (VerifyWindowSize (w.frame,
+				   currentX - left,
+				   currentY - top,
+				   currentWidth + (left + right),
+				   currentHeight + (top + bottom)));
+}

=== modified file 'tests/system/xorg-gtest/tests/compiz_xorg_gtest_ewmh.cpp'
--- tests/system/xorg-gtest/tests/compiz_xorg_gtest_ewmh.cpp	2013-01-16 01:48:25 +0000
+++ tests/system/xorg-gtest/tests/compiz_xorg_gtest_ewmh.cpp	2013-02-19 15:13:21 +0000
@@ -94,7 +94,8 @@
 {
     ::Display *dpy = Display ();
     StartCompiz (static_cast <ct::CompizProcess::StartupFlags> (
-		     ct::CompizProcess::ReplaceCurrentWM));
+		     ct::CompizProcess::ReplaceCurrentWM),
+		 ct::CompizProcess::PluginList ());
 
     ct::PropertyNotifyXEventMatcher desktopHintsProperty (dpy,
 							  "_NET_DESKTOP_GEOMETRY");

=== modified file 'tests/system/xorg-gtest/tests/compiz_xorg_gtest_icccm.cpp'
--- tests/system/xorg-gtest/tests/compiz_xorg_gtest_icccm.cpp	2013-02-15 11:28:27 +0000
+++ tests/system/xorg-gtest/tests/compiz_xorg_gtest_icccm.cpp	2013-02-19 15:13:21 +0000
@@ -95,6 +95,12 @@
 {
     public:
 
+	CompizXorgSystemICCCM () :
+	    /* See note in the acceptance tests about this */
+	    env ("XORG_GTEST_CHILD_STDOUT", "1")
+	{
+	}
+
 	virtual void SetUp ()
 	{
 	    ct::CompizXorgSystemTest::SetUp ();
@@ -109,6 +115,8 @@
 	}
 
     private:
+
+	TmpEnv env;
 };
 
 TEST_F (CompizXorgSystemICCCM, SomeoneElseHasSubstructureRedirectMask)
@@ -116,7 +124,8 @@
     StartCompiz (static_cast <ct::CompizProcess::StartupFlags> (
 		     ct::CompizProcess::ExpectStartupFailure |
 		     ct::CompizProcess::ReplaceCurrentWM |
-		     ct::CompizProcess::WaitForStartupMessage));
+		     ct::CompizProcess::WaitForStartupMessage),
+		 ct::CompizProcess::PluginList ());
 
     WaitForSuccessDeathTask::GetProcessState processState (boost::bind (&CompizXorgSystemICCCM::CompizProcessState,
 								 this));
@@ -152,7 +161,8 @@
 
 	    StartCompiz (static_cast <ct::CompizProcess::StartupFlags> (
 			     ct::CompizProcess::ReplaceCurrentWM |
-			     ct::CompizProcess::WaitForStartupMessage));
+			     ct::CompizProcess::WaitForStartupMessage),
+			  ct::CompizProcess::PluginList ());
 	}
 };
 
@@ -233,7 +243,9 @@
 						       REQUEST_X,
 						       REQUEST_Y,
 						       REQUEST_WIDTH,
-						       REQUEST_HEIGHT);
+						       REQUEST_HEIGHT,
+						       configureRequestEvent->value_mask &
+						       ~(CWSibling | CWStackMode));
 
     /* Should get a ConfigureNotify with the right parameters */
     EXPECT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindowMatching (dpy,

=== added directory 'tests/system/xorg-gtest/tests/plugins'
=== added file 'tests/system/xorg-gtest/tests/plugins/CMakeLists.txt'
--- tests/system/xorg-gtest/tests/plugins/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/system/xorg-gtest/tests/plugins/CMakeLists.txt	2013-02-19 15:13:21 +0000
@@ -0,0 +1,10 @@
+set (COMPIZ_CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
+set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${COMPIZ_CMAKE_MODULE_PATH})
+include (CompizDefaults)
+include (CompizCommon)
+
+set (COMPIZ_FOUND "true")
+
+include_directories (${COMPIZ_INTERNAL_INCLUDES})
+
+add_subdirectory (testhelper)

=== added directory 'tests/system/xorg-gtest/tests/plugins/testhelper'
=== added file 'tests/system/xorg-gtest/tests/plugins/testhelper/CMakeLists.txt'
--- tests/system/xorg-gtest/tests/plugins/testhelper/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/system/xorg-gtest/tests/plugins/testhelper/CMakeLists.txt	2013-02-19 15:13:21 +0000
@@ -0,0 +1,7 @@
+find_package (Compiz REQUIRED)
+
+include (CompizPlugin)
+
+include_directories (${COMPIZ_XORG_GTEST_COMMUNICATOR_INCLUDE_DIR})
+
+compiz_plugin (testhelper LIBRARIES ${COMPIZ_XORG_GTEST_COMMUNICATOR_LIBRARY})

=== added directory 'tests/system/xorg-gtest/tests/plugins/testhelper/src'
=== added file 'tests/system/xorg-gtest/tests/plugins/testhelper/src/testhelper.cpp'
--- tests/system/xorg-gtest/tests/plugins/testhelper/src/testhelper.cpp	1970-01-01 00:00:00 +0000
+++ tests/system/xorg-gtest/tests/plugins/testhelper/src/testhelper.cpp	2013-02-19 15:13:21 +0000
@@ -0,0 +1,231 @@
+/*
+* Copyright © 2013 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
+* Novell, Inc. not be used in advertising or publicity pertaining to
+* distribution of the software without specific, written prior permission.
+* Novell, Inc. makes no representations about the suitability of this
+* software for any purpose. It is provided "as is" without express or
+* implied warranty.
+*
+* NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+* NO EVENT SHALL NOVELL, INC. 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.
+*
+* Author: Sam Spilsbury <[e-mail]>
+*/
+
+#include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
+#include "testhelper.h"
+
+COMPIZ_PLUGIN_20090315 (testhelper, TestHelperPluginVTable)
+
+namespace
+{
+template <typename T>
+void XFreeT (T *t)
+{
+    XFree (t);
+}
+}
+
+namespace ct = compiz::testing;
+namespace ctm = compiz::testing::messages;
+
+void
+TestHelperScreen::handleEvent (XEvent *event)
+{
+    if (event->type == ClientMessage)
+    {
+	if (event->xclient.window != screen->root ())
+	{
+	    std::map <Atom, ClientMessageHandler>::iterator it =
+		mMessageHandlers.find (event->xclient.message_type);
+
+	    if (it != mMessageHandlers.end ())
+	    {
+		ClientMessageHandler handler (it->second);
+		CompWindow *w = screen->findWindow (event->xclient.window);
+
+		XClientMessageEvent *xce = &event->xclient;
+		long                *data = xce->data.l;
+
+		if (w)
+		    ((*TestHelperWindow::get (w)).*(handler)) (data);
+	    }
+	}
+    }
+
+    screen->handleEvent (event);
+}
+
+void
+TestHelperScreen::watchForMessage (Atom message, ClientMessageHandler handler)
+{
+    if (mMessageHandlers.find (message) != mMessageHandlers.end ())
+    {
+	boost::shared_ptr <char> name (XGetAtomName (screen->dpy (), message),
+				       boost::bind (XFreeT <char>, _1));
+	compLogMessage ("testhelper", CompLogLevelWarn,
+			"a message handler was already defined for %s",
+			name.get ());
+	return;
+    }
+
+    mMessageHandlers[message] = handler;
+}
+
+void
+TestHelperScreen::removeMessageWatch (Atom message)
+{
+    std::map <Atom, ClientMessageHandler>::iterator it =
+	mMessageHandlers.find (message);
+
+    if (it != mMessageHandlers.end ())
+	mMessageHandlers.erase (it);
+}
+
+Atom
+TestHelperScreen::fetchAtom (const char *message)
+{
+    return mAtomStore.FetchForString (message);
+}
+
+void
+TestHelperWindow::configureAndReport (long *data)
+{
+    XWindowChanges xwc;
+    XWindowChanges saved;
+
+    xwc.x = data[0];
+    xwc.y = data[1];
+    xwc.width = data[2];
+    xwc.height = data[3];
+    int mask = data[4];
+
+    /* configureXWindow has a nasty side-effect of
+     * changing xwc to the client-window co-ordinates,
+     * so we should back it up first */
+    saved = xwc;
+
+    window->configureXWindow (mask, &xwc);
+
+    xwc = saved;
+
+    std::vector <long> response;
+
+    response.push_back (xwc.x);
+    response.push_back (xwc.y);
+    response.push_back (xwc.width);
+    response.push_back (xwc.height);
+
+    TestHelperScreen *ts = TestHelperScreen::get (screen);
+    const Atom       atom = ts->fetchAtom (ctm::TEST_HELPER_WINDOW_CONFIGURE_PROCESSED);
+
+    ct::SendClientMessage (screen->dpy (),
+			   atom,
+			   screen->root (),
+			   window->id (),
+			   response);
+}
+
+void
+TestHelperWindow::setFrameExtentsAndReport (long *data)
+{
+    CompWindowExtents input;
+
+    input.left = data[0];
+    input.right = data[1];
+    input.top = data[2];
+    input.bottom = data[3];
+
+    window->setWindowFrameExtents (&input, &input);
+
+    std::vector <long> response;
+
+    response.push_back (input.left);
+    response.push_back (input.right);
+    response.push_back (input.top);
+    response.push_back (input.bottom);
+
+    TestHelperScreen *ts = TestHelperScreen::get (screen);
+    const Atom       atom = ts->fetchAtom (ctm::TEST_HELPER_FRAME_EXTENTS_CHANGED);
+
+    ct::SendClientMessage (screen->dpy (),
+			   atom,
+			   screen->root (),
+			   window->id (),
+			   response);
+}
+
+void
+TestHelperWindow::setConfigureLock (long *data)
+{
+    bool enabled = data[0] ? true : false;
+
+    if (enabled && !configureLock)
+	configureLock = window->obtainLockOnConfigureRequests ();
+    else if (!enabled && configureLock)
+    {
+	configureLock->release ();
+	configureLock.reset ();
+    }
+}
+
+TestHelperWindow::TestHelperWindow (CompWindow *w) :
+    PluginClassHandler <TestHelperWindow, CompWindow> (w),
+    window (w),
+    configureLock ()
+{
+    WindowInterface::setHandler (w);
+
+    TestHelperScreen *ts = TestHelperScreen::get (screen);
+
+    std::vector <long> data;
+    data.push_back (static_cast <long> (window->id ()));
+    ct::SendClientMessage (screen->dpy (),
+			   ts->fetchAtom (ctm::TEST_HELPER_WINDOW_READY),
+			   screen->root (),
+			   screen->root (),
+			   data);
+}
+
+TestHelperScreen::TestHelperScreen (CompScreen *s) :
+    PluginClassHandler <TestHelperScreen, CompScreen> (s),
+    screen (s),
+    mAtomStore (s->dpy ())
+{
+    ScreenInterface::setHandler (s);
+
+    /* Register the message handlers on each window */
+    watchForMessage (fetchAtom (ctm::TEST_HELPER_CONFIGURE_WINDOW),
+		     &TestHelperWindow::configureAndReport);
+    watchForMessage (fetchAtom (ctm::TEST_HELPER_CHANGE_FRAME_EXTENTS),
+		     &TestHelperWindow::setFrameExtentsAndReport);
+    watchForMessage (fetchAtom (ctm::TEST_HELPER_LOCK_CONFIGURE_REQUESTS),
+		     &TestHelperWindow::setConfigureLock);
+
+    ct::SendClientMessage (s->dpy (),
+			   mAtomStore.FetchForString (ctm::TEST_HELPER_READY_MSG),
+			   s->root (),
+			   s->root (),
+			   std::vector <long> ());
+}
+
+bool
+TestHelperPluginVTable::init ()
+{
+    if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION))
+	return false;
+
+    return true;
+}

=== added file 'tests/system/xorg-gtest/tests/plugins/testhelper/src/testhelper.h'
--- tests/system/xorg-gtest/tests/plugins/testhelper/src/testhelper.h	1970-01-01 00:00:00 +0000
+++ tests/system/xorg-gtest/tests/plugins/testhelper/src/testhelper.h	2013-02-19 15:13:21 +0000
@@ -0,0 +1,95 @@
+/*
+* Copyright © 2013 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
+* Novell, Inc. not be used in advertising or publicity pertaining to
+* distribution of the software without specific, written prior permission.
+* Novell, Inc. makes no representations about the suitability of this
+* software for any purpose. It is provided "as is" without express or
+* implied warranty.
+*
+* NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+* NO EVENT SHALL NOVELL, INC. 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.
+*
+* Author: Sam Spilsbury <[e-mail]>
+*/
+#ifndef _COMPIZ_TESTHELPER_H
+#define _COMPIZ_TESTHELPER_H
+
+#include <map>
+#include <boost/function.hpp>
+
+#include <X11/Xatom.h>
+
+#include <core/core.h>
+#include <core/pluginclasshandler.h>
+#include <core/configurerequestbuffer.h>
+
+#include <compiz_xorg_gtest_communicator.h>
+
+#include "testhelper_options.h"
+
+class TestHelperWindow;
+
+class TestHelperScreen :
+    public PluginClassHandler <TestHelperScreen, CompScreen>,
+    public ScreenInterface,
+    public TesthelperOptions
+{
+    public:
+
+	typedef void (TestHelperWindow::*ClientMessageHandler) (long *);
+
+	TestHelperScreen (CompScreen *);
+
+	void handleEvent (XEvent *event);
+
+	void watchForMessage (Atom, ClientMessageHandler);
+	void removeMessageWatch (Atom);
+
+	Atom fetchAtom (const char *);
+
+
+    private:
+
+	CompScreen *screen;
+	compiz::testing::MessageAtoms         mAtomStore;
+	std::map <Atom, ClientMessageHandler> mMessageHandlers;
+};
+
+class TestHelperWindow :
+    public PluginClassHandler <TestHelperWindow, CompWindow>,
+    public WindowInterface
+{
+    public:
+
+	TestHelperWindow (CompWindow *);
+
+	void configureAndReport (long *);
+	void setFrameExtentsAndReport (long *);
+	void setConfigureLock (long *);
+
+    private:
+
+	CompWindow                                         *window;
+	compiz::window::configure_buffers::Releasable::Ptr configureLock;
+};
+
+class TestHelperPluginVTable :
+    public CompPlugin::VTableForScreenAndWindow <TestHelperScreen, TestHelperWindow>
+{
+    public:
+
+	bool init ();
+};
+
+#endif

=== added file 'tests/system/xorg-gtest/tests/plugins/testhelper/testhelper.xml.in'
--- tests/system/xorg-gtest/tests/plugins/testhelper/testhelper.xml.in	1970-01-01 00:00:00 +0000
+++ tests/system/xorg-gtest/tests/plugins/testhelper/testhelper.xml.in	2013-02-19 15:13:21 +0000
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<compiz>
+    <plugin name="testhelper" useBcop="true">
+    <options/>
+    </plugin>
+</compiz>

=== modified file 'tests/xorg-gtest/include/compiz-xorg-gtest.h'
--- tests/xorg-gtest/include/compiz-xorg-gtest.h	2013-01-11 06:27:22 +0000
+++ tests/xorg-gtest/include/compiz-xorg-gtest.h	2013-02-19 15:13:21 +0000
@@ -37,6 +37,24 @@
     {
 	typedef  ::testing::MatcherInterface <const XEvent &> XEventMatcher;
 
+	class PrivateClientMessageXEventMatcher;
+	class ClientMessageXEventMatcher :
+	    public compiz::testing::XEventMatcher
+	{
+	    public:
+
+		ClientMessageXEventMatcher (Display *display,
+					    Atom    message,
+					    Window  target);
+
+		virtual bool MatchAndExplain (const XEvent &event, MatchResultListener *listener) const;
+		virtual void DescribeTo (std::ostream *os) const;
+
+	    private:
+
+		std::auto_ptr <PrivateClientMessageXEventMatcher> priv;
+	};
+
 	class PrivatePropertyNotifyXEventMatcher;
 	class PropertyNotifyXEventMatcher :
 	    public compiz::testing::XEventMatcher
@@ -65,7 +83,8 @@
 					      int          x,
 					      int          y,
 					      unsigned int width,
-					      unsigned int height);
+					      unsigned int height,
+					      unsigned int mask);
 
 		virtual bool MatchAndExplain (const XEvent &event, MatchResultListener *listener) const;
 		virtual void DescribeTo (std::ostream *os) const;
@@ -132,7 +151,12 @@
 		    ExpectStartupFailure = (1 << 2)
 		} StartupFlags;
 
-		CompizProcess (Display *dpy, StartupFlags, unsigned int waitTimeout);
+		typedef std::vector <std::string> PluginList;
+
+		CompizProcess (Display *dpy,
+			       StartupFlags,
+			       const PluginList &plugins,
+			       unsigned int waitTimeout);
 		~CompizProcess ();
 		xorg::testing::Process::State State ();
 		pid_t Pid ();
@@ -153,18 +177,52 @@
 		virtual void TearDown ();
 
 		xorg::testing::Process::State CompizProcessState ();
-		void StartCompiz (CompizProcess::StartupFlags flags);
+		void StartCompiz (CompizProcess::StartupFlags     flags,
+				  const CompizProcess::PluginList &plugins);
 
 	    private:
 		std::auto_ptr <PrivateCompizXorgSystemTest> priv;
 	};
 
+	class PrivateAutostartCompizXorgSystemTest;
 	class AutostartCompizXorgSystemTest :
 	    public CompizXorgSystemTest
 	{
 	    public:
 
-		virtual void SetUp ();
+		AutostartCompizXorgSystemTest ();
+
+		virtual CompizProcess::StartupFlags GetStartupFlags ();
+		virtual int GetEventMask ();
+		virtual CompizProcess::PluginList GetPluginList ();
+		virtual void SetUp ();
+
+	    private:
+		std::auto_ptr <PrivateAutostartCompizXorgSystemTest> priv;
+	};
+
+	class PrivateAutostartCompizXorgSystemTestWithTestHelper;
+	class AutostartCompizXorgSystemTestWithTestHelper :
+	    public AutostartCompizXorgSystemTest
+	{
+	    public:
+
+		AutostartCompizXorgSystemTestWithTestHelper ();
+
+		virtual CompizProcess::PluginList GetPluginList ();
+
+	    protected:
+
+		Atom FetchAtom (const char *);
+		void WaitForWindowCreation (Window w);
+
+		virtual int  GetEventMask ();
+
+	    private:
+
+		virtual void SetUp ();
+
+		std::auto_ptr <PrivateAutostartCompizXorgSystemTestWithTestHelper> priv;
 	};
     }
 }

=== modified file 'tests/xorg-gtest/src/CMakeLists.txt'
--- tests/xorg-gtest/src/CMakeLists.txt	2013-02-15 11:28:27 +0000
+++ tests/xorg-gtest/src/CMakeLists.txt	2013-02-19 15:13:21 +0000
@@ -1,2 +1,59 @@
+<<<<<<< TREE
 add_executable (xorg_gtest_wrapper
 		${CMAKE_CURRENT_SOURCE_DIR}/xorg_gtest_wrapper.cpp)
+=======
+set (COMPIZ_LD_LIBRARY_PATH ${CMAKE_BINARY_DIR}/src CACHE STRING "" FORCE)
+set (COMPIZ_BINARY ${CMAKE_BINARY_DIR}/src/compiz CACHE STRING "" FORCE)
+
+configure_file (${CMAKE_CURRENT_SOURCE_DIR}/compiz-xorg-gtest-config.h.in
+		${CMAKE_CURRENT_BINARY_DIR}/compiz-xorg-gtest-config.h
+		@ONLY)
+
+add_definitions (${_xorg_gtest_cflags})
+
+include_directories (${COMPIZ_XORG_SYSTEM_TEST_INCLUDE_DIR}
+		     ${XORG_SERVER_INCLUDE_DIRS}
+		     ${GTEST_INCLUDE_DIRS}
+		     ${XORG_SERVER_INCLUDE_XORG_GTEST}
+		     ${XORG_SERVER_GTEST_SRC}
+                     ${CMAKE_CURRENT_BINARY_DIR}
+                     ${COMPIZ_XORG_GTEST_COMMUNICATOR_INCLUDE_DIR}
+                     ${compiz_SOURCE_DIR}/tests/shared)
+
+link_directories (${XORG_SERVER_LIBRARY_DIRS})
+
+# This actually includes xorg-gtest-all and the defines
+set (_xorg_gtest_all_srcs
+     ${XORG_SERVER_GTEST_SRC}/src/xorg-gtest-all.cpp)
+
+set (_xorg_gtest_main_srcs
+     ${XORG_SERVER_GTEST_SRC}/src/xorg-gtest_main.cpp)
+
+add_library (xorg_gtest_all STATIC
+	     ${_xorg_gtest_all_srcs})
+
+add_library (xorg_gtest_main STATIC
+	     ${_xorg_gtest_main_srcs})
+
+add_library (compiz_xorg_gtest_system_test STATIC
+	     ${CMAKE_CURRENT_SOURCE_DIR}/compiz-xorg-gtest.cpp)
+
+target_link_libraries (xorg_gtest_all
+		       ${GTEST_BOTH_LIBRARIES}
+		       ${CMAKE_THREAD_LIBS_INIT}
+		       ${XORG_SERVER_LIBRARIES})
+
+target_link_libraries (xorg_gtest_main
+		       ${GTEST_BOTH_LIBRARIES}
+		       ${CMAKE_THREAD_LIBS_INIT}
+		       ${XORG_SERVER_LIBRARIES})
+
+target_link_libraries (compiz_xorg_gtest_system_test
+		       xorg_gtest_all
+		       xorg_gtest_main
+		       ${GTEST_BOTH_LIBRARIES}
+		       ${CMAKE_THREAD_LIBS_INIT}
+		       ${XORG_SERVER_LIBRARIES}
+                       ${X11_XI_LIBRARIES}
+                       ${COMPIZ_XORG_GTEST_COMMUNICATOR_LIBRARY})
+>>>>>>> MERGE-SOURCE

=== modified file 'tests/xorg-gtest/src/compiz-xorg-gtest-config.h.in'
--- tests/xorg-gtest/src/compiz-xorg-gtest-config.h.in	2012-09-18 13:17:09 +0000
+++ tests/xorg-gtest/src/compiz-xorg-gtest-config.h.in	2013-02-19 15:13:21 +0000
@@ -25,8 +25,9 @@
 
 namespace
 {
-    const std::string compizLDLibraryPath ("@COMPIZ_LD_LIBRARY_PATH@");//("/home/smspillaz/Source/Compiz/dev/dev/merges/compiz/proposed/compiz/build/src/");
-    const std::string compizBinaryPath ("@COMPIZ_BINARY@");//("/home/smspillaz/Source/Compiz/dev/dev/merges/compiz/proposed/compiz/build/src/compiz");
+    const std::string compizLDLibraryPath ("@COMPIZ_LD_LIBRARY_PATH@");
+    const std::string compizBinaryPath ("@COMPIZ_BINARY@");
+    const std::string compizOverridePluginPath ("@COMPIZ_OVERRIDE_PLUGIN_PATH@");
 }
 
 #endif

=== modified file 'tests/xorg-gtest/src/compiz-xorg-gtest.cpp'
--- tests/xorg-gtest/src/compiz-xorg-gtest.cpp	2013-02-19 01:06:21 +0000
+++ tests/xorg-gtest/src/compiz-xorg-gtest.cpp	2013-02-19 15:13:21 +0000
@@ -22,12 +22,16 @@
  */
 #include <list>
 #include <stdexcept>
+#include <sstream>
 #include <iomanip>
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <boost/shared_ptr.hpp>
+#include <gtest_shared_tmpenv.h>
+#include <gtest_shared_characterwrapper.h>
 #include <xorg/gtest/xorg-gtest.h>
 #include <compiz-xorg-gtest.h>
+#include <compiz_xorg_gtest_communicator.h>
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 #include <X11/extensions/shape.h>
@@ -49,7 +53,6 @@
 const unsigned int WINDOW_CLASS = InputOutput;
 Visual             *WINDOW_VISUAL = CopyFromParent;
 
-
 const long                 WINDOW_ATTRIB_VALUE_MASK = 0;
 
 void RemoveEventFromQueue (Display *dpy)
@@ -142,6 +145,10 @@
 	return true;
     }
 
+    std::stringstream ss;
+    matcher.DescribeTo (&ss);
+    ADD_FAILURE () << "Expected event matching: " << ss.str ();
+
     return false;
 }
 
@@ -221,6 +228,54 @@
 };
 }
 
+class ct::PrivateClientMessageXEventMatcher
+{
+    public:
+
+	PrivateClientMessageXEventMatcher (Display *display,
+					   Atom    message,
+					   Window  target) :
+	    display (display),
+	    message (message),
+	    target (target)
+	{
+	}
+
+	Display *display;
+	Atom    message;
+	Window  target;
+};
+
+ct::ClientMessageXEventMatcher::ClientMessageXEventMatcher (Display *display,
+							    Atom    message,
+							    Window  target) :
+    priv (new ct::PrivateClientMessageXEventMatcher (display, message, target))
+{
+}
+
+bool
+ct::ClientMessageXEventMatcher::MatchAndExplain (const XEvent &event, MatchResultListener *listener) const
+{
+    const XClientMessageEvent *xce = reinterpret_cast <const XClientMessageEvent *> (&event);
+
+    if (xce->message_type == priv->message &&
+	xce->window == priv->target)
+	return true;
+
+    return false;
+}
+
+void
+ct::ClientMessageXEventMatcher::DescribeTo (std::ostream *os) const
+{
+    CharacterWrapper name (XGetAtomName (priv->display,
+					 priv->message));
+    *os << "matches ClientMessage with type " << name
+	<< " on window "
+	<< std::hex << static_cast <long> (priv->target)
+	<< std::dec << std::endl;
+}
+
 class ct::PrivatePropertyNotifyXEventMatcher
 {
     public:
@@ -268,13 +323,15 @@
 					     int          x,
 					     int          y,
 					     unsigned int width,
-					     unsigned int height) :
+					     unsigned int height,
+					     unsigned int mask) :
 	    mAbove (above),
 	    mBorder (border),
 	    mX (x),
 	    mY (y),
 	    mWidth (width),
-	    mHeight (height)
+	    mHeight (height),
+	    mMask (mask)
 	{
 	}
 
@@ -284,6 +341,7 @@
 	int          mY;
 	int          mWidth;
 	int          mHeight;
+	unsigned int mMask;
 };
 
 ct::ConfigureNotifyXEventMatcher::ConfigureNotifyXEventMatcher (Window       above,
@@ -291,13 +349,15 @@
 								int          x,
 								int          y,
 								unsigned int width,
-								unsigned int height) :
+								unsigned int height,
+								unsigned int mask) :
     priv (new ct::PrivateConfigureNotifyXEventMatcher (above,
 						       border,
 						       x,
 						       y,
 						       width,
-						       height))
+						       height,
+						       mask))
 {
 }
 
@@ -306,24 +366,58 @@
 {
     const XConfigureEvent *ce = reinterpret_cast <const XConfigureEvent *> (&event);
 
-    return ce->above == priv->mAbove &&
-	   ce->border_width == priv->mBorder &&
-	   ce->x == priv->mX &&
-	   ce->y == priv->mY &&
-	   ce->width == priv->mWidth &&
-	   ce->height == priv->mHeight;
+    if (priv->mMask & CWSibling)
+	if (ce->above != priv->mAbove)
+	    return false;
+
+    if (priv->mMask & CWBorderWidth)
+	if (ce->border_width != priv->mBorder)
+	    return false;
+
+    if (priv->mMask & CWX)
+	if (ce->x != priv->mX)
+	    return false;
+
+    if (priv->mMask & CWY)
+	if (ce->y != priv->mY)
+	    return false;
+
+    if (priv->mMask & CWWidth)
+	if (ce->width != priv->mWidth)
+	    return false;
+
+    if (priv->mMask & CWHeight)
+	if (ce->height != priv->mHeight)
+	    return false;
+
+    return true;
 }
 
 void
 ct::ConfigureNotifyXEventMatcher::DescribeTo (std::ostream *os) const
 {
+    std::stringstream x, y, width, height, border, sibling;
+
+    if (priv->mMask & CWX)
+	x << " x: " << priv->mX;
+
+    if (priv->mMask & CWY)
+	y << " y: " << priv->mY;
+
+    if (priv->mMask & CWWidth)
+	width << " width: " << priv->mWidth;
+
+    if (priv->mMask & CWHeight)
+	height << " height: " << priv->mHeight;
+
+    if (priv->mMask & CWBorderWidth)
+	border << " border: " << priv->mBorder;
+
+    if (priv->mMask & CWSibling)
+	sibling << " above: " << std::hex << priv->mAbove << std::dec;
+
     *os << "Matches ConfigureNotify with parameters : " << std::endl <<
-	   " x: " << priv->mX <<
-	   " y: " << priv->mY <<
-	   " width: " << priv->mWidth <<
-	   " height: " << priv->mHeight <<
-	   " border: " << priv->mBorder <<
-	   " above: " << std::hex << priv->mAbove << std::dec;
+	   x.str () << y.str () << width.str () << height.str () << border.str () << sibling.str ();
 }
 
 class ct::PrivateShapeNotifyXEventMatcher
@@ -450,9 +544,10 @@
     XSelectInput (dpy, root, attrib.your_event_mask);
 }
 
-ct::CompizProcess::CompizProcess (::Display                       *dpy,
-				  ct::CompizProcess::StartupFlags flags,
-				  unsigned int                    waitTimeout) :
+ct::CompizProcess::CompizProcess (::Display                           *dpy,
+				  ct::CompizProcess::StartupFlags     flags,
+				  const ct::CompizProcess::PluginList &plugins,
+				  unsigned int                        waitTimeout) :
     priv (new PrivateCompizProcess (flags))
 {
     xorg::testing::Process::SetEnv ("LD_LIBRARY_PATH", compizLDLibraryPath, true);
@@ -464,6 +559,12 @@
 
     args.push_back ("--send-startup-message");
 
+    /* Copy in plugin list */
+    for (ct::CompizProcess::PluginList::const_iterator it = plugins.begin ();
+	 it != plugins.end ();
+	 ++it)
+	args.push_back (*it);
+
     priv->mProcess.Start (compizBinaryPath, args);
     EXPECT_EQ (priv->mProcess.GetState (), xorg::testing::Process::RUNNING);
 
@@ -571,16 +672,136 @@
 }
 
 void
-ct::CompizXorgSystemTest::StartCompiz (ct::CompizProcess::StartupFlags flags)
-{
-    priv->mProcess.reset (new ct::CompizProcess (Display (), flags, 3000));
+ct::CompizXorgSystemTest::StartCompiz (ct::CompizProcess::StartupFlags     flags,
+				       const ct::CompizProcess::PluginList &plugins)
+{
+    priv->mProcess.reset (new ct::CompizProcess (Display (), flags, plugins, 3000));
+}
+
+class ct::PrivateAutostartCompizXorgSystemTest
+{
+    public:
+
+	PrivateAutostartCompizXorgSystemTest () :
+	    overridePluginDirEnv ("COMPIZ_PLUGIN_DIR", compizOverridePluginPath.c_str ())
+	{
+	}
+
+	TmpEnv overridePluginDirEnv;
+};
+
+ct::AutostartCompizXorgSystemTest::AutostartCompizXorgSystemTest () :
+    priv (new ct::PrivateAutostartCompizXorgSystemTest ())
+{
+}
+
+ct::CompizProcess::StartupFlags
+ct::AutostartCompizXorgSystemTest::GetStartupFlags ()
+{
+    return static_cast <ct::CompizProcess::StartupFlags> (
+		ct::CompizProcess::ReplaceCurrentWM |
+		ct::CompizProcess::WaitForStartupMessage);
+}
+
+int
+ct::AutostartCompizXorgSystemTest::GetEventMask ()
+{
+    return 0;
+}
+
+ct::CompizProcess::PluginList
+ct::AutostartCompizXorgSystemTest::GetPluginList ()
+{
+    return ct::CompizProcess::PluginList ();
 }
 
 void
 ct::AutostartCompizXorgSystemTest::SetUp ()
 {
     ct::CompizXorgSystemTest::SetUp ();
-    StartCompiz (static_cast <ct::CompizProcess::StartupFlags> (
-		     ct::CompizProcess::ReplaceCurrentWM |
-		     ct::CompizProcess::WaitForStartupMessage));
+
+    ::Display *display = Display ();
+    XSelectInput (display, DefaultRootWindow (display),
+		  GetEventMask ());
+
+    StartCompiz (GetStartupFlags (),
+		 GetPluginList ());
+}
+
+class ct::PrivateAutostartCompizXorgSystemTestWithTestHelper
+{
+    public:
+
+	std::auto_ptr <ct::MessageAtoms> mMessages;
+};
+
+void
+ct::AutostartCompizXorgSystemTestWithTestHelper::WaitForWindowCreation (Window w)
+{
+    ::Display *dpy = Display ();
+
+    XEvent event;
+
+    bool requestAcknowledged = false;
+    while (ct::ReceiveMessage (dpy,
+			       FetchAtom (ct::messages::TEST_HELPER_WINDOW_READY),
+			       event))
+    {
+	requestAcknowledged =
+	    w == static_cast <unsigned long> (event.xclient.data.l[0]);
+
+	if (requestAcknowledged)
+	    break;
+
+    }
+
+    ASSERT_TRUE (requestAcknowledged);
+}
+
+Atom
+ct::AutostartCompizXorgSystemTestWithTestHelper::FetchAtom (const char *message)
+{
+    return priv->mMessages->FetchForString (message);
+}
+
+ct::AutostartCompizXorgSystemTestWithTestHelper::AutostartCompizXorgSystemTestWithTestHelper () :
+    priv (new ct::PrivateAutostartCompizXorgSystemTestWithTestHelper)
+{
+}
+
+int
+ct::AutostartCompizXorgSystemTestWithTestHelper::GetEventMask ()
+{
+    return AutostartCompizXorgSystemTest::GetEventMask () |
+	   StructureNotifyMask;
+}
+
+void
+ct::AutostartCompizXorgSystemTestWithTestHelper::SetUp ()
+{
+    ct::AutostartCompizXorgSystemTest::SetUp ();
+    priv->mMessages.reset (new ct::MessageAtoms (Display ()));
+
+    ::Display *dpy = Display ();
+    Window root = DefaultRootWindow (dpy);
+
+    Atom    ready = priv->mMessages->FetchForString (ct::messages::TEST_HELPER_READY_MSG);
+    ct::ClientMessageXEventMatcher matcher (dpy, ready, root);
+
+    ASSERT_TRUE (ct::AdvanceToNextEventOnSuccess (
+		     dpy,
+		     ct::WaitForEventOfTypeOnWindowMatching (dpy,
+							     root,
+							     ClientMessage,
+							     -1,
+							     -1,
+							     matcher)));
+}
+
+ct::CompizProcess::PluginList
+ct::AutostartCompizXorgSystemTestWithTestHelper::GetPluginList ()
+{
+    ct::CompizProcess::PluginList list;
+    list.push_back ("testhelper");
+    return list;
 }