Merge lp:~kdub/mir/display-groups into lp:mir

[Kevin DuBois]

graphics: move the post() command from the DisplayBuffers to the new DisplayGroup interface. This allows platforms to designate which DisplayBuffers must be posted in a common function.

graphics: move the post() command from the DisplayBuffers to the new DisplayGroup interface. This allows platforms to designate which DisplayBuffers must be posted in a common function.

This is mostly for android, which requires us to figure out the fencing for the displays, and post one nonblocking function (https://android.googlesource.com/platform/hardware/libhardware/+/master/include/hardware/hwcomposer.h l587). To rephrase android's requirements, we're required to post 2 egl contexts in one post command. (ie, have 1 displaygroup with 2 buffers in it)

Mesa/offscreen/nested remain with one thread per displaybuffer, although the idea of a group of displays posting together isn't foreign to mesa and nested. Particularly these platforms do this in the case where the outputs overlap and share a common scanout buffer. Unfortunately android really needs 2 egl contexts backed by 2 bundles of framebuffers, so it cannot play a similar trick.

It also has the nice benefit that the DisplayBufferCompositor implementations becomes concerned with the content (GL/overlays), and the Compositor implementations now issue the post() command.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2288
http://jenkins.qa.ubuntu.com/job/mir-ci/2935/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1246
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1245
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1202
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/932
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/932/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1202
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1202/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4243
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/17890

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/2935/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

262 +class ConfigurableDisplayBuffer : public graphics::DisplayBuffer,
263 + public graphics::DisplayGroup
...
469 +class DisplayBuffer : public graphics::DisplayBuffer,
470 + public graphics::DisplayGroup

I don't feel I understand the relationship between graphics::DisplayBuffer and graphics::DisplayGroup.

My gut says there's a composite pattern hidden in there somewhere, but that the interfaces are not quite right.

review: Abstain

[Kevin DuBois (kdub)]

> I don't feel I understand the relationship between graphics::DisplayBuffer and
> graphics::DisplayGroup.

DisplayGroups are DisplayBuffers that share a common post() function. The DisplayBuffer becomes an abstraction for the content of the buffer, and the DisplayGroup becomes the abstraction for how that content is flipped to the frontbuffer. In lp:mir right now, DisplayBuffer is the abstraction for the content, and the posting.

> My gut says there's a composite pattern hidden in there somewhere, but that
> the interfaces are not quite right.

For android, I was intending to split the inheritance in the next round of updates. For mesa, I was intending on leaving it, but since having to look at it, the code does become more clean if I switch mgm::DisplayBuffer from inheritance to to composition. I am working on disentangling this too, will propose mesa and android in subsequent MP's, as they're both about 1k lines each.

[Kevin DuBois (kdub)]

Okay, so I made mgm::DisplayBuffer inherit only from mg::DisplayBuffer, and introduced a mgm::DisplayGroup in this branch lp:~kdub/mir/mesa-display-group. I'll propose that after this, and am working on the android branch (which might have the MM changes).

[Alexandros Frantzis (afrantzis)]

173 + * This may wait for based on hardware conditions and platform requirements */

Something missing.

178 +private:

(Nit) No need for private, protected will do.

629 + for (auto& compositor : compositors)
630 + {
631 + target.ensure_current(std::get<0>(compositor));
632 + std::get<1>(compositor)->composite(scene->scene_elements_for(comp_id));

(Non-blocking) As discussed on IRC, this approach serializes rendering of multiple outputs on Android (i.e., it's R1,R2,...,Rn,Post vs the ideal Parallel(R1,R2,...,Rn),Post). This could lead to some performance loss for the multimonitor case on Android, so hopefully there is a way to improve this if needed.

1711 +// display->for_each_mock_buffer([](mtd::MockDisplayBuffer& mock_buf)
1712 +// {
1713 +// EXPECT_CALL(mock_buf, make_current()).Times(1);
1714 +// EXPECT_CALL(mock_buf, view_area())
1715 +// .WillOnce(Return(geom::Rectangle()));
1716 +// });

Not needed?

1769 +#if 0
1770 TEST(MultiThreadedCompositor, makes_and_releases_display_buffer_current_target)

?

review: Needs Fixing

[Kevin DuBois (kdub)]

fixed nits/tests I forgot to reenable.

As for the performance concern, thats true. Ideally two threads would draw, and then one thread would post. This is forced on us somewhat by the android api, although its mitigated by:
* Android (surfaceflinger) would have the same multimonitor performance hit, as it drives rendering from one thread as well.
* mesa, and the other platforms are still driven in sensible way we have it.
* iirc, most android gpus have 2 or more banks of pipeline/contexts for this scenario
* The bottleneck is probably the system bus, instead of the cpu assembly of the gl commands (which is what the two threads would help with)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2292
http://jenkins.qa.ubuntu.com/job/mir-ci/2948/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1265
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1264
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1221
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/945
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/945/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1221
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1221/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4261
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/17941

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/2948/rebuild

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

I'm a bit concerned that so much code has been rewritten here. Including many parts where a one line change means life-or-death for performance and multimonitor. Needs some serious manual testing...

[Daniel van Vugt (vanvugt)]

(1) Found a regression on trunk when testing this. Will work on that now... bug 1420678.

(2) I'm concerned that "groups" are never useful or desirable with real displays;
If you use groups, support for displays with different refresh rates is lost. It's important that we never synchronize between different threads running different displays. Because one could easily be running much faster than the other (24Hz TV + 60Hz laptop in sidebyside mode) and still we need to be posting at the full 60Hz.

628 - display_buffer_compositor->composite(
629 - scene->scene_elements_for(comp_id));
630 + for (auto& compositor : compositors)
631 + {
632 + target.ensure_current(std::get<0>(compositor));
633 + std::get<1>(compositor)->composite(scene->scene_elements_for(comp_id));
634 + }
635 + group.post();

So groups in this way almost never make sense. I'm not sure it's a good idea for Android even. Definitely not desktop. Also, we already have a kind of grouping that we know is more annoying than useful; see bug 1395416.

[Daniel van Vugt (vanvugt)]

(3) Even if you have multiple displays running at the same rate, they will be out of phase by half a frame on average, sometimes worse. So if you synchronize their post() calls then you're dooming all-but-one display to get a shorter render time than 16ms, and this will often leave insufficient render time to composite a whole frame without missing the next one. Our old workaround of triple buffering saves us here, but that's a step backwards in performance. So you have to choose between high lag or sometimes skipping frames. For this reason, I disapprove of the groups design.
It's important each display's flip() occurs on a separate thread asynchronously, so that its own rendering of the next frame can start immediately and we have a full frame time to render.

We need to reduce our use of grouping logic (bug 1395416) rather than extending it.

If you still need some sort of grouping to resolve Android problems, I suggest utilizing the grouping logic ("overlapping outputs") we already have, and only utilizing it in Android.

review: Disapprove

[Alexandros Frantzis (afrantzis)]

After conversations with Kevin, my understanding is that the Android APIs enforce synchronized posting of all outputs even if their contents are completely independent (i.e. different DisplayBuffers). That's _not_ the same problem we have with clone mode on desktop, where we have a single DisplayBuffer which we can post to different outputs.

I would, too, prefer it if we didn't need to have the DisplayGroup abstraction, but it seems that the Android display architecture forces this design choice. My preference would be use the current DisplayBuffer interface and hide all the synchronization inside the Android platform, but Kevin has tried this and found it to be both complicated and fragile.

> It's important each display's flip() occurs on a separate thread asynchronously, so that its
> own rendering of the next frame can start immediately and we have a full frame time to render.

Unfortunaetly, as described in the first paragraph, this is exactly what's not possible on Android. The bright side is that neither this concern, nor the one I noted in a previous comment affect the desktop, since on the desktop 1 DisplayGroup always contains 1 DisplayBuffer.

review: Approve

[Alan Griffiths (alan-griffiths)]

OK as a intermediate form

review: Approve

[Daniel van Vugt (vanvugt)]

I think much greater care needs to be taken by all here.

This proposal can and should be improved. The DisplayGroup is not only undesirable for desktop but downright dangerous for a desktop compositor to use. Because there's no way to do so (e.g. with Mesa) without either causing frame skipping, reduced performance or lag.

As such, please hide DisplayGroup from the common code so that desktoppers can't accidentally find themselves using it.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

At least one way springs to mind in which Android can be supported without DisplayGroup:
Implement a "MultiDisplayBuffer" containing multiple displays attached to a single DisplayBufferCompositor. That way they are composited together and posted together. And the code classes don't need modification.

Alternatively, please consider other ways to avoid touching so much common code. As it stands now, this increases the risk of short and long term regressions (confusion by future developers). And it scares me. We have the ability to pause and try to think of better solutions still.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

-code classes
+common classes

Even if this seems like the only solution right now, we owe it to ourselves to ponder this a bit more. It's a 2000 line change that touches one of the most highly sensitive portions of Mir. It's only been up less than 48 hours. So just stop and think about other possibilities for a while...

[Kevin DuBois (kdub)]

@code rewrite:
The current interfaces are insufficient for android multimonitor, because android has a weird commit interface (line 587, https://android.googlesource.com/platform/hardware/libhardware/+/master/include/hardware/hwcomposer.h). Our current platform interfaces do not have explicit hints about threading, and this avoids this by saying "this group of monitors must post together in DisplayGroup".

I tried to work within the existing API and thread model in lp:~kdub/mir/hwc-sync-and-post-external, but this led to some complex, not-universal and heavy-handed synchronization. (eg, You couldn't drive that code from one thread, one thread per display was the only way. Furthermore, the displays were still synced together, making the second thread mostly useless)

(2) Its true that having two DisplayBuffers in one DisplayGroup ties the displays together, but mesa remain 1DisplayBuffer/1DisplayGroup, so mesa can still be driven in its preferred way, that is, one thread that syncs at the vsync rate of the respective monitor. Android also does not wait in mg::DisplayGroup::post(), so the disadvantages of having one thread drive 2 monitors is less severe. I share the sentiment that the android mm interface is strange, but we have to sync between the different display threads for the interface.

(3) Its important to remember that android's set() call does not block, so the timings are quite different than a model that relies on waiting on the vsync of a particular display. The vsync signal and the commit call are detached; the buffers are protected by fences. Its more that we're scheduling work in the kernel as opposed to controlling the timing carefully like in KMS/drm.

I did look into using OverlappingOutputGrouping in the same way that mesa does, that is, to model 2 monitors an 1 DisplayBuffer, with one common scanout buffer. This relies on being able set the scanout buffer of the monitors, which android doesn't let us do. We need one eglContext per display, and cannot force both monitors to read from one bundle of framebuffers.

[Kevin DuBois (kdub)]

> (3) Even if you have multiple displays running at the same rate, they will be
> out of phase by half a frame on average, sometimes worse. So if you
> synchronize their post() calls then you're dooming all-but-one display to get
> a shorter render time than 16ms, and this will often leave insufficient render
> time to composite a whole frame without missing the next one. Our old
> workaround of triple buffering saves us here, but that's a step backwards in
> performance. So you have to choose between high lag or sometimes skipping
> frames. For this reason, I disapprove of the groups design.

I disapprove of the HWC multimonitor design, but we're stuck with it :).

Given that we really-truly-have-to synchronize and commit from one thread in android, I like DisplayGroups because it keeps the threading model implicit. The alternative is to have an explicit threading model (some sort of "force single threaded composition" flag) or to require the compositor writers to call strange functions that give the android code hints about when it can commit. [1] Both of these are somewhat vague to a compositor writer ("why do I have to call this?, or "what does 'force_single_threading' mean?")

Its also nice that we're splitting DisplayBuffer's concerns. DisplayBuffer is concerned about the content of the buffer, and DisplayGroup is concerned with issuing the commands to post. I chose the execute-around way of giving access to the DisplayBuffers, but down the road, we could probably even give ownership of the DB's.

The other nice thing is that we regain control of the posting, that is, the post() call that drives the display update is now called from MultiThreadedCompositor. The DisplayBufferCompositors are now just what we intended them to be; they are a place where the compositor writers can override to draw different content into the monitors.

[1] specifically, looking at lp:~kdub/mir/hwc-sync-and-post-external, you can see how with the existing model, I can't tell if the external display wants its content updated, so I just make the assumption that we're getting a 1-for-1 buffer update on both displays.

[Kevin DuBois (kdub)]

> At least one way springs to mind in which Android can be supported without
> DisplayGroup:
> Implement a "MultiDisplayBuffer" containing multiple displays attached to a
> single DisplayBufferCompositor. That way they are composited together and
> posted together. And the code classes don't need modification.

This is generally what this MP is intended to be, except that multiple displays are attached to the DisplayGroup, instead of having the grouping requirements somewhere in DisplayBufferCompositiors. I guess I'd have to see the MultiDisplayBuffer interface to figure out if android's mm requirements can fit within it.

[Kevin DuBois (kdub)]

> Even if this seems like the only solution right now, we owe it to ourselves to
> ponder this a bit more. It's a 2000 line change that touches one of the most
> highly sensitive portions of Mir. It's only been up less than 48 hours. So
> just stop and think about other possibilities for a while...

Fair enough, we can allot more time to review and consider, and I can chase more reviews as well.

[Andreas Pokorny (andreas-pokorny)]

Even if it could be done with a MultiDisplayBuffer approach, I think splitting out the post part looks reasonable.

review: Approve

[Alberto Aguirre (albaguirre)]

Looks reasonable and becomes clearer when peeking at the next mesa branch.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2293
http://jenkins.qa.ubuntu.com/job/mir-ci/2962/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1285
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1284
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1241
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/959
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/959/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1241
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1241/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4280
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/18012

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/2962/rebuild

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

downstream compatibility branch: lp:~kdub/qtmir/display-groups

[Gerry Boland (gerboland)]

I understand the motivation for DisplayGroup. The concept will make qtmir's multimonitor support complicated however, as QtMir will allocate one QWindow per Display, and expects to be able to call swap buffers on each Display individually.

Individuality being important: if the scene on monitor 2 changes, then its render loop will spin up, draw and call swap buffers for Display2. However if Display2 is part of a DisplayGroup, it would be presumptuous for it to swap the whole DisplayGroup.

What if Display1 (part of DisplayGroup too) was also being rendered, but finished later than Display2? It can't call swapBuffers on the whole DisplayGroup again, so instead need a sync point between the 2 threads where both are done, before calling swap.

But if Display1 doesn't need changing, then Display2 can legitimately call swap on the whole DisplayGroup.

I don't see how I can support this with Qt without some form of synchronization between the render threads which share a DisplayGroup. Is that a correct conclusion?

If so, it'll be work getting Qt to support this.

[Daniel van Vugt (vanvugt)]

I'd rather see a "MultiDisplayBuffer" or "EverythingDisplayBuffer" that composites multiple outputs together with a single "post" for Android. Then DisplayBufferCompositor doesn't have to change.

The currently proposed design isn't just undesirable for mesa/DRM, but undesirable for any raw platform that flips/blits on post. All our future platforms will also want to avoid DisplayGroups so that the non-primary monitors don't tear or skip frames. So I think it's a better idea to invest in making this more clearly Android-specific.

I can only imagine this works at all on Android without tearing or skipping (does it?) if Android is abstracting and asynchronously deferring the page flipping in the background.

[Andreas Pokorny (andreas-pokorny)]

> I understand the motivation for DisplayGroup. The concept will make qtmir's
> multimonitor support complicated however, as QtMir will allocate one QWindow
> per Display, and expects to be able to call swap buffers on each Display
> individually.

Do you mean Display as in mir::graphics::Display? Or rather DisplayBuffer?

> Individuality being important: if the scene on monitor 2 changes, then its
> render loop will spin up, draw and call swap buffers for Display2. However if
> Display2 is part of a DisplayGroup, it would be presumptuous for it to swap
> the whole DisplayGroup.
>
> What if Display1 (part of DisplayGroup too) was also being rendered, but
> finished later than Display2? It can't call swapBuffers on the whole
> DisplayGroup again, so instead need a sync point between the 2 threads where
> both are done, before calling swap.

This problem is a subset of the problem we have with the underlying android API.
So even with this MP the problem still exists.. but it seems slightly simpler, we only need an optional sync point or optional sync time-window? (optional since for nested/offscreen/mesa DisplayGroup : DisplayBuffer will be a 1:1 relation, as I understood)..

[Kevin DuBois (kdub)]

> I understand the motivation for DisplayGroup. The concept will make qtmir's
> multimonitor support complicated however, as QtMir will allocate one QWindow
> per Display, and expects to be able to call swap buffers on each Display
> individually.
>
> Individuality being important: if the scene on monitor 2 changes, then its
> render loop will spin up, draw and call swap buffers for Display2. However if
> Display2 is part of a DisplayGroup, it would be presumptuous for it to swap
> the whole DisplayGroup.
> What if Display1 (part of DisplayGroup too) was also being rendered, but
> finished later than Display2? It can't call swapBuffers on the whole
> DisplayGroup again, so instead need a sync point between the 2 threads where
> both are done, before calling swap.
>
> But if Display1 doesn't need changing, then Display2 can legitimately call
> swap on the whole DisplayGroup.

Good points, but these are implications of how HWC/multimonitor are driven.
On android, it doesn't cause that much of a performance headache because swap_buffers() can be called independently on each "display buffer"/GL context, and the hwc functions themselves don't block, they just schedule work.

>
> I don't see how I can support this with Qt without some form of
> synchronization between the render threads which share a DisplayGroup. Is that
> a correct conclusion?
>
> If so, it'll be work getting Qt to support this.

Right, so, to rephrase an above comment, this change to DisplayBuffer implicitly gives a hint about how the threads of the compositor should be structured, now that we have a platform that does not prefer 1 thread per monitor, but rather prefers a synchronized submission for all DisplayBuffers.

So, my hope with QtMir and other compositors is that we have MultiThreadedCompositor handle the compositor threads and the compositor notification system, and have the compositors override DisplayBufferCompositor, with the already-existing stipulation that DisplayBufferCompositors have to be threadsafe, as composite() can be called from different threads with different DisplayBuffers.

[Kevin DuBois (kdub)]

@andreas, correct, this abstraction change in this MP is expanding to cover a goofy requirement (from a 1 thread/monitor world's perspective at least) that the HWC api has. A multithreaded setup on android would hit a lot of the same timing inconveniences in synchronizing, just down in the HwcDevice code, where it is not in the best position to make decisions to wait or continue.

[Kevin DuBois (kdub)]

> I'd rather see a "MultiDisplayBuffer" or "EverythingDisplayBuffer" that
> composites multiple outputs together with a single "post" for Android. Then
> DisplayBufferCompositor doesn't have to change.
>

I would too, and this is mostly what we get with mesa's OverlappingOutputGroup. Multiple outputs are implemented as one display buffer if they overlap. The reason this is problematic is that android really needs one EGL context per buffer, and cannot set scanout regions as mesa can. For example, with two different display contexts in one DisplayBuffer, mg::DisplayBuffer::make_current() can't know which of the two contexts the user intends to make current. (or swap, etc.)

> The currently proposed design isn't just undesirable for mesa/DRM, but
> undesirable for any raw platform that flips/blits on post. All our future
> platforms will also want to avoid DisplayGroups so that the non-primary
> monitors don't tear or skip frames. So I think it's a better idea to invest in
> making this more clearly Android-specific.

I'd rather see two DisplayBuffers (each modelling content), with a DisplayGroup (which can post to screen) than have a function that mentions that one of our platforms is android, and special steps have to be taken with the threads. Its better to have a universal concept with synchronization implications, than it is to point to one platform and say that its weird in light of another platform. After all, the point of having the platform abstraction is so that the server code doesn't have to be written on a platform-by-platform basis.

> I can only imagine this works at all on Android without tearing or skipping
> (does it?) if Android is abstracting and asynchronously deferring the page
> flipping in the background.

Yes, the kernel helps out to avoid tearing. We're guaranteed that the set() function won't block, so its more that we're scheduling work with the driver and the kernel than controlling the timing of the threads.

[Robert Carr (robertcarr)]

Lots of review already done so not going in depth. No high level objections though.

review: Abstain

[Daniel van Vugt (vanvugt)]

> > I can only imagine this works at all on Android without tearing or skipping
> > (does it?) if Android is abstracting and asynchronously deferring the page
> > flipping in the background.
>
> Yes, the kernel helps out to avoid tearing. We're guaranteed that the set()
> function won't block, so its more that we're scheduling work with the driver
> and the kernel than controlling the timing of the threads.

Right, so this works for Android because Android isn't a low-level display system. It's a high-level abstraction of displays (and very much OpenGL-only). Native platforms (mesa, nvidia etc) will usually be low-level display systems that need asynchronous posting (hence never use DisplayGroup).

Although I can now imagine some virtual Mir platform in a window. If you wanted to represent multiple virtual outputs for visualization all in a single window then DisplayGroups would be used. But I doubt any such use case beyond Android will really ever be required.

[Daniel van Vugt (vanvugt)]

Wait a minute, post() is a no-op as is flip() for Android. You must be planning to change this in future if DisplayGroup is to have any function at all...?

Previously Android correctly had an empty flip() (now an empty post()), because it's a high-level platform abstraction that just needs to gl_swap_buffers.

I suggest part of the problem then is that you've misappropriated flip() on a platform that has no flip().

[Kevin DuBois (kdub)]

> Wait a minute, post() is a no-op as is flip() for Android. You must be
> planning to change this in future if DisplayGroup is to have any function at
> all...?
>

Yes, the subsequent branch uses the interface changes made here:
http://bazaar.launchpad.net/~kdub/mir/android-multimonitor/view/head:/src/platforms/android/server/display_group.cpp#L68

> Previously Android correctly had an empty flip() (now an empty post()),
> because it's a high-level platform abstraction that just needs to
> gl_swap_buffers.
>
> I suggest part of the problem then is that you've misappropriated flip() on a
> platform that has no flip().

Right, a no-op flip() seemed inappropriate for the android platform, as it did a "flip" operation from within gl_swap_buffers(). So, a user of the interface might be calling gl_swap_buffers(), which drives the display on android, and on mesa, it would just be rendering without posting to screen. It seems more appropriate to have gl_swap_buffers handle updating the context, and have flip/post() drive the content making it to the screen.

[Daniel van Vugt (vanvugt)]

OK, I see the need. And I understand it's a painful thought to redesign the way I've suggested.

As a compromise how about just a rename of DisplayGroup so as to make it less likely that we don't accidentally use it on non-Android platforms; "SynchronousDisplayGroup" or "SyncGroup".

review: Needs Fixing

[Kevin DuBois (kdub)]

> OK, I see the need. And I understand it's a painful thought to redesign the
> way I've suggested.

Well, its not simply painful, but rather our current interfaces don't allow the android platform to present to the server code what the platform requires as its threading structure to post to the external monitor.

>
> As a compromise how about just a rename of DisplayGroup so as to make it less
> likely that we don't accidentally use it on non-Android platforms;
> "SynchronousDisplayGroup" or "SyncGroup".

Sounds good, how about DisplaySyncGroup?

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2295
http://jenkins.qa.ubuntu.com/job/mir-ci/3034/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1375
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1374
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1331
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1031
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1031/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1331
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1331/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4360
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/18249

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3034/rebuild

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

include/platform/mir/graphics/display.h:
Documentation should be improved to point out DisplaySyncGroup is only for virtual display buffer implementations (VMs, Android) that have non-blocking post implementations. And most importantly it should not be used by native platform drivers.

Then I abstain.

[Daniel van Vugt (vanvugt)]

Also don't say "to their respective monitors" because nobody should flip to real monitors using a DisplaySyncGroup. That would result in bugs.

[Kevin DuBois (kdub)]

Updated!
I don't know if I agree that Android is somehow "virtual" while mesa is somehow "native". They just have different sync mechanisms.

=== modified file 'benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp'
--- benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp	2015-02-13 06:12:34 +0000
+++ benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp	2015-02-23 13:13:47 +0000
@@ -36,20 +36,21 @@
 namespace
 {
 
-struct StubDisplayBuffer : mtd::StubDisplayBuffer
+struct StubDisplaySyncGroup : mg::DisplaySyncGroup
 {
-    StubDisplayBuffer(geom::Size output_size, int vsync_rate_in_hz)
-        : mtd::StubDisplayBuffer({{0, 0}, output_size}),
-          vsync_rate_in_hz(vsync_rate_in_hz),
-          last_sync(std::chrono::high_resolution_clock::now())
-    {
-    }
-    
-    void gl_swap_buffers() override
-    {
-    }
-
-    void flip() override
+    StubDisplaySyncGroup(geom::Size output_size, int vsync_rate_in_hz) :
+        vsync_rate_in_hz(vsync_rate_in_hz),
+        last_sync(std::chrono::high_resolution_clock::now()),
+        buffer({{0, 0}, output_size})
+    {
+    }
+
+    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& exec) override
+    {
+        exec(buffer);
+    }
+
+    void post() override
     {
         auto now = std::chrono::high_resolution_clock::now();
         auto next_sync = last_sync + std::chrono::seconds(1) / vsync_rate_in_hz;
@@ -63,22 +64,24 @@
     double const vsync_rate_in_hz;
 
     std::chrono::high_resolution_clock::time_point last_sync;
+
+    mtd::StubDisplayBuffer buffer;
 };
 
 struct StubDisplay : public mtd::StubDisplay
 {
-    StubDisplay(geom::Size output_size, int vsync_rate_in_hz)
-        : mtd::StubDisplay({{{0,0}, output_size}}),
-          buffer(output_size, vsync_rate_in_hz)
+    StubDisplay(geom::Size output_size, int vsync_rate_in_hz) :
+        mtd::StubDisplay({{{0,0}, output_size}}),
+        group(output_size, vsync_rate_in_hz)
     {
     }
     
-    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& exec) override
+    void for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& exec) override
     {
-        exec(buffer);
+        exec(group);
     }
 
-    StubDisplayBuffer buffer;
+    StubDisplaySyncGroup group;
 };
 
 }
 
=== modified file 'examples/render_overlays.cpp'
--- examples/render_overlays.cpp	2015-01-21 09:03:53 +0000
+++ examples/render_overlays.cpp	2015-02-23 13:13:47 +0000
@@ -202,12 +202,16 @@
 
     while (running)
     {
-        display->for_each_display_buffer([&](mg::DisplayBuffer& buffer)
+        client1->update_green_channel();
+        client2->update_green_channel();
+        display->for_each_display_sync_group([&](mg::DisplaySyncGroup& group)
         {
-            buffer.make_current();
-            client1->update_green_channel();
-            client2->update_green_channel();
-            buffer.post_renderables_if_optimizable(renderlist);
+            group.for_each_display_buffer([&](mg::DisplayBuffer& buffer)
+            {
+                buffer.make_current();
+                buffer.post_renderables_if_optimizable(renderlist);
+            });
+            group.post();
         });
     }
 }
 
=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2015-01-21 07:34:50 +0000
+++ examples/render_surfaces.cpp	2015-02-23 13:13:47 +0000
@@ -337,9 +337,12 @@
 
         /* TODO: Get proper configuration */
         geom::Rectangles view_area;
-        display->for_each_display_buffer([&view_area](mg::DisplayBuffer const& db)
+        display->for_each_display_sync_group([&](mg::DisplaySyncGroup& group)
         {
-            view_area.add(db.view_area());
+            group.for_each_display_buffer([&](mg::DisplayBuffer& db)
+            {
+                view_area.add(db.view_area());
+            });
         });
         geom::Size const display_size{view_area.bounding_rectangle().size};
         uint32_t const surface_side{300};
 
=== modified file 'examples/render_to_fb.cpp'
--- examples/render_to_fb.cpp	2015-01-21 07:34:50 +0000
+++ examples/render_to_fb.cpp	2015-02-23 13:13:47 +0000
@@ -53,22 +53,26 @@
 
     mir::draw::glAnimationBasic gl_animation;
 
-    display->for_each_display_buffer([&](mg::DisplayBuffer& buffer)
+    display->for_each_display_sync_group([&](mg::DisplaySyncGroup& group)
     {
-        buffer.make_current();
-        gl_animation.init_gl();
+        group.for_each_display_buffer([&](mg::DisplayBuffer& buffer)
+        {
+            buffer.make_current();
+            gl_animation.init_gl();
+        });
     });
 
     while (running)
     {
-        display->for_each_display_buffer([&](mg::DisplayBuffer& buffer)
+        display->for_each_display_sync_group([&](mg::DisplaySyncGroup& group)
         {
-            buffer.make_current();
-
-            gl_animation.render_gl();
-
-            buffer.gl_swap_buffers();
-            buffer.flip();
+            group.for_each_display_buffer([&](mg::DisplayBuffer& buffer)
+            {
+                buffer.make_current();
+                gl_animation.render_gl();
+                buffer.gl_swap_buffers();
+            });
+            group.post();
         });
 
         gl_animation.step();
 
=== modified file 'include/platform/mir/graphics/display.h'
--- include/platform/mir/graphics/display.h	2015-01-21 07:34:50 +0000
+++ include/platform/mir/graphics/display.h	2015-02-23 13:13:47 +0000
@@ -39,6 +39,32 @@
 typedef std::function<bool()> DisplayResumeHandler;
 typedef std::function<void()> DisplayConfigurationChangeHandler;
 
+/* DisplaySyncGroup allows for multiple displays to be posted together.
+ * A DisplayGroup containing multiple DisplayBuffers should only be used
+ * by platforms that have a nonblocking post implemenation. 
+ * One DisplayBuffer per DisplaySyncGroup is preferable for platforms that
+ * wait for the post to complete.
+ */
+class DisplaySyncGroup
+{
+public:
+    /**
+     *  Executes a functor that allows the DisplayBuffer contents to be updated
+    **/
+    virtual void for_each_display_buffer(std::function<void(DisplayBuffer&)> const& f) = 0;
+
+    /** Post the content of the DisplayBuffers associated with this DisplaySyncGroup.
+     *  The content of all the DisplayBuffers in this DisplaySyncGroup are guaranteed to be onscreen
+     *  in the near future. On some platforms, this may wait a potentially long time for vsync. 
+    **/
+    virtual void post() = 0;
+    virtual ~DisplaySyncGroup() = default;
+protected:
+    DisplaySyncGroup() = default;
+    DisplaySyncGroup(DisplaySyncGroup const&) = delete;
+    DisplaySyncGroup& operator=(DisplaySyncGroup const&) = delete;
+};
+
 /**
  * Interface to the display subsystem.
  */
@@ -46,9 +72,9 @@
 {
 public:
     /**
-     * Executes a functor for each output framebuffer.
+     * Executes a functor for each output group.
      */
-    virtual void for_each_display_buffer(std::function<void(DisplayBuffer&)> const& f) = 0;
+    virtual void for_each_display_sync_group(std::function<void(DisplaySyncGroup&)> const& f) = 0;
 
     /**
      * Gets a copy of the current output configuration.
 
=== modified file 'include/platform/mir/graphics/display_buffer.h'
--- include/platform/mir/graphics/display_buffer.h	2015-01-21 07:34:50 +0000
+++ include/platform/mir/graphics/display_buffer.h	2015-02-23 13:13:47 +0000
@@ -54,28 +54,6 @@
      */
     virtual void gl_swap_buffers() = 0;
 
-    /**
-     * After gl_swap_buffers, flip the new front buffer to the screen
-     * This most likely involves a wait for vblank so can be very time
-     * consuming. This function is separate to gl_swap_buffers() because in
-     * real display systems the act of scanning out (or flipping) the
-     * front buffer is a very separate step to the GL buffer swapping. Not
-     * least because "flipping" is a hardware operation that is independent
-     * of the graphics library (OpenGL or other). Also, flip() can be a
-     * dramatically slower operation than gl_swap_buffers() and it would be
-     * an unacceptable performance hit to wait for both before freeing
-     * GL resources.
-     */
-    virtual void flip() = 0;
-
-    /**
-     * \deprecated Please try to implement separate gl_swap_buffers and
-     * flip functions instead. If not possible, just move your old
-     * post_update() logic into gl_swap_buffers.
-     */
-    __attribute__((__deprecated__("Use gl_swap_buffers() and flip(), remembering to release all compositor buffers in the middle.")))
-    void post_update() { gl_swap_buffers(); flip(); }
-
     /** This will render renderlist to the screen and post the result to the 
      *  screen if there is a hardware optimization that can be done.
      *  \param [in] renderlist 
 
=== modified file 'playground/demo-shell/demo_compositor.cpp'
--- playground/demo-shell/demo_compositor.cpp	2015-01-21 09:03:53 +0000
+++ playground/demo-shell/demo_compositor.cpp	2015-02-23 13:13:47 +0000
@@ -141,8 +141,6 @@
         // flip() ...
         // FIXME: This clear() call is blocking a little (LP: #1395421)
         renderable_list.clear();
-
-        display_buffer.flip();
     }
 
     report->finished_frame(this);
 
=== modified file 'src/platforms/android/server/configurable_display_buffer.h'
--- src/platforms/android/server/configurable_display_buffer.h	2015-01-22 09:00:14 +0000
+++ src/platforms/android/server/configurable_display_buffer.h	2015-02-23 13:13:47 +0000
@@ -19,6 +19,7 @@
 #ifndef MIR_GRAPHICS_ANDROID_CONFIGURABLE_DISPLAY_BUFFER_H_
 #define MIR_GRAPHICS_ANDROID_CONFIGURABLE_DISPLAY_BUFFER_H_
 
+#include "mir/graphics/display.h"
 #include "mir/graphics/display_buffer.h"
 #include "mir/graphics/display_configuration.h"
 
@@ -29,7 +30,9 @@
 namespace android
 {
 
-class ConfigurableDisplayBuffer : public graphics::DisplayBuffer
+//TODO: break this dependency, android displaybuffers shouldn't be their own DisplaySyncGroups
+class ConfigurableDisplayBuffer : public graphics::DisplayBuffer,
+                                  public graphics::DisplaySyncGroup
 {
 public:
     virtual void configure(MirPowerMode power_mode, MirOrientation orientation) = 0;
 
=== modified file 'src/platforms/android/server/display.cpp'
--- src/platforms/android/server/display.cpp	2015-02-13 06:12:34 +0000
+++ src/platforms/android/server/display.cpp	2015-02-23 13:13:47 +0000
@@ -218,7 +218,7 @@
 
 }
 
-void mga::Display::for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f)
+void mga::Display::for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& f)
 {
     std::lock_guard<decltype(configuration_mutex)> lock{configuration_mutex};
     update_configuration(lock);
 
=== modified file 'src/platforms/android/server/display.h'
--- src/platforms/android/server/display.h	2015-02-13 06:12:34 +0000
+++ src/platforms/android/server/display.h	2015-02-23 13:13:47 +0000
@@ -57,7 +57,7 @@
         OverlayOptimization overlay_option);
     ~Display() noexcept;
 
-    void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const& f) override;
+    void for_each_display_sync_group(std::function<void(graphics::DisplaySyncGroup&)> const& f) override;
 
     std::unique_ptr<graphics::DisplayConfiguration> configuration() const override;
     void configure(graphics::DisplayConfiguration const&) override;
 
=== modified file 'src/platforms/android/server/display_buffer.cpp'
--- src/platforms/android/server/display_buffer.cpp	2015-02-13 06:12:34 +0000
+++ src/platforms/android/server/display_buffer.cpp	2015-02-23 13:13:47 +0000
@@ -98,10 +98,6 @@
     display_device->commit(display_name, *layer_list, gl_context, overlay_program);
 }
 
-void mga::DisplayBuffer::flip()
-{
-}
-
 MirOrientation mga::DisplayBuffer::orientation() const
 {
     /*
@@ -118,6 +114,15 @@
     return false;
 }
 
+void mga::DisplayBuffer::for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f)
+{
+    f(*this);
+}
+
+void mga::DisplayBuffer::post()
+{
+}
+
 void mga::DisplayBuffer::configure(MirPowerMode power_mode, MirOrientation orientation)
 {
     if (power_mode != mir_power_mode_on)
 
=== modified file 'src/platforms/android/server/display_buffer.h'
--- src/platforms/android/server/display_buffer.h	2015-02-13 06:12:34 +0000
+++ src/platforms/android/server/display_buffer.h	2015-02-23 13:13:47 +0000
@@ -59,9 +59,11 @@
     void make_current() override;
     void release_current() override;
     void gl_swap_buffers() override;
-    void flip() override;
     bool post_renderables_if_optimizable(RenderableList const& renderlist) override;
 
+    void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const& f) override;
+    void post() override;
+
     MirOrientation orientation() const override;
     bool uses_alpha() const override;
     void configure(MirPowerMode power_mode, MirOrientation orientation) override;
 
=== modified file 'src/platforms/mesa/server/display.cpp'
--- src/platforms/mesa/server/display.cpp	2015-01-22 09:00:14 +0000
+++ src/platforms/mesa/server/display.cpp	2015-02-23 13:13:47 +0000
@@ -113,8 +113,8 @@
 {
 }
 
-void mgm::Display::for_each_display_buffer(
-    std::function<void(graphics::DisplayBuffer&)> const& f)
+void mgm::Display::for_each_display_sync_group(
+    std::function<void(graphics::DisplaySyncGroup&)> const& f)
 {
     std::lock_guard<std::mutex> lg{configuration_mutex};
 
 
=== modified file 'src/platforms/mesa/server/display.h'
--- src/platforms/mesa/server/display.h	2015-01-22 09:00:14 +0000
+++ src/platforms/mesa/server/display.h	2015-02-23 13:13:47 +0000
@@ -61,8 +61,8 @@
     ~Display();
 
     geometry::Rectangle view_area() const;
-    void for_each_display_buffer(
-        std::function<void(graphics::DisplayBuffer&)> const& f) override;
+    void for_each_display_sync_group(
+        std::function<void(graphics::DisplaySyncGroup&)> const& f) override;
 
     std::unique_ptr<DisplayConfiguration> configuration() const override;
     void configure(DisplayConfiguration const& conf) override;
 
=== modified file 'src/platforms/mesa/server/display_buffer.cpp'
--- src/platforms/mesa/server/display_buffer.cpp	2015-02-12 18:08:46 +0000
+++ src/platforms/mesa/server/display_buffer.cpp	2015-02-23 13:13:47 +0000
@@ -204,11 +204,22 @@
         auto bypass_it = std::find_if(renderable_list.rbegin(), renderable_list.rend(), bypass_match);
         if (bypass_it != renderable_list.rend())
         {
-            auto bypass_buf = (*bypass_it)->buffer();
-            if ((bypass_buf->native_buffer_handle()->flags & mir_buffer_flag_can_scanout) &&
-                bypass_buf->size() == geom::Size{fb_width,fb_height})
-            {
-                return flip(bypass_buf);
+            auto bypass_buffer = (*bypass_it)->buffer();
+            auto native = bypass_buffer->native_buffer_handle();
+            auto gbm_native = static_cast<mgm::GBMNativeBuffer*>(native.get());
+            auto bufobj = get_buffer_object(gbm_native->bo);
+            if (bufobj &&
+                native->flags & mir_buffer_flag_can_scanout &&
+                bypass_buffer->size() == geom::Size{fb_width,fb_height})
+            {
+                bypass_buf = bypass_buffer;
+                bypass_bufobj = bufobj;
+                return true;
+            }
+            else
+            {
+                bypass_buf = nullptr;
+                bypass_bufobj = nullptr;
             }
         }
     }
@@ -216,19 +227,21 @@
     return false;
 }
 
-void mgm::DisplayBuffer::flip()
+void mgm::DisplayBuffer::for_each_display_buffer(
+    std::function<void(graphics::DisplayBuffer&)> const& f)
 {
-    flip(nullptr);
+    f(*this);
 }
 
 void mgm::DisplayBuffer::gl_swap_buffers()
 {
     if (!egl.swap_buffers())
         fatal_error("Failed to perform buffer swap");
+    bypass_buf = nullptr;
+    bypass_bufobj = nullptr;
 }
 
-bool mgm::DisplayBuffer::flip(
-    std::shared_ptr<graphics::Buffer> bypass_buf)
+void mgm::DisplayBuffer::post()
 {
     /*
      * We might not have waited for the previous frame to page flip yet.
@@ -257,12 +270,7 @@
     mgm::BufferObject *bufobj;
     if (bypass_buf)
     {
-        auto native = bypass_buf->native_buffer_handle();
-        auto gbm_native = static_cast<mgm::GBMNativeBuffer*>(native.get());
-        bufobj = get_buffer_object(gbm_native->bo);
-        // If bypass fails, just fall back to compositing.
-        if (!bufobj)
-            return false;
+        bufobj = bypass_bufobj;
     }
     else
     {
@@ -345,8 +353,6 @@
 
         scheduled_bufobj = bufobj;
     }
-
-    return true;
 }
 
 mgm::BufferObject* mgm::DisplayBuffer::get_front_buffer_object()
 
=== modified file 'src/platforms/mesa/server/display_buffer.h'
--- src/platforms/mesa/server/display_buffer.h	2015-01-22 09:00:14 +0000
+++ src/platforms/mesa/server/display_buffer.h	2015-02-23 13:13:47 +0000
@@ -20,6 +20,7 @@
 #define MIR_GRAPHICS_MESA_DISPLAY_BUFFER_H_
 
 #include "mir/graphics/display_buffer.h"
+#include "mir/graphics/display.h"
 #include "display_helpers.h"
 
 #include <vector>
@@ -41,7 +42,8 @@
 class BufferObject;
 class KMSOutput;
 
-class DisplayBuffer : public graphics::DisplayBuffer
+class DisplayBuffer : public graphics::DisplayBuffer,
+                      public graphics::DisplaySyncGroup
 {
 public:
     DisplayBuffer(std::shared_ptr<Platform> const& platform,
@@ -58,9 +60,12 @@
     void make_current() override;
     void release_current() override;
     void gl_swap_buffers() override;
-    void flip() override;
     bool post_renderables_if_optimizable(RenderableList const& renderlist) override;
 
+    void for_each_display_buffer(
+        std::function<void(graphics::DisplayBuffer&)> const& f) override;
+    void post() override;
+
     MirOrientation orientation() const override;
     void set_orientation(MirOrientation const rot, geometry::Rectangle const& a);
     bool uses_alpha() const override;
@@ -68,8 +73,6 @@
     void wait_for_page_flip();
 
 private:
-    bool flip(std::shared_ptr<graphics::Buffer> bypass_buf);
-
     BufferObject* get_front_buffer_object();
     BufferObject* get_buffer_object(struct gbm_bo *bo);
     bool schedule_page_flip(BufferObject* bufobj);
@@ -77,6 +80,8 @@
     BufferObject* last_flipped_bufobj;
     BufferObject* scheduled_bufobj;
     std::shared_ptr<graphics::Buffer> last_flipped_bypass_buf;
+    std::shared_ptr<Buffer> bypass_buf{nullptr};
+    BufferObject* bypass_bufobj{nullptr};
     std::shared_ptr<Platform> const platform;
     std::shared_ptr<DisplayReport> const listener;
     /* DRM helper from mgm::Platform */
 
=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2015-02-13 06:12:34 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2015-02-23 13:13:47 +0000
@@ -88,10 +88,8 @@
 
         // Release the buffers we did use back to the clients, before starting
         // on the potentially slow flip().
-        // FIXME: This clear() call is blocking a little (LP: #1395421)
+        // FIXME: This clear() call is blocking a little because we drive IPC here (LP: #1395421)
         renderable_list.clear();
-
-        display_buffer.flip();
     }
 
     report->finished_frame(this);
 
=== modified file 'src/server/compositor/multi_threaded_compositor.cpp'
--- src/server/compositor/multi_threaded_compositor.cpp	2015-02-17 11:58:56 +0000
+++ src/server/compositor/multi_threaded_compositor.cpp	2015-02-23 13:13:47 +0000
@@ -71,34 +71,37 @@
 class CurrentRenderingTarget
 {
 public:
-    CurrentRenderingTarget(mg::DisplayBuffer& buffer)
-        : buffer(buffer)
+    CurrentRenderingTarget() = default;
+    void ensure_current(mg::DisplayBuffer* buffer)
     {
-        buffer.make_current();
+        if ((buffer) && (buffer != current_buffer))
+            buffer->make_current();
+        current_buffer = buffer;
     }
 
     ~CurrentRenderingTarget()
     {
-        buffer.release_current();
+        if (current_buffer) current_buffer->release_current();
     }
 
 private:
-    mg::DisplayBuffer& buffer;
+    mg::DisplayBuffer* current_buffer{nullptr};
 };
 
 class CompositingFunctor
 {
 public:
-    CompositingFunctor(std::shared_ptr<mc::DisplayBufferCompositorFactory> const& db_compositor_factory,
-                       mg::DisplayBuffer& buffer,
-                       std::shared_ptr<mc::Scene> const& scene,
-                       std::shared_ptr<CompositorReport> const& report)
-        : display_buffer_compositor_factory{db_compositor_factory},
-          buffer(buffer),
-          scene(scene),
-          running{true},
-          frames_scheduled{0},
-          report{report}
+    CompositingFunctor(
+        std::shared_ptr<mc::DisplayBufferCompositorFactory> const& db_compositor_factory,
+        mg::DisplaySyncGroup& group,
+        std::shared_ptr<mc::Scene> const& scene,
+        std::shared_ptr<CompositorReport> const& report) :
+        compositor_factory{db_compositor_factory},
+        group(group),
+        scene(scene),
+        running{true},
+        frames_scheduled{0},
+        report{report}
     {
     }
 
@@ -107,26 +110,25 @@
     {
         mir::set_thread_name("Mir/Comp");
 
-        /*
-         * Make the buffer the current rendering target, and release
-         * it when the thread is finished.
-         */
-        CurrentRenderingTarget target{buffer};
-
-        auto display_buffer_compositor = display_buffer_compositor_factory->create_compositor_for(buffer);
-        auto const comp_id = display_buffer_compositor.get();
-
-        CompositorReport::SubCompositorId report_id =
-            display_buffer_compositor.get();
-
-        const auto& r = buffer.view_area();
-        report->added_display(r.size.width.as_int(), r.size.height.as_int(),
-                              r.top_left.x.as_int(), r.top_left.y.as_int(),
-                              report_id);
+        CurrentRenderingTarget target;
+        auto const comp_id = this;
+        std::vector<std::tuple<mg::DisplayBuffer*, std::unique_ptr<mc::DisplayBufferCompositor>>> compositors;
+        group.for_each_display_buffer(
+        [this, &compositors, &comp_id, &target](mg::DisplayBuffer& buffer)
+        {
+            target.ensure_current(&buffer);
+            compositors.emplace_back(
+                std::make_tuple(&buffer, compositor_factory->create_compositor_for(buffer)));
+
+            const auto& r = buffer.view_area();
+            report->added_display(r.size.width.as_int(), r.size.height.as_int(),
+                                  r.top_left.x.as_int(), r.top_left.y.as_int(),
+                                  CompositorReport::SubCompositorId{comp_id});
+        });
 
         auto compositor_registration = mir::raii::paired_calls(
-            [this,&display_buffer_compositor]{scene->register_compositor(display_buffer_compositor.get());},
-            [this,&display_buffer_compositor]{scene->unregister_compositor(display_buffer_compositor.get());});
+            [this,&comp_id]{scene->register_compositor(comp_id);},
+            [this,&comp_id]{scene->unregister_compositor(comp_id);});
 
         std::unique_lock<std::mutex> lock{run_mutex};
         while (running)
@@ -150,8 +152,12 @@
                 frames_scheduled--;
                 lock.unlock();
 
-                display_buffer_compositor->composite(
-                    scene->scene_elements_for(comp_id));
+                for (auto& compositor : compositors)
+                {
+                    target.ensure_current(std::get<0>(compositor));
+                    std::get<1>(compositor)->composite(scene->scene_elements_for(comp_id));
+                }
+                group.post();
 
                 lock.lock();
 
@@ -191,8 +197,8 @@
     }
 
 private:
-    std::shared_ptr<mc::DisplayBufferCompositorFactory> const display_buffer_compositor_factory;
-    mg::DisplayBuffer& buffer;
+    std::shared_ptr<mc::DisplayBufferCompositorFactory> const compositor_factory;
+    mg::DisplaySyncGroup& group;
     std::shared_ptr<mc::Scene> const scene;
     bool running;
     int frames_scheduled;
@@ -305,12 +311,12 @@
 void mc::MultiThreadedCompositor::create_compositing_threads()
 {
     /* Start the display buffer compositing threads */
-    display->for_each_display_buffer([this](mg::DisplayBuffer& buffer)
+    display->for_each_display_sync_group([this](mg::DisplaySyncGroup& group)
     {
         auto thread_functor = std::make_unique<mc::CompositingFunctor>(
-            display_buffer_compositor_factory, buffer, scene, report);
+            display_buffer_compositor_factory, group, scene, report);
 
-        futures.push_back(thread_pool.run(std::ref(*thread_functor), &buffer));
+        futures.push_back(thread_pool.run(std::ref(*thread_functor), &group));
         thread_functors.push_back(std::move(thread_functor));
     });
 
 
=== modified file 'src/server/compositor/screencast_display_buffer.cpp'
--- src/server/compositor/screencast_display_buffer.cpp	2015-01-21 07:34:50 +0000
+++ src/server/compositor/screencast_display_buffer.cpp	2015-02-23 13:13:47 +0000
@@ -95,10 +95,6 @@
     glFinish();
 }
 
-void mc::ScreencastDisplayBuffer::flip()
-{
-}
-
 MirOrientation mc::ScreencastDisplayBuffer::orientation() const
 {
     return mir_orientation_normal;
 
=== modified file 'src/server/compositor/screencast_display_buffer.h'
--- src/server/compositor/screencast_display_buffer.h	2015-01-21 07:34:50 +0000
+++ src/server/compositor/screencast_display_buffer.h	2015-02-23 13:13:47 +0000
@@ -62,7 +62,6 @@
     bool post_renderables_if_optimizable(graphics::RenderableList const&) override;
 
     void gl_swap_buffers() override;
-    void flip() override;
 
     MirOrientation orientation() const override;
 
 
=== modified file 'src/server/graphics/nested/nested_display.cpp'
--- src/server/graphics/nested/nested_display.cpp	2015-02-17 11:58:56 +0000
+++ src/server/graphics/nested/nested_display.cpp	2015-02-23 13:13:47 +0000
@@ -119,6 +119,22 @@
     eglTerminate(egl_display);
 }
 
+mgn::detail::DisplaySyncGroup::DisplaySyncGroup(
+    std::shared_ptr<mgn::detail::NestedOutput> const& output) :
+    output(output)
+{
+}
+
+void mgn::detail::DisplaySyncGroup::for_each_display_buffer(
+    std::function<void(DisplayBuffer&)> const& f)
+{
+    f(*output);
+}
+
+void mgn::detail::DisplaySyncGroup::post()
+{
+}
+
 mgn::NestedDisplay::NestedDisplay(
     std::shared_ptr<mg::Platform> const& platform,
     std::shared_ptr<HostConnection> const& connection,
@@ -144,7 +160,7 @@
         eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 }
 
-void mgn::NestedDisplay::for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f)
+void mgn::NestedDisplay::for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& f)
 {
     std::unique_lock<std::mutex> lock(outputs_mutex);
     for (auto& i : outputs)
@@ -205,12 +221,13 @@
 
                         auto const host_surface = connection->create_surface(request_params);
 
-                        result[output.id] = std::make_shared<mgn::detail::NestedOutput>(
-                            egl_display,
-                            host_surface,
-                            area,
-                            dispatcher,
-                            output.current_format);
+                        result[output.id] = std::make_shared<mgn::detail::DisplaySyncGroup>( 
+                            std::make_shared<mgn::detail::NestedOutput>(
+                                egl_display,
+                                host_surface,
+                                area,
+                                dispatcher,
+                                output.current_format));
                         have_output_for_group = true;
                     }
                 });
 
=== modified file 'src/server/graphics/nested/nested_display.h'
--- src/server/graphics/nested/nested_display.h	2015-01-21 07:34:50 +0000
+++ src/server/graphics/nested/nested_display.h	2015-02-23 13:13:47 +0000
@@ -87,6 +87,16 @@
 
 class NestedOutput;
 
+class DisplaySyncGroup : public graphics::DisplaySyncGroup
+{
+public:
+    DisplaySyncGroup(std::shared_ptr<detail::NestedOutput> const& output);
+    void for_each_display_buffer(std::function<void(DisplayBuffer&)> const&) override;
+    void post() override;
+private:
+    std::shared_ptr<detail::NestedOutput> const output;
+};
+
 extern EGLint const nested_egl_context_attribs[];
 }
 
@@ -105,7 +115,7 @@
 
     ~NestedDisplay() noexcept;
 
-    void for_each_display_buffer(std::function<void(DisplayBuffer&)>const& f) override;
+    void for_each_display_sync_group(std::function<void(DisplaySyncGroup&)>const& f) override;
 
     std::unique_ptr<DisplayConfiguration> configuration() const override;
     void configure(DisplayConfiguration const&) override;
@@ -133,7 +143,7 @@
     detail::EGLDisplayHandle egl_display;
 
     std::mutex outputs_mutex;
-    std::unordered_map<DisplayConfigurationOutputId, std::shared_ptr<detail::NestedOutput>> outputs;
+    std::unordered_map<DisplayConfigurationOutputId, std::shared_ptr<detail::DisplaySyncGroup>> outputs;
     DisplayConfigurationChangeHandler my_conf_change_handler;
     void create_surfaces(mir::graphics::DisplayConfiguration const& configuration);
     void apply_to_connection(mir::graphics::DisplayConfiguration const& configuration);
 
=== modified file 'src/server/graphics/nested/nested_output.cpp'
--- src/server/graphics/nested/nested_output.cpp	2015-02-13 06:12:34 +0000
+++ src/server/graphics/nested/nested_output.cpp	2015-02-23 13:13:47 +0000
@@ -70,10 +70,6 @@
     eglSwapBuffers(egl_display, egl_surface);
 }
 
-void mgn::detail::NestedOutput::flip()
-{
-}
-
 bool mgn::detail::NestedOutput::post_renderables_if_optimizable(RenderableList const&)
 {
     return false;
 
=== modified file 'src/server/graphics/nested/nested_output.h'
--- src/server/graphics/nested/nested_output.h	2015-01-21 07:34:50 +0000
+++ src/server/graphics/nested/nested_output.h	2015-02-23 13:13:47 +0000
@@ -48,7 +48,6 @@
     void make_current() override;
     void release_current() override;
     void gl_swap_buffers() override;
-    void flip() override;
     MirOrientation orientation() const override;
     bool uses_alpha() const override;
 
 
=== modified file 'src/server/graphics/offscreen/display.cpp'
--- src/server/graphics/offscreen/display.cpp	2015-02-17 11:58:56 +0000
+++ src/server/graphics/offscreen/display.cpp	2015-02-23 13:13:47 +0000
@@ -71,6 +71,21 @@
         eglTerminate(egl_display);
 }
 
+mgo::detail::DisplaySyncGroup::DisplaySyncGroup(std::unique_ptr<mg::DisplayBuffer> output) :
+    output(std::move(output))
+{
+}
+
+void mgo::detail::DisplaySyncGroup::for_each_display_buffer(
+    std::function<void(mg::DisplayBuffer&)> const& f)
+{
+    f(*output);
+}
+
+void mgo::detail::DisplaySyncGroup::post()
+{
+}
+
 mgo::Display::Display(
     EGLNativeDisplayType egl_native_display,
     std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
@@ -94,13 +109,13 @@
 {
 }
 
-void mgo::Display::for_each_display_buffer(
-    std::function<void(mg::DisplayBuffer&)> const& f)
+void mgo::Display::for_each_display_sync_group(
+    std::function<void(mg::DisplaySyncGroup&)> const& f)
 {
     std::lock_guard<std::mutex> lock{configuration_mutex};
 
-    for (auto& db_ptr : display_buffers)
-        f(*db_ptr);
+    for (auto& dg_ptr : display_sync_groups)
+        f(*dg_ptr);
 }
 
 std::unique_ptr<mg::DisplayConfiguration> mgo::Display::configuration() const
@@ -120,7 +135,7 @@
 
     std::lock_guard<std::mutex> lock{configuration_mutex};
 
-    display_buffers.clear();
+    display_sync_groups.clear();
 
     conf.for_each_output(
         [this] (DisplayConfigurationOutput const& output)
@@ -131,7 +146,8 @@
                     SurfacelessEGLContext{egl_display, egl_context_shared},
                     output.extents()};
 
-                display_buffers.push_back(std::unique_ptr<mg::DisplayBuffer>(raw_db));
+                display_sync_groups.emplace_back(
+                    new mgo::detail::DisplaySyncGroup(std::unique_ptr<mg::DisplayBuffer>(raw_db)));
             }
         });
 }
 
=== modified file 'src/server/graphics/offscreen/display.h'
--- src/server/graphics/offscreen/display.h	2015-01-21 07:34:50 +0000
+++ src/server/graphics/offscreen/display.h	2015-02-23 13:13:47 +0000
@@ -58,6 +58,16 @@
     EGLDisplay egl_display;
 };
 
+class DisplaySyncGroup : public graphics::DisplaySyncGroup
+{
+public:
+    DisplaySyncGroup(std::unique_ptr<DisplayBuffer> output);
+    void for_each_display_buffer(std::function<void(DisplayBuffer&)> const&) override;
+    void post() override;
+private:
+    std::unique_ptr<DisplayBuffer> const output;
+};
+
 }
 
 class Display : public graphics::Display
@@ -68,7 +78,7 @@
             std::shared_ptr<DisplayReport> const& listener);
     ~Display() noexcept;
 
-    void for_each_display_buffer(std::function<void(DisplayBuffer&)> const& f) override;
+    void for_each_display_sync_group(std::function<void(DisplaySyncGroup&)> const& f) override;
 
     std::unique_ptr<graphics::DisplayConfiguration> configuration() const override;
     void configure(graphics::DisplayConfiguration const& conf) override;
@@ -93,7 +103,7 @@
     SurfacelessEGLContext const egl_context_shared;
     mutable std::mutex configuration_mutex;
     DisplayConfiguration current_display_configuration;
-    std::vector<std::unique_ptr<DisplayBuffer>> display_buffers;
+    std::vector<std::unique_ptr<DisplaySyncGroup>> display_sync_groups;
 };
 
 }
 
=== modified file 'src/server/graphics/offscreen/display_buffer.cpp'
--- src/server/graphics/offscreen/display_buffer.cpp	2015-01-21 07:34:50 +0000
+++ src/server/graphics/offscreen/display_buffer.cpp	2015-02-23 13:13:47 +0000
@@ -144,10 +144,6 @@
     glFinish();
 }
 
-void mgo::DisplayBuffer::flip()
-{
-}
-
 bool mgo::DisplayBuffer::post_renderables_if_optimizable(RenderableList const&)
 {
     return false;
 
=== modified file 'src/server/graphics/offscreen/display_buffer.h'
--- src/server/graphics/offscreen/display_buffer.h	2015-01-21 07:34:50 +0000
+++ src/server/graphics/offscreen/display_buffer.h	2015-02-23 13:13:47 +0000
@@ -66,7 +66,6 @@
     void make_current() override;
     void release_current() override;
     void gl_swap_buffers() override;
-    void flip() override;
 
     MirOrientation orientation() const override;
     bool uses_alpha() const override;
 
=== modified file 'src/server/input/display_input_region.cpp'
--- src/server/input/display_input_region.cpp	2014-03-06 06:05:17 +0000
+++ src/server/input/display_input_region.cpp	2015-02-23 13:13:47 +0000
@@ -37,11 +37,14 @@
 {
     geom::Rectangles rectangles;
 
-    display->for_each_display_buffer(
-        [&rectangles](mg::DisplayBuffer const& buffer)
-        {
-            rectangles.add(buffer.view_area());
-        });
+    display->for_each_display_sync_group([&rectangles](mg::DisplaySyncGroup& group)
+    {
+        group.for_each_display_buffer(
+            [&rectangles](mg::DisplayBuffer const& buffer)
+            {
+                rectangles.add(buffer.view_area());
+            });
+    });
 
     return rectangles.bounding_rectangle();
 }
@@ -50,11 +53,14 @@
 {
     geom::Rectangles rectangles;
 
-    display->for_each_display_buffer(
-        [&rectangles](mg::DisplayBuffer const& buffer)
-        {
-            rectangles.add(buffer.view_area());
-        });
+    display->for_each_display_sync_group([&rectangles](mg::DisplaySyncGroup& group)
+    {
+        group.for_each_display_buffer(
+            [&rectangles](mg::DisplayBuffer const& buffer)
+            {
+                rectangles.add(buffer.view_area());
+            });
+    });
 
     rectangles.confine(point);
 }
 
=== modified file 'src/server/shell/graphics_display_layout.cpp'
--- src/server/shell/graphics_display_layout.cpp	2015-01-21 07:34:50 +0000
+++ src/server/shell/graphics_display_layout.cpp	2015-02-23 13:13:47 +0000
@@ -98,20 +98,22 @@
     int max_area = -1;
     geometry::Rectangle best = rect;
 
-    display->for_each_display_buffer(
-        [&](mg::DisplayBuffer const& db)
-        {
-            auto const& screen = db.view_area();
-            auto const& overlap = rect.intersection_with(screen);
-            int area = overlap.size.width.as_int() *
-                       overlap.size.height.as_int();
-
-            if (area > max_area)
+    display->for_each_display_sync_group([&](mg::DisplaySyncGroup& group) 
+    {
+        group.for_each_display_buffer([&](mg::DisplayBuffer const& db)
             {
-                best = screen;
-                max_area = area;
-            }
-        });
+                auto const& screen = db.view_area();
+                auto const& overlap = rect.intersection_with(screen);
+                int area = overlap.size.width.as_int() *
+                           overlap.size.height.as_int();
+
+                if (area > max_area)
+                {
+                    best = screen;
+                    max_area = area;
+                }
+            });
+    });
 
     return best;
 }
 
=== modified file 'tests/acceptance-tests/test_display_configuration.cpp'
--- tests/acceptance-tests/test_display_configuration.cpp	2015-01-21 07:34:50 +0000
+++ tests/acceptance-tests/test_display_configuration.cpp	2015-02-23 13:13:47 +0000
@@ -24,7 +24,7 @@
 #include "mir_test_framework/connected_client_headless_server.h"
 #include "mir_test_doubles/null_platform.h"
 #include "mir_test_doubles/null_display.h"
-#include "mir_test_doubles/null_display_buffer.h"
+#include "mir_test_doubles/null_display_sync_group.h"
 #include "mir_test_doubles/null_platform.h"
 #include "mir_test/display_config_matchers.h"
 #include "mir_test_doubles/stub_display_configuration.h"
@@ -64,9 +64,9 @@
     {
     }
 
-    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override
+    void for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& f) override
     {
-        f(display_buffer);
+        f(display_sync_group);
     }
 
     std::unique_ptr<mg::DisplayConfiguration> configuration() const override
@@ -111,7 +111,7 @@
 
 private:
     std::shared_ptr<mtd::StubDisplayConfig> config;
-    mtd::NullDisplayBuffer display_buffer;
+    mtd::NullDisplaySyncGroup display_sync_group;
     mt::Pipe p;
     std::atomic<bool> handler_called;
 };
 
=== modified file 'tests/include/mir_test_doubles/mock_display.h'
--- tests/include/mir_test_doubles/mock_display.h	2015-01-21 07:34:50 +0000
+++ tests/include/mir_test_doubles/mock_display.h	2015-02-23 13:13:47 +0000
@@ -35,7 +35,7 @@
 struct MockDisplay : public graphics::Display
 {
 public:
-    MOCK_METHOD1(for_each_display_buffer, void (std::function<void(graphics::DisplayBuffer&)> const&));
+    MOCK_METHOD1(for_each_display_sync_group, void (std::function<void(graphics::DisplaySyncGroup&)> const&));
     MOCK_CONST_METHOD0(configuration, std::unique_ptr<graphics::DisplayConfiguration>());
     MOCK_METHOD1(configure, void(graphics::DisplayConfiguration const&));
     MOCK_METHOD2(register_configuration_change_handler,
 
=== modified file 'tests/include/mir_test_doubles/mock_display_buffer.h'
--- tests/include/mir_test_doubles/mock_display_buffer.h	2015-01-21 07:34:50 +0000
+++ tests/include/mir_test_doubles/mock_display_buffer.h	2015-02-23 13:13:47 +0000
@@ -43,7 +43,6 @@
     MOCK_METHOD0(make_current, void());
     MOCK_METHOD0(release_current, void());
     MOCK_METHOD0(gl_swap_buffers, void());
-    MOCK_METHOD0(flip, void());
     MOCK_METHOD1(post_renderables_if_optimizable, bool(graphics::RenderableList const&));
     MOCK_CONST_METHOD0(orientation, MirOrientation());
     MOCK_CONST_METHOD0(uses_alpha, bool());
 
=== modified file 'tests/include/mir_test_doubles/null_display.h'
--- tests/include/mir_test_doubles/null_display.h	2015-01-21 07:34:50 +0000
+++ tests/include/mir_test_doubles/null_display.h	2015-02-23 13:13:47 +0000
@@ -22,7 +22,7 @@
 #include "mir/graphics/display.h"
 #include "null_gl_context.h"
 #include "null_display_configuration.h"
-#include <thread>
+#include "null_display_sync_group.h"
 
 namespace mir
 {
@@ -34,10 +34,9 @@
 class NullDisplay : public graphics::Display
 {
  public:
-    void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const&) override
+    void for_each_display_sync_group(std::function<void(graphics::DisplaySyncGroup&)> const& f) override
     {
-        /* yield() is needed to ensure reasonable runtime under valgrind for some tests */
-        std::this_thread::yield();
+        f(group);
     }
     std::unique_ptr<graphics::DisplayConfiguration> configuration() const override
     {
@@ -66,6 +65,7 @@
     {
         return std::unique_ptr<NullGLContext>{new NullGLContext()};
     }
+    NullDisplaySyncGroup group;
 };
 
 }
 
=== modified file 'tests/include/mir_test_doubles/null_display_buffer.h'
--- tests/include/mir_test_doubles/null_display_buffer.h	2015-01-21 07:34:50 +0000
+++ tests/include/mir_test_doubles/null_display_buffer.h	2015-02-23 13:13:47 +0000
@@ -35,7 +35,6 @@
     void make_current() override {}
     void release_current() override {}
     void gl_swap_buffers() override {}
-    void flip() override {}
     bool post_renderables_if_optimizable(graphics::RenderableList const&) override { return false; }
     MirOrientation orientation() const override { return mir_orientation_normal; }
     bool uses_alpha() const override { return false; }
 
=== added file 'tests/include/mir_test_doubles/null_display_sync_group.h'
--- tests/include/mir_test_doubles/null_display_sync_group.h	1970-01-01 00:00:00 +0000
+++ tests/include/mir_test_doubles/null_display_sync_group.h	2015-02-23 13:13:47 +0000
@@ -0,0 +1,81 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_NULL_DISPLAY_SYNC_GROUP_H_
+#define MIR_TEST_DOUBLES_NULL_DISPLAY_SYNC_GROUP_H_
+
+#include "mir/graphics/display.h"
+#include "mir/geometry/size.h"
+#include "null_display_buffer.h"
+#include "stub_display_buffer.h"
+#include <thread>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubDisplaySyncGroup : graphics::DisplaySyncGroup
+{
+public:
+    StubDisplaySyncGroup(std::vector<geometry::Rectangle> const& output_rects)
+        : output_rects{output_rects}
+    {
+        for (auto const& output_rect : output_rects)
+            display_buffers.emplace_back(output_rect);
+    }
+    StubDisplaySyncGroup(geometry::Size sz) : StubDisplaySyncGroup({{{0,0}, sz}}) {}
+
+    void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const& f) override
+    {
+        for (auto& db : display_buffers)
+            f(db);
+    }
+
+    void post() override
+    {
+        /* yield() is needed to ensure reasonable runtime under valgrind for some tests */
+        std::this_thread::yield();
+    }
+
+private:
+    std::vector<geometry::Rectangle> const output_rects;
+    std::vector<StubDisplayBuffer> display_buffers;
+};
+
+struct NullDisplaySyncGroup : graphics::DisplaySyncGroup
+{
+    void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const& f) override
+    {
+        f(db);
+    }
+    virtual void post() override
+    {
+        /* yield() is needed to ensure reasonable runtime under valgrind for some tests */
+        std::this_thread::yield();
+    }
+    NullDisplayBuffer db;
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_NULL_DISPLAY_SYNC_GROUP_H_ */
 
=== modified file 'tests/include/mir_test_doubles/stub_display.h'
--- tests/include/mir_test_doubles/stub_display.h	2015-01-21 07:34:50 +0000
+++ tests/include/mir_test_doubles/stub_display.h	2015-02-23 13:13:47 +0000
@@ -20,6 +20,7 @@
 #define MIR_TEST_DOUBLES_STUB_DISPLAY_H_
 
 #include "null_display.h"
+#include "null_display_sync_group.h"
 #include "stub_display_buffer.h"
 #include "stub_display_configuration.h"
 
@@ -37,17 +38,22 @@
 class StubDisplay : public NullDisplay
 {
 public:
-    StubDisplay(std::vector<geometry::Rectangle> const& output_rects)
-        : output_rects{output_rects}
-    {
-        for (auto const& output_rect : output_rects)
-            display_buffers.emplace_back(output_rect);
-    }
-
-    void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const& f) override
-    {
-        for (auto& db : display_buffers)
-            f(db);
+    StubDisplay(std::vector<geometry::Rectangle> const& output_rects) :
+        output_rects(output_rects)
+    {
+        for (auto const& rect : output_rects)
+            groups.emplace_back(new StubDisplaySyncGroup({rect}));
+    }
+
+    StubDisplay(unsigned int nbuffers) :
+        StubDisplay(generate_stub_rects(nbuffers))
+    {
+    }
+
+    void for_each_display_sync_group(std::function<void(graphics::DisplaySyncGroup&)> const& f) override
+    {
+        for (auto& group : groups)
+            f(*group);
     }
 
     std::unique_ptr<graphics::DisplayConfiguration> configuration() const override
@@ -59,7 +65,15 @@
 
     std::vector<geometry::Rectangle> const output_rects;
 private:
-    std::vector<StubDisplayBuffer> display_buffers;
+    std::vector<geometry::Rectangle> generate_stub_rects(unsigned int nbuffers)
+    {
+        std::vector<geometry::Rectangle> rects;
+        for (auto i = 0u; i < nbuffers; i++)
+            rects.push_back(geometry::Rectangle{{0,0},{1,1}});
+        return rects;
+    }
+
+    std::vector<std::unique_ptr<StubDisplaySyncGroup>> groups;
 };
 
 }
 
=== modified file 'tests/integration-tests/graphics/android/test_display_integration.cpp'
--- tests/integration-tests/graphics/android/test_display_integration.cpp	2015-02-13 06:12:34 +0000
+++ tests/integration-tests/graphics/android/test_display_integration.cpp	2015-02-23 13:13:47 +0000
@@ -81,34 +81,38 @@
 
 TEST_F(AndroidDisplay, display_can_post)
 {
-    display->for_each_display_buffer([](mg::DisplayBuffer& buffer)
-    {
-        buffer.make_current();
-        md::glAnimationBasic gl_animation;
-        gl_animation.init_gl();
-
-        gl_animation.render_gl();
-        buffer.gl_swap_buffers();
-        buffer.flip();
-
-        gl_animation.render_gl();
-        buffer.gl_swap_buffers();
-        buffer.flip();
+    display->for_each_display_sync_group([](mg::DisplaySyncGroup& group) {
+        group.for_each_display_buffer([](mg::DisplayBuffer& buffer)
+        {
+            buffer.make_current();
+            md::glAnimationBasic gl_animation;
+            gl_animation.init_gl();
+
+            gl_animation.render_gl();
+            buffer.gl_swap_buffers();
+
+            gl_animation.render_gl();
+            buffer.gl_swap_buffers();
+        });
+        group.post();
     });
 }
 
 TEST_F(AndroidDisplay, display_can_post_overlay)
 {
-    display->for_each_display_buffer([](mg::DisplayBuffer& db)
-    {
-        db.make_current();
-        auto area = db.view_area();
-        auto buffer = buffer_allocator->alloc_buffer_platform(
-            area.size, mir_pixel_format_abgr_8888, mga::BufferUsage::use_hardware);
-        mg::RenderableList list{
-            std::make_shared<mtd::StubRenderable>(buffer, area)
-        };
+    display->for_each_display_sync_group([](mg::DisplaySyncGroup& group) {
+        group.for_each_display_buffer([](mg::DisplayBuffer& db)
+        {
+            db.make_current();
+            auto area = db.view_area();
+            auto buffer = buffer_allocator->alloc_buffer_platform(
+                area.size, mir_pixel_format_abgr_8888, mga::BufferUsage::use_hardware);
+            mg::RenderableList list{
+                std::make_shared<mtd::StubRenderable>(buffer, area)
+            };
 
-        db.post_renderables_if_optimizable(list);
+            db.post_renderables_if_optimizable(list);
+        });
+        group.post();
     });
 }
 
=== modified file 'tests/integration-tests/test_display_info.cpp'
--- tests/integration-tests/test_display_info.cpp	2015-01-21 07:34:50 +0000
+++ tests/integration-tests/test_display_info.cpp	2015-02-23 13:13:47 +0000
@@ -29,6 +29,7 @@
 #include "mir_test_doubles/null_display.h"
 #include "mir_test_doubles/null_event_sink.h"
 #include "mir_test_doubles/null_display_changer.h"
+#include "mir_test_doubles/null_display_sync_group.h"
 #include "mir_test_doubles/stub_display_buffer.h"
 #include "mir_test_doubles/null_platform.h"
 #include "mir_test/display_config_matchers.h"
@@ -61,13 +62,13 @@
     {
     }
 
-    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override
+    void for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& f) override
     {
-        f(display_buffer);
+        f(display_sync_group);
     }
 
 private:
-    mtd::NullDisplayBuffer display_buffer;
+    mtd::NullDisplaySyncGroup display_sync_group;
 };
 
 class StubChanger : public mtd::NullDisplayChanger
 
=== modified file 'tests/integration-tests/test_display_server_main_loop_events.cpp'
--- tests/integration-tests/test_display_server_main_loop_events.cpp	2015-02-13 06:12:34 +0000
+++ tests/integration-tests/test_display_server_main_loop_events.cpp	2015-02-23 13:13:47 +0000
@@ -86,9 +86,9 @@
     {
     }
 
-    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override
+    void for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& f) override
     {
-        display->for_each_display_buffer(f);
+        display->for_each_display_sync_group(f);
     }
 
     std::unique_ptr<mg::DisplayConfiguration> configuration() const
 
=== modified file 'tests/integration-tests/test_surface_first_frame_sync.cpp'
--- tests/integration-tests/test_surface_first_frame_sync.cpp	2015-02-13 06:12:34 +0000
+++ tests/integration-tests/test_surface_first_frame_sync.cpp	2015-02-23 13:13:47 +0000
@@ -56,32 +56,42 @@
 public:
     SynchronousCompositor(std::shared_ptr<mg::Display> const& display_,
                           std::shared_ptr<mc::Scene> const& s,
-                          std::shared_ptr<mc::DisplayBufferCompositorFactory> const& db_compositor_factory)
+                          std::shared_ptr<mc::DisplayBufferCompositorFactory> const& dbc_factory)
         : display{display_},
           scene{s}
     {
-        display->for_each_display_buffer(
-            [this, &db_compositor_factory](mg::DisplayBuffer& display_buffer)
+        display->for_each_display_sync_group([this, &dbc_factory](mg::DisplaySyncGroup& group)
+        {
+            group.for_each_display_buffer([this, &dbc_factory](mg::DisplayBuffer& display_buffer)
             {
-                auto dbc = db_compositor_factory->create_compositor_for(display_buffer);
+                auto dbc = dbc_factory->create_compositor_for(display_buffer);
                 scene->register_compositor(dbc.get());
                 display_buffer_compositor_map[&display_buffer] = std::move(dbc);
             });
-       
+        });
+ 
         auto notify = [this]()
         {
-            display->for_each_display_buffer([this](mg::DisplayBuffer& display_buffer)
+            display->for_each_display_sync_group([this](mg::DisplaySyncGroup& group)
             {
-                auto& dbc = display_buffer_compositor_map[&display_buffer];
-                dbc->composite(scene->scene_elements_for(dbc.get()));
+                group.for_each_display_buffer([this](mg::DisplayBuffer& display_buffer)
+                {
+                    auto& dbc = display_buffer_compositor_map[&display_buffer];
+                    dbc->composite(scene->scene_elements_for(dbc.get()));
+                });
+                group.post();
             });
         };
         auto notify2 = [this](int)
         {
-            display->for_each_display_buffer([this](mg::DisplayBuffer& display_buffer)
+            display->for_each_display_sync_group([this](mg::DisplaySyncGroup& group)
             {
-                auto& dbc = display_buffer_compositor_map[&display_buffer];
-                dbc->composite(scene->scene_elements_for(dbc.get()));
+                group.for_each_display_buffer([this](mg::DisplayBuffer& display_buffer)
+                {
+                    auto& dbc = display_buffer_compositor_map[&display_buffer];
+                    dbc->composite(scene->scene_elements_for(dbc.get()));
+                });
+                group.post();
             });
         };
         observer = std::make_shared<ms::LegacySceneChangeNotification>(notify, notify2);
 
=== modified file 'tests/integration-tests/test_surface_stack_with_compositor.cpp'
--- tests/integration-tests/test_surface_stack_with_compositor.cpp	2015-02-12 22:31:44 +0000
+++ tests/integration-tests/test_surface_stack_with_compositor.cpp	2015-02-23 13:13:47 +0000
@@ -30,6 +30,8 @@
 #include "mir_test_doubles/stub_display_buffer.h"
 #include "mir_test_doubles/stub_buffer.h"
 #include "mir_test_doubles/stub_input_sender.h"
+#include "mir_test_doubles/null_surface_configurator.h"
+#include "mir_test_doubles/null_display_sync_group.h"
 
 #include <condition_variable>
 #include <mutex>
@@ -56,23 +58,14 @@
     }
 };
 
-struct CountingDisplayBuffer : public mtd::StubDisplayBuffer
+struct CountingDisplaySyncGroup : public mtd::StubDisplaySyncGroup
 {
-    CountingDisplayBuffer() :
-        StubDisplayBuffer({{0,0}, {10, 10}})
-    {
-    }
-
-    bool post_renderables_if_optimizable(mg::RenderableList const&) override
-    {
-        return false;
-    }
-
-    void gl_swap_buffers() override
-    {
-    }
-
-    void flip() override
+    CountingDisplaySyncGroup() :
+    mtd::StubDisplaySyncGroup({100,100})
+    {
+    }
+
+    void post() override
     {
         increment_post_count();
     }
@@ -101,19 +94,19 @@
 
 struct StubDisplay : public mtd::NullDisplay
 {
-    StubDisplay(mg::DisplayBuffer& primary, mg::DisplayBuffer& secondary)
+    StubDisplay(mg::DisplaySyncGroup& primary, mg::DisplaySyncGroup& secondary)
       : primary(primary),
         secondary(secondary)
     {
     } 
-    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& fn) override
+    void for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& fn) override
     {
         fn(primary);
         fn(secondary);
     }
 private:
-    mg::DisplayBuffer& primary;
-    mg::DisplayBuffer& secondary;
+    mg::DisplaySyncGroup& primary;
+    mg::DisplaySyncGroup& secondary;
 };
 
 struct SurfaceStackCompositor : public testing::Test
@@ -144,8 +137,8 @@
     std::shared_ptr<ms::BasicSurface> stub_surface;
     ms::SurfaceCreationParameters default_params;
     mtd::StubBuffer stubbuf;
-    CountingDisplayBuffer stub_primary_db;
-    CountingDisplayBuffer stub_secondary_db;
+    CountingDisplaySyncGroup stub_primary_db;
+    CountingDisplaySyncGroup stub_secondary_db;
     StubDisplay stub_display{stub_primary_db, stub_secondary_db};
     mc::DefaultDisplayBufferCompositorFactory dbc_factory{
         mt::fake_shared(renderer_factory),
 
=== modified file 'tests/integration-tests/test_surfaceloop.cpp'
--- tests/integration-tests/test_surfaceloop.cpp	2015-01-21 07:34:50 +0000
+++ tests/integration-tests/test_surfaceloop.cpp	2015-02-23 13:13:47 +0000
@@ -22,6 +22,7 @@
 #include "mir_test_doubles/stub_buffer_allocator.h"
 #include "mir_test_doubles/null_platform.h"
 #include "mir_test_doubles/null_display.h"
+#include "mir_test_doubles/null_display_sync_group.h"
 #include "mir_test_doubles/stub_display_buffer.h"
 
 #include "mir_test_framework/stubbed_server_configuration.h"
@@ -75,18 +76,18 @@
 class StubDisplay : public mtd::NullDisplay
 {
 public:
-    StubDisplay()
-        : display_buffer{geom::Rectangle{geom::Point{0,0}, geom::Size{1600,1600}}}
+    StubDisplay() :
+        display_sync_group{geom::Size{1600,1600}}
     {
     }
 
-    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override
+    void for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& f) override
     {
-        f(display_buffer);
+        f(display_sync_group);
     }
 
 private:
-    mtd::StubDisplayBuffer display_buffer;
+    mtd::StubDisplaySyncGroup display_sync_group;
 };
 
 struct SurfaceSync
 
=== modified file 'tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp'
--- tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2015-01-21 09:03:53 +0000
+++ tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2015-02-23 13:13:47 +0000
@@ -124,8 +124,6 @@
         .Times(1);
     EXPECT_CALL(display_buffer, gl_swap_buffers())
         .Times(1);
-    EXPECT_CALL(display_buffer, flip())
-        .Times(1);
 
     mc::DefaultDisplayBufferCompositor compositor(
         display_buffer,
@@ -205,8 +203,6 @@
         .InSequence(render_seq);
     EXPECT_CALL(display_buffer, gl_swap_buffers())
         .InSequence(render_seq);
-    EXPECT_CALL(display_buffer, flip())
-        .InSequence(render_seq);
 
     mc::DefaultDisplayBufferCompositor compositor(
         display_buffer,
@@ -242,8 +238,6 @@
         .InSequence(seq);
     EXPECT_CALL(display_buffer, gl_swap_buffers())
         .InSequence(seq);
-    EXPECT_CALL(display_buffer, flip())
-        .InSequence(seq);
 
     EXPECT_CALL(display_buffer, post_renderables_if_optimizable(_))
         .InSequence(seq)
@@ -263,8 +257,6 @@
         .InSequence(seq);
     EXPECT_CALL(display_buffer, gl_swap_buffers())
         .InSequence(seq);
-    EXPECT_CALL(display_buffer, flip())
-        .InSequence(seq);
 
     mc::DefaultDisplayBufferCompositor compositor(
         display_buffer,
@@ -302,8 +294,6 @@
         .InSequence(seq);
     EXPECT_CALL(display_buffer, gl_swap_buffers())
         .InSequence(seq);
-    EXPECT_CALL(display_buffer, flip())
-        .InSequence(seq);
 
     mc::DefaultDisplayBufferCompositor compositor(
         display_buffer,
 
=== modified file 'tests/unit-tests/compositor/test_multi_threaded_compositor.cpp'
--- tests/unit-tests/compositor/test_multi_threaded_compositor.cpp	2015-02-13 06:12:34 +0000
+++ tests/unit-tests/compositor/test_multi_threaded_compositor.cpp	2015-02-23 13:13:47 +0000
@@ -31,6 +31,7 @@
 #include "mir_test_doubles/mock_compositor_report.h"
 #include "mir_test_doubles/mock_scene.h"
 #include "mir_test_doubles/stub_scene.h"
+#include "mir_test_doubles/stub_display.h"
 #include "mir_test_doubles/null_display_buffer_compositor_factory.h"
 
 #include <boost/throw_exception.hpp>
@@ -52,30 +53,12 @@
 namespace mtd = mir::test::doubles;
 namespace mt = mir::test;
 
-namespace
-{
-
-class StubDisplay : public mtd::NullDisplay
-{
- public:
-    StubDisplay(unsigned int nbuffers) : buffers{nbuffers} {}
-
-    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override
-    {
-        for (auto& db : buffers)
-            f(db);
-    }
-
-private:
-    std::vector<mtd::NullDisplayBuffer> buffers;
-};
-
 class StubDisplayWithMockBuffers : public mtd::NullDisplay
 {
- public:
+public:
     StubDisplayWithMockBuffers(unsigned int nbuffers) : buffers{nbuffers} {}
 
-    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f)
+    void for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& f) override
     {
         for (auto& db : buffers)
             f(db);
@@ -84,11 +67,21 @@
     void for_each_mock_buffer(std::function<void(mtd::MockDisplayBuffer&)> const& f)
     {
         for (auto& db : buffers)
-            f(db);
+            f(db.buffer);
     }
 
 private:
-    std::vector<testing::NiceMock<mtd::MockDisplayBuffer>> buffers;
+    struct StubDisplaySyncGroup : mg::DisplaySyncGroup
+    {
+        void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override
+        {
+            f(buffer);            
+        }
+        void post() override {}
+        testing::NiceMock<mtd::MockDisplayBuffer> buffer; 
+    };
+
+    std::vector<StubDisplaySyncGroup> buffers;
 };
 
 class StubScene : public mtd::StubScene
@@ -337,6 +330,8 @@
     std::vector<std::string> thread_names;
 };
 
+namespace
+{
 auto const null_report = mr::null_compositor_report();
 unsigned int const composites_per_update{1};
 }
@@ -347,7 +342,7 @@
 
     unsigned int const nbuffers{3};
 
-    auto display = std::make_shared<StubDisplay>(nbuffers);
+    auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
     mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_report, true};
@@ -422,7 +417,7 @@
 
     unsigned int const nbuffers = 3;
 
-    auto display = std::make_shared<StubDisplay>(nbuffers);
+    auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
     mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_report, true};
@@ -482,7 +477,7 @@
 
     unsigned int const nbuffers = 3;
 
-    auto display = std::make_shared<StubDisplay>(nbuffers);
+    auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
     mc::MultiThreadedCompositor compositor{display, scene, factory,
@@ -555,7 +550,7 @@
 
     unsigned int const nbuffers = 3;
 
-    auto display = std::make_shared<StubDisplay>(nbuffers);
+    auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
     mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_report, false};
@@ -578,7 +573,7 @@
 
     unsigned int const nbuffers = 3;
 
-    auto display = std::make_shared<StubDisplay>(nbuffers);
+    auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
     mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_report, false};
@@ -613,7 +608,7 @@
 
     unsigned int const nbuffers{3};
 
-    auto display = std::make_shared<StubDisplay>(nbuffers);
+    auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<SurfaceUpdatingDisplayBufferCompositorFactory>(scene);
     mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_report, true};
 
=== modified file 'tests/unit-tests/graphics/android/test_display.cpp'
--- tests/unit-tests/graphics/android/test_display.cpp	2015-02-13 06:12:34 +0000
+++ tests/unit-tests/graphics/android/test_display.cpp	2015-02-23 13:13:47 +0000
@@ -656,25 +656,28 @@
         null_display_report,
         mga::OverlayOptimization::enabled);
 
-    auto db_count = 0;
-    display.for_each_display_buffer([&](mg::DisplayBuffer&){ db_count++; });
-    EXPECT_THAT(db_count, Eq(2));
+    auto group_count = 0; 
+    auto db_group_counter = [&](mg::DisplaySyncGroup&) {
+        group_count++;
+    };
+    display.for_each_display_sync_group(db_group_counter);
+    EXPECT_THAT(group_count, Eq(2));
 
     //hotplug external away
     external_connected = false;
     hotplug_fn();
 
-    db_count = 0;
-    display.for_each_display_buffer([&](mg::DisplayBuffer&){ db_count++; });
-    EXPECT_THAT(db_count, Eq(1));
+    group_count = 0;
+    display.for_each_display_sync_group(db_group_counter);
+    EXPECT_THAT(group_count, Eq(1));
 
     //hotplug external back 
     external_connected = true;
     hotplug_fn();
 
-    db_count = 0;
-    display.for_each_display_buffer([&](mg::DisplayBuffer&){ db_count++; });
-    EXPECT_THAT(db_count, Eq(2));
+    group_count = 0;
+    display.for_each_display_sync_group(db_group_counter);
+    EXPECT_THAT(group_count, Eq(2));
 }
 
 TEST_F(Display, turns_external_display_on_with_hotplug)
@@ -715,12 +718,12 @@
     //hotplug external away
     external_connected = false;
     hotplug_fn();
-    display.for_each_display_buffer([](mg::DisplayBuffer&){});
+    display.for_each_display_sync_group([](mg::DisplaySyncGroup&){});
 
     //hotplug external back 
     external_connected = true;
     hotplug_fn();
-    display.for_each_display_buffer([](mg::DisplayBuffer&){});
+    display.for_each_display_sync_group([](mg::DisplaySyncGroup&){});
 }
 
 TEST_F(Display, configures_external_display)
 
=== modified file 'tests/unit-tests/graphics/android/test_display_buffer.cpp'
--- tests/unit-tests/graphics/android/test_display_buffer.cpp	2015-02-13 06:12:34 +0000
+++ tests/unit-tests/graphics/android/test_display_buffer.cpp	2015-02-23 13:13:47 +0000
@@ -104,7 +104,6 @@
         mga::OverlayOptimization::enabled};
 
     db.gl_swap_buffers();
-    db.flip();
 }
 
 TEST_F(DisplayBuffer, posts_overlay_list_returns_display_device_decision)
 
=== modified file 'tests/unit-tests/graphics/mesa/test_display.cpp'
--- tests/unit-tests/graphics/mesa/test_display.cpp	2015-01-22 09:00:14 +0000
+++ tests/unit-tests/graphics/mesa/test_display.cpp	2015-02-23 13:13:47 +0000
@@ -438,10 +438,11 @@
 
     auto display = create_display(create_platform());
 
-    display->for_each_display_buffer([](mg::DisplayBuffer& db)
-    {
-        db.gl_swap_buffers();
-        db.flip();
+    display->for_each_display_sync_group([](mg::DisplaySyncGroup& group) {
+        group.for_each_display_buffer([](mg::DisplayBuffer& db) {
+            db.gl_swap_buffers();
+        });
+        group.post();
     });
 }
 
@@ -476,11 +477,11 @@
     EXPECT_THROW(
     {
         auto display = create_display(create_platform());
-
-        display->for_each_display_buffer([](mg::DisplayBuffer& db)
-        {
-            db.gl_swap_buffers();
-            db.flip();
+        display->for_each_display_sync_group([](mg::DisplaySyncGroup& group) {
+            group.for_each_display_buffer([](mg::DisplayBuffer& db) {
+                db.gl_swap_buffers();
+            });
+            group.post();
         });
     }, std::runtime_error);
 }
@@ -622,9 +623,10 @@
 
     int callback_count{0};
 
-    display->for_each_display_buffer([&](mg::DisplayBuffer&)
-    {
-        callback_count++;
+    display->for_each_display_sync_group([&](mg::DisplaySyncGroup& group) {
+        group.for_each_display_buffer([&](mg::DisplayBuffer&) {
+            callback_count++;
+        });
     });
 
     EXPECT_NE(0, callback_count);
 
=== modified file 'tests/unit-tests/graphics/mesa/test_display_buffer.cpp'
--- tests/unit-tests/graphics/mesa/test_display_buffer.cpp	2015-02-12 22:46:39 +0000
+++ tests/unit-tests/graphics/mesa/test_display_buffer.cpp	2015-02-23 13:13:47 +0000
@@ -312,7 +312,7 @@
         mock_egl.fake_egl_context);
 
     db.gl_swap_buffers();
-    db.flip();
+    db.post();
 }
 
 TEST_F(MesaDisplayBufferTest, single_mode_first_post_flips_with_wait)
@@ -333,7 +333,7 @@
         mock_egl.fake_egl_context);
 
     db.gl_swap_buffers();
-    db.flip();
+    db.post();
 }
 
 TEST_F(MesaDisplayBufferTest, clone_mode_waits_for_page_flip_on_second_flip)
@@ -362,10 +362,10 @@
         mock_egl.fake_egl_context);
 
     db.gl_swap_buffers();
-    db.flip();
+    db.post();
 
     db.gl_swap_buffers();
-    db.flip();
+    db.post();
 }
 
 TEST_F(MesaDisplayBufferTest, skips_bypass_because_of_incompatible_list)
 
=== modified file 'tests/unit-tests/graphics/mesa/test_display_multi_monitor.cpp'
--- tests/unit-tests/graphics/mesa/test_display_multi_monitor.cpp	2015-02-13 06:12:34 +0000
+++ tests/unit-tests/graphics/mesa/test_display_multi_monitor.cpp	2015-02-23 13:13:47 +0000
@@ -358,18 +358,16 @@
     auto display = create_display_cloned(create_platform());
 
     /* First frame: Page flips are scheduled, but not waited for */
-    display->for_each_display_buffer([](mg::DisplayBuffer& buffer)
+    display->for_each_display_sync_group([](mg::DisplaySyncGroup& group)
     {
-        buffer.gl_swap_buffers();
-        buffer.flip();
+        group.post();
     });
 
     /* Second frame: Previous page flips finish (drmHandleEvent) and new ones
        are scheduled */
-    display->for_each_display_buffer([](mg::DisplayBuffer& buffer)
+    display->for_each_display_sync_group([](mg::DisplaySyncGroup& group)
     {
-        buffer.gl_swap_buffers();
-        buffer.flip();
+        group.post();
     });
 }
 
 
=== modified file 'tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp'
--- tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp	2015-02-13 06:12:34 +0000
+++ tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp	2015-02-23 13:13:47 +0000
@@ -68,12 +68,12 @@
         mr::null_display_report()};
 
     int count = 0;
-    display.for_each_display_buffer(
-        [&](mg::DisplayBuffer& db)
-        {
+    display.for_each_display_sync_group([&](mg::DisplaySyncGroup& group) {
+        group.for_each_display_buffer([&](mg::DisplayBuffer& db) {
             ++count;
             EXPECT_EQ(mir_orientation_normal, db.orientation());
         });
+    });
 
     EXPECT_TRUE(count);
 }
@@ -107,9 +107,8 @@
     Mock::VerifyAndClearExpectations(&mock_gl);
 
     /* Binds the GL framebuffer objects */
-    display.for_each_display_buffer(
-        [this](mg::DisplayBuffer& db)
-        {
+    display.for_each_display_sync_group([&](mg::DisplaySyncGroup& group) {
+        group.for_each_display_buffer([&](mg::DisplayBuffer& db) {
             EXPECT_CALL(mock_egl, eglMakeCurrent(_,_,_,Ne(EGL_NO_CONTEXT)));
             EXPECT_CALL(mock_gl, glBindFramebuffer(_,Ne(0)));
 
@@ -118,13 +117,14 @@
             Mock::VerifyAndClearExpectations(&mock_egl);
             Mock::VerifyAndClearExpectations(&mock_gl);
         });
+    });
 
     /* Contexts are released at teardown */
-    display.for_each_display_buffer(
-        [this](mg::DisplayBuffer&)
-        {
+    display.for_each_display_sync_group([&](mg::DisplaySyncGroup& group) {
+        group.for_each_display_buffer([&](mg::DisplayBuffer&) {
             EXPECT_CALL(mock_egl, eglMakeCurrent(_,_,_,EGL_NO_CONTEXT));
         });
+    });
 }
 
 TEST_F(OffscreenDisplayTest, restores_previous_state_on_fbo_setup_failure)
 
=== modified file 'tests/unit-tests/graphics/test_display.cpp'
--- tests/unit-tests/graphics/test_display.cpp	2015-01-21 07:34:50 +0000
+++ tests/unit-tests/graphics/test_display.cpp	2015-02-23 13:13:47 +0000
@@ -191,7 +191,9 @@
     auto display = create_display();
     int db_count{0};
 
-    display->for_each_display_buffer([&] (mg::DisplayBuffer&) { ++db_count; });
+    display->for_each_display_sync_group([&](mg::DisplaySyncGroup& group) {
+        group.for_each_display_buffer([&] (mg::DisplayBuffer&) { ++db_count; });
+    });
     EXPECT_THAT(db_count, Eq(1));
 
     auto conf = display->configuration();
@@ -204,6 +206,8 @@
     display->configure(*conf);
 
     db_count = 0;
-    display->for_each_display_buffer([&] (mg::DisplayBuffer&) { ++db_count; });
+    display->for_each_display_sync_group([&](mg::DisplaySyncGroup& group) {
+        group.for_each_display_buffer([&] (mg::DisplayBuffer&) { ++db_count; });
+    });
     EXPECT_THAT(db_count, Eq(0));
 }
 
=== modified file 'tests/unit-tests/input/test_display_input_region.cpp'
--- tests/unit-tests/input/test_display_input_region.cpp	2014-03-06 06:05:17 +0000
+++ tests/unit-tests/input/test_display_input_region.cpp	2015-02-23 13:13:47 +0000
@@ -19,7 +19,7 @@
 #include "src/server/input/display_input_region.h"
 
 #include "mir_test_doubles/null_display.h"
-#include "mir_test_doubles/stub_display_buffer.h"
+#include "mir_test_doubles/stub_display.h"
 
 #include <vector>
 #include <tuple>
@@ -33,35 +33,17 @@
 
 namespace
 {
-
-class StubDisplay : public mtd::NullDisplay
-{
-public:
-    StubDisplay()
-        : display_buffers{
-              mtd::StubDisplayBuffer{geom::Rectangle{geom::Point{0,0}, geom::Size{800,600}}},
-              mtd::StubDisplayBuffer{geom::Rectangle{geom::Point{0,600}, geom::Size{100,100}}},
-              mtd::StubDisplayBuffer{geom::Rectangle{geom::Point{800,0}, geom::Size{100,100}}}}
-    {
-
-    }
-
-    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override
-    {
-        for (auto& db : display_buffers)
-            f(db);
-    }
-
-private:
-    std::vector<mtd::StubDisplayBuffer> display_buffers;
+std::vector<geom::Rectangle> const rects{
+    geom::Rectangle{{0,0}, {800,600}},
+    geom::Rectangle{{0,600}, {100,100}},
+    geom::Rectangle{{800,0}, {100,100}}
 };
-
 }
 
 TEST(DisplayInputRegionTest, returns_correct_bounding_rectangle)
 {
     geom::Rectangle const expected_bounding_rect{geom::Point{0,0}, geom::Size{900,700}};
-    auto stub_display = std::make_shared<StubDisplay>();
+    auto stub_display = std::make_shared<mtd::StubDisplay>(rects);
 
     mi::DisplayInputRegion input_region{stub_display};
 
@@ -71,7 +53,7 @@
 
 TEST(DisplayInputRegionTest, confines_point_to_closest_valid_position)
 {
-    auto stub_display = std::make_shared<StubDisplay>();
+    auto stub_display = std::make_shared<mtd::StubDisplay>(rects);
 
     mi::DisplayInputRegion input_region{stub_display};