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

[Sam Spilsbury]

Add support for the GLX_EXT_buffer_age extension on hardware that supports it, which should result in a nice speed-boost due to the fact that we no longer have to abuse fillrate by retaining old frame contents, and instead asking the driver how defined the current frame is.

Added external API for plugins to register their own damage tracking objects - with a callback as to whether or not to track the specified damage. This allows plugins that rely on both the retrospective and new damage to the framebuffer to ignore feedback caused by their old damage events.

(LP: #1024304)

Add support for the GLX_EXT_buffer_age extension on hardware that supports it, which should result in a nice speed-boost due to the fact that we no longer have to abuse fillrate by retaining old frame contents, and instead asking the driver how defined the current frame is.

Note: I've marked this needs review for now, but it shouldn't be merged because it confuses unity a fair bit. I've got some branches on unity which will make it work with this code (albeit, the launcher and panel will be re-presented on every frame, but that is what was happening anyways and is harmless for performance).

1. https://code.launchpad.net/~smspillaz/nux/nux.fix_1091589/+merge/147543 (WindowThread::PresentWindowsIntersectingGeometryOnThisFrame, WindowThread::ForeignFrameCutoff, WindowThread::ForeignFrameEnded)
2. https://code.launchpad.net/~smspillaz/unity/unity.fix_1080947/+merge/147544 (make unity use the new APIs)

Note 2: I don't have any solid numbers on this yet. Daniel reported a 10% difference with redirect-to-fbo-on-each-frame in bug 1024304, so I think that is a good start, because with this branch we are effectively not doing that (on NVIDIA). I've got some testers to gather some more concrete numbers in a few days.

Update: test results here: http://www.ucc.asn.au/~smspillaz/phoronix-test-suite/composite.xml

I was careful to modify phoronix-test-suite to run tests in windowed mode only, and those were the only three tests I was able to get to run in windowed mode. Of particular interest was the fact that the unigine demos had a 5x performance improvement, probably because the driver was spending less time filling redundant pixels from the compositor. In other areas we had a roughly 5FPS boost.

Compiz framerate graph:

http://www.ucc.asn.au/~smspillaz/compiz-perf-graph.png

You'll see that especially on the last test, it drops off quite a bit on the non buffer_age case, and is generally speaking lower across the board.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3556
http://jenkins.qa.ubuntu.com/job/compiz-ci/8/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-clang-ci/./build=pbuilder,distribution=quantal,flavor=amd64/46/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=quantal,flavor=amd64/45/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=quantal,flavor=amd64/397/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3557
http://jenkins.qa.ubuntu.com/job/compiz-ci/14/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-clang-ci/./build=pbuilder,distribution=quantal,flavor=amd64/52/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=quantal,flavor=amd64/51/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=quantal,flavor=amd64/403/console

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3560
http://jenkins.qa.ubuntu.com/job/compiz-ci/19/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-clang-ci/./build=pbuilder,distribution=quantal,flavor=amd64/57/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=quantal,flavor=amd64/56/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=quantal,flavor=amd64/408/console

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

review: Approve (continuous-integration)

[Esokrates (esokrarkose)]

I have used the ppa containing these changes since the beginning and could confirm the performance improvements using Phoronix Test Suite (and of course my subjective feeling). Comparing benchmarks of compiz 0.9.9.0 and the branch containing the improvements (both disabled "unredirect fullscreen windows") clearly shows that there is an substantial performance improvement.
Part of my benchmark results can be downloaded here:
http://ubuntuone.com/2JNLvWQiYiQmOCAca0bIEn

review: Approve (testing, benchmarking)

[MC Return (mc-return)]

The change to debian/changelog seems to be unintended and should probably be removed.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3561
http://jenkins.qa.ubuntu.com/job/compiz-ci/27/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-clang-ci/./build=pbuilder,distribution=quantal,flavor=amd64/65/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=quantal,flavor=amd64/64/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=quantal,flavor=amd64/416/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3563
http://jenkins.qa.ubuntu.com/job/compiz-ci/29/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-clang-ci/./build=pbuilder,distribution=raring,flavor=amd64/67/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/66/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/418/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3563
http://jenkins.qa.ubuntu.com/job/compiz-ci/46/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/83/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/435/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3564
http://jenkins.qa.ubuntu.com/job/compiz-ci/53/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/90/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/442/console

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

review: Approve (continuous-integration)

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

3565. By Sam Spilsbury on 2013-02-18

Revert more changes which should not have happened

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3565
http://jenkins.qa.ubuntu.com/job/compiz-ci/56/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/93/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/445/console

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

review: Approve (continuous-integration)

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

3566. By Sam Spilsbury on 2013-02-25

Merge lp:compiz

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3566
http://jenkins.qa.ubuntu.com/job/compiz-ci/88/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/125/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/477/console

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

review: Needs Fixing (continuous-integration)

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

3567. By Sam Spilsbury on 2013-02-25

Fix using the postprocess frame provider in situations where that isn't
actually allowed.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3567
http://jenkins.qa.ubuntu.com/job/compiz-ci/89/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/126/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/478/console

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

review: Approve (continuous-integration)

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

3568. By Sam Spilsbury on 2013-02-28

Merge lp:compiz

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3568
http://jenkins.qa.ubuntu.com/job/compiz-ci/97/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/134/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/486/console

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

review: Needs Fixing (continuous-integration)

Unmerged revisions

3568. By Sam Spilsbury on 2013-02-28

Merge lp:compiz

3567. By Sam Spilsbury on 2013-02-25

Fix using the postprocess frame provider in situations where that isn't
actually allowed.

3566. By Sam Spilsbury on 2013-02-25

Merge lp:compiz

3565. By Sam Spilsbury on 2013-02-18

Revert more changes which should not have happened

3564. By Sam Spilsbury on 2013-02-15

Merge lp:compiz

3563. By Sam Spilsbury on 2013-02-13

Fix broken merge

3562. By Sam Spilsbury on 2013-02-13

Merge lp:compiz

3561. By Sam Spilsbury on 2013-02-13

Fix typo

3560. By Sam Spilsbury on 2013-02-12

Unrevert changes which should not have been reverted

3559. By Sam Spilsbury on 2013-02-12

Merge lp:compiz

=== modified file 'include/core/CMakeLists.txt'
--- include/core/CMakeLists.txt	2013-01-03 16:05:26 +0000
+++ include/core/CMakeLists.txt	2013-02-28 03:13:24 +0000
@@ -1,7 +1,6 @@
 set (_headers
     action.h
     atoms.h
-    configurerequestbuffer.h
     core.h
     countedlist.h
     global.h

=== removed file 'include/core/configurerequestbuffer.h'
--- include/core/configurerequestbuffer.h	2012-12-13 11:12:32 +0000
+++ include/core/configurerequestbuffer.h	1970-01-01 00:00:00 +0000
@@ -1,73 +0,0 @@
-/*
- * 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-02-10 05:01:50 +0000
+++ include/core/window.h	2013-02-28 03:13:24 +0000
@@ -54,26 +54,13 @@
 class PrivateWindow;
 struct CompStartupSequence;
 
-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;
-}
-}
+namespace compiz { namespace private_screen {
+    class Ping;
+    class GrabManager;
+    class OutputDevices;
+    class WindowManager;
+    class StartupSequence;
+}}
 
 #define ROOTPARENT(x) (((x)->frame ()) ? (x)->frame () : (x)->id ())
 
@@ -542,12 +529,6 @@
 	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/animation/src/animation.cpp'
--- plugins/animation/src/animation.cpp	2013-01-11 08:28:51 +0000
+++ plugins/animation/src/animation.cpp	2013-02-28 03:13:24 +0000
@@ -1617,7 +1617,7 @@
     // Is this the first glPaint call this round
     // without the mask PAINT_WINDOW_OCCLUSION_DETECTION_MASK?
     if (mPAScreen->mStartingNewPaintRound &&
-	!(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK))
+	!(mask & PAINT_WINDOW_NO_DRAW_MASKS))
     {
 	mPAScreen->mStartingNewPaintRound = false;
 

=== modified file 'plugins/composite/CMakeLists.txt'
--- plugins/composite/CMakeLists.txt	2012-09-25 01:15:36 +0000
+++ plugins/composite/CMakeLists.txt	2013-02-28 03:13:24 +0000
@@ -2,9 +2,14 @@
 
 include (CompizPlugin)
 
+include_directories (${CMAKE_CURRENT_SOURCE_DIR}/include)
 include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/pixmapbinding/include)
+include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/backbuffertracking/include)
+
 link_directories (${CMAKE_CURRENT_BINARY_DIR}/src/pixmapbinding)
+link_directories (${CMAKE_CURRENT_BINARY_DIR}/src/backbuffertracking)
 
-compiz_plugin (composite LIBRARIES compiz_composite_pixmapbinding)
+compiz_plugin (composite LIBRARIES compiz_composite_pixmapbinding compiz_composite_backbuffertracking)
 
 add_subdirectory (src/pixmapbinding)
+add_subdirectory (src/backbuffertracking)

=== added file 'plugins/composite/include/composite/agedamagequery.h'
--- plugins/composite/include/composite/agedamagequery.h	1970-01-01 00:00:00 +0000
+++ plugins/composite/include/composite/agedamagequery.h	2013-02-28 03:13:24 +0000
@@ -0,0 +1,53 @@
+/*
+ * Compiz, composite plugin, GLX_EXT_buffer_age logic
+ *
+ * Copyright (c) 2012 Sam Spilsbury
+ * Authors: Sam Spilsbury <[e-mail]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef _COMPIZ_COMPOSITE_AGEDAMAGEQUERY_H
+#define _COMPIZ_COMPOSITE_AGEDAMAGEQUERY_H
+
+#include <boost/shared_ptr.hpp>
+#include <core/region.h>
+
+namespace compiz
+{
+namespace composite
+{
+namespace buffertracking
+{
+class AgeDamageQuery
+{
+    public:
+
+	typedef boost::shared_ptr <AgeDamageQuery> Ptr;
+	typedef boost::function <bool (const CompRegion &)> AreaShouldBeMarkedDirty;
+
+	virtual ~AgeDamageQuery () {}
+	virtual CompRegion damageForFrameAge (unsigned int) = 0;
+	virtual const CompRegion & currentFrameDamage () = 0;
+};
+}
+}
+}
+
+#endif
+

=== modified file 'plugins/composite/include/composite/composite.h'
--- plugins/composite/include/composite/composite.h	2012-10-16 05:11:10 +0000
+++ plugins/composite/include/composite/composite.h	2013-02-28 03:13:24 +0000
@@ -30,7 +30,7 @@
 
 #include <X11/extensions/Xcomposite.h>
 
-#define COMPIZ_COMPOSITE_ABI 5
+#define COMPIZ_COMPOSITE_ABI 6
 
 #include "core/pluginclasshandler.h"
 #include "core/timer.h"
@@ -38,6 +38,8 @@
 #include "core/screen.h"
 #include "core/wrapsystem.h"
 
+#include "composite/agedamagequery.h"
+
 #define COMPOSITE_SCREEN_DAMAGE_PENDING_MASK (1 << 0)
 #define COMPOSITE_SCREEN_DAMAGE_REGION_MASK  (1 << 1)
 #define COMPOSITE_SCREEN_DAMAGE_ALL_MASK     (1 << 2)
@@ -98,18 +100,19 @@
 namespace composite
 {
 class PaintHandler {
-public:
-    virtual ~PaintHandler () {};
-
-    virtual void paintOutputs (CompOutput::ptrList &outputs,
-			       unsigned int        mask,
-			       const CompRegion    &region) = 0;
-
-    virtual bool hasVSync () { return false; };
-    virtual bool requiredForcedRefreshRate () { return false; };
-
-    virtual void prepareDrawing () {};
-    virtual bool compositingActive () { return false; };
+    public:
+	virtual ~PaintHandler () {};
+
+	virtual void paintOutputs (CompOutput::ptrList &outputs,
+				   unsigned int        mask,
+				   const CompRegion    &region) = 0;
+
+	virtual bool hasVSync () { return false; };
+	virtual bool requiredForcedRefreshRate () { return false; };
+
+	virtual void prepareDrawing () {};
+	virtual bool compositingActive () { return false; };
+	virtual unsigned int getFrameAge () { return 1; }
 };
 }
 }
@@ -173,12 +176,19 @@
 	 * Hookable function to damage regions directly
 	 */
 	virtual void damageRegion (const CompRegion &r);
+
+	/**
+	 * Hookable function to notify plugins that the last damage
+	 * event for this frame has been received, and all further damage
+	 * events will be for the next frame
+	 */
+	virtual void damageCutoff ();
 };
 
 extern template class PluginClassHandler<CompositeScreen, CompScreen, COMPIZ_COMPOSITE_ABI>;
 
 class CompositeScreen :
-    public WrapableHandler<CompositeScreenInterface, 7>,
+    public WrapableHandler<CompositeScreenInterface, 8>,
     public PluginClassHandler<CompositeScreen, CompScreen, COMPIZ_COMPOSITE_ABI>,
     public CompOption::Class
 {
@@ -203,6 +213,24 @@
 	void damageScreen ();
 
 	void damagePending ();
+
+	/**
+	 * Causes the damage that was recorded on N - 1 number of
+	 * frames ago to be added to the current frame, applied
+	 * culmulatively. An age of "zero" means that the entire frame
+	 * is considered undefined and must be completely repaired,
+	 * wheras an age of 1 means that this frame is the same as the
+	 * last frame, so no damage is required.
+	 */
+	void applyDamageForFrameAge (unsigned int);
+	unsigned int getFrameAge ();
+	void addOverdrawDamageRegion (const CompRegion &);
+
+	typedef compiz::composite::buffertracking::AgeDamageQuery DamageQuery;
+	typedef DamageQuery::AreaShouldBeMarkedDirty AreaShouldBeMarkedDirty;
+
+	DamageQuery::Ptr
+	getDamageQuery (const AreaShouldBeMarkedDirty &callback);
 	
 
 	unsigned int damageMask ();
@@ -248,6 +276,7 @@
 	 * event loop
 	 */
 	WRAPABLE_HND (6, CompositeScreenInterface, void, damageRegion, const CompRegion &);
+	WRAPABLE_HND (7, CompositeScreenInterface, void, damageCutoff);
 
 	friend class PrivateCompositeDisplay;
 
@@ -310,6 +339,12 @@
  */
 #define PAINT_WINDOW_BLEND_MASK			(1 << 19)
 
+/**
+ * flags that would indicate the window is never actually drawn
+ */
+#define PAINT_WINDOW_NO_DRAW_MASKS (PAINT_WINDOW_OCCLUSION_DETECTION_MASK | \
+				    PAINT_WINDOW_NO_CORE_INSTANCE_MASK)
+
 class CompositeWindowInterface;
 extern template class WrapableInterface<CompositeWindow, CompositeWindowInterface>;
 

=== added directory 'plugins/composite/src/backbuffertracking'
=== added file 'plugins/composite/src/backbuffertracking/CMakeLists.txt'
--- plugins/composite/src/backbuffertracking/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/composite/src/backbuffertracking/CMakeLists.txt	2013-02-28 03:13:24 +0000
@@ -0,0 +1,31 @@
+INCLUDE_DIRECTORIES (  
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../include
+  ${CMAKE_CURRENT_SOURCE_DIR}/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/src
+    
+  ${Boost_INCLUDE_DIRS}
+)
+
+LINK_DIRECTORIES (${COMPIZ_LIBRARY_DIRS}) 
+
+SET( 
+  SRCS 
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/backbuffertracking.cpp
+)
+
+ADD_LIBRARY( 
+  compiz_composite_backbuffertracking STATIC
+  
+  ${SRCS}
+)
+
+if (COMPIZ_BUILD_TESTING)
+ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/tests )
+endif (COMPIZ_BUILD_TESTING)
+
+TARGET_LINK_LIBRARIES(
+  compiz_composite_backbuffertracking
+
+  compiz_size
+  compiz_core
+)

=== added directory 'plugins/composite/src/backbuffertracking/include'
=== added file 'plugins/composite/src/backbuffertracking/include/backbuffertracking.h'
--- plugins/composite/src/backbuffertracking/include/backbuffertracking.h	1970-01-01 00:00:00 +0000
+++ plugins/composite/src/backbuffertracking/include/backbuffertracking.h	2013-02-28 03:13:24 +0000
@@ -0,0 +1,125 @@
+/*
+ * Compiz, composite plugin, GLX_EXT_buffer_age logic
+ *
+ * Copyright (c) 2012 Sam Spilsbury
+ * Authors: Sam Spilsbury <[e-mail]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef _COMPIZ_COMPOSITE_BACKBUFFERTRACKING_H
+#define _COMPIZ_COMPOSITE_BACKBUFFERTRACKING_H
+
+#include <memory>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/function.hpp>
+
+#include <composite/agedamagequery.h>
+
+class CompSize;
+class CompRegion;
+
+namespace compiz
+{
+namespace composite
+{
+namespace buffertracking
+{
+class DamageAgeTracking
+{
+    public:
+
+	virtual ~DamageAgeTracking () {};
+	virtual void dirtyAreaOnCurrentFrame (const CompRegion &) = 0;
+	virtual void overdrawRegionOnPaintingFrame (const CompRegion &) = 0;
+	virtual void subtractObscuredArea (const CompRegion &) = 0;
+	virtual void incrementFrameAges () = 0;
+};
+
+class AgeingDamageBufferObserver
+{
+    public:
+
+	virtual ~AgeingDamageBufferObserver () {};
+	virtual void observe (DamageAgeTracking &damageAgeTracker) = 0;
+	virtual void unobserve (DamageAgeTracking &damageAgeTracker) = 0;
+};
+
+class AgeingDamageBuffers :
+    public AgeingDamageBufferObserver,
+    boost::noncopyable
+{
+    public:
+
+	AgeingDamageBuffers ();
+
+	void observe (DamageAgeTracking &damageAgeTracker);
+	void unobserve (DamageAgeTracking &damageAgeTracker);
+	void incrementAges ();
+	void markAreaDirty (const CompRegion &reg);
+	void markAreaDirtyOnLastFrame (const CompRegion &reg);
+	void subtractObscuredArea (const CompRegion &reg);
+
+    private:
+
+	class Private;
+	std::auto_ptr <Private> priv;
+};
+
+class FrameRoster :
+    public DamageAgeTracking,
+    public AgeDamageQuery,
+    boost::noncopyable
+{
+    public:
+
+	typedef AgeDamageQuery::AreaShouldBeMarkedDirty AreaShouldBeMarkedDirty;
+	typedef boost::shared_ptr <FrameRoster> Ptr;
+
+	FrameRoster (const CompSize                   &size,
+		     AgeingDamageBufferObserver       &tracker,
+		     const AreaShouldBeMarkedDirty    &shouldMarkDirty);
+
+	~FrameRoster ();
+
+	void dirtyAreaOnCurrentFrame (const CompRegion &);
+	void overdrawRegionOnPaintingFrame (const CompRegion &);
+	void subtractObscuredArea (const CompRegion &);
+	void incrementFrameAges ();
+	CompRegion damageForFrameAge (unsigned int);
+	const CompRegion & currentFrameDamage ();
+
+	class Private;
+	std::auto_ptr <Private> priv;
+
+	static const unsigned int NUM_TRACKED_FRAMES = 10;
+
+	static
+	FrameRoster::Ptr create (const CompSize                &size,
+
+				 const AreaShouldBeMarkedDirty &shouldMarkDirty);
+
+    private:
+
+};
+} // namespace buffertracking
+} // namespace composite
+} // namespace compiz
+#endif

=== added directory 'plugins/composite/src/backbuffertracking/src'
=== added file 'plugins/composite/src/backbuffertracking/src/backbuffertracking.cpp'
--- plugins/composite/src/backbuffertracking/src/backbuffertracking.cpp	1970-01-01 00:00:00 +0000
+++ plugins/composite/src/backbuffertracking/src/backbuffertracking.cpp	2013-02-28 03:13:24 +0000
@@ -0,0 +1,214 @@
+/*
+ * Compiz, composite plugin, GLX_EXT_buffer_age logic
+ *
+ * Copyright (c) 2012 Sam Spilsbury
+ * Authors: Sam Spilsbury <[e-mail]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <deque>
+#include <core/size.h>
+#include <core/region.h>
+#include "backbuffertracking.h"
+#include <cstdio>
+
+namespace bt = compiz::composite::buffertracking;
+
+class bt::FrameRoster::Private
+{
+    public:
+
+	Private (const CompSize                                 &size,
+		 bt::AgeingDamageBufferObserver                 &observer,
+		 const bt::FrameRoster::AreaShouldBeMarkedDirty &shouldBeMarkedDirty) :
+	    screenSize (size),
+	    observer (observer),
+	    shouldBeMarkedDirty (shouldBeMarkedDirty),
+	    oldFrames (1)
+	{
+	}
+
+	CompSize                                 screenSize;
+	bt::AgeingDamageBufferObserver           &observer;
+	bt::FrameRoster::AreaShouldBeMarkedDirty shouldBeMarkedDirty;
+	std::deque <CompRegion>                  oldFrames;
+};
+
+bt::FrameRoster::FrameRoster (const CompSize                 &size,
+			      bt::AgeingDamageBufferObserver &tracker,
+			      const AreaShouldBeMarkedDirty  &shouldBeMarkedDirty) :
+    priv (new bt::FrameRoster::Private (size,
+					tracker,
+					shouldBeMarkedDirty))
+{
+    priv->observer.observe (*this);
+}
+
+bt::FrameRoster::~FrameRoster ()
+{
+    priv->observer.unobserve (*this);
+}
+
+CompRegion
+bt::FrameRoster::damageForFrameAge (unsigned int age)
+{
+    if (!age)
+	return CompRegion (0, 0,
+			   priv->screenSize.width (),
+			   priv->screenSize.height ());
+
+    if (age >= priv->oldFrames.size ())
+	return CompRegion (0, 0,
+			   priv->screenSize.width (),
+			   priv->screenSize.height ());
+
+    CompRegion accumulatedDamage;
+
+    while (age--)
+    {
+	unsigned int frameNum = (priv->oldFrames.size () - age) - 1;
+	accumulatedDamage += priv->oldFrames[frameNum];
+    }
+
+    return accumulatedDamage;
+}
+
+void
+bt::FrameRoster::dirtyAreaOnCurrentFrame (const CompRegion &r)
+{
+    if (priv->shouldBeMarkedDirty (r))
+	(*priv->oldFrames.rbegin ()) += r;
+}
+
+void
+bt::FrameRoster::subtractObscuredArea (const CompRegion &r)
+{
+    (*priv->oldFrames.rbegin ()) -= r;
+}
+
+void
+bt::FrameRoster::overdrawRegionOnPaintingFrame (const CompRegion &r)
+{
+    assert (priv->oldFrames.size () > 1);
+    std::deque <CompRegion>::reverse_iterator it = priv->oldFrames.rbegin ();
+    ++it;
+    (*it) += r;
+}
+
+void
+bt::FrameRoster::incrementFrameAges ()
+{
+    priv->oldFrames.push_back (CompRegion ());
+
+    /* Get rid of old frames */
+    if (priv->oldFrames.size () > NUM_TRACKED_FRAMES)
+	priv->oldFrames.pop_front ();
+}
+
+const CompRegion &
+bt::FrameRoster::currentFrameDamage ()
+{
+    return *priv->oldFrames.rbegin ();
+}
+
+class bt::AgeingDamageBuffers::Private
+{
+    public:
+
+	std::vector <bt::DamageAgeTracking *> damageAgeTrackers;
+};
+
+bt::AgeingDamageBuffers::AgeingDamageBuffers () :
+    priv (new bt::AgeingDamageBuffers::Private ())
+{
+}
+
+void
+bt::AgeingDamageBuffers::observe (bt::DamageAgeTracking &damageAgeTracker)
+{
+    priv->damageAgeTrackers.push_back (&damageAgeTracker);
+}
+
+void
+bt::AgeingDamageBuffers::unobserve (bt::DamageAgeTracking &damageAgeTracker)
+{
+    std::vector <bt::DamageAgeTracking *>::iterator it =
+	std::find (priv->damageAgeTrackers.begin (),
+		   priv->damageAgeTrackers.end (),
+		   &damageAgeTracker);
+
+    if (it != priv->damageAgeTrackers.end ())
+	priv->damageAgeTrackers.erase (it);
+}
+
+void
+bt::AgeingDamageBuffers::incrementAges ()
+{
+    for (std::vector <bt::DamageAgeTracking *>::iterator it =
+	 priv->damageAgeTrackers.begin ();
+	 it != priv->damageAgeTrackers.end ();
+	 ++it)
+    {
+	bt::DamageAgeTracking *tracker = *it;
+
+	tracker->incrementFrameAges ();
+    }
+}
+
+void
+bt::AgeingDamageBuffers::markAreaDirty (const CompRegion &reg)
+{
+    for (std::vector <bt::DamageAgeTracking *>::iterator it =
+	 priv->damageAgeTrackers.begin ();
+	 it != priv->damageAgeTrackers.end ();
+	 ++it)
+    {
+	bt::DamageAgeTracking *tracker = *it;
+
+	tracker->dirtyAreaOnCurrentFrame (reg);
+    }
+}
+
+void
+bt::AgeingDamageBuffers::subtractObscuredArea (const CompRegion &reg)
+{
+    for (std::vector <bt::DamageAgeTracking *>::iterator it =
+	 priv->damageAgeTrackers.begin ();
+	 it != priv->damageAgeTrackers.end ();
+	 ++it)
+    {
+	bt::DamageAgeTracking *tracker = *it;
+
+	tracker->subtractObscuredArea (reg);
+    }
+}
+
+void
+bt::AgeingDamageBuffers::markAreaDirtyOnLastFrame (const CompRegion &reg)
+{
+    for (std::vector <bt::DamageAgeTracking *>::iterator it =
+	 priv->damageAgeTrackers.begin ();
+	 it != priv->damageAgeTrackers.end ();
+	 ++it)
+    {
+	bt::DamageAgeTracking *tracker = *it;
+
+	tracker->overdrawRegionOnPaintingFrame (reg);
+    }
+}

=== added directory 'plugins/composite/src/backbuffertracking/tests'
=== added file 'plugins/composite/src/backbuffertracking/tests/CMakeLists.txt'
--- plugins/composite/src/backbuffertracking/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/composite/src/backbuffertracking/tests/CMakeLists.txt	2013-02-28 03:13:24 +0000
@@ -0,0 +1,24 @@
+find_library (GMOCK_LIBRARY gmock)
+find_library (GMOCK_MAIN_LIBRARY gmock_main)
+
+if (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
+  message ("Google Mock and Google Test not found - cannot build tests!")
+  set (COMPIZ_BUILD_TESTING OFF)
+endif (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
+
+include_directories (${GTEST_INCLUDE_DIRS})
+
+link_directories (${COMPIZ_LIBRARY_DIRS})
+
+add_executable (compiz_test_composite_backbuffertracking
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-composite-backbuffertracking.cpp)
+
+target_link_libraries (compiz_test_composite_backbuffertracking
+                       compiz_composite_backbuffertracking
+                       ${GTEST_BOTH_LIBRARIES}
+		       ${GMOCK_LIBRARY}
+		       ${GMOCK_MAIN_LIBRARY}
+		       ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
+                       )
+
+compiz_discover_tests (compiz_test_composite_backbuffertracking COVERAGE compiz_composite_backbuffertracking)

=== added file 'plugins/composite/src/backbuffertracking/tests/test-composite-backbuffertracking.cpp'
--- plugins/composite/src/backbuffertracking/tests/test-composite-backbuffertracking.cpp	1970-01-01 00:00:00 +0000
+++ plugins/composite/src/backbuffertracking/tests/test-composite-backbuffertracking.cpp	2013-02-28 03:13:24 +0000
@@ -0,0 +1,450 @@
+/*
+ * Compiz, composite plugin, GLX_EXT_buffer_age logic
+ *
+ * Copyright (c) 2012 Sam Spilsbury
+ * Authors: Sam Spilsbury <[e-mail]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <boost/bind.hpp>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <core/region.h>
+#include <core/size.h>
+
+#include "backbuffertracking.h"
+
+using ::testing::NiceMock;
+using ::testing::_;
+using ::testing::AtLeast;
+
+namespace bt = compiz::composite::buffertracking;
+
+namespace
+{
+class MockAgeingDamageBufferObserver :
+    public bt::AgeingDamageBufferObserver
+{
+    public:
+
+	MOCK_METHOD1 (observe, void (bt::DamageAgeTracking &));
+	MOCK_METHOD1 (unobserve, void (bt::DamageAgeTracking &));
+};
+
+bool alwaysTrackDamage (const CompRegion &)
+{
+    return true;
+}
+
+
+class BackbufferTracking :
+    public ::testing::Test
+{
+    public:
+
+	BackbufferTracking () :
+	    screen (1000, 1000),
+	    roster ()
+	{
+	}
+
+	virtual void SetUp ()
+	{
+	    SetupRoster ();
+	}
+
+	virtual void SetupRoster ()
+	{
+	    roster.reset (new bt::FrameRoster (screen,
+					       niceTracker,
+					       boost::bind (alwaysTrackDamage,
+							   _1)));
+	}
+
+    protected:
+
+	CompSize                           screen;
+	NiceMock <MockAgeingDamageBufferObserver> niceTracker;
+	bt::FrameRoster::Ptr               roster;
+};
+
+class BackbufferTrackingCallbacks :
+    public BackbufferTracking
+{
+    public:
+
+	BackbufferTrackingCallbacks () :
+	    shouldDamage (false)
+	{
+	}
+
+    protected:
+
+	void allowDamage (bool allow)
+	{
+	    shouldDamage = allow;
+	}
+
+    private:
+
+	virtual void SetupRoster ()
+	{
+	    roster.reset (new bt::FrameRoster (screen,
+					       niceTracker,
+					       boost::bind (&BackbufferTrackingCallbacks::shouldDamageCallback,
+							    this, _1)));
+	}
+
+	bool shouldDamageCallback (const CompRegion &)
+	{
+	    return shouldDamage;
+	}
+
+	bool shouldDamage;
+};
+}
+
+std::ostream &
+operator<< (std::ostream &os, const CompRegion &reg)
+{
+    os << "Region with Bounding Rectangle : " <<
+	  reg.boundingRect ().x () << " " <<
+	  reg.boundingRect ().y () << " " <<
+	  reg.boundingRect ().width () << " " <<
+	  reg.boundingRect ().height () << std::endl;
+    CompRect::vector rects (reg.rects ());
+    for (CompRect::vector::iterator it = rects.begin ();
+	 it != rects.end ();
+	 it++)
+	os << " - subrectangle: " <<
+	      (*it).x () << " " <<
+	      (*it).y () << " " <<
+	      (*it).width () << " " <<
+	      (*it).height () << " " << std::endl;
+
+    return os;
+}
+
+TEST (BackbufferTrackingConstruction, CreateAddsToObserverList)
+{
+    MockAgeingDamageBufferObserver mockAgeingDamageBufferObserver;
+
+    /* We can't verify the argument here,
+     * but we can verify the function call */
+    EXPECT_CALL (mockAgeingDamageBufferObserver, observe (_));
+    EXPECT_CALL (mockAgeingDamageBufferObserver, unobserve (_)).Times (AtLeast (0));
+    bt::FrameRoster roster (CompSize (),
+			    mockAgeingDamageBufferObserver,
+			    boost::bind (alwaysTrackDamage, _1));
+}
+
+TEST (BackbufferTrackingConstruction, DestroyRemovesFromObserverList)
+{
+    MockAgeingDamageBufferObserver mockAgeingDamageBufferObserver;
+
+    /* We can't verify the argument here,
+     * but we can verify the function call */
+    EXPECT_CALL (mockAgeingDamageBufferObserver, observe (_)).Times (AtLeast (0));
+    EXPECT_CALL (mockAgeingDamageBufferObserver, unobserve (_));
+    bt::FrameRoster roster (CompSize (),
+			    mockAgeingDamageBufferObserver,
+			    boost::bind (alwaysTrackDamage, _1));
+}
+
+TEST_F (BackbufferTrackingCallbacks, TrackIntoCurrentIfCallbackTrue)
+{
+    allowDamage (true);
+    CompRegion damage (100, 100, 100, 100);
+    roster->dirtyAreaOnCurrentFrame (damage);
+    EXPECT_EQ (damage, roster->currentFrameDamage ());
+}
+
+TEST_F (BackbufferTrackingCallbacks, NoTrackIntoCurrentIfCallbackFalse)
+{
+    allowDamage (false);
+    CompRegion damage (100, 100, 100, 100);
+    roster->dirtyAreaOnCurrentFrame (damage);
+    EXPECT_EQ (emptyRegion, roster->currentFrameDamage ());
+}
+
+TEST_F (BackbufferTracking, DirtyAreaSubtraction)
+{
+    CompRegion dirty (100, 100, 100, 100);
+    CompRegion obscured (150, 150, 50, 50);
+    roster->dirtyAreaOnCurrentFrame (dirty);
+    roster->subtractObscuredArea (obscured);
+    EXPECT_EQ (dirty - obscured, roster->currentFrameDamage ());
+}
+
+TEST_F (BackbufferTracking, DirtyAreaForAgeZeroAll)
+{
+    EXPECT_EQ (CompRegion (0, 0, screen.width (), screen.height ()),
+	       roster->damageForFrameAge (0));
+}
+
+TEST_F (BackbufferTracking, DirtyAreaAllForOlderThanTrackedAge)
+{
+    EXPECT_EQ (CompRegion (0, 0, screen.width (), screen.height ()),
+	       roster->damageForFrameAge (1));
+}
+
+TEST_F (BackbufferTracking, NoDirtyAreaForLastFrame)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    EXPECT_EQ (emptyRegion, roster->damageForFrameAge (1));
+}
+
+TEST_F (BackbufferTracking, DirtyAreaIfMoreSinceLastFrame)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame(all);
+    EXPECT_EQ (all, roster->damageForFrameAge (1));
+}
+
+TEST_F (BackbufferTracking, AddOverdrawRegionForLastFrame)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->incrementFrameAges ();
+    roster->overdrawRegionOnPaintingFrame (all);
+    EXPECT_EQ (all, roster->damageForFrameAge (2));
+}
+
+TEST_F (BackbufferTracking, TwoFramesAgo)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topleft);
+    roster->incrementFrameAges ();
+    EXPECT_EQ (topleft, roster->damageForFrameAge (2));
+}
+
+TEST_F (BackbufferTracking, TwoFramesAgoCulmulative)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
+    CompRegion topright (0, screen.width () / 2,
+			 screen.width () / 2,
+			 screen.height () / 2);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topleft);
+    roster->dirtyAreaOnCurrentFrame (topright);
+    roster->incrementFrameAges ();
+    EXPECT_EQ (topleft + topright, roster->damageForFrameAge (2));
+}
+
+TEST_F (BackbufferTracking, ThreeFramesAgo)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
+    CompRegion bottomright (screen.width () / 2,
+			    screen.height () / 2,
+			    screen.width () / 2,
+			    screen.height () / 2);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topleft);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (bottomright);
+    roster->incrementFrameAges ();
+
+    EXPECT_EQ (topleft + bottomright, roster->damageForFrameAge (3));
+}
+
+/* These are more or less functional tests from this point forward
+ * just checking a number of different situations */
+
+TEST_F (BackbufferTracking, ThreeFramesAgoWithFourFrames)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
+    CompRegion bottomright (screen.width () / 2,
+			    screen.height () / 2,
+			    screen.width () / 2,
+			    screen.height () / 2);
+    CompRegion topright (screen.width () / 2,
+			 0,
+			 screen.width () / 2,
+			 screen.height () / 2);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topleft);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (bottomright);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topright);
+    roster->incrementFrameAges ();
+
+    EXPECT_EQ (topright + bottomright, roster->damageForFrameAge (3));
+}
+
+TEST_F (BackbufferTracking, ThreeFramesAgoWithFourFramesAndOverlap)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
+    CompRegion bottomright (screen.width () / 2,
+			    screen.height () / 2,
+			    screen.width () / 2,
+			    screen.height () / 2);
+    CompRegion topright (screen.width () / 2,
+			 0,
+			 screen.width () / 2,
+			 screen.height () / 2);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topleft);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (bottomright);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (bottomright);
+    roster->incrementFrameAges ();
+
+    EXPECT_EQ (bottomright, roster->damageForFrameAge (3));
+}
+
+TEST_F (BackbufferTracking, AllDamageForExceedingMaxTrackedFrames)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion damage (0, 0, 1, 1);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+
+    for (unsigned int i = 0; i < bt::FrameRoster::NUM_TRACKED_FRAMES - 1; ++i)
+    {
+	roster->incrementFrameAges ();
+	roster->dirtyAreaOnCurrentFrame (damage);
+    }
+
+    EXPECT_EQ (all, roster->damageForFrameAge (bt::FrameRoster::NUM_TRACKED_FRAMES + 1));
+}
+
+TEST_F (BackbufferTracking, DamageForMaxTrackedFrame)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion damage (0, 0, 1, 1);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+
+    for (unsigned int i = 0; i < bt::FrameRoster::NUM_TRACKED_FRAMES + 1; ++i)
+    {
+	roster->incrementFrameAges ();
+	roster->dirtyAreaOnCurrentFrame (damage);
+    }
+
+    EXPECT_EQ (all, roster->damageForFrameAge (bt::FrameRoster::NUM_TRACKED_FRAMES));
+}
+
+class MockDamageAgeTracking :
+    public bt::DamageAgeTracking
+{
+    public:
+
+	typedef boost::shared_ptr <MockDamageAgeTracking> Ptr;
+
+	MOCK_METHOD0 (incrementFrameAges, void ());
+	MOCK_METHOD1 (dirtyAreaOnCurrentFrame, void (const CompRegion &));
+	MOCK_METHOD1 (subtractObscuredArea, void (const CompRegion &));
+	MOCK_METHOD1 (overdrawRegionOnPaintingFrame, void (const CompRegion &));
+};
+
+class AgeingDamageBuffers :
+    public ::testing::Test
+{
+    public:
+
+	AgeingDamageBuffers ()
+	{
+	    ageing.observe (mockDamageAgeTracker);
+	}
+
+	MockDamageAgeTracking   mockDamageAgeTracker;
+	bt::AgeingDamageBuffers ageing;
+};
+
+TEST_F (AgeingDamageBuffers, IncrementAgesOnValidRosters)
+{
+    EXPECT_CALL (mockDamageAgeTracker, incrementFrameAges ());
+    ageing.incrementAges ();
+}
+
+TEST_F (AgeingDamageBuffers, DirtyAreaOnValidRosters)
+{
+    CompRegion dirtyArea (100, 100, 100, 100);
+    EXPECT_CALL (mockDamageAgeTracker, dirtyAreaOnCurrentFrame (dirtyArea));
+    ageing.markAreaDirty (dirtyArea);
+}
+
+TEST_F (AgeingDamageBuffers, SubtractObscuredAreaOnValidRosters)
+{
+    CompRegion obscuredArea (100, 100, 100, 100);
+    EXPECT_CALL (mockDamageAgeTracker, subtractObscuredArea (obscuredArea));
+    ageing.subtractObscuredArea (obscuredArea);
+}
+
+TEST_F (AgeingDamageBuffers, AddOverdrawAreaOnValidRosters)
+{
+    CompRegion overdrawArea (100, 100, 100, 100);
+    EXPECT_CALL (mockDamageAgeTracker, overdrawRegionOnPaintingFrame (overdrawArea));
+    ageing.markAreaDirtyOnLastFrame (overdrawArea);
+}
+
+TEST_F (AgeingDamageBuffers, IncrementAgesOnInvalidRosters)
+{
+    EXPECT_CALL (mockDamageAgeTracker, incrementFrameAges ()).Times (0);
+    ageing.unobserve (mockDamageAgeTracker);
+    ageing.incrementAges ();
+}
+
+TEST_F (AgeingDamageBuffers, DirtyAreaOnInvalidRosters)
+{
+    EXPECT_CALL (mockDamageAgeTracker, dirtyAreaOnCurrentFrame (_)).Times (0);
+    ageing.unobserve (mockDamageAgeTracker);
+    ageing.markAreaDirty (emptyRegion);
+}
+
+TEST_F (AgeingDamageBuffers, SubtractObscuredAreaOnInvalidRosters)
+{
+    EXPECT_CALL (mockDamageAgeTracker, subtractObscuredArea (_)).Times (0);
+    ageing.unobserve (mockDamageAgeTracker);
+    ageing.subtractObscuredArea (emptyRegion);
+}
+
+TEST_F (AgeingDamageBuffers, AddOverdrawAreaOnInvalidRosters)
+{
+    EXPECT_CALL (mockDamageAgeTracker, overdrawRegionOnPaintingFrame (_)).Times (0);
+    ageing.unobserve (mockDamageAgeTracker);
+    ageing.markAreaDirtyOnLastFrame (emptyRegion);
+}
+
+

=== modified file 'plugins/composite/src/privates.h'
--- plugins/composite/src/privates.h	2012-09-20 09:35:40 +0000
+++ plugins/composite/src/privates.h	2013-02-28 03:13:24 +0000
@@ -36,12 +36,20 @@
 #include <map>
 
 #include "pixmapbinding.h"
+#include "backbuffertracking.h"
 #include "composite_options.h"
 
 extern CompPlugin::VTable *compositeVTable;
 
 extern CompWindow *lastDamagedWindow;
 
+enum DamageTracking
+{
+    DamageForCurrentFrame = 0,
+    DamageForLastFrame = 1,
+    DamageFinalPaintRegion
+};
+
 class PrivateCompositeScreen :
     ScreenInterface,
     public CompositeOptions
@@ -66,6 +74,8 @@
 
 	void scheduleRepaint ();
 
+	const CompRegion * damageTrackedBuffer (const CompRegion &);
+
     public:
 
 	CompositeScreen *cScreen;
@@ -80,10 +90,12 @@
 	bool randrExtension;
 	int  randrEvent, randrError;
 
-	CompRegion    damage;
+	CompRegion    lastFrameDamage;
 	unsigned long damageMask;
 
-	CompRegion    tmpRegion;
+	CompRegion     tmpRegion;
+
+	DamageTracking currentlyTrackingDamage;
 
 	Window	      overlay;
 	Window	      output;
@@ -99,6 +111,7 @@
 	int            redrawTime;
 	int            optimalRedrawTime;
 	bool           scheduled, painting, reschedule;
+	bool           damageRequiresRepaintReschedule;
 
 	bool slowAnimations;
 
@@ -115,6 +128,9 @@
 
 	/* Map Damage handle to its bounding box */
 	std::map<Damage, XRectangle> damages;
+
+	compiz::composite::buffertracking::AgeingDamageBuffers ageingBuffers;
+	compiz::composite::buffertracking::FrameRoster         roster;
 };
 
 class PrivateCompositeWindow :

=== modified file 'plugins/composite/src/screen.cpp'
--- plugins/composite/src/screen.cpp	2013-01-28 19:22:29 +0000
+++ plugins/composite/src/screen.cpp	2013-02-28 03:13:24 +0000
@@ -47,6 +47,8 @@
 
 template class WrapableInterface<CompositeScreen, CompositeScreenInterface>;
 
+namespace bt = compiz::composite::buffertracking;
+
 static const int FALLBACK_REFRESH_RATE = 60;   /* if all else fails */
 
 CompWindow *lastDamagedWindow = 0;
@@ -276,6 +278,14 @@
     delete priv;
 }
 
+namespace
+{
+bool alwaysMarkDirty ()
+{
+    return true;
+}
+}
+
 
 PrivateCompositeScreen::PrivateCompositeScreen (CompositeScreen *cs) :
     cScreen (cs),
@@ -294,6 +304,7 @@
     randrEvent (0),
     randrError (0),
     damageMask (COMPOSITE_SCREEN_DAMAGE_ALL_MASK),
+    currentlyTrackingDamage (DamageForCurrentFrame),
     overlay (None),
     output (None),
     exposeRects (),
@@ -305,12 +316,16 @@
     scheduled (false),
     painting (false),
     reschedule (false),
+    damageRequiresRepaintReschedule (true),
     slowAnimations (false),
     pHnd (NULL),
     FPSLimiterMode (CompositeFPSLimiterModeDefault),
     withDestroyedWindows (),
     cmSnAtom (0),
-    newCmSnOwner (None)
+    newCmSnOwner (None),
+    roster (*screen,
+	    ageingBuffers,
+	    boost::bind (alwaysMarkDirty))
 {
     gettimeofday (&lastRedraw, 0);
     // wrap outputChangeNotify
@@ -491,15 +506,47 @@
     return false;
 }
 
+const CompRegion *
+PrivateCompositeScreen::damageTrackedBuffer (const CompRegion &region)
+{
+    const CompRegion *currentDamage = NULL;
+
+    switch (currentlyTrackingDamage)
+    {
+	case DamageForCurrentFrame:
+	    currentDamage = &(roster.currentFrameDamage ());
+	    ageingBuffers.markAreaDirty (region);
+	    break;
+	case DamageForLastFrame:
+	    currentDamage = &(lastFrameDamage);
+	    lastFrameDamage += region;
+	    break;
+	case DamageFinalPaintRegion:
+	    currentDamage = &(tmpRegion);
+	    tmpRegion += region;
+	    break;
+	default:
+	    compLogMessage ("composite", CompLogLevelFatal, "unreachable section");
+	    assert (false);
+	    abort ();
+    }
+
+    assert (currentDamage);
+    return currentDamage;
+}
+
 void
 CompositeScreen::damageScreen ()
 {
+    /* Don't tell plugins about damage events when the damage buffer is already full */
     bool alreadyDamaged = priv->damageMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK;
+    alreadyDamaged |= ((currentDamage () & screen->region ()) == screen->region ());
 
     priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_ALL_MASK;
     priv->damageMask &= ~COMPOSITE_SCREEN_DAMAGE_REGION_MASK;
 
-    priv->scheduleRepaint ();
+    if (priv->damageRequiresRepaintReschedule)
+	priv->scheduleRepaint ();
 
     /*
      * Call through damageRegion since plugins listening for incoming damage
@@ -507,7 +554,15 @@
      */
 
     if (!alreadyDamaged)
+    {
 	damageRegion (CompRegion (0, 0, screen->width (), screen->height ()));
+
+	/* Set the damage region as the fullscreen region, because if
+	 * windows are unredirected we need to correctly subtract from
+	 * it later
+	 */
+	priv->damageTrackedBuffer (screen->region ());
+    }
 }
 
 void
@@ -518,7 +573,12 @@
     if (priv->damageMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
 	return;
 
-    priv->damage += region;
+    /* Don't cause repaints to be scheduled for empty damage
+     * regions */
+    if (region.isEmpty ())
+        return;
+
+    const CompRegion *currentDamage = priv->damageTrackedBuffer (region);
     priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_REGION_MASK;
 
     /* if the number of damage rectangles grows two much between repaints,
@@ -526,16 +586,61 @@
        in order to make sure we're not having too much overhead, damage
        the whole screen if we have a lot of damage rects */
 
-    if (priv->damage.numRects () > 100)
-       damageScreen ();
-    priv->scheduleRepaint ();
+    if (currentDamage->numRects () > 100)
+	damageScreen ();
+
+    if (priv->damageRequiresRepaintReschedule)
+	priv->scheduleRepaint ();
+}
+
+void
+CompositeScreen::damageCutoff ()
+{
+    WRAPABLE_HND_FUNCTN (damageCutoff);
 }
 
 void
 CompositeScreen::damagePending ()
 {
     priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_PENDING_MASK;
-    priv->scheduleRepaint ();
+
+    if (priv->damageRequiresRepaintReschedule)
+	priv->scheduleRepaint ();
+}
+
+void
+CompositeScreen::applyDamageForFrameAge (unsigned int age)
+{
+    /* Track into "last frame damage" */
+    priv->currentlyTrackingDamage = DamageForLastFrame;
+    damageRegion (priv->roster.damageForFrameAge (age));
+    priv->currentlyTrackingDamage = DamageForCurrentFrame;
+}
+
+unsigned int
+CompositeScreen::getFrameAge ()
+{
+    if (priv->pHnd)
+	return priv->pHnd->getFrameAge ();
+
+    return 1;
+}
+
+void
+CompositeScreen::addOverdrawDamageRegion (const CompRegion &r)
+{
+    priv->ageingBuffers.markAreaDirtyOnLastFrame (r);
+}
+
+typedef CompositeScreen::AreaShouldBeMarkedDirty ShouldMarkDirty;
+
+CompositeScreen::DamageQuery::Ptr
+CompositeScreen::getDamageQuery (const ShouldMarkDirty &callback)
+{
+    /* No initial damage */
+    return bt::FrameRoster::Ptr (new bt::FrameRoster (CompSize (),
+						      priv->ageingBuffers,
+						      callback));
 }
 
 unsigned int
@@ -780,6 +885,10 @@
     {
 	int         timeDiff;
 
+	/* Damage that accumulates here does not require a repaint reschedule
+	 * as it will end up on this frame */
+	priv->damageRequiresRepaintReschedule = false;
+
 	if (priv->pHnd)
 	    priv->pHnd->prepareDrawing ();
 
@@ -814,7 +923,7 @@
 		    continue;
 
 		if (!CompositeWindow::get (w)->redirected ())
-		    priv->damage -= w->region ();
+		    priv->ageingBuffers.subtractObscuredArea (w->region ());
 
 		break;
 	    }
@@ -826,7 +935,13 @@
 	    }
 	}
 
-	priv->tmpRegion = priv->damage & screen->region ();
+	/* All further damage is for the next frame now, as
+	 * priv->tmpRegion will be assigned. Notify plugins that do
+	 * damage tracking of this */
+	damageCutoff ();
+
+	priv->tmpRegion = (priv->roster.currentFrameDamage () + priv->lastFrameDamage) & screen->region ();
+	priv->currentlyTrackingDamage = DamageFinalPaintRegion;
 
 	if (priv->damageMask & COMPOSITE_SCREEN_DAMAGE_REGION_MASK)
 	{
@@ -848,7 +963,9 @@
 	XSync (dpy, False);
 	priv->damages.clear ();
 
-	priv->damage = CompRegion ();
+	/* Any more damage requires a repaint reschedule */
+	priv->damageRequiresRepaintReschedule = true;
+	priv->lastFrameDamage = CompRegion ();
 
 	int mask = priv->damageMask;
 	priv->damageMask = 0;
@@ -864,9 +981,13 @@
 	else
 	    outputs.push_back (&screen->fullscreenOutput ());
 
+	priv->currentlyTrackingDamage = DamageForCurrentFrame;
+
+	/* All new damage goes on the next frame */
+	priv->ageingBuffers.incrementAges ();
+
 	paint (outputs, mask);
 
-
 	donePaint ();
 
 	priv->outputShapeChanged = false;
@@ -1023,8 +1144,12 @@
 CompositeScreenInterface::damageRegion (const CompRegion &r)
     WRAPABLE_DEF (damageRegion, r);
 
+void
+CompositeScreenInterface::damageCutoff ()
+    WRAPABLE_DEF (damageCutoff);
+
 const CompRegion &
 CompositeScreen::currentDamage () const
 {
-    return priv->damage;
+    return priv->roster.currentFrameDamage ();
 }

=== modified file 'plugins/composite/src/window.cpp'
--- plugins/composite/src/window.cpp	2013-01-03 16:05:26 +0000
+++ plugins/composite/src/window.cpp	2013-02-28 03:13:24 +0000
@@ -181,7 +181,11 @@
 bool
 PrivateCompositeWindow::getAttributes (XWindowAttributes &attr)
 {
-    return window->queryFrameAttributes (attr);
+    if (XGetWindowAttributes (screen->dpy (),
+			      ROOTPARENT (window), &attr))
+	return true;
+
+    return false;
 }
 
 bool

=== modified file 'plugins/kdecompat/src/kdecompat.cpp'
--- plugins/kdecompat/src/kdecompat.cpp	2012-08-14 06:33:22 +0000
+++ plugins/kdecompat/src/kdecompat.cpp	2013-02-28 03:13:24 +0000
@@ -196,7 +196,7 @@
     if ((!(ks->optionGetPlasmaThumbnails () || mPreviews.empty ()) &&
         !(mSlideData || mSlideData->remaining)) ||
 	!window->mapNum ()                ||
-	(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK))
+	(mask & PAINT_WINDOW_NO_DRAW_MASKS))
     {
 	status = gWindow->glPaint (attrib, transform, region, mask);
 	return status;
@@ -210,7 +210,7 @@
 	CompRect           clipBox (window->x (), window->y (),
 				    window->width (), window->height ());
 
-	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+	if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
 	    return false;
 
 	remainder = (float) data->remaining / data->duration;

=== modified file 'plugins/move/src/move.cpp'
--- plugins/move/src/move.cpp	2013-01-03 16:05:26 +0000
+++ plugins/move/src/move.cpp	2013-02-28 03:13:24 +0000
@@ -158,14 +158,6 @@
 		if (mw->gWindow)
 		mw->gWindow->glPaintSetEnabled (mw, true);
 	    }
-
-	    if (ms->optionGetLazyPositioning ())
-	    {
-		MOVE_WINDOW (w);
-
-		if (mw->gWindow)
-		    mw->releasable = w->obtainLockOnConfigureRequests ();
-	    }
 	}
     }
 
@@ -181,8 +173,6 @@
 
     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);
@@ -204,14 +194,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;
     }
@@ -499,6 +489,9 @@
 	    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	2013-01-03 16:05:26 +0000
+++ plugins/move/src/move.h	2013-02-28 03:13:24 +0000
@@ -27,7 +27,6 @@
 
 #include <core/screen.h>
 #include <core/pluginclasshandler.h>
-#include <core/configurerequestbuffer.h>
 
 #include <composite/composite.h>
 #include <opengl/opengl.h>
@@ -118,7 +117,6 @@
 	CompWindow      *window;
 	GLWindow        *gWindow;
 	CompositeWindow *cWindow;
-	compiz::window::configure_buffers::Releasable::Ptr releasable;
 };
 
 #define MOVE_SCREEN(s) \

=== modified file 'plugins/opengl/include/opengl/opengl.h'
--- plugins/opengl/include/opengl/opengl.h	2013-01-10 09:23:24 +0000
+++ plugins/opengl/include/opengl/opengl.h	2013-02-28 03:13:24 +0000
@@ -37,6 +37,13 @@
 #else
 #include <GL/gl.h>
 #include <GL/glx.h>
+
+/* Some implementations have not yet given a definition
+ * to GLX_BACK_BUFFER_AGE_EXT but this is the token as defined
+ * in the spec (https://www.opengl.org/registry/specs/EXT/glx_buffer_age.txt)
+ */
+#define GLX_BACK_BUFFER_AGE_EXT 0x20F4
+
 #endif
 
 #include <core/size.h>
@@ -50,7 +57,7 @@
 #include <opengl/programcache.h>
 #include <opengl/shadercache.h>
 
-#define COMPIZ_OPENGL_ABI 6
+#define COMPIZ_OPENGL_ABI 8
 
 /*
  * Some plugins check for #ifdef USE_MODERN_COMPIZ_GL. Support it for now, but
@@ -525,6 +532,7 @@
     extern bool  shaders;
     extern bool  stencilBuffer;
     extern GLint maxTextureUnits;
+    extern bool  bufferAge;
 
     extern bool canDoSaturated;
     extern bool canDoSlightlySaturated;
@@ -663,6 +671,11 @@
 					      unsigned int         mask);
 
 	/**
+	 * Return true if glPaintCompositedOutput is required for this frame
+	 */
+	virtual bool glPaintCompositedOutputRequired ();
+
+	/**
 	 * Hookable function used by plugins to determine stenciling mask
 	 */
 	virtual void glBufferStencil (const GLMatrix       &matrix,
@@ -674,7 +687,7 @@
 extern template class PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI>;
 
 class GLScreen :
-    public WrapableHandler<GLScreenInterface, 8>,
+    public WrapableHandler<GLScreenInterface, 9>,
     public PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI>,
     public CompOption::Class
 {
@@ -788,7 +801,9 @@
 	WRAPABLE_HND (6, GLScreenInterface, void, glPaintCompositedOutput,
 		      const CompRegion &, GLFramebufferObject *, unsigned int);
 
-	WRAPABLE_HND (7, GLScreenInterface, void, glBufferStencil, const GLMatrix &,
+	WRAPABLE_HND (7, GLScreenInterface, bool, glPaintCompositedOutputRequired);
+
+	WRAPABLE_HND (8, GLScreenInterface, void, glBufferStencil, const GLMatrix &,
 		      GLVertexBuffer &,
 		      CompOutput *);
 

=== modified file 'plugins/opengl/src/doublebuffer/src/double-buffer.cpp'
--- plugins/opengl/src/doublebuffer/src/double-buffer.cpp	2012-11-09 06:13:00 +0000
+++ plugins/opengl/src/doublebuffer/src/double-buffer.cpp	2013-02-28 03:13:24 +0000
@@ -26,6 +26,7 @@
 
 #include <cstdlib>
 #include <cassert>
+#include <cstdio>
 #include "opengl/doublebuffer.h"
 
 using namespace compiz::opengl;
@@ -77,9 +78,7 @@
 
 	if (setting[NEED_PERSISTENT_BACK_BUFFER] &&
 	    !setting[HAVE_PERSISTENT_BACK_BUFFER])
-	{
 	    copyFrontToBack ();
-	}
     }
     else
     {

=== modified file 'plugins/opengl/src/framebufferobject.cpp'
--- plugins/opengl/src/framebufferobject.cpp	2012-08-06 09:44:49 +0000
+++ plugins/opengl/src/framebufferobject.cpp	2013-02-28 03:13:24 +0000
@@ -131,7 +131,7 @@
 
     (*GL::framebufferTexture2D) (GL::FRAMEBUFFER, GL::COLOR_ATTACHMENT0,
                                  priv->glTex->target (),
-                                 priv->glTex->name (), 0);
+				 priv->glTex->name (), 0);
 
     priv->status = (*GL::checkFramebufferStatus) (GL::DRAW_FRAMEBUFFER);
 

=== modified file 'plugins/opengl/src/paint.cpp'
--- plugins/opengl/src/paint.cpp	2013-01-03 16:05:26 +0000
+++ plugins/opengl/src/paint.cpp	2013-02-28 03:13:24 +0000
@@ -418,11 +418,6 @@
 	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;
 
@@ -432,6 +427,8 @@
 		continue;
 	}
 
+	gw = GLWindow::get (w);
+
 	const CompRegion &clip =
 	    (!(mask & PAINT_SCREEN_NO_OCCLUSION_DETECTION_MASK)) ?
 	    gw->clip () : region;
@@ -629,8 +626,8 @@
 	    if (mask & PAINT_SCREEN_FULL_MASK)
 	    {
 		glPaintTransformedOutput (sAttrib, sTransform,
-					  CompRegion (*output), output, mask);
-
+					  CompRegionRef (output->region ()), output, mask);
+		priv->cScreen->addOverdrawDamageRegion (CompRegionRef (output->region ()));
 		return true;
 	    }
 
@@ -660,8 +657,9 @@
     }
     else if (mask & PAINT_SCREEN_FULL_MASK)
     {
-	glPaintTransformedOutput (sAttrib, sTransform, CompRegion (*output),
+        glPaintTransformedOutput (sAttrib, sTransform, CompRegionRef (output->region ()),
 				  output, mask);
+	priv->cScreen->addOverdrawDamageRegion (CompRegionRef (output->region ()));
 
 	return true;
     }
@@ -671,6 +669,13 @@
     }
 }
 
+bool
+GLScreen::glPaintCompositedOutputRequired ()
+{
+    WRAPABLE_HND_FUNCTN_RETURN (bool, glPaintCompositedOutputRequired);
+    return false;
+}
+
 void
 GLScreen::glPaintCompositedOutput (const CompRegion    &region,
 				   GLFramebufferObject *fbo,

=== modified file 'plugins/opengl/src/privates.h'
--- plugins/opengl/src/privates.h	2013-01-03 16:05:26 +0000
+++ plugins/opengl/src/privates.h	2013-02-28 03:13:24 +0000
@@ -29,11 +29,13 @@
 #define _OPENGL_PRIVATES_H
 
 #include <memory>
+#include <vector>
+#include <tr1/tuple>
+#include <boost/shared_ptr.hpp>
 
 #include <composite/composite.h>
 #include <opengl/opengl.h>
 #include <core/atoms.h>
-#include <core/configurerequestbuffer.h>
 
 #ifdef USE_GLES
 #include <opengl/framebufferobject.h>
@@ -120,8 +122,26 @@
 	GLTexture::List textures;
 };
 
+class FrameProvider
+{
+    public:
+
+	typedef boost::shared_ptr <FrameProvider> Ptr;
+	typedef std::tr1::tuple <GLFramebufferObject *, int> Frame;
+
+	virtual ~FrameProvider () {}
+
+	virtual GLuint getCurrentFrame () = 0;
+	virtual void endFrame () = 0;
+
+	virtual bool providesPersistence () = 0;
+	virtual bool alwaysPostprocess () = 0;
+	virtual void invalidateAll () = 0;
+};
+
 class PrivateGLScreen :
     public ScreenInterface,
+    public CompositeScreenInterface,
     public compiz::composite::PaintHandler,
     public OpenglOptions
 {
@@ -142,12 +162,17 @@
 	bool hasVSync ();
 	bool requiredForcedRefreshRate ();
 
+	unsigned int getFrameAge ();
+
 	void updateRenderMode ();
+	void updateFrameProvider ();
 
 	void prepareDrawing ();
 
 	bool compositingActive ();
 
+	void damageCutoff ();
+
 	void paintBackground (const GLMatrix   &transform,
 	                      const CompRegion &region,
 			      bool             transformed);
@@ -163,6 +188,8 @@
 
 	bool driverIsBlacklisted (const char *regex) const;
 
+	bool postprocessRequiredForCurrentFrame ();
+
     public:
 
 	GLScreen        *gScreen;
@@ -197,7 +224,7 @@
 	GLXDoubleBuffer doubleBuffer;
 	#endif
 
-	GLFramebufferObject *scratchFbo;
+	boost::shared_ptr <GLFramebufferObject> scratchFbo;
 	CompRegion outputRegion;
 
 	XRectangle lastViewport;
@@ -222,8 +249,10 @@
 	Pixmap rootPixmapCopy;
 	CompSize rootPixmapSize;
 
+	FrameProvider::Ptr frameProvider;
 	const char *glVendor, *glRenderer, *glVersion;
 
+	bool postprocessingRequired;
 	mutable CompString prevRegex;
 	mutable bool       prevBlacklisted;
 };
@@ -284,8 +313,6 @@
 	GLVertexBuffer::AutoProgram *autoProgram;
 
 	std::list<GLIcon> icons;
-
-	compiz::window::configure_buffers::Releasable::Ptr configureLock;
 };
 
 #endif

=== modified file 'plugins/opengl/src/screen.cpp'
--- plugins/opengl/src/screen.cpp	2013-01-09 10:57:03 +0000
+++ plugins/opengl/src/screen.cpp	2013-02-28 03:13:24 +0000
@@ -186,6 +186,7 @@
     bool  vboEnabled = false;
     bool  shaders = false;
     GLint maxTextureUnits = 1;
+    bool  bufferAge = false;
 
     bool canDoSaturated = false;
     bool canDoSlightlySaturated = false;
@@ -301,6 +302,52 @@
 
 #ifndef USE_GLES
 
+class BufferAgeFrameProvider :
+    public FrameProvider
+{
+    public:
+
+	BufferAgeFrameProvider (Display     *disp,
+				GLXDrawable drawable) :
+	    mDisplay (disp),
+	    mDrawable (drawable)
+	{
+	}
+
+	unsigned int getCurrentFrame ()
+	{
+	    unsigned int age = 0;
+	    (*GL::queryDrawable) (mDisplay,
+				  mDrawable,
+				  GLX_BACK_BUFFER_AGE_EXT,
+				  &age);
+	    return age;
+	}
+
+	void endFrame ()
+	{
+	}
+
+	void invalidateAll ()
+	{
+	}
+
+	bool providesPersistence ()
+	{
+	    return true;
+	}
+
+	bool alwaysPostprocess ()
+	{
+	    return false;
+	}
+
+    private:
+
+	Display *mDisplay;
+	GLXDrawable mDrawable;
+};
+
 namespace compiz
 {
 namespace opengl
@@ -358,6 +405,137 @@
 
 #endif
 
+class UndefinedFrameProvider :
+    public FrameProvider
+{
+    public:
+
+	unsigned int getCurrentFrame ()
+	{
+	    return 0;
+	}
+
+	void endFrame ()
+	{
+	}
+
+	void invalidateAll ()
+	{
+	}
+
+	bool providesPersistence ()
+	{
+	    return false;
+	}
+
+	bool alwaysPostprocess ()
+	{
+	    return false;
+	}
+};
+
+class PostprocessFrameProvider :
+    public FrameProvider
+{
+    public:
+
+	PostprocessFrameProvider (GLFramebufferObject *object) :
+	    mObject (object),
+	    mAge (0)
+	{
+	}
+
+	unsigned int getCurrentFrame ()
+	{
+	    /* We are now using this buffer, reset
+	     * age back to zero */
+	    unsigned int lastAge = mAge;
+	    mAge = 0;
+
+	    return lastAge;
+	}
+
+	void endFrame ()
+	{
+	    ++mAge;
+	}
+
+	void invalidateAll ()
+	{
+	    mAge = 0;
+	}
+
+	bool providesPersistence ()
+	{
+	    return true;
+	}
+
+	bool alwaysPostprocess ()
+	{
+	    return true;
+	}
+
+    private:
+
+	GLFramebufferObject *mObject;
+	unsigned int        mAge;
+};
+
+class OptionalPostprocessFrameProvider :
+    public FrameProvider
+{
+    public:
+
+	typedef boost::function <bool ()> PostprocessRequired;
+
+	OptionalPostprocessFrameProvider (const FrameProvider::Ptr  &backbuffer,
+					  const FrameProvider::Ptr  &scratchbuffer,
+					  const PostprocessRequired &ppRequired) :
+	    mBackbuffer (backbuffer),
+	    mScratchbuffer (scratchbuffer),
+	    mPPRequired (ppRequired)
+	{
+	}
+
+	unsigned int getCurrentFrame ()
+	{
+	    if (mPPRequired ())
+		return mScratchbuffer->getCurrentFrame ();
+	    else
+		return mBackbuffer->getCurrentFrame ();
+	}
+
+	void endFrame ()
+	{
+	    mScratchbuffer->endFrame ();
+	}
+
+	void invalidateAll ()
+	{
+	    mScratchbuffer->invalidateAll ();
+	}
+
+	bool providesPersistence ()
+	{
+	    /* We are only as good as the backbuffer is */
+	    return mBackbuffer->providesPersistence ();
+	}
+
+	bool alwaysPostprocess ()
+	{
+	    if (mPPRequired ())
+		return mScratchbuffer->alwaysPostprocess ();
+	    else
+		return mBackbuffer->alwaysPostprocess ();
+	}
+
+    private:
+
+	FrameProvider::Ptr mBackbuffer;
+	FrameProvider::Ptr mScratchbuffer;
+	PostprocessRequired mPPRequired;
+};
+
 bool
 GLScreen::glInitContext (XVisualInfo *visinfo)
 {
@@ -593,6 +771,8 @@
 
     priv->incorrectRefreshRate = false;
 
+    priv->frameProvider.reset (new PostprocessFrameProvider ());
+
     #else
 
     Display		 *dpy = screen->dpy ();
@@ -899,12 +1079,17 @@
 
     if (GL::fboSupported)
     {
-	priv->scratchFbo = new GLFramebufferObject;
+	priv->scratchFbo.reset (new GLFramebufferObject ());
 	priv->scratchFbo->allocate (*screen, NULL, GL_BGRA);
     }
 
     GLVertexBuffer::streamingBuffer ()->setAutoProgram (priv->autoProgram);
 
+    /* We need scratchFbo to be set before doing this, and it is common
+     * to both the GLES and non-GLES codepaths, so using another #ifdef
+     */
+    priv->updateFrameProvider ();
+
     return true;
 }
 
@@ -993,6 +1178,13 @@
 	return;
     }
 
+    if (strstr (glxExtensions, "GLX_EXT_buffer_age"))
+    {
+	compLogMessage ("opengl", CompLogLevelInfo,
+			"GLX_EXT_buffer_age is supported");
+	GL::bufferAge = true;
+    }
+
     priv->getProcAddress = (GL::GLXGetProcAddressProc)
 	getProcAddress ("glXGetProcAddressARB");
     GL::bindTexImage = (GL::GLXBindTexImageProc)
@@ -1209,9 +1401,6 @@
 	glXDestroyContext (screen->dpy (), priv->ctx);
     #endif
 
-    if (priv->scratchFbo)
-	delete priv->scratchFbo;
-
     delete priv;
 }
 
@@ -1233,7 +1422,7 @@
     ctx (EGL_NO_CONTEXT),
     doubleBuffer (screen->dpy (), *screen, surface),
     #endif
-    scratchFbo (NULL),
+    scratchFbo (),
     outputRegion (),
     refreshSubBuffer (false),
     lastMask (0),
@@ -1246,13 +1435,16 @@
     autoProgram (new GLScreenAutoProgram(gs)),
     rootPixmapCopy (None),
     rootPixmapSize (),
+    frameProvider (),
     glVendor (NULL),
     glRenderer (NULL),
     glVersion (NULL),
+    postprocessingRequired (false),
     prevRegex (),
     prevBlacklisted (false)
 {
     ScreenInterface::setHandler (screen);
+    CompositeScreenInterface::setHandler (cScreen);
 }
 
 PrivateGLScreen::~PrivateGLScreen ()
@@ -1443,8 +1635,11 @@
 {
     screen->outputChangeNotify ();
 
+    frameProvider->invalidateAll ();
+
     if (scratchFbo)
 	scratchFbo->allocate (*screen, NULL, GL_BGRA);
+
     updateView ();
 }
 
@@ -1669,6 +1864,10 @@
 GLScreenInterface::projectionMatrix ()
     WRAPABLE_DEF (projectionMatrix)
 
+bool
+GLScreenInterface::glPaintCompositedOutputRequired ()
+    WRAPABLE_DEF (glPaintCompositedOutputRequired)
+
 void
 GLScreenInterface::glPaintCompositedOutput (const CompRegion    &region,
 					    GLFramebufferObject *fbo,
@@ -1977,18 +2176,6 @@
     glDepthMask (GL_FALSE);
     glStencilMask (0);
 
-    GLFramebufferObject *oldFbo = NULL;
-    bool useFbo = false;
-
-    /* Clear the color buffer where appropriate */
-    if (GL::fboEnabled && scratchFbo)
-    {
-	oldFbo = scratchFbo->bind ();
-	useFbo = scratchFbo->checkStatus () && scratchFbo->tex ();
-	if (!useFbo)
-	    GLFramebufferObject::rebind (oldFbo);
-    }
-
 #ifdef UNSAFE_ARM_SGX_FIXME
     refreshSubBuffer = ((lastMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
                         !(mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
@@ -2006,8 +2193,21 @@
     }
 #endif
 
-    CompRegion tmpRegion = (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) ?
-                           screen->region () : region;
+    CompRegion paintRegion ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) ?
+			     screen->region () : region);
+    bool useFbo = false;
+    GLFramebufferObject *oldFbo = NULL;
+
+    postprocessingRequired = gScreen->glPaintCompositedOutputRequired ();
+    postprocessingRequired |= frameProvider->alwaysPostprocess ();
+
+    /* Clear the color buffer where appropriate */
+    if ((GL::fboEnabled && postprocessRequiredForCurrentFrame ()))
+    {
+	oldFbo = scratchFbo->bind ();
+	if (scratchFbo->checkStatus ())
+	    useFbo = true;
+    }
 
     foreach (CompOutput *output, outputs)
     {
@@ -2034,7 +2234,8 @@
 
 	    gScreen->glPaintOutput (defaultScreenPaintAttrib,
 				    identity,
-				    CompRegion (*output), output,
+				    CompRegion (*output),
+				    output,
 				    PAINT_SCREEN_REGION_MASK |
 				    PAINT_SCREEN_FULL_MASK);
 	}
@@ -2057,7 +2258,9 @@
 		tmpRegion = CompRegion (*output);
 #endif
 
-	    outputRegion = tmpRegion & CompRegion (*output);
+	    /* Clip current paint region to output extents */
+	    CompRegionRef wholeOutput (output->region ());
+	    outputRegion = (paintRegion & wholeOutput);
 
 	    if (!gScreen->glPaintOutput (defaultScreenPaintAttrib,
 					 identity,
@@ -2068,10 +2271,11 @@
 
 		gScreen->glPaintOutput (defaultScreenPaintAttrib,
 					identity,
-					CompRegion (*output), output,
+					wholeOutput, output,
 					PAINT_SCREEN_FULL_MASK);
 
-		tmpRegion += *output;
+		paintRegion += wholeOutput;
+		cScreen->addOverdrawDamageRegion (wholeOutput);
 	    }
 	}
     }
@@ -2082,13 +2286,18 @@
 
     if (useFbo)
     {
-	GLFramebufferObject::rebind (oldFbo);
-
 	// FIXME: does not work if screen dimensions exceed max texture size
 	//        We should try to use glBlitFramebuffer instead.
-	gScreen->glPaintCompositedOutput (screen->region (), scratchFbo, mask);
+	GLFramebufferObject::rebind (oldFbo);
+	/* If we must always postprocess, then we don't have any
+	 * "real" backbuffer persistence, redraw the whole thing */
+	gScreen->glPaintCompositedOutput (frameProvider->alwaysPostprocess () ?
+					      screen->region () :
+					      paintRegion, scratchFbo.get (), mask);
     }
 
+    frameProvider->endFrame ();
+
     if (cScreen->outputWindowChanged ())
     {
 	/*
@@ -2100,20 +2309,27 @@
 	return;
     }
 
+    bool persistence = frameProvider->providesPersistence ();
     bool alwaysSwap = optionGetAlwaysSwapBuffers ();
-    bool fullscreen = useFbo ||
+    bool fullscreen = persistence ||
                       alwaysSwap ||
                       ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
                        commonFrontbuffer);
 
     doubleBuffer.set (DoubleBuffer::VSYNC, optionGetSyncToVblank ());
-    doubleBuffer.set (DoubleBuffer::HAVE_PERSISTENT_BACK_BUFFER, useFbo);
+    doubleBuffer.set (DoubleBuffer::HAVE_PERSISTENT_BACK_BUFFER, persistence);
     doubleBuffer.set (DoubleBuffer::NEED_PERSISTENT_BACK_BUFFER, alwaysSwap);
-    doubleBuffer.render (tmpRegion, fullscreen);
+    doubleBuffer.render (paintRegion, fullscreen);
 
     lastMask = mask;
 }
 
+unsigned int
+PrivateGLScreen::getFrameAge ()
+{
+    return frameProvider->getCurrentFrame ();
+}
+
 bool
 PrivateGLScreen::hasVSync ()
 {
@@ -2138,6 +2354,13 @@
 }
 
 void
+PrivateGLScreen::damageCutoff ()
+{
+    cScreen->applyDamageForFrameAge (frameProvider->getCurrentFrame ());
+    cScreen->damageCutoff ();
+}
+
+void
 PrivateGLScreen::updateRenderMode ()
 {
 #ifndef USE_GLES
@@ -2147,12 +2370,54 @@
 }
 
 void
+PrivateGLScreen::updateFrameProvider ()
+{
+#ifndef USE_GLES
+    const Window outputWindow = CompositeScreen::get (screen)->output ();
+
+    if (GL::fboEnabled)
+    {
+	if (GL::bufferAge)
+	{
+	    FrameProvider::Ptr back (new BufferAgeFrameProvider (screen->dpy (),
+								 outputWindow));
+	    FrameProvider::Ptr scratch (new PostprocessFrameProvider (scratchFbo.get ()));
+	    OptionalPostprocessFrameProvider::PostprocessRequired ppReq
+		    (boost::bind (&PrivateGLScreen::postprocessRequiredForCurrentFrame,
+				  this));
+	    frameProvider.reset (new OptionalPostprocessFrameProvider (back,
+								       scratch,
+								       ppReq));
+	}
+	else
+	{
+	    /* Prefer using FBO's instead of switching between a defined/undefined backbuffer */
+	    frameProvider.reset (new PostprocessFrameProvider (scratchFbo.get ()));
+	}
+    }
+    else
+    {
+	if (GL::bufferAge)
+	    frameProvider.reset (new BufferAgeFrameProvider (screen->dpy (),
+								   outputWindow));
+	else
+	    frameProvider.reset (new UndefinedFrameProvider ());
+    }
+#else
+    frameProvider.reset (new PostprocessFrameProvider (scratchFbo.get ()));
+#endif
+}
+
+void
 PrivateGLScreen::prepareDrawing ()
 {
     bool wasFboEnabled = GL::fboEnabled;
     updateRenderMode ();
     if (wasFboEnabled != GL::fboEnabled)
+    {
+	updateFrameProvider ();
 	CompositeScreen::get (screen)->damageScreen ();
+    }
 }
 
 bool
@@ -2170,6 +2435,12 @@
     return prevBlacklisted;
 }
 
+bool
+PrivateGLScreen::postprocessRequiredForCurrentFrame ()
+{
+    return postprocessingRequired;
+}
+
 GLTexture::BindPixmapHandle
 GLScreen::registerBindPixmap (GLTexture::BindPixmapProc proc)
 {
@@ -2198,7 +2469,7 @@
 GLFramebufferObject *
 GLScreen::fbo ()
 {
-    return priv->scratchFbo;
+    return priv->scratchFbo.get ();
 }
 
 GLTexture *

=== modified file 'plugins/opengl/src/window.cpp'
--- plugins/opengl/src/window.cpp	2013-01-03 16:05:26 +0000
+++ plugins/opengl/src/window.cpp	2013-02-28 03:13:24 +0000
@@ -86,8 +86,7 @@
     bindFailed (false),
     vertexBuffer (new GLVertexBuffer ()),
     autoProgram(new GLWindowAutoProgram(this)),
-    icons (),
-    configureLock (w->obtainLockOnConfigureRequests ())
+    icons ()
 {
     paint.xScale	= 1.0f;
     paint.yScale	= 1.0f;

=== modified file 'plugins/resize/src/resize.cpp'
--- plugins/resize/src/resize.cpp	2012-10-19 09:23:11 +0000
+++ plugins/resize/src/resize.cpp	2013-02-28 03:13:24 +0000
@@ -257,7 +257,7 @@
 	float	       xScale, yScale;
 	int            x, y;
 
-	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+	if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
 	    return false;
 
 	status = gWindow->glPaint (attrib, transform, region,

=== modified file 'plugins/ring/src/ring.cpp'
--- plugins/ring/src/ring.cpp	2013-01-19 11:47:22 +0000
+++ plugins/ring/src/ring.cpp	2013-02-28 03:13:24 +0000
@@ -264,7 +264,7 @@
 	    GLWindowPaintAttrib wAttrib (gWindow->lastPaintAttrib ());
 	    GLMatrix           wTransform = transform;
 
-	    if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+	    if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
 		return false;
 
 	    if (mSlot)

=== modified file 'plugins/scale/src/scale.cpp'
--- plugins/scale/src/scale.cpp	2013-01-29 23:16:32 +0000
+++ plugins/scale/src/scale.cpp	2013-02-28 03:13:24 +0000
@@ -384,12 +384,14 @@
 
 	status = gWindow->glPaint (sAttrib, transform, region, mask);
 
+	mask &= ~(PAINT_WINDOW_NO_CORE_INSTANCE_MASK);
+
 	if (scaled)
 	{
 	    GLWindowPaintAttrib lastAttrib (gWindow->lastPaintAttrib ());
 	    GLMatrix           wTransform (transform);
 
-	    if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+	    if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
 		return false;
 
 	    if (window->alpha () || lastAttrib.opacity != OPAQUE)

=== modified file 'plugins/staticswitcher/src/staticswitcher.cpp'
--- plugins/staticswitcher/src/staticswitcher.cpp	2012-12-10 03:28:47 +0000
+++ plugins/staticswitcher/src/staticswitcher.cpp	2013-02-28 03:13:24 +0000
@@ -1246,7 +1246,7 @@
 
 	const CompWindow::Geometry &g = window->geometry ();
 
-	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK ||
+	if (mask & PAINT_WINDOW_NO_DRAW_MASKS ||
 	    sScreen->ignoreSwitcher)
 	    return false;
 

=== modified file 'plugins/switcher/src/switcher.cpp'
--- plugins/switcher/src/switcher.cpp	2012-12-10 03:28:47 +0000
+++ plugins/switcher/src/switcher.cpp	2013-02-28 03:13:24 +0000
@@ -971,7 +971,7 @@
 
 	const CompWindow::Geometry &g = window->geometry ();
 
-	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK ||
+	if (mask & PAINT_WINDOW_NO_DRAW_MASKS ||
 	    sScreen->ignoreSwitcher)
 	    return false;
 

=== modified file 'plugins/td/src/3d.cpp'
--- plugins/td/src/3d.cpp	2013-02-03 17:50:59 +0000
+++ plugins/td/src/3d.cpp	2013-02-28 03:13:24 +0000
@@ -163,7 +163,7 @@
     glGetIntegerv (GL_CULL_FACE_MODE, &cull);
     cullInv = (cull == GL_BACK)? GL_FRONT : GL_BACK;
 
-    if (ww && wh && !(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK) &&
+    if (ww && wh && !(mask & PAINT_WINDOW_NO_DRAW_MASKS) &&
 	((cs->paintOrder () == FTB && mFtb) ||
 	(cs->paintOrder () == BTF && !mFtb)))
     {

=== modified file 'plugins/water/src/water.cpp'
--- plugins/water/src/water.cpp	2013-01-28 19:45:04 +0000
+++ plugins/water/src/water.cpp	2013-02-28 03:13:24 +0000
@@ -317,6 +317,12 @@
     }
 }
 
+bool
+WaterScreen::glPaintCompositedOutputRequired ()
+{
+    return true;
+}
+
 void
 WaterScreen::glPaintCompositedOutput (const CompRegion    &region,
                                       GLFramebufferObject *fbo,
@@ -467,6 +473,7 @@
 	cScreen->preparePaintSetEnabled (this, false);
 	gScreen->glPaintOutputSetEnabled (this, false);
 	gScreen->glPaintCompositedOutputSetEnabled (this, false);
+	gScreen->glPaintCompositedOutputRequiredSetEnabled (this, false);
 	cScreen->donePaintSetEnabled (this, false);
     }
 

=== modified file 'plugins/water/src/water.h'
--- plugins/water/src/water.h	2012-09-07 23:56:21 +0000
+++ plugins/water/src/water.h	2013-02-28 03:13:24 +0000
@@ -64,6 +64,7 @@
 
 	void handleEvent (XEvent *);
 
+	bool glPaintCompositedOutputRequired ();
 	void glPaintCompositedOutput (const CompRegion    &region,
 				      GLFramebufferObject *fbo,
 				      unsigned int         mask);

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2013-01-03 16:05:26 +0000
+++ src/CMakeLists.txt	2013-02-28 03:13:24 +0000
@@ -160,12 +160,6 @@
     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)
 
@@ -198,7 +192,6 @@
     compiz_servergrab
     compiz_output
     compiz_outputdevices
-    compiz_configurerequestbuffer
     -Wl,-no-whole-archive
 #    ${CORE_MOD_LIBRARIES}
 )

=== removed file 'src/asyncserverwindow.h'
--- src/asyncserverwindow.h	2012-12-13 11:12:32 +0000
+++ src/asyncserverwindow.h	1970-01-01 00:00:00 +0000
@@ -1,52 +0,0 @@
-/*
- * 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

=== removed file 'src/configurerequestbuffer-impl.h'
--- src/configurerequestbuffer-impl.h	2012-12-13 11:12:32 +0000
+++ src/configurerequestbuffer-impl.h	1970-01-01 00:00:00 +0000
@@ -1,145 +0,0 @@
-/*
- * 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

=== removed file 'src/configurerequestbuffer.cpp'
--- src/configurerequestbuffer.cpp	2013-02-14 12:12:53 +0000
+++ src/configurerequestbuffer.cpp	1970-01-01 00:00:00 +0000
@@ -1,363 +0,0 @@
-/*
- * 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-02-10 05:01:50 +0000
+++ src/event.cpp	2013-02-28 03:13:24 +0000
@@ -1947,7 +1947,7 @@
 
 	    /* We should check the override_redirect flag here, because the
 	       client might have changed it while being unmapped. */
-	    if (w->queryAttributes (attr))
+	    if (XGetWindowAttributes (privateScreen.dpy, w->id (), &attr))
 		w->priv->setOverrideRedirect (attr.override_redirect != 0);
 
 	    if (w->state () & CompWindowStateHiddenMask)

=== modified file 'src/privatewindow.h'
--- src/privatewindow.h	2013-02-10 05:01:50 +0000
+++ src/privatewindow.h	2013-02-28 03:13:24 +0000
@@ -35,11 +35,6 @@
 
 #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
@@ -112,47 +107,12 @@
 
 typedef CompWindowExtents CompFullscreenMonitorSet;
 
-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
-{
+class PrivateWindow {
 
     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 ();
@@ -422,7 +382,6 @@
 
 	CompWindowExtents input;
 	CompWindowExtents serverInput;
-	CompWindowExtents lastServerInput;
 	CompWindowExtents border;
 	CompWindowExtents output;
 
@@ -448,9 +407,6 @@
 	Time lastCloseRequestTime;
 
 	bool nextMoveImmediate;
-
-	X11SyncServerWindow                            syncServerWindow;
-	compiz::window::configure_buffers::Buffer::Ptr configureBuffer;
 };
 
 #endif

=== removed file 'src/serverwindow.h'
=== removed file 'src/syncserverwindow.h'
--- src/syncserverwindow.h	2012-12-13 11:12:32 +0000
+++ src/syncserverwindow.h	1970-01-01 00:00:00 +0000
@@ -1,49 +0,0 @@
-/*
- * 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-02-10 05:01:50 +0000
+++ src/tests/CMakeLists.txt	2013-02-28 03:13:24 +0000
@@ -30,14 +30,3 @@
 
 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)

=== removed file 'src/tests/test_configurerequestbuffer.cpp'
--- src/tests/test_configurerequestbuffer.cpp	2012-12-13 14:07:01 +0000
+++ src/tests/test_configurerequestbuffer.cpp	1970-01-01 00:00:00 +0000
@@ -1,667 +0,0 @@
-/*
- * 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 ();
-}
-