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)

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

3564. By Sam Spilsbury on 2013-02-15

Merge lp:compiz

3565. By Sam Spilsbury on 2013-02-18

Revert more changes which should not have happened

3566. By Sam Spilsbury on 2013-02-25

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.

3568. By Sam Spilsbury on 2013-02-28

Merge lp:compiz

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/window.h'
--- include/core/window.h	2013-01-03 16:06:41 +0000
+++ include/core/window.h	2013-02-13 11:42:35 +0000
@@ -43,12 +43,12 @@
 #include <core/region.h>
 #include <core/windowgeometry.h>
 #include <core/windowextents.h>
-#include <core/servergrab.h>
 
 #include <core/wrapsystem.h>
 
 #include <map>
 
+class ServerLock;
 class CompWindow;
 class CompIcon;
 class PrivateWindow;
@@ -434,7 +434,7 @@
 	void moveInputFocusToOtherWindow ();
 
 	/* wraps XConfigureWindow and updates serverGeometry */
-	void configureXWindow (unsigned int   valueMask,
+	void configureXWindow (unsigned int valueMask,
 			       XWindowChanges *xwc);
 
 	void restackAndConfigureXWindow (unsigned int     valueMask,

=== 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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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/kdecompat/src/kdecompat.cpp'
--- plugins/kdecompat/src/kdecompat.cpp	2012-08-14 06:33:22 +0000
+++ plugins/kdecompat/src/kdecompat.cpp	2013-02-13 11:42:35 +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/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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-01 10:04:50 +0000
+++ plugins/opengl/src/paint.cpp	2013-02-13 11:42:35 +0000
@@ -626,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;
 	    }
 
@@ -657,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;
     }
@@ -668,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-01 09:41:41 +0000
+++ plugins/opengl/src/privates.h	2013-02-13 11:42:35 +0000
@@ -29,6 +29,9 @@
 #define _OPENGL_PRIVATES_H
 
 #include <memory>
+#include <vector>
+#include <tr1/tuple>
+#include <boost/shared_ptr.hpp>
 
 #include <composite/composite.h>
 #include <opengl/opengl.h>
@@ -119,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
 {
@@ -141,12 +162,16 @@
 	bool hasVSync ();
 	bool requiredForcedRefreshRate ();
 
+	unsigned int getFrameAge ();
+
 	void updateRenderMode ();
 
 	void prepareDrawing ();
 
 	bool compositingActive ();
 
+	void damageCutoff ();
+
 	void paintBackground (const GLMatrix   &transform,
 	                      const CompRegion &region,
 			      bool             transformed);
@@ -162,6 +187,8 @@
 
 	bool driverIsBlacklisted (const char *regex) const;
 
+	bool postprocessRequiredForCurrentFrame ();
+
     public:
 
 	GLScreen        *gScreen;
@@ -196,7 +223,7 @@
 	GLXDoubleBuffer doubleBuffer;
 	#endif
 
-	GLFramebufferObject *scratchFbo;
+	boost::shared_ptr <GLFramebufferObject> scratchFbo;
 	CompRegion outputRegion;
 
 	XRectangle lastViewport;
@@ -221,8 +248,10 @@
 	Pixmap rootPixmapCopy;
 	CompSize rootPixmapSize;
 
+	FrameProvider::Ptr frameProvider;
 	const char *glVendor, *glRenderer, *glVersion;
 
+	bool postprocessingRequired;
 	mutable CompString prevRegex;
 	mutable bool       prevBlacklisted;
 };

=== 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-13 11:42:35 +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,48 @@
 
     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
+     */
+#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 (priv->scratchFbo.get ()));
+	    OptionalPostprocessFrameProvider::PostprocessRequired ppReq
+		    (boost::bind (&PrivateGLScreen::postprocessRequiredForCurrentFrame,
+				  priv));
+	    priv->frameProvider.reset (new OptionalPostprocessFrameProvider (back,
+									     scratch,
+									     ppReq));
+	}
+	else
+	{
+	    /* Prefer using FBO's instead of switching between a defined/undefined backbuffer */
+	    priv->frameProvider.reset (new PostprocessFrameProvider (priv->scratchFbo.get ()));
+	}
+    }
+    else
+    {
+	if (GL::bufferAge)
+	    priv->frameProvider.reset (new BufferAgeFrameProvider (screen->dpy (),
+								   outputWindow));
+	else
+	    priv->frameProvider.reset (new UndefinedFrameProvider ());
+    }
+#endif
+
     return true;
 }
 
@@ -993,6 +1209,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 +1432,6 @@
 	glXDestroyContext (screen->dpy (), priv->ctx);
     #endif
 
-    if (priv->scratchFbo)
-	delete priv->scratchFbo;
-
     delete priv;
 }
 
@@ -1233,7 +1453,7 @@
     ctx (EGL_NO_CONTEXT),
     doubleBuffer (screen->dpy (), *screen, surface),
     #endif
-    scratchFbo (NULL),
+    scratchFbo (),
     outputRegion (),
     refreshSubBuffer (false),
     lastMask (0),
@@ -1246,13 +1466,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 +1666,11 @@
 {
     screen->outputChangeNotify ();
 
+    frameProvider->invalidateAll ();
+
     if (scratchFbo)
 	scratchFbo->allocate (*screen, NULL, GL_BGRA);
+
     updateView ();
 }
 
@@ -1669,6 +1895,10 @@
 GLScreenInterface::projectionMatrix ()
     WRAPABLE_DEF (projectionMatrix)
 
+bool
+GLScreenInterface::glPaintCompositedOutputRequired ()
+    WRAPABLE_DEF (glPaintCompositedOutputRequired)
+
 void
 GLScreenInterface::glPaintCompositedOutput (const CompRegion    &region,
 					    GLFramebufferObject *fbo,
@@ -1977,18 +2207,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 +2224,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 +2265,8 @@
 
 	    gScreen->glPaintOutput (defaultScreenPaintAttrib,
 				    identity,
-				    CompRegion (*output), output,
+				    CompRegion (*output),
+				    output,
 				    PAINT_SCREEN_REGION_MASK |
 				    PAINT_SCREEN_FULL_MASK);
 	}
@@ -2057,7 +2289,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 +2302,11 @@
 
 		gScreen->glPaintOutput (defaultScreenPaintAttrib,
 					identity,
-					CompRegion (*output), output,
+					wholeOutput, output,
 					PAINT_SCREEN_FULL_MASK);
 
-		tmpRegion += *output;
+		paintRegion += wholeOutput;
+		cScreen->addOverdrawDamageRegion (wholeOutput);
 	    }
 	}
     }
@@ -2082,13 +2317,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 +2340,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 +2385,13 @@
 }
 
 void
+PrivateGLScreen::damageCutoff ()
+{
+    cScreen->applyDamageForFrameAge (frameProvider->getCurrentFrame ());
+    cScreen->damageCutoff ();
+}
+
+void
 PrivateGLScreen::updateRenderMode ()
 {
 #ifndef USE_GLES
@@ -2170,6 +2424,12 @@
     return prevBlacklisted;
 }
 
+bool
+PrivateGLScreen::postprocessRequiredForCurrentFrame ()
+{
+    return postprocessingRequired;
+}
+
 GLTexture::BindPixmapHandle
 GLScreen::registerBindPixmap (GLTexture::BindPixmapProc proc)
 {
@@ -2198,7 +2458,7 @@
 GLFramebufferObject *
 GLScreen::fbo ()
 {
-    return priv->scratchFbo;
+    return priv->scratchFbo.get ();
 }
 
 GLTexture *

=== 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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +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-13 11:42:35 +0000
@@ -64,6 +64,7 @@
 
 	void handleEvent (XEvent *);
 
+	bool glPaintCompositedOutputRequired ();
 	void glPaintCompositedOutput (const CompRegion    &region,
 				      GLFramebufferObject *fbo,
 				      unsigned int         mask);

=== modified file 'src/event.cpp'
--- src/event.cpp	2013-01-03 16:06:41 +0000
+++ src/event.cpp	2013-02-13 11:42:35 +0000
@@ -1288,17 +1288,6 @@
 	if (!XGetWindowAttributes (privateScreen.dpy, event->xcreatewindow.window, &wa))
 	    privateScreen.setDefaultWindowAttributes (&wa);
 
-	/* That being said, we should store as much information as possible
-	 * about it. There may be requests relative to this window that could
-	 * use the data in the XCreateWindowEvent structure, especially the
-	 * override redirect state */
-	wa.x = event->xcreatewindow.x;
-	wa.y = event->xcreatewindow.y;
-	wa.width = event->xcreatewindow.width;
-	wa.height = event->xcreatewindow.height;
-	wa.border_width = event->xcreatewindow.border_width;
-	wa.override_redirect = event->xcreatewindow.override_redirect;
-
 	foreach (CompWindow *w, screen->windows ())
 	{
 	    if (w->priv->serverFrame == event->xcreatewindow.window)
@@ -1478,15 +1467,7 @@
 		if (!XGetWindowAttributes (privateScreen.dpy, event->xcreatewindow.window, &wa))
 		    privateScreen.setDefaultWindowAttributes (&wa);
 
-		/* That being said, we should store as much information as possible
-		 * about it. There may be requests relative to this window that could
-		 * use the data in the XCreateWindowEvent structure, especially the
-		 * override redirect state */
-		wa.x = event->xreparent.x;
-		wa.y = event->xreparent.y;
-		wa.override_redirect = event->xreparent.override_redirect;
-
-		PrivateWindow::createCompWindow (getTopWindow ()->id (), getTopServerWindow ()->id (), wa, event->xreparent.window);
+		PrivateWindow::createCompWindow (getTopWindow ()->id (), getTopServerWindow ()->id (), wa, event->xcreatewindow.window);
 		break;
 	    }
 	    else
@@ -2118,10 +2099,7 @@
 					ServerLock lock (screen->serverGrabInterface ());
 
 					/* This will be the window that we must lower relative to */
-					CompWindow *sibling =
-						PrivateWindow::findValidStackSiblingBelow (active,
-											   fsw,
-											   lock);
+					CompWindow *sibling = PrivateWindow::findValidStackSiblingBelow (active, fsw, lock);
 
 					if (sibling)
 					{
@@ -2199,11 +2177,7 @@
 		if (w)
 		{
 		    ServerLock lock (screen->serverGrabInterface ());
-		    if (PrivateWindow::stackDocks (w,
-						   dockWindows,
-						   &xwc,
-						   &mask,
-						   lock))
+		    if (PrivateWindow::stackDocks (w, dockWindows, &xwc, &mask, lock))
 		    {
 			Window sibling = xwc.sibling;
 			xwc.stack_mode = Above;

=== modified file 'src/option/tests/CMakeLists.txt'
--- src/option/tests/CMakeLists.txt	2012-12-10 13:01:00 +0000
+++ src/option/tests/CMakeLists.txt	2013-02-13 11:42:35 +0000
@@ -10,7 +10,6 @@
   ${compiz_SOURCE_DIR}/src/point/include
   ${compiz_SOURCE_DIR}/src/window/geometry/include
   ${compiz_SOURCE_DIR}/src/window/extents/include
-  ${compiz_SOURCE_DIR}/src/servergrab/include
   ${COMPIZ_INCLUDE_DIRS}
 )
 

=== modified file 'src/option/tests/option.cpp'
--- src/option/tests/option.cpp	2012-12-10 13:01:00 +0000
+++ src/option/tests/option.cpp	2013-02-13 11:42:35 +0000
@@ -1,9 +1,5 @@
 #include <gtest/gtest.h>
 
-/* XXX: including core.h means that we pull in
- * both window.h and screen.h which are cascading
- * includes. We should eliminate this dependency
- */
 #include "core/core.h"
 #include "core/action.h"
 #include "core/match.h"

=== modified file 'src/outputdevices.h'
--- src/outputdevices.h	2012-12-10 13:01:00 +0000
+++ src/outputdevices.h	2013-02-13 11:42:35 +0000
@@ -25,11 +25,6 @@
 #include <core/output.h>
 #include <core/rect.h>
 #include <core/region.h>
-
-/* XXX: Including screen.h includes window.h and other unnecessary
- * headers which cause cascading header dependencies. We should seek to
- * eliminate this dependency
- */
 #include <core/screen.h>
 
 namespace compiz

=== modified file 'src/privatewindow.h'
--- src/privatewindow.h	2013-01-03 16:06:41 +0000
+++ src/privatewindow.h	2013-02-13 11:42:35 +0000
@@ -33,6 +33,8 @@
 #include <core/point.h>
 #include <core/timer.h>
 
+class ServerLock;
+
 #include <boost/shared_ptr.hpp>
 
 #define XWINDOWCHANGES_INIT {0, 0, 0, 0, 0, None, 0}
@@ -127,22 +129,23 @@
 
 	bool isInvisible() const;
 
-	static bool stackLayerCheck (CompWindow       *w,
-				     Window           clientLeader,
-				     CompWindow       *below,
+	static bool stackLayerCheck (CompWindow *w,
+				     Window     clientLeader,
+				     CompWindow *below,
 				     const ServerLock &lock);
 
-	static bool avoidStackingRelativeTo (CompWindow *w, const ServerLock &lock);
+	static bool avoidStackingRelativeTo (CompWindow *w,
+					     const ServerLock &lock);
 
-	static CompWindow * findSiblingBelow (CompWindow       *w,
-					      bool             aboveFs,
+	static CompWindow * findSiblingBelow (CompWindow *w,
+					      bool       aboveFs,
 					      const ServerLock &lock);
 
-	static CompWindow * findLowestSiblingBelow (CompWindow       *w,
+	static CompWindow * findLowestSiblingBelow (CompWindow *w,
 						    const ServerLock &lock);
 
-	static bool validSiblingBelow (CompWindow       *w,
-				       CompWindow       *sibling,
+	static bool validSiblingBelow (CompWindow *w,
+				       CompWindow *sibling,
 				       const ServerLock &lock);
 
 	void saveGeometry (int mask);
@@ -152,21 +155,21 @@
 	void reconfigureXWindow (unsigned int   valueMask,
 				 XWindowChanges *xwc);
 
-	static bool stackDocks (CompWindow       *w,
-				CompWindowList   &updateList,
-				XWindowChanges   *xwc,
-				unsigned int     *mask,
+	static bool stackDocks (CompWindow     *w,
+				CompWindowList &updateList,
+				XWindowChanges *xwc,
+				unsigned int   *mask,
 				const ServerLock &lock);
 
-	static bool stackTransients (CompWindow       *w,
-				     CompWindow       *avoid,
-				     XWindowChanges   *xwc,
-				     CompWindowList   &updateList,
+	static bool stackTransients (CompWindow     *w,
+				     CompWindow     *avoid,
+				     XWindowChanges *xwc,
+				     CompWindowList &updateList,
 				     const ServerLock &lock);
 
-	static void stackAncestors (CompWindow       *w,
-				    XWindowChanges   *xwc,
-				    CompWindowList   &updateList,
+	static void stackAncestors (CompWindow *w,
+				    XWindowChanges *xwc,
+				    CompWindowList &updateList,
 				    const ServerLock &lock);
 
 	static bool isAncestorTo (CompWindow *transient,
@@ -179,8 +182,8 @@
 	int addWindowSizeChanges (XWindowChanges *xwc,
 				  CompWindow::Geometry old);
 
-	int addWindowStackChanges (XWindowChanges   *xwc,
-				   CompWindow       *sibling,
+	int addWindowStackChanges (XWindowChanges *xwc,
+				   CompWindow     *sibling,
 				   const ServerLock &lock);
 
 	static CompWindow * findValidStackSiblingBelow (CompWindow *w,

=== modified file 'src/tests/CMakeLists.txt'
--- src/tests/CMakeLists.txt	2013-01-03 16:06:41 +0000
+++ src/tests/CMakeLists.txt	2013-02-13 11:42:35 +0000
@@ -10,7 +10,6 @@
     ${COMPIZ_MAIN_SOURCE_DIR}/pluginclasshandler/include
     ${COMPIZ_MAIN_SOURCE_DIR}/window/geometry/include
     ${COMPIZ_MAIN_SOURCE_DIR}/window/extents/include
-    ${COMPIZ_MAIN_SOURCE_DIR}/servergrab/include
     ${COMPIZ_INCLUDE_DIRS}
 )
 

=== modified file 'src/window.cpp'
--- src/window.cpp	2013-02-12 22:02:10 +0000
+++ src/window.cpp	2013-02-13 11:42:35 +0000
@@ -41,6 +41,7 @@
 #include <core/icon.h>
 #include <core/atoms.h>
 #include "core/windowconstrainment.h"
+#include <core/servergrab.h>
 #include "privatewindow.h"
 #include "privatescreen.h"
 #include "privatestackdebugger.h"

=== modified file 'tests/system/xorg-gtest/tests/compiz_xorg_gtest_test_window_stacking.cpp'
--- tests/system/xorg-gtest/tests/compiz_xorg_gtest_test_window_stacking.cpp	2012-12-10 12:38:48 +0000
+++ tests/system/xorg-gtest/tests/compiz_xorg_gtest_test_window_stacking.cpp	2013-02-13 11:42:35 +0000
@@ -293,83 +293,3 @@
     EXPECT_EQ (*it++, w3);
     EXPECT_EQ (*it++, w2);
 }
-
-TEST_F (CompizXorgSystemStackingTest, TestCreateRelativeToDestroyedWindowFindsAnotherAppropriatePosition)
-{
-    ::Display *dpy = Display ();
-    ct::PropertyNotifyXEventMatcher matcher (dpy, "_NET_CLIENT_LIST_STACKING");
-
-    Window dock = ct::CreateNormalWindow (dpy);
-
-    /* Make it a dock */
-    MakeDock (dpy, dock);
-
-    /* Immediately map the dock window and clear the event queue for it */
-    XMapRaised (dpy, dock);
-
-    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy, dock, ReparentNotify, -1, -1)));
-    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy, dock, MapNotify, -1, -1)));
-
-    /* Dock window needs to be in the client list */
-    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindowMatching (dpy,
-								       DefaultRootWindow (dpy),
-								       PropertyNotify,
-								       -1,
-								       -1,
-								       matcher)));
-    std::list <Window> clientList = ct::NET_CLIENT_LIST_STACKING (dpy);
-    ASSERT_EQ (clientList.size (), 1);
-
-    Window w1 = ct::CreateNormalWindow (dpy);
-    Window w2 = ct::CreateNormalWindow (dpy);
-
-    XMapRaised (dpy, w1);
-
-    /* All reparented and mapped */
-    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy,w1, ReparentNotify, -1, -1)));
-    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy, w1, MapNotify, -1, -1)));
-
-    /* Grab the server so that we can guaruntee that all of these requests
-     * happen before compiz gets them */
-    XGrabServer (dpy);
-    XSync (dpy, false);
-
-    /* Map the second window, so it ideally goes above w1. Compiz will
-     * receive the MapRequest for this first */
-    XMapRaised (dpy, w2);
-
-    /* Create window that has w2 as its ideal above-candidate
-     * (compiz will receive the CreateNotify for this window
-     *  after the MapRequest but before the subsequent MapNotify) */
-    Window w3 = ct::CreateNormalWindow (dpy);
-
-    XMapRaised (dpy, w3);
-
-    /* Destroy w2 */
-    XDestroyWindow (dpy, w2);
-
-    XUngrabServer (dpy);
-    XSync (dpy, false);
-
-    /* Reparented and mapped */
-    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy, w3, ReparentNotify, -1, -1)));
-    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy, w3, MapNotify, -1, -1)));
-
-    /* Update _NET_CLIENT_LIST_STACKING twice */
-    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindowMatching (dpy,
-								       DefaultRootWindow (dpy),
-								       PropertyNotify,
-								       -1,
-								       -1,
-								       matcher)));
-
-    /* Check the client list to see that dock > w3 > w1 */
-    clientList = ct::NET_CLIENT_LIST_STACKING (dpy);
-
-    std::list <Window>::iterator it = clientList.begin ();
-
-    EXPECT_EQ (3, clientList.size ());
-    EXPECT_EQ (w1, (*it++));
-    EXPECT_EQ (w3, (*it++));
-    EXPECT_EQ (dock, (*it++));
-}