Merge lp:~compiz-team/compiz/compiz.fix_1024304.1 into lp:compiz/0.9.10

[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)

[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)

[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)

[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)

[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)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3628
http://jenkins.qa.ubuntu.com/job/compiz-ci/98/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/135/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/487/console

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

review: Approve (continuous-integration)

[Timo Jyrinki (timo-jyrinki)]

I'm getting a crash on Intel SandyBridge with this branch. At least machine information at bug #1153482 - that was after canceling the first apport dialog. Apport refuses to file the actual compiz .crash file since it notices the version numbers are out of date, but I can send the CoreDump.gz and/or .crash via e-mail.

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

Don't worry it doesn't matter. I've been told that all
non-insignificant changes to compiz are automatically vetoed at this
point.

On Mon, Mar 11, 2013 at 3:52 PM, Timo Jyrinki
<email address hidden> wrote:
> Review: Needs Fixing
>
> I'm getting a crash on Intel SandyBridge with this branch. At least machine information at bug #1153482 - that was after canceling the first apport dialog. Apport refuses to file the actual compiz .crash file since it notices the version numbers are out of date, but I can send the CoreDump.gz and/or .crash via e-mail.
> --
> https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1024304.1/+merge/150951
> Your team Compiz Maintainers is subscribed to branch lp:compiz.

--
Sam Spilsbury

[Sam Spilsbury (smspillaz)]

Stacktrace would be nice though. Can you get one manually?

On Mon, Mar 11, 2013 at 4:01 PM, Sam Spilsbury <email address hidden> wrote:
> Don't worry it doesn't matter. I've been told that all
> non-insignificant changes to compiz are automatically vetoed at this
> point.
>
> On Mon, Mar 11, 2013 at 3:52 PM, Timo Jyrinki
> <email address hidden> wrote:
>> Review: Needs Fixing
>>
>> I'm getting a crash on Intel SandyBridge with this branch. At least machine information at bug #1153482 - that was after canceling the first apport dialog. Apport refuses to file the actual compiz .crash file since it notices the version numbers are out of date, but I can send the CoreDump.gz and/or .crash via e-mail.
>> --
>> https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1024304.1/+merge/150951
>> Your team Compiz Maintainers is subscribed to branch lp:compiz.
>
>
>
> --
> Sam Spilsbury

--
Sam Spilsbury

[Timo Jyrinki (timo-jyrinki)]

Sorry, PEBKAC, recompiled Unity against it and now it works. I don't have a raring machine where I could test the actual functionality, but seems to work on Intel identically to before.

So approved with regards to build / run on Intel without GLX_EXT_buffer_age.

review: Approve (build&run)

[Sam Spilsbury (smspillaz)]

Ah, cool that you got it working on intel hw.

Unfortunately my understanding is that this won't go in for raring. It requires both a Unity and Nux change in order to ensure that there isn't a performance /regression/ (because of Unity's brain-dead damageScreen-on-any-damage hook), and those changes are quite substantial.

Sadly, the ps-team had three months to review these changes and I kept them up-to-date during that entire time, but the feet-dragging has effectively meant its come to a point where they won't be merged :(

[Andrea Azzarone (azzar1)]

Does this branch depends on? https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1040478/+merge/150949

review: Needs Information

[Timo Jyrinki (timo-jyrinki)]

Andrea: I don't think so (I might be wrong), but these are surely required to go in together with this:
https://code.launchpad.net/~smspillaz/unity/unity.fix_1080947/+merge/147544
https://code.launchpad.net/~smspillaz/nux/nux.fix_1091589/+merge/147543

[Sam Spilsbury (smspillaz)]

@Timo: at the moment, it kinda pulls in https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1040478/+merge/150949 because I wrote https://code.launchpad.net/~smspillaz/unity/unity.fix_1080947/+merge/147544 with the former in mind. If we're still interested in getting this is (I'd be happy if we were) I can do a quick refactor to try and remove the dependency.

[Andrea Azzarone (azzar1)]

> @Timo: at the moment, it kinda pulls in https://code.launchpad.net/~compiz-
> team/compiz/compiz.fix_1040478/+merge/150949 because I wrote
> https://code.launchpad.net/~smspillaz/unity/unity.fix_1080947/+merge/147544
> with the former in mind. If we're still interested in getting this is (I'd be
> happy if we were) I can do a quick refactor to try and remove the dependency.

Yes, please. If we can get this into a mergeable state in the next week there's a good chance we can get it in by final beta freeze (March 28). Otherwise, it's still worth getting in post-13.04

[Sam Spilsbury (smspillaz)]

On Thu, Mar 21, 2013 at 9:14 PM, Andrea Azzarone <email address hidden> wrote:
>> @Timo: at the moment, it kinda pulls in https://code.launchpad.net/~compiz-
>> team/compiz/compiz.fix_1040478/+merge/150949 because I wrote
>> https://code.launchpad.net/~smspillaz/unity/unity.fix_1080947/+merge/147544
>> with the former in mind. If we're still interested in getting this is (I'd be
>> happy if we were) I can do a quick refactor to try and remove the dependency.
>
> Yes, please. If we can get this into a mergeable state in the next week there's a good chance we can get it in by final beta freeze (March 28). Otherwise, it's still worth getting in post-13.04

:) Alrighty, glad to see this resolved. Is it cleared with distro?
> --
> https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1024304.1/+merge/150951
> Your team Compiz Maintainers is subscribed to branch lp:compiz.

--
Sam Spilsbury

[Didier Roche-Tolomelli (didrocks)]

Hey Sam, do you mind talking to duflu and see if he gets time to review this branch? If he's happy with it, we can get it in.

[Sam Spilsbury (smspillaz)]

I think Daniel is busy on other projects. Subscribe him if you want, but I
think this should be left to the main legacy stack maintainers.
On 21/03/2013 11:39 PM, "Didier Roche" <email address hidden> wrote:

> Hey Sam, do you mind talking to duflu and see if he gets time to review
> this branch? If he's happy with it, we can get it in.
> --
>
> https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1024304.1/+merge/150951
> Your team Compiz Maintainers is subscribed to branch lp:compiz.
>

[Sam Spilsbury (smspillaz)]

Okay, so the unity branch should only depend on this one now.

Though the other one is certainly a nice to have - it means we don't have to read out the bindings from opengl in unity.

[Daniel van Vugt (vanvugt)]

Please re-target this for lp:compiz/0.9.10

review: Needs Resubmitting

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3628
http://jenkins.qa.ubuntu.com/job/compiz-ci/118/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/155
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/507

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/118/rebuild

review: Approve (continuous-integration)

[Sam Spilsbury (smspillaz)]

Okay, so I've talked to Didier about this and we've come up with a small plan of action. We'll need to give this a week solid of QA at the beginning of the S cycle and then make sure that we don't have any AP regressions. That'll happen in about two weeks.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3633
http://jenkins.qa.ubuntu.com/job/compiz-ci/130/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/167
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-pbuilder/./build=pbuilder,distribution=raring,flavor=amd64/519

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/130/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3634
http://jenkins.qa.ubuntu.com/job/compiz-ci/146/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/184/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-amd64-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-armhf-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-i386-ci/1/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/146/rebuild

review: Needs Fixing (continuous-integration)

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

3635. By Sam Spilsbury on 2013-04-24

Fix typo

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3635
http://jenkins.qa.ubuntu.com/job/compiz-ci/147/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/185
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-amd64-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-armhf-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-i386-ci/2/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/147/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3635
http://jenkins.qa.ubuntu.com/job/compiz-ci/148/
Executed test runs:
    None: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/186/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-amd64-ci/3/console
    None: http://jenkins.qa.ubuntu.com/job/compiz-raring-armhf-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-i386-ci/3/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/148/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3635
http://jenkins.qa.ubuntu.com/job/compiz-ci/149/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/187
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-amd64-ci/4
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-armhf-ci/4/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-i386-ci/4

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/149/rebuild

review: Needs Fixing (continuous-integration)

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

3636. By Sam Spilsbury on 2013-04-25

We reset the frame provider at the end of glXInitContext, no need to do
it before that in the GLES case

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3636
http://jenkins.qa.ubuntu.com/job/compiz-ci/151/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/189
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-amd64-ci/6
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-armhf-ci/6
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-i386-ci/6

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/151/rebuild

review: Approve (continuous-integration)

[MC Return (mc-return)]

I do not understand this part:

1891 + /* We need scratchFbo to be set before doing this, and it is common
1892 + * to both the GLES and non-GLES codepaths, so using another #ifdef
1893 + */
1894 + priv->updateFrameProvider ();
1895 +

Is configureLock not needed here anymore ?:

2202 - icons (),
2203 - configureLock (w->obtainLockOnConfigureRequests ())
2204 + icons ()

There is no #ifdef here ?

These changes seem to be unrelated, but okay:

2216 - case PlaceOptions::ModeCascade:
2217 + case PlaceOptions::ModeCascade:

2225 -

2359 - if (serverFrameGeometry.width () == xwc->width + serverGeometry.border () * 2
2360 + if (serverFrameGeometry.width () == xwc->width + serverGeometry.border () * 2

Was this wrong ?:

2368 - /* Gravity here is assumed to be SouthEast, clients can update
2369 + /* Gravity here is assumed to be NorthWest, clients can update

What is the water change about ? Water needs FBOs to work AFAIK.

Here brackets could be removed:

1995 - CompRegion tmpRegion = (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) ?
1996 - screen->region () : region;
1997 + CompRegion paintRegion ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) ?
1998 + screen->region () : region);

Here also:

2006 + if ((GL::fboEnabled && postprocessRequiredForCurrentFrame ()))

Why not 7 ?:

1469 -#define COMPIZ_OPENGL_ABI 6
1470 +#define COMPIZ_OPENGL_ABI 8

Is this intended, it looks strange ?:

626 + ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
627 + )

The rest LGTM AFAICT.

[MC Return (mc-return)]

Note: The "There is no #ifdef here ?" sentence above belongs after "1895 +".

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

3637. By Sam Spilsbury on 2013-04-25

Revert unrelated changes, unrevert some unintentional changes to
window.cpp

[Sam Spilsbury (smspillaz)]

Thanks for the review :)

> I do not understand this part:
>
> 1891 + /* We need scratchFbo to be set before doing this, and it is
> common
> 1892 + * to both the GLES and non-GLES codepaths, so using another
> #ifdef
> 1893 + */
> 1894 + priv->updateFrameProvider ();
> 1895 +
>
> Is configureLock not needed here anymore ?:
>

Yep, that was an error, possibly caused by the tons-of-re-merging I've had to do here. Fixed now.

> 2202 - icons (),
> 2203 - configureLock (w->obtainLockOnConfigureRequests ())
> 2204 + icons ()
>
> There is no #ifdef here ?

The comment itself was outdated, fixed.
>
> These changes seem to be unrelated, but okay:
>
> 2216 - case PlaceOptions::ModeCascade:
> 2217 + case PlaceOptions::ModeCascade:
>
> 2225 -
>
> 2359 - if (serverFrameGeometry.width () == xwc->width +
> serverGeometry.border () * 2
> 2360 + if (serverFrameGeometry.width () == xwc->width +
> serverGeometry.border () * 2
>

Reverted.

> Was this wrong ?:
>
> 2368 - /* Gravity here is assumed to be SouthEast, clients can update
> 2369 + /* Gravity here is assumed to be NorthWest, clients can update
>

Also reverted. I'll propose it separately, looks like it probably got in there by accident.

> What is the water change about ? Water needs FBOs to work AFAIK.
>

Painting the whole scene to an framebuffer object was turned off by default unless some plugin or opengl indicates that it is necessary on this frame. The water change basically hooks glPaintCompositedOutputRequired when water is active and always returns true.

> Here brackets could be removed:
>
> 1995 - CompRegion tmpRegion = (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
> ?
> 1996 - screen->region () : region;
> 1997 + CompRegion paintRegion ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
> ?
> 1998 + screen->region () : region);
>

Bracketing bitwise operations is usually a good idea when they are mixed with other parts of if statements.

> Here also:
>
> 2006 + if ((GL::fboEnabled && postprocessRequiredForCurrentFrame ()))
>

Fixed, thanks.

> Why not 7 ?:
>
> 1469 -#define COMPIZ_OPENGL_ABI 6
> 1470 +#define COMPIZ_OPENGL_ABI 8
>

Fixed.

> Is this intended, it looks strange ?:
>
> 626 + ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
> 627 + )
>

Fixed. Its left over from when I removed all of the references but wasn't able to do so here yet.

> The rest LGTM AFAICT.

I might self-review this a little later, so for now.

review: Abstain

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3637
http://jenkins.qa.ubuntu.com/job/compiz-ci/156/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/194
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-amd64-ci/11
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-armhf-ci/11
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-i386-ci/11

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/156/rebuild

review: Approve (continuous-integration)

[MC Return (mc-return)]

> Thanks for the review :)
>
No problem, thanks 4 your reviews as well ;)

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

3638. By Sam Spilsbury on 2013-04-26

Merge lp:compiz

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3638
http://jenkins.qa.ubuntu.com/job/compiz-ci/159/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/197
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-amd64-ci/14
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-armhf-ci/14/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-i386-ci/14

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/159/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3638
http://jenkins.qa.ubuntu.com/job/compiz-ci/160/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/198
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-amd64-ci/15
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-armhf-ci/15/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-i386-ci/15

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/160/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3638
http://jenkins.qa.ubuntu.com/job/compiz-ci/161/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/199
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-amd64-ci/16
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-armhf-ci/16
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-i386-ci/16

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/161/rebuild

review: Approve (continuous-integration)

[MC Return (mc-return)]

This was tested. This was reviewed. This compiles and passes tests.

There is time until the next version (0.9.10) of Compiz gets released and there is time until the next version of *buntu gets released.

I say -> let us land this now and fix eventually remaining regressions later...

Sam, I have one additional idea and suggestion for this though:
We should ideally make this configurable via CCSM, so even users, who own hardware that supports GLX_EXT_buffer_age are not forced to use this OpenGL extension, should problems occur for them.

Could you implement such an option ?

Enable GLX_EXT_buffer_age Support (X)

I am just choosing "Abstain" here, because Sam mentioned he would like to self-review this once again, but this is
effectively an "Approve" from me... :)

review: Approve

[MC Return (mc-return)]

review: Abstain

[Sam Spilsbury (smspillaz)]

On Sun, Apr 28, 2013 at 12:18 AM, MC Return <email address hidden> wrote:
> Review: Approve
>
> Sam, I have one additional idea and suggestion for this though:
> We should ideally make this configurable via CCSM, so even users, who own hardware that supports GLX_EXT_buffer_age are not forced to use this OpenGL extension, should problems occur for them.
>
> Could you implement such an option ?
>
> Enable GLX_EXT_buffer_age Support (X)

I don't like the idea of options affecting the rendering system
generally. The system should pick the most optimal rendering path and
if it doesn't work then we fix it rather than having people disable
it.

EXT_b_a is straightforward to implement in a driver, any problems are
likely to be on the client implementation and not the driver.

>
> I am just choosing "Abstain" here, because Sam mentioned he would like to self-review this once again, but this is
> effectively an "Approve" from me... :)
> --
> https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1024304.1/+merge/160687
> You proposed lp:~compiz-team/compiz/compiz.fix_1024304.1 for merging.

--
Sam Spilsbury

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

3639. By Sam Spilsbury on 2013-04-27

Merge lp:compiz

3640. By Sam Spilsbury on 2013-05-03

Merge lp:compiz

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3640
http://jenkins.qa.ubuntu.com/job/compiz-ci/167/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/205
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-amd64-ci/22/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-armhf-ci/22/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-i386-ci/22/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/167/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3640
http://jenkins.qa.ubuntu.com/job/compiz-ci/168/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/207
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-amd64-ci/25
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-raring-armhf-ci/23/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-raring-i386-ci/23

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/168/rebuild

review: Needs Fixing (continuous-integration)

[Sam Spilsbury (smspillaz)]

Self-review:

1. This PAINT_WINDOW_NO_DRAW_MASKS was really necessary for the blur plugin and can probably be moved out into a separate branch:

1 === modified file 'plugins/animation/src/animation.cpp'
2 --- plugins/animation/src/animation.cpp 2013-04-25 11:07:54 +0000
3 +++ plugins/animation/src/animation.cpp 2013-05-03 22:53:26 +0000
4 @@ -1618,7 +1618,7 @@
5 // Is this the first glPaint call this round
6 // without the mask PAINT_WINDOW_OCCLUSION_DETECTION_MASK?
7 if (mPAScreen->mStartingNewPaintRound &&
8 - !(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK))
9 + !(mask & PAINT_WINDOW_NO_DRAW_MASKS))
10 {
11 mPAScreen->mStartingNewPaintRound = false;

(see also lines 206, 2202, 2215, 2227. 2235, 2261, 2274)

2.

181 + void addOverdrawDamageRegion (const CompRegion &);

This can probably be renamed to addOverdrawDamageRegionForCurrentlyPaintingFrame

3.

340 +class FrameRoster :

Perhaps rename to PreviousDamageBuffers

4.

468 + while (age--)

do
{
} while (--age)

5.

717 + NiceMock <MockAgeingDamageBufferObserver> niceTracker;

Possibly better to explicitly set unused expectations as opposed to using NiceMock. Or perhaps not because we want to shortcut it in the constructor.

6.

915 +/* These are more or less functional tests from this point forward
916 + * just checking a number of different situations */
917 +
918 +TEST_F (BackbufferTracking, ThreeFramesAgoWithFourFrames)
919 +{

Better rename the test fixture.

7.

1167 +namespace
1168 +{
1169 +bool alwaysMarkDirty ()
1170 +{
1171 + return true;
1172 +}
1173 +}

1199 + roster (*screen,
1200 + ageingBuffers,
1201 + boost::bind (alwaysMarkDirty))

1338 +CompositeScreen::DamageQuery::Ptr
1339 +CompositeScreen::getDamageQuery (const ShouldMarkDirty &callback)

This feels clunky. Perhaps the default could be an empty boost function which, upon being empty would always mark the area dirty.

9.

1536 + CompRegionRef (output->region ()), output, mask);

Needs to be 80 columns

10.

1546 + glPaintTransformedOutput (sAttrib, sTransform, CompRegionRef (output->region ()),

Conversion of tabs to spaces

11.

1583 -#ifdef USE_GLES
1584 #include <opengl/framebufferobject.h>
1585 -#endif
1586 -

Probably not necessary any longer?

review: Needs Fixing

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

3641. By Sam Spilsbury on 2013-05-12

Revert introduction of PAINT_WINDOW_NO_DRAW_MASKS. It isn't entirely
relevant here.

3642. By Sam Spilsbury on 2013-05-12

Merge lp:compiz

3643. By Sam Spilsbury on 2013-05-12

Rename addOverdrawDamageRegion to recordDamageOnCurrentFrame and tidy
up some formatting

3644. By Sam Spilsbury on 2013-05-12

Allow an empty callback argument to getDamageQuery. Makes the plugin API
simpler

3645. By Sam Spilsbury on 2013-05-15

Merge lp:compiz

3646. By Sam Spilsbury on 2013-05-16

Merge lp:compiz

3647. By Sam Spilsbury on 2013-05-20

Merge lp:compiz

Unmerged revisions

3647. By Sam Spilsbury on 2013-05-20

Merge lp:compiz

3646. By Sam Spilsbury on 2013-05-16

Merge lp:compiz

3645. By Sam Spilsbury on 2013-05-15

Merge lp:compiz

3644. By Sam Spilsbury on 2013-05-12

Allow an empty callback argument to getDamageQuery. Makes the plugin API
simpler

3643. By Sam Spilsbury on 2013-05-12

Rename addOverdrawDamageRegion to recordDamageOnCurrentFrame and tidy
up some formatting

3642. By Sam Spilsbury on 2013-05-12

Merge lp:compiz

3641. By Sam Spilsbury on 2013-05-12

Revert introduction of PAINT_WINDOW_NO_DRAW_MASKS. It isn't entirely
relevant here.

3640. By Sam Spilsbury on 2013-05-03

Merge lp:compiz

3639. By Sam Spilsbury on 2013-04-27

Merge lp:compiz

3638. By Sam Spilsbury on 2013-04-26

Merge lp:compiz

=== modified file 'plugins/animation/src/animation.cpp'
--- plugins/animation/src/animation.cpp	2013-04-25 11:07:54 +0000
+++ plugins/animation/src/animation.cpp	2013-05-03 22:53:26 +0000
@@ -1618,7 +1618,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-05-03 22:53:26 +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-05-03 22:53:26 +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-05-03 22:53:26 +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-05-03 22:53:26 +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-05-03 22:53:26 +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-05-03 22:53:26 +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-05-03 22:53:26 +0000
@@ -0,0 +1,22 @@
+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})
+
+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-05-03 22:53:26 +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-05-03 22:53:26 +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-04-19 11:03:09 +0000
+++ plugins/composite/src/screen.cpp	2013-05-03 22:53:26 +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;
@@ -265,6 +267,15 @@
     delete priv;
 }
 
+namespace
+{
+bool alwaysMarkDirty ()
+{
+    return true;
+}
+}
+
+
 PrivateCompositeScreen::PrivateCompositeScreen (CompositeScreen *cs) :
     cScreen (cs),
     compositeEvent (0),
@@ -282,6 +293,7 @@
     randrEvent (0),
     randrError (0),
     damageMask (COMPOSITE_SCREEN_DAMAGE_ALL_MASK),
+    currentlyTrackingDamage (DamageForCurrentFrame),
     overlay (None),
     output (None),
     exposeRects (),
@@ -293,12 +305,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
@@ -474,22 +490,62 @@
     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
      * may need to know that the whole screen was redrawn
      */
     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
@@ -500,7 +556,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,
@@ -509,17 +570,61 @@
      * the whole screen if we have a lot of damage rects
      */
 
-    if (priv->damage.numRects () > 100)
+    if (currentDamage->numRects () > 100)
 	damageScreen ();
 
-    priv->scheduleRepaint ();
+    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
@@ -758,6 +863,10 @@
 
     if (priv->damageMask)
     {
+	/* 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 ();
 
@@ -792,7 +901,7 @@
 		    continue;
 
 		if (!CompositeWindow::get (w)->redirected ())
-		    priv->damage -= w->region ();
+		    priv->ageingBuffers.subtractObscuredArea (w->region ());
 
 		break;
 	    }
@@ -804,7 +913,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 &&
 	    priv->tmpRegion == screen->region ())
@@ -826,7 +941,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;
@@ -844,9 +961,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;
@@ -1003,8 +1124,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-05-03 22:53:26 +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-04-27 05:54:57 +0000
+++ plugins/opengl/include/opengl/opengl.h	2013-05-03 22:53:26 +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 7
 
 /*
  * Some plugins check for #ifdef USE_MODERN_COMPIZ_GL. Support it for now, but
@@ -529,6 +536,7 @@
     extern bool  shaders;
     extern bool  stencilBuffer;
     extern GLint maxTextureUnits;
+    extern bool  bufferAge;
 
     extern bool canDoSaturated;
     extern bool canDoSlightlySaturated;
@@ -667,6 +675,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,
@@ -678,7 +691,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
 {
@@ -792,7 +805,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/paint.cpp'
--- plugins/opengl/src/paint.cpp	2013-01-03 16:05:26 +0000
+++ plugins/opengl/src/paint.cpp	2013-05-03 22:53:26 +0000
@@ -418,10 +418,10 @@
 	if (w->destroyed ())
 	    continue;
 
-        gw = GLWindow::get (w);
+	gw = GLWindow::get (w);
 
-        /* Release any queued ConfigureWindow requests now */
-        gw->priv->configureLock->release ();
+	/* Release any queued ConfigureWindow requests now */
+	gw->priv->configureLock->release ();
 
 	if (unredirected.find (w) != unredirected.end ())
 	    continue;
@@ -629,8 +629,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 +660,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 +672,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-05-03 22:53:26 +0000
@@ -29,16 +29,16 @@
 #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>
-#endif
-
 #include <opengl/doublebuffer.h>
 
 #include "privatetexture.h"
@@ -120,8 +120,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 +160,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 +186,8 @@
 
 	bool driverIsBlacklisted (const char *regex) const;
 
+	bool postprocessRequiredForCurrentFrame ();
+
     public:
 
 	GLScreen        *gScreen;
@@ -197,7 +222,7 @@
 	GLXDoubleBuffer doubleBuffer;
 	#endif
 
-	GLFramebufferObject *scratchFbo;
+	boost::shared_ptr <GLFramebufferObject> scratchFbo;
 	CompRegion outputRegion;
 
 	XRectangle lastViewport;
@@ -222,8 +247,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-05-03 22:53:26 +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)
 {
@@ -897,13 +1075,16 @@
 	registerBindPixmap (TfpTexture::bindPixmapToTexture);
 #endif
 
+    /* Scratch framebuffer must be allocated before updating
+     * the backbuffer provider */
     if (GL::fboSupported)
     {
-	priv->scratchFbo = new GLFramebufferObject;
+	priv->scratchFbo.reset (new GLFramebufferObject ());
 	priv->scratchFbo->allocate (*screen, NULL, GL_BGRA);
     }
 
     GLVertexBuffer::streamingBuffer ()->setAutoProgram (priv->autoProgram);
+    priv->updateFrameProvider ();
 
     return true;
 }
@@ -993,6 +1174,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 +1397,6 @@
 	glXDestroyContext (screen->dpy (), priv->ctx);
     #endif
 
-    if (priv->scratchFbo)
-	delete priv->scratchFbo;
-
     delete priv;
 }
 
@@ -1233,7 +1418,7 @@
     ctx (EGL_NO_CONTEXT),
     doubleBuffer (screen->dpy (), *screen, surface),
     #endif
-    scratchFbo (NULL),
+    scratchFbo (),
     outputRegion (),
     refreshSubBuffer (false),
     lastMask (0),
@@ -1246,13 +1431,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 +1631,11 @@
 {
     screen->outputChangeNotify ();
 
+    frameProvider->invalidateAll ();
+
     if (scratchFbo)
 	scratchFbo->allocate (*screen, NULL, GL_BGRA);
+
     updateView ();
 }
 
@@ -1669,6 +1860,10 @@
 GLScreenInterface::projectionMatrix ()
     WRAPABLE_DEF (projectionMatrix)
 
+bool
+GLScreenInterface::glPaintCompositedOutputRequired ()
+    WRAPABLE_DEF (glPaintCompositedOutputRequired)
+
 void
 GLScreenInterface::glPaintCompositedOutput (const CompRegion    &region,
 					    GLFramebufferObject *fbo,
@@ -1977,18 +2172,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 +2189,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 +2230,8 @@
 
 	    gScreen->glPaintOutput (defaultScreenPaintAttrib,
 				    identity,
-				    CompRegion (*output), output,
+				    CompRegion (*output),
+				    output,
 				    PAINT_SCREEN_REGION_MASK |
 				    PAINT_SCREEN_FULL_MASK);
 	}
@@ -2057,7 +2254,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 +2267,11 @@
 
 		gScreen->glPaintOutput (defaultScreenPaintAttrib,
 					identity,
-					CompRegion (*output), output,
+					wholeOutput, output,
 					PAINT_SCREEN_FULL_MASK);
 
-		tmpRegion += *output;
+		paintRegion += wholeOutput;
+		cScreen->addOverdrawDamageRegion (wholeOutput);
 	    }
 	}
     }
@@ -2082,13 +2282,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 +2305,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 +2350,13 @@
 }
 
 void
+PrivateGLScreen::damageCutoff ()
+{
+    cScreen->applyDamageForFrameAge (frameProvider->getCurrentFrame ());
+    cScreen->damageCutoff ();
+}
+
+void
 PrivateGLScreen::updateRenderMode ()
 {
 #ifndef USE_GLES
@@ -2147,12 +2366,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 +2431,12 @@
     return prevBlacklisted;
 }
 
+bool
+PrivateGLScreen::postprocessRequiredForCurrentFrame ()
+{
+    return postprocessingRequired;
+}
+
 GLTexture::BindPixmapHandle
 GLScreen::registerBindPixmap (GLTexture::BindPixmapProc proc)
 {
@@ -2198,7 +2465,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-05-03 22:53:26 +0000
@@ -85,7 +85,7 @@
     clip (),
     bindFailed (false),
     vertexBuffer (new GLVertexBuffer ()),
-    autoProgram(new GLWindowAutoProgram(this)),
+    autoProgram(new GLWindowAutoProgram (this)),
     icons (),
     configureLock (w->obtainLockOnConfigureRequests ())
 {

=== 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-05-03 22:53:26 +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-05-03 22:53:26 +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-05-03 22:53:26 +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-05-03 22:53:26 +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-05-03 22:53:26 +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-05-03 22:53:26 +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-05-03 22:53:26 +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-05-03 22:53:26 +0000
@@ -64,6 +64,7 @@
 
 	void handleEvent (XEvent *);
 
+	bool glPaintCompositedOutputRequired ();
 	void glPaintCompositedOutput (const CompRegion    &region,
 				      GLFramebufferObject *fbo,
 				      unsigned int         mask);