Merge lp:~vanvugt/mir/bypass into lp:~mir-team/mir/trunk

[Daniel van Vugt]

Add "composition bypass" support, whereby fullscreen surfaces are allowed
to go straight to the display hardware without being composited at all,
hence avoiding the overhead of any OpenGL or texturing where possible.

Hardware support:
  intel: Excellent
  radeon: Good, but REQUIRES kernel 3.11.0
  nouveau: Good, but REQUIRES kernel 3.11.0
  android: No bypass implemented yet.

Testing status:

intel: Excellent. No issues observed anywhere.

nouveau: Good. Requires kernel 3.11.0+, otherwise crashes with page flip failures.
Also beware of bug 1211700 which is amplified by bug 1195811!

radeon: Good (according to Alexandros). Requires kernel 3.11.0+, otherwise you will just see corruption on bypassed surfaces. I can't test this due to bug 1212977 and other bugs which prevent me from using radeon+3.11.0 on raring.

android: Should have no effect, but untestable due to bug 1211694.

[Daniel van Vugt (vanvugt)]

Update: Failures to schedule pageflips on nouveau are fixed. The problem was a known nouveau bug in older kernels, now fixed in 3.11.0-rc*... But nouveau does seem to still have issues with some (not all) bypass clients hanging. Looks similar to 1211700.

[Daniel van Vugt (vanvugt)]

Update 2: nouveau's client hangs seem to be bug 1211700, which is nothing new, but made worse the higher the client frame rate (hence much worse when bypassing).

So I think nouveau is now bypass feature-complete, so long as you make sure you have kernel 3.11 and are aware of bug 1211700.

[Daniel van Vugt (vanvugt)]

Update 3: I am told that radeon also works with kernel 3.11+. However I cannot test it for myself due to various kernel problems including bug 1212977.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:924
http://jenkins.qa.ubuntu.com/job/mir-ci/1321/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1763
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1648
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/559
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/559/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

A quick first pass:

37 + virtual void post_update(std::shared_ptr<Buffer> /* bypass_buf */) {}

DisplayBuffer should be a pure abstract (interface) class.

701 + last_flipped_bypass_buf = bypass_buf; // Can be nullptr

The variable isn't used anywhere else.

673 + auto native = bypass_buf->native_buffer_handle();
674 + struct gbm_bo *bo = *(struct gbm_bo**)native->data;
675 + bufobj = get_buffer_object(bo);

Since we are making the assumption that the mg::Buffer is a GBMBuffer, why not cast to a GBMBuffer and provide a GBMBuffer::get_buffer_object() method?

review: Needs Fixing

[Alexandros Frantzis (afrantzis)]

> Since we are making the assumption that the mg::Buffer is a GBMBuffer, why not cast to a GBMBuffer and provide a GBMBuffer::get_buffer_object() method?

GBMBuffer::get_gbm_bo()

[Daniel van Vugt (vanvugt)]

Alexandros,

1. Purifying: virtual void post_update(std::shared_ptr<Buffer> /* bypass_buf */) {}
I think it would be worse to ask platforms which don't implement bypass to implement an unused stub. That's just going to confuse people and bloat the code with unused stub methods.

2. "Unused" last_flipped_bypass_buf is actually important and very much used. It holds a reference to the TemporaryBuffer being scanned out for the lifetime of the frame. Without it the buffer will get reused too soon and you will see that as tearing.

3. Ugly casting... Your suggestion probably is not possible exactly how you put it. It's a TemporaryBuffer so the get_gbm_bo function would have to exist in the common interfaces for all platforms. I did have a similar generic solution implemented until r891, but decided using native_buffer_handle was more appropriate and avoided polluting non-GBM platforms. Please bzr diff -r891..890 and tell me if that would be preferable.

[Alexandros Frantzis (afrantzis)]

> 1. Purifying: virtual void post_update(std::shared_ptr<Buffer> /* bypass_buf */) {}
> I think it would be worse to ask platforms which don't implement bypass to implement
> an unused stub. That's just going to confuse people and bloat the code with unused stub methods.

All of our interface classes are pure abstract, and it pays to be consistent. I don't think it's such a big overhead to add a stub method to a platform if it doesn't support bypass.

> 2. "Unused" last_flipped_bypass_buf is actually important and very much used.
> It holds a reference to the TemporaryBuffer being scanned out for the lifetime of the frame.
> Without it the buffer will get reused too soon and you will see that as tearing.

OK. Perhaps a comment here would help to make the intent more apparent.

> 3. Ugly casting... Your suggestion probably is not possible exactly how you put it.
> It's a TemporaryBuffer so the get_gbm_bo function would have to exist in the common
> interfaces for all platforms. I did have a similar generic solution implemented until
> r891, but decided using native_buffer_handle was more appropriate and avoided polluting
> non-GBM platforms. Please bzr diff -r891..890 and tell me if that would be preferable.

How about having a MirGBMBufferPackage struct which extends MirBufferPackage? We can then cast the returned MirNativeBuffer struct that GBMBuffer::native_buffer_handle() returns to MirGBMBufferPackage to gain access to GBM specific server-side data (like the gbm_bo).

235 +BypassFilter::BypassFilter(const graphics::DisplayBuffer &display_buffer)
...and at other points

'T const&' is the preferred style.

[Daniel van Vugt (vanvugt)]

Alexandros,

1. Pure virtual: Disagree
"Consistency" in this case would just produce unreachable and confusing code. It would increase code bloat, reduce test coverage and likely confuse anyone reading it.

2. last_flipped_bypass_buf: Fixed with a comment

3. Ugly casting: Fixed as you suggested

4. Tconst&: Disagree
I've been using "const T&" ever since I raised the issue;
https://lists.ubuntu.com/archives/mir-devel/2013-April/000098.html
https://lists.ubuntu.com/archives/mir-devel/2013-April/000106.html
I hoped that others would follow, but the conversation went quiet.

[Alan Griffiths (alan-griffiths)]

> 4. Tconst&: Disagree
> I've been using "const T&" ever since I raised the issue;
> https://lists.ubuntu.com/archives/mir-devel/2013-April/000098.html
> https://lists.ubuntu.com/archives/mir-devel/2013-April/000106.html
> I hoped that others would follow, but the conversation went quiet.

"We favor the form int const* foo to const int* foo. This keeps the const with the type modifier (& or *).

"That said, while we encourage putting const after the type, we do not require it. But be consistent with the code around you!"

http://unity.ubuntu.com/mir/cppguide/index.html?showone=Use_of_const#Use_of_const

[Alan Griffiths (alan-griffiths)]

50 -private:
51 +protected:

BasicDisplayBufferCompositor is a weird piece of design an this makes it weirder. (Protected member data increases coupling and suggests poor coherence.)

Existing issue here: What on earth does "void BasicDisplayBufferCompositor::composite()" convey to the user?

But this MP is probably not the place to address this (unless a better design makes other things simpler).

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:927
http://jenkins.qa.ubuntu.com/job/mir-ci/1327/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1773
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1658
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/565/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:927
http://jenkins.qa.ubuntu.com/job/mir-ci/1328/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1775
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1660
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/566
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/566/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

416 +void mc::DefaultDisplayBufferCompositor::composite()
417 +{
418 + bool bypassed = false;
419 +
420 + if (display_buffer.can_bypass())
421 + {
422 + mc::BypassFilter filter(display_buffer);
423 + mc::BypassMatch match;
424 +
425 + // It would be *really* nice if Scene had an iterator to simplify this
426 + scene->for_each_if(filter, match);
427 +
428 + if (filter.fullscreen_on_top())
429 + {
430 + auto bypass_buf =
431 + match.topmost_fullscreen()->lock_compositor_buffer();
432 +
433 + if (bypass_buf->can_bypass())
434 + {
435 + display_buffer.post_update(bypass_buf);
436 + bypassed = true;
437 + }
438 + }
439 + }
440 +
441 + if (!bypassed)
442 + mc::BasicDisplayBufferCompositor::composite();
443 +}

On an initial reading this looks as though it violates "Tell, Don't Ask".

I'd rather it read:

void mc::DefaultDisplayBufferCompositor::composite()
{
    if (!display_buffer.effects_bypass(scene))
        mc::BasicDisplayBufferCompositor::composite();
}

With the logic to handle determining if bypass is possible and effecting it owned by a single method in the DisplayBuffer implementation instead of the proposed pair of can_bypass() and post_update(...).

"Needs Information" as there's no "Needs Discussion"

review: Needs Information

[Alan Griffiths (alan-griffiths)]

BypassMatch is used to capture a pointer into a data structure guarded by a mutex - and that pointer is later used after the mutex is unlocked.

(Also, BypassMatch would be more readable as a lambda.)

review: Needs Fixing

[Robert Ancell (robert-ancell)]

This feature has been requested to be tested on the QA test machines before merging. So I'll put a "needs fixing" block on it until that has been completed.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

There's a lot going on here. But it looks like only Alan's raising new issues that "Needs Fixing" right now...

Alan,

I agree BasicDisplayBufferCompositor is a bit odd and could possibly be cleaned up. But that's a pre-existing issue.

I dislike BypassFilter/BypassMatch too. But that's all the Scene interface gives us right now. I would prefer that Scene simply provided an iterator (which points to surfaces) instead. But I thought in the interest of keeping diffs small and delivering on time, I should work with the existing iteration interface.

On first read I like your proposal of DisplayBuffer::effects_bypass. But then I realized that would either move the bypass decision logic into the interface class DisplayBuffer, or it would move the platform-independent decision logic into GBMDisplayBuffer. Hence rendering it inaccessible to other platforms/drivers. So I think the decision logic is best placed where it is -- in the compositing logic common to all platforms.

Re: lambdas... Again, I would prefer to see a simple Scene::iterator instead. But that's a pre-existing problem.

pointer used after mutex unlocked: I'm not sure there's significant risk yet. Will have to investigate and likely (regretfully) have to change the Scene interface. The big issue is that I cannot use OperatorForScene it is current form. Because I need to ensure only one surface gets bypassed per frame. That means doing it after for_each_if().

[Daniel van Vugt (vanvugt)]

-"it is"
+"in its"

[Daniel van Vugt (vanvugt)]

Work in progress. Waiting on new prerequisite: lp:~vanvugt/mir/lockable-scene
to solve the locking issue Alan mentioned.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:930
http://jenkins.qa.ubuntu.com/job/mir-ci/1336/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1784
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1669
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/574
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/574/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Robert Ancell (robert-ancell)]

When testing with ppa:mir-team/qa-testing I'm seeing a ~50% drop in framerates when running glmark2. Unity otherwise seems to run with no perceptible performance hit and is stable.

From archive:

=======================================================
    glmark2 2012.08
=======================================================
    OpenGL Information
    GL_VENDOR: Intel Open Source Technology Center
    GL_RENDERER: Mesa DRI Intel(R) Ironlake Mobile
    GL_VERSION: 2.1 Mesa 9.2.0-devel
=======================================================
[build] use-vbo=false: FPS: 113 FrameTime: 8.850 ms
[build] use-vbo=true: FPS: 215 FrameTime: 4.651 ms
[texture] texture-filter=nearest: FPS: 280 FrameTime: 3.571 ms
[texture] texture-filter=linear: FPS: 302 FrameTime: 3.311 ms
[texture] texture-filter=mipmap: FPS: 276 FrameTime: 3.623 ms
[shading] shading=gouraud: FPS: 248 FrameTime: 4.032 ms
[shading] shading=blinn-phong-inf: FPS: 200 FrameTime: 5.000 ms
[shading] shading=phong: FPS: 169 FrameTime: 5.917 ms
[bump] bump-render=high-poly: FPS: 105 FrameTime: 9.524 ms
[bump] bump-render=normals: FPS: 244 FrameTime: 4.098 ms
[bump] bump-render=height: FPS: 251 FrameTime: 3.984 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 134 FrameTime: 7.463 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 66 FrameTime: 15.152 ms
[pulsar] light=false:quads=5:texture=false: FPS: 222 FrameTime: 4.505 ms

From PPA:

=======================================================
    glmark2 2012.08
=======================================================
    OpenGL Information
    GL_VENDOR: Intel Open Source Technology Center
    GL_RENDERER: Mesa DRI Intel(R) Ironlake Mobile
    GL_VERSION: 2.1 Mesa 9.2.0-devel
=======================================================
[build] use-vbo=false: FPS: 114 FrameTime: 8.772 ms
[build] use-vbo=true: FPS: 116 FrameTime: 8.621 ms
[texture] texture-filter=nearest: FPS: 120 FrameTime: 8.333 ms
[texture] texture-filter=linear: FPS: 118 FrameTime: 8.475 ms
[texture] texture-filter=mipmap: FPS: 118 FrameTime: 8.475 ms
[shading] shading=gouraud: FPS: 101 FrameTime: 9.901 ms
[shading] shading=blinn-phong-inf: FPS: 117 FrameTime: 8.547 ms
[shading] shading=phong: FPS: 105 FrameTime: 9.524 ms
[bump] bump-render=high-poly: FPS: 90 FrameTime: 11.111 ms
[bump] bump-render=normals: FPS: 120 FrameTime: 8.333 ms
[bump] bump-render=height: FPS: 117 FrameTime: 8.547 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 102 FrameTime: 9.804 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 59 FrameTime: 16.949 ms
[pulsar] light=false:quads=5:texture=false: FPS: 116 FrameTime: 8.621 ms

(both crash after pulsar due to bug 1203742)

[Robert Ancell (robert-ancell)]

review: Needs Fixing

[kevin gunn (kgunn72)]

ok, so the metric is phoronix
with the qa-testing ppa created from this branch on latest ubuntu archive
openarena = 10 fps on standalone X
openarena = 10 fps on Xmir

then i cross checked on a machine running xmir from archive updated just now
openarena = 60 fps on standalone X
openarena = 60 fps on Xmir

which indicates something effected standalone X (with xmir components installed, but type=unity commented out)

review: Needs Fixing

[Robert Ancell (robert-ancell)]

I get with phoronix openarena [1]:

With traditional X:
800x600 - 28.92
1366x768 - 17.27

With XMir bypass:
800x600 - 29.30
1366x768 - 16.98

So no significant impact.

[1] $ phoronix-test-suite benchmark pts/openarena

[Robert Ancell (robert-ancell)]

For completeness:

With archive XMir:
800x600 - 21.07
1366x768 - 14.97

So there is an improvement from the archive XMir to XMir with bypass.

[Robert Ancell (robert-ancell)]

Re-running the glmark2 tests doesn't show a big change anymore, so I think there might have been something wrong with the way I first tested it.

[kevin gunn (kgunn72)]

ok, reran on a more well known machine - good results
openarena 800x600
w/ bypass 109.33 w/o bypass 103 fps
openarena 1280 x 800
w/ bypass 58.4 w/o bypass 56 fps

also, rebuilt local bypass - compared to main for egltriangle demo client
w/ bypass 264 fps
w/o bypass 173 fps

review: Approve

[Daniel van Vugt (vanvugt)]

I don't think it's appropriate to discuss detailed XMir results here, but while we are...

Platform / glmark2-window / glmark2-fullscreen / glxgears / OpenArena
XMir / 1531 / 1044 / 5600 / 265
XMir+bypass / 1628 / 1119 / 6000 / 280
Legacy X / 1847 / 1125 / 6600 / 270

* OpenArena seems very erratic for me so those numbers can't be trusted.
But any XMir results are going to be suboptimal while XMir can't do full direct GLX bypass yet.

For native Mir apps like eglplasma/egltriangle, the fullscreen performance benefit is much more exciting. Anywhere from 15% to 50% improvement.

[Alexandros Frantzis (afrantzis)]

Looks good overall.

Ideally, we could make some design improvements in terms of how we deal with display buffers, as mentioned in previous comments, but I haven't thought through the details of how to not push too much responsibility and the platform independent logic to the display buffer while doing this. If we can we work out something in this MP, great... otherwise I am OK with improving this later.

review: Approve

[Daniel van Vugt (vanvugt)]

Well, it's a compositing decision so the logic going in the compositor (as it is) seems logical to me. But at the same time, I know I keep saying "Compositor" should not be a /thing/. It's too abstract. Composition should be the role of some more concrete class. Maybe it's just a naming problem...

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:932
http://jenkins.qa.ubuntu.com/job/mir-ci/1349/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1806
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1691
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/587
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/587/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:934
http://jenkins.qa.ubuntu.com/job/mir-ci/1362/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1823
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1708
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/600
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/600/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

I found an issue, that requires investigation, but can't be reproduced without modifying the code...

On one particular machine, I can make page flips fail and the server die, if I:
  (a) Remove 627 + if (buffer_properties.usage == BufferUsage::hardware &&
  (b) Run a fullscreen software client.

The failure is:

terminate called after throwing an instance of 'boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<std::runtime_error> >'
  what(): Failed to schedule page flip

However this is not something that's possible with the current code, and is something I tested many times before adding the hardware check. It used to work, at least on a different machine...

To make matters worse, bug 1215754 (which is a recent regression) prevents you from testing this with most software clients.

review: Needs Information

[Daniel van Vugt (vanvugt)]

Hmm, the above scenario *does* still work on my desktop. Only fails on the laptop. And only by modifying code.

[Daniel van Vugt (vanvugt)]

review: Abstain

[Daniel van Vugt (vanvugt)]

Robert,

Can you please change your review to something that won't mislead readers? Like "needs information". As I understand it, you're just blocking waiting on further PPA testing.

[Robert Ancell (robert-ancell)]

review: Needs Information

[Robert Ancell (robert-ancell)]

Passed testing on the QA-8

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:936
http://jenkins.qa.ubuntu.com/job/mir-ci/1387/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1860
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1745
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/625
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/625/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:938
http://jenkins.qa.ubuntu.com/job/mir-ci/1398/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1874
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1759
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/636/console

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

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

There are still design issues around BasicDisplayBufferCompositor, BypassFilter, BypassMatch, Scene::lock()/unlock() and DefaultDisplayBufferCompositor::composite().

But some of that is pre-existing and all of it is better sorted after landing this stuff.

review: Approve

[Alan Griffiths (alan-griffiths)]

I've seen that test failure before this morning. I thought it a fluke: rebuild...

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:938
http://jenkins.qa.ubuntu.com/job/mir-ci/1401/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1879
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1764
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/639
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/639/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/mir-autolanding/635/
Executed test runs:
    FAILURE: http://s-jenkins:8080/job/generic-cleanup-mbs/1831/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1887
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1772
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-autolanding/290/console

review: Needs Fixing (continuous-integration)

[Robert Ancell (robert-ancell)]

On ps-radeon-hd5750-le this branch is failing with screen corruption.

A standard build works fine:
http://10.97.2.12:8080/job/openarena-benchmark-ps-radeon-hd5750-le-xmir/44/

A build with just bypass fails (from ppa:mir-team/qa-testing)
http://10.97.2.12:8080/view/qa-ppa/job/qa-ppa-openarena-ps-radeon-hd5750-le/5/

[Robert Ancell (robert-ancell)]

review: Needs Fixing

[Robert Ancell (robert-ancell)]

Image showing this machine running openarena: http://imgur.com/1k7tQE5

[Daniel van Vugt (vanvugt)]

Removed today's experiments. They should live in separate branches. Back to the old version we've been testing for the past few weeks...

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:943
http://jenkins.qa.ubuntu.com/job/mir-ci/1409/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1897/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1782/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/647/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:946
http://jenkins.qa.ubuntu.com/job/mir-ci/1417/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1907
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1792
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/655
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/655/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'include/platform/mir/graphics/buffer.h'
--- include/platform/mir/graphics/buffer.h	2013-08-06 11:56:40 +0000
+++ include/platform/mir/graphics/buffer.h	2013-08-29 01:27:06 +0000
@@ -42,6 +42,7 @@
     virtual geometry::Stride stride() const = 0;
     virtual geometry::PixelFormat pixel_format() const = 0;
     virtual void bind_to_texture() = 0;
+    virtual bool can_bypass() const = 0;
 
 protected:
     Buffer() = default;

=== modified file 'include/platform/mir/graphics/display_buffer.h'
--- include/platform/mir/graphics/display_buffer.h	2013-08-06 11:56:40 +0000
+++ include/platform/mir/graphics/display_buffer.h	2013-08-29 01:27:06 +0000
@@ -20,12 +20,15 @@
 #define MIR_GRAPHICS_DISPLAY_BUFFER_H_
 
 #include <mir/geometry/rectangle.h>
+#include <memory>
 
 namespace mir
 {
 namespace graphics
 {
 
+class Buffer;
+
 /**
  * Interface to an output framebuffer.
  */
@@ -43,6 +46,9 @@
     /** Posts the DisplayBuffer to the screen. */
     virtual void post_update() = 0;
 
+    virtual bool can_bypass() const = 0;
+    virtual void post_update(std::shared_ptr<Buffer> /* bypass_buf */) {}
+
 protected:
     DisplayBuffer() = default;
     DisplayBuffer(DisplayBuffer const& c) = delete;

=== modified file 'include/server/mir/compositor/basic_display_buffer_compositor.h'
--- include/server/mir/compositor/basic_display_buffer_compositor.h	2013-07-30 01:30:15 +0000
+++ include/server/mir/compositor/basic_display_buffer_compositor.h	2013-08-29 01:27:06 +0000
@@ -49,7 +49,7 @@
         mir::geometry::Rectangle const& view_area,
         std::function<void(std::shared_ptr<void> const&)> save_resource) = 0;
 
-private:
+protected:
     graphics::DisplayBuffer& display_buffer;
 };
 }

=== modified file 'include/test/mir_test_doubles/mock_buffer.h'
--- include/test/mir_test_doubles/mock_buffer.h	2013-07-24 05:22:03 +0000
+++ include/test/mir_test_doubles/mock_buffer.h	2013-08-29 01:27:06 +0000
@@ -65,6 +65,8 @@
 
     MOCK_METHOD0(bind_to_texture, void());
     MOCK_CONST_METHOD0(id, graphics::BufferID());
+
+    MOCK_CONST_METHOD0(can_bypass, bool());
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_compositing_criteria.h'
--- include/test/mir_test_doubles/mock_compositing_criteria.h	2013-07-31 02:22:28 +0000
+++ include/test/mir_test_doubles/mock_compositing_criteria.h	2013-08-29 01:27:06 +0000
@@ -38,7 +38,6 @@
     MOCK_CONST_METHOD1(should_be_rendered_in, bool(geometry::Rectangle const&));
 };
 
-typedef ::testing::NiceMock<MockCompositingCriteria> StubCompositingCriteria;
 }
 }
 }

=== modified file 'include/test/mir_test_doubles/mock_display_buffer.h'
--- include/test/mir_test_doubles/mock_display_buffer.h	2013-05-21 15:11:41 +0000
+++ include/test/mir_test_doubles/mock_display_buffer.h	2013-08-29 01:27:06 +0000
@@ -37,6 +37,7 @@
     MOCK_METHOD0(make_current, void());
     MOCK_METHOD0(release_current, void());
     MOCK_METHOD0(post_update, void());
+    MOCK_CONST_METHOD0(can_bypass, bool());
 };
 
 }

=== modified file 'include/test/mir_test_doubles/null_display_buffer.h'
--- include/test/mir_test_doubles/null_display_buffer.h	2013-07-24 05:22:03 +0000
+++ include/test/mir_test_doubles/null_display_buffer.h	2013-08-29 01:27:06 +0000
@@ -35,6 +35,7 @@
     void make_current() {}
     void release_current() {}
     void post_update() {}
+    bool can_bypass() const override { return false; }
 };
 
 }

=== modified file 'include/test/mir_test_doubles/stub_buffer.h'
--- include/test/mir_test_doubles/stub_buffer.h	2013-08-26 03:43:20 +0000
+++ include/test/mir_test_doubles/stub_buffer.h	2013-08-29 01:27:06 +0000
@@ -62,6 +62,8 @@
     }
     virtual void bind_to_texture() {}
 
+    virtual bool can_bypass() const override { return false; }
+
     geometry::Size const buf_size;
     geometry::PixelFormat const buf_pixel_format;
 };

=== added file 'include/test/mir_test_doubles/stub_compositing_criteria.h'
--- include/test/mir_test_doubles/stub_compositing_criteria.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_compositing_criteria.h	2013-08-29 01:27:06 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright © 2013 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: Daniel van Vugt <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_COMPOSITING_CRITERIA_H_
+#define MIR_TEST_DOUBLES_STUB_COMPOSITING_CRITERIA_H_
+
+#include "mir/compositor/compositing_criteria.h"
+#include <glm/gtc/matrix_transform.hpp>
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class StubCompositingCriteria : public compositor::CompositingCriteria
+{
+public:
+    StubCompositingCriteria(int x, int y, int width, int height,
+                            float opacity=1.0f)
+        : rect{{x, y}, {width, height}},
+          opacity(opacity)
+    {
+        const glm::mat4 ident;
+        glm::vec3 size(width, height, 0.0f);
+        glm::vec3 pos(x + width / 2, y + height / 2, 0.0f);
+        trans = glm::scale( glm::translate(ident, pos), size);
+    }
+
+    float alpha() const override
+    {
+        return opacity;
+    }
+
+    glm::mat4 const& transformation() const override
+    {
+        return trans;
+    }
+
+    bool should_be_rendered_in(const mir::geometry::Rectangle &r) const override
+    {
+        return rect.overlaps(r);
+    }
+
+private:
+    mir::geometry::Rectangle rect;
+    glm::mat4 trans;
+    float opacity;
+};
+
+} // namespace doubles
+} // namespace test
+} // namespace mir
+#endif // MIR_TEST_DOUBLES_STUB_COMPOSITING_CRITERIA_H_

=== modified file 'src/server/compositor/CMakeLists.txt'
--- src/server/compositor/CMakeLists.txt	2013-07-30 01:30:15 +0000
+++ src/server/compositor/CMakeLists.txt	2013-08-29 01:27:06 +0000
@@ -12,6 +12,7 @@
   gl_renderer_factory.cpp
   multi_threaded_compositor.cpp
   switching_bundle.cpp
+  bypass.cpp
 )
 
 ADD_LIBRARY(

=== added file 'src/server/compositor/bypass.cpp'
--- src/server/compositor/bypass.cpp	1970-01-01 00:00:00 +0000
+++ src/server/compositor/bypass.cpp	2013-08-29 01:27:06 +0000
@@ -0,0 +1,118 @@
+/*
+ * Copyright © 2013 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: Daniel van Vugt <[e-mail]>
+ */
+
+#include "mir/compositor/compositing_criteria.h"
+#include "mir/graphics/display_buffer.h"
+#include "bypass.h"
+
+using namespace mir;
+using namespace mir::compositor;
+
+BypassFilter::BypassFilter(const graphics::DisplayBuffer &display_buffer)
+        : display_buffer(display_buffer)
+{
+    const geometry::Rectangle &rect = display_buffer.view_area();
+    int width = rect.size.width.as_int();
+    int height = rect.size.height.as_int();
+
+    /*
+     * For a surface to exactly fit the display_buffer, its transformation
+     * will look exactly like this:
+     */
+    fullscreen[0][0] = width;
+    fullscreen[0][1] = 0.0f;
+    fullscreen[0][2] = 0.0f;
+    fullscreen[0][3] = 0.0f;
+
+    fullscreen[1][0] = 0.0f;
+    fullscreen[1][1] = height;
+    fullscreen[1][2] = 0.0f;
+    fullscreen[1][3] = 0.0f;
+
+    fullscreen[2][0] = 0.0f;
+    fullscreen[2][1] = 0.0f;
+    fullscreen[2][2] = 0.0f;
+    fullscreen[2][3] = 0.0f;
+
+    fullscreen[3][0] = rect.top_left.x.as_int() + width / 2;
+    fullscreen[3][1] = rect.top_left.y.as_int() + height / 2;
+    fullscreen[3][2] = 0.0f;
+    fullscreen[3][3] = 1.0f;
+}
+
+bool BypassFilter::operator()(const CompositingCriteria &criteria)
+{
+    if (criteria.alpha() != 1.0f)
+        return false;
+
+    if (!all_orthogonal)
+        return false;
+
+    const glm::mat4 &trans = criteria.transformation();
+    bool orthogonal =
+        trans[0][1] == 0.0f &&
+        trans[0][2] == 0.0f &&
+        trans[0][3] == 0.0f &&
+        trans[1][0] == 0.0f &&
+        trans[1][2] == 0.0f &&
+        trans[1][3] == 0.0f &&
+        trans[2][0] == 0.0f &&
+        trans[2][1] == 0.0f &&
+        trans[2][2] == 0.0f &&
+        trans[2][3] == 0.0f &&
+        trans[3][2] == 0.0f &&
+        trans[3][3] == 1.0f;
+
+    // Any weird transformations? Then we can't risk any bypass
+    if (!orthogonal)
+    {
+        all_orthogonal = false;
+        return false;
+    }
+
+    // This could be replaced by adding a "CompositingCriteria::rect()"
+    int width = trans[0][0];
+    int height = trans[1][1];
+    int x = trans[3][0] - width / 2;
+    int y = trans[3][1] - height / 2;
+    geometry::Rectangle window{{x, y}, {width, height}};
+
+    // Not weirdly transformed but also not on this monitor? Don't care...
+    if (!window.overlaps(display_buffer.view_area()))
+        return false;
+
+    // Transformed perfectly to fit the monitor? Bypass!
+    topmost_fits = criteria.transformation() == fullscreen;
+    return topmost_fits;
+}
+
+bool BypassFilter::fullscreen_on_top() const
+{
+    return all_orthogonal && topmost_fits;
+}
+
+void BypassMatch::operator()(const CompositingCriteria &,
+                             surfaces::BufferStream &stream)
+{
+    latest = &stream;
+}
+
+surfaces::BufferStream *BypassMatch::topmost_fullscreen() const
+{
+    return latest;
+}

=== added file 'src/server/compositor/bypass.h'
--- src/server/compositor/bypass.h	1970-01-01 00:00:00 +0000
+++ src/server/compositor/bypass.h	2013-08-29 01:27:06 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2013 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: Daniel van Vugt <[e-mail]>
+ */
+
+#ifndef MIR_COMPOSITOR_BYPASS_H_
+#define MIR_COMPOSITOR_BYPASS_H_
+
+#include "mir/compositor/scene.h"
+#include "glm/glm.hpp"
+
+namespace mir
+{
+namespace graphics
+{
+class DisplayBuffer;
+}
+namespace compositor
+{
+class CompositingCriteria;
+
+class BypassFilter : public FilterForScene
+{
+public:
+    BypassFilter(const graphics::DisplayBuffer &display_buffer);
+    bool operator()(const CompositingCriteria &criteria) override;
+    bool fullscreen_on_top() const;
+
+private:
+    bool all_orthogonal = true;
+    bool topmost_fits = false;
+    glm::mat4 fullscreen;
+    const graphics::DisplayBuffer &display_buffer;
+};
+
+class BypassMatch : public OperatorForScene
+{
+public:
+    void operator()(const CompositingCriteria &,
+                    surfaces::BufferStream &stream) override;
+    surfaces::BufferStream *topmost_fullscreen() const;
+
+private:
+    // This has to be a pointer. We have no control over BufferStream lifetime
+    surfaces::BufferStream *latest = nullptr;
+};
+
+} // namespace compositor
+} // namespace mir
+
+#endif // MIR_COMPOSITOR_BYPASS_H_

=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2013-07-31 02:22:28 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2013-08-29 01:27:06 +0000
@@ -22,6 +22,12 @@
 #include "mir/compositor/overlay_renderer.h"
 #include "mir/compositor/scene.h"
 #include "mir/compositor/compositing_criteria.h"
+#include "mir/graphics/display_buffer.h"
+#include "mir/graphics/buffer.h"
+#include "mir/surfaces/buffer_stream.h"
+#include "bypass.h"
+#include <mutex>
+#include <cstdlib>
 
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
@@ -57,6 +63,49 @@
 {
 }
 
+void mc::DefaultDisplayBufferCompositor::composite()
+{
+    static bool got_bypass_env = false;
+    static bool bypass_env = true;
+    bool bypassed = false;
+
+    if (!got_bypass_env)
+    {
+        const char *env = getenv("MIR_BYPASS");
+        if (env != NULL)
+            bypass_env = env[0] != '0';
+
+        got_bypass_env = true;
+    }
+
+    if (bypass_env && display_buffer.can_bypass())
+    {
+        std::unique_lock<Scene> lock(*scene);
+
+        mc::BypassFilter filter(display_buffer);
+        mc::BypassMatch match;
+
+        // It would be *really* nice if Scene had an iterator to simplify this
+        scene->for_each_if(filter, match);
+
+        if (filter.fullscreen_on_top())
+        {
+            auto bypass_buf =
+                match.topmost_fullscreen()->lock_compositor_buffer();
+
+            if (bypass_buf->can_bypass())
+            {
+                lock.unlock();
+                display_buffer.post_update(bypass_buf);
+                bypassed = true;
+            }
+        }
+    }
+
+    if (!bypassed)
+        mc::BasicDisplayBufferCompositor::composite();
+}
+
 void mc::DefaultDisplayBufferCompositor::compose(
     mir::geometry::Rectangle const& view_area,
     std::function<void(std::shared_ptr<void> const&)> save_resource)

=== modified file 'src/server/compositor/default_display_buffer_compositor.h'
--- src/server/compositor/default_display_buffer_compositor.h	2013-07-23 16:59:10 +0000
+++ src/server/compositor/default_display_buffer_compositor.h	2013-08-29 01:27:06 +0000
@@ -43,6 +43,8 @@
         std::shared_ptr<Renderer> const& renderer,
         std::shared_ptr<OverlayRenderer> const& overlay_renderer);
 
+    void composite() override;
+
     void compose(
         mir::geometry::Rectangle const& view_area,
         std::function<void(std::shared_ptr<void> const&)> save_resource);

=== modified file 'src/server/compositor/temporary_buffers.cpp'
--- src/server/compositor/temporary_buffers.cpp	2013-07-24 05:13:16 +0000
+++ src/server/compositor/temporary_buffers.cpp	2013-08-29 01:27:06 +0000
@@ -93,3 +93,8 @@
 {
     return buffer->native_buffer_handle();
 }
+
+bool mc::TemporaryBuffer::can_bypass() const
+{
+    return buffer->can_bypass();
+}

=== modified file 'src/server/compositor/temporary_buffers.h'
--- src/server/compositor/temporary_buffers.h	2013-07-22 10:28:12 +0000
+++ src/server/compositor/temporary_buffers.h	2013-08-29 01:27:06 +0000
@@ -41,6 +41,7 @@
     mg::BufferID id() const;
     void bind_to_texture();
     std::shared_ptr<MirNativeBuffer> native_buffer_handle() const;
+    bool can_bypass() const override;
 
 protected:
     explicit TemporaryBuffer(std::shared_ptr<mg::Buffer> const& real_buffer);

=== modified file 'src/server/graphics/android/buffer.cpp'
--- src/server/graphics/android/buffer.cpp	2013-07-24 05:22:03 +0000
+++ src/server/graphics/android/buffer.cpp	2013-08-29 01:27:06 +0000
@@ -94,6 +94,11 @@
 
     egl_extensions->glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
 }
+
+bool mga::Buffer::can_bypass() const
+{
+    return false;
+}
  
 std::shared_ptr<ANativeWindowBuffer> mga::Buffer::native_buffer_handle() const
 {

=== modified file 'src/server/graphics/android/buffer.h'
--- src/server/graphics/android/buffer.h	2013-07-24 05:22:03 +0000
+++ src/server/graphics/android/buffer.h	2013-08-29 01:27:06 +0000
@@ -49,6 +49,7 @@
     geometry::Stride stride() const;
     geometry::PixelFormat pixel_format() const;
     void bind_to_texture();
+    bool can_bypass() const override;
     std::shared_ptr<ANativeWindowBuffer> native_buffer_handle() const;
 
 private:

=== modified file 'src/server/graphics/android/gpu_hwc_android_display_buffer_factory.cpp'
--- src/server/graphics/android/gpu_hwc_android_display_buffer_factory.cpp	2013-07-15 12:28:23 +0000
+++ src/server/graphics/android/gpu_hwc_android_display_buffer_factory.cpp	2013-08-29 01:27:06 +0000
@@ -106,6 +106,11 @@
         }
     }
 
+    bool can_bypass() const override
+    {
+        return false;
+    }
+
 protected:
     std::shared_ptr<mga::AndroidFramebufferWindowQuery> const native_window;
     EGLDisplay const egl_display;

=== modified file 'src/server/graphics/gbm/gbm_buffer.cpp'
--- src/server/graphics/gbm/gbm_buffer.cpp	2013-08-08 17:23:29 +0000
+++ src/server/graphics/gbm/gbm_buffer.cpp	2013-08-29 01:27:06 +0000
@@ -75,8 +75,12 @@
 }
 
 mgg::GBMBuffer::GBMBuffer(std::shared_ptr<gbm_bo> const& handle,
+                          uint32_t bo_flags,
                           std::unique_ptr<BufferTextureBinder> texture_binder)
-    : gbm_handle{handle}, texture_binder{std::move(texture_binder)}, prime_fd{-1}
+    : gbm_handle{handle},
+      bo_flags{bo_flags},
+      texture_binder{std::move(texture_binder)},
+      prime_fd{-1}
 {
     auto device = gbm_bo_get_device(gbm_handle.get());
     auto gem_handle = gbm_bo_get_handle(gbm_handle.get()).u32;
@@ -121,10 +125,17 @@
 
 std::shared_ptr<MirNativeBuffer> mgg::GBMBuffer::native_buffer_handle() const
 {
-    auto temp = std::make_shared<MirNativeBuffer>();
+    auto temp = std::make_shared<GBMNativeBuffer>();
 
     temp->fd_items = 1;
     temp->fd[0] = prime_fd;
     temp->stride = stride().as_uint32_t();
+    temp->bo = gbm_handle.get();
+
     return temp;
 }
+
+bool mgg::GBMBuffer::can_bypass() const
+{
+    return bo_flags & GBM_BO_USE_SCANOUT;
+}

=== modified file 'src/server/graphics/gbm/gbm_buffer.h'
--- src/server/graphics/gbm/gbm_buffer.h	2013-08-08 17:23:29 +0000
+++ src/server/graphics/gbm/gbm_buffer.h	2013-08-29 01:27:06 +0000
@@ -34,6 +34,11 @@
 namespace gbm
 {
 
+struct GBMNativeBuffer : MirNativeBuffer
+{
+    struct gbm_bo *bo;
+};
+
 geometry::PixelFormat gbm_format_to_mir_format(uint32_t format);
 uint32_t mir_format_to_gbm_format(geometry::PixelFormat format);
 enum : uint32_t { invalid_gbm_format = std::numeric_limits<uint32_t>::max() };
@@ -44,6 +49,7 @@
 {
 public:
     GBMBuffer(std::shared_ptr<gbm_bo> const& handle,
+              uint32_t bo_flags,
               std::unique_ptr<BufferTextureBinder> texture_binder);
     GBMBuffer(const GBMBuffer&) = delete;
     ~GBMBuffer();
@@ -60,8 +66,11 @@
 
     virtual void bind_to_texture();
 
+    bool can_bypass() const override;
+
 private:
     std::shared_ptr<gbm_bo> const gbm_handle;
+    uint32_t bo_flags;
     std::unique_ptr<BufferTextureBinder> const texture_binder;
     int prime_fd;
 };

=== modified file 'src/server/graphics/gbm/gbm_buffer_allocator.cpp'
--- src/server/graphics/gbm/gbm_buffer_allocator.cpp	2013-08-26 07:35:33 +0000
+++ src/server/graphics/gbm/gbm_buffer_allocator.cpp	2013-08-29 01:27:06 +0000
@@ -133,6 +133,25 @@
     if (buffer_properties.usage == BufferUsage::software)
         bo_flags |= GBM_BO_USE_WRITE;
 
+    /*
+     * Bypass is generally only beneficial to hardware buffers where the
+     * blitting happens on the GPU. For software buffers it is slower to blit
+     * individual pixels from CPU to GPU memory, so don't do it.
+     * Also try to avoid allocating scanout buffers for small surfaces that
+     * are unlikely to ever be fullscreen.
+     *
+     * TODO: Be more intelligent about when to apply GBM_BO_USE_SCANOUT. That
+     *       may have to come after buffer reallocation support (surface
+     *       resizing). We may also want to check for
+     *       mir_surface_state_fullscreen later when it's fully wired up.
+     */
+    if (buffer_properties.usage == BufferUsage::hardware &&
+        buffer_properties.size.width.as_uint32_t() >= 800 &&
+        buffer_properties.size.height.as_uint32_t() >= 600)
+    {
+        bo_flags |= GBM_BO_USE_SCANOUT;
+    }
+
     gbm_bo *bo_raw = gbm_bo_create(
         device,
         buffer_properties.size.width.as_uint32_t(),
@@ -149,7 +168,7 @@
         new EGLImageBufferTextureBinder{bo, egl_extensions}};
 
     /* Create the GBMBuffer */
-    std::shared_ptr<mg::Buffer> buffer{new GBMBuffer{bo, std::move(texture_binder)}};
+    std::shared_ptr<mg::Buffer> buffer{new GBMBuffer{bo, bo_flags, std::move(texture_binder)}};
 
     (*buffer_initializer)(*buffer);
 

=== modified file 'src/server/graphics/gbm/gbm_display_buffer.cpp'
--- src/server/graphics/gbm/gbm_display_buffer.cpp	2013-07-31 02:22:28 +0000
+++ src/server/graphics/gbm/gbm_display_buffer.cpp	2013-08-29 01:27:06 +0000
@@ -20,6 +20,7 @@
 #include "gbm_platform.h"
 #include "kms_output.h"
 #include "mir/graphics/display_report.h"
+#include "gbm_buffer.h"
 
 #include <boost/throw_exception.hpp>
 #include <GLES2/gl2.h>
@@ -161,16 +162,38 @@
     return area;
 }
 
+bool mgg::GBMDisplayBuffer::can_bypass() const
+{
+    return true;
+}
+
 void mgg::GBMDisplayBuffer::post_update()
 {
+    post_update(nullptr);
+}
+
+void mgg::GBMDisplayBuffer::post_update(
+    std::shared_ptr<graphics::Buffer> bypass_buf)
+{
     /*
      * Bring the back buffer to the front and get the buffer object
      * corresponding to the front buffer.
      */
-    if (!egl.swap_buffers())
+    if (!bypass_buf && !egl.swap_buffers())
         BOOST_THROW_EXCEPTION(std::runtime_error("Failed to perform initial surface buffer swap"));
 
-    auto bufobj = get_front_buffer_object();
+    mgg::BufferObject *bufobj;
+    if (bypass_buf)
+    {
+        auto native = bypass_buf->native_buffer_handle();
+        auto gbm_native = static_cast<mgg::GBMNativeBuffer*>(native.get());
+        bufobj = get_buffer_object(gbm_native->bo);
+    }
+    else
+    {
+        bufobj = get_front_buffer_object();
+    }
+
     if (!bufobj)
         BOOST_THROW_EXCEPTION(std::runtime_error("Failed to get front buffer object"));
 
@@ -183,7 +206,8 @@
      */
     if (!needs_set_crtc && !schedule_and_wait_for_page_flip(bufobj))
     {
-        bufobj->release();
+        if (!bypass_buf)
+            bufobj->release();
         BOOST_THROW_EXCEPTION(std::runtime_error("Failed to schedule page flip"));
     }
     else if (needs_set_crtc)
@@ -203,12 +227,31 @@
     if (last_flipped_bufobj)
         last_flipped_bufobj->release();
 
-    last_flipped_bufobj = bufobj;
+    last_flipped_bufobj = bypass_buf ? nullptr : bufobj;
+
+    /*
+     * Keep a reference to the buffer being bypassed for the entire duration
+     * of the frame. This ensures the buffer doesn't get reused by the client
+     * prematurely, which would be seen as tearing.
+     * If not bypassing, then bypass_buf will be nullptr.
+     */
+    last_flipped_bypass_buf = bypass_buf;
 }
 
 mgg::BufferObject* mgg::GBMDisplayBuffer::get_front_buffer_object()
 {
-    auto bo = gbm_surface_lock_front_buffer(surface_gbm.get());
+    auto front = gbm_surface_lock_front_buffer(surface_gbm.get());
+    auto ret = get_buffer_object(front);
+
+    if (!ret)
+        gbm_surface_release_buffer(surface_gbm.get(), front);
+
+    return ret;
+}
+
+mgg::BufferObject* mgg::GBMDisplayBuffer::get_buffer_object(
+    struct gbm_bo *bo)
+{
     if (!bo)
         return nullptr;
 
@@ -228,10 +271,7 @@
     auto ret = drmModeAddFB(drm.fd, area.size.width.as_uint32_t(), area.size.height.as_uint32_t(),
                             24, 32, stride, handle, &fb_id);
     if (ret)
-    {
-        gbm_surface_release_buffer(surface_gbm.get(), bo);
         return nullptr;
-    }
 
     /* Create a BufferObject and associate it with the gbm_bo */
     bufobj = new BufferObject{surface_gbm.get(), bo, fb_id};

=== modified file 'src/server/graphics/gbm/gbm_display_buffer.h'
--- src/server/graphics/gbm/gbm_display_buffer.h	2013-07-31 02:22:28 +0000
+++ src/server/graphics/gbm/gbm_display_buffer.h	2013-08-29 01:27:06 +0000
@@ -56,13 +56,18 @@
     void release_current();
     void post_update();
 
+    bool can_bypass() const override;
+    void post_update(std::shared_ptr<graphics::Buffer> bypass_buf) override;
+
     void schedule_set_crtc();
 
 private:
     BufferObject* get_front_buffer_object();
+    BufferObject* get_buffer_object(struct gbm_bo *bo);
     bool schedule_and_wait_for_page_flip(BufferObject* bufobj);
 
     BufferObject* last_flipped_bufobj;
+    std::shared_ptr<graphics::Buffer> last_flipped_bypass_buf;
     std::shared_ptr<GBMPlatform> const platform;
     std::shared_ptr<DisplayReport> const listener;
     /* DRM helper from GBMPlatform */

=== modified file 'tests/unit-tests/compositor/CMakeLists.txt'
--- tests/unit-tests/compositor/CMakeLists.txt	2013-08-02 03:01:12 +0000
+++ tests/unit-tests/compositor/CMakeLists.txt	2013-08-29 01:27:06 +0000
@@ -6,6 +6,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_multi_threaded_compositor.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_switching_bundle.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_gl_renderer.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_bypass.cpp
 )
 
 set(UNIT_TEST_SOURCES ${UNIT_TEST_SOURCES} PARENT_SCOPE)

=== added file 'tests/unit-tests/compositor/test_bypass.cpp'
--- tests/unit-tests/compositor/test_bypass.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/compositor/test_bypass.cpp	2013-08-29 01:27:06 +0000
@@ -0,0 +1,258 @@
+/*
+ * Copyright © 2013 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: Daniel van Vugt <[e-mail]>
+ */
+
+#include "mir/compositor/compositing_criteria.h"
+#include "src/server/compositor/bypass.h"
+#include "mir_test_doubles/mock_display_buffer.h"
+#include "mir_test_doubles/stub_buffer_stream.h"
+#include "mir_test_doubles/stub_compositing_criteria.h"
+
+#include <gtest/gtest.h>
+#include <memory>
+
+using namespace testing;
+using namespace mir::geometry;
+using namespace mir::compositor;
+using namespace mir::test::doubles;
+
+struct BypassFilterTest : public Test
+{
+    BypassFilterTest()
+    {
+        monitor_rect[0].top_left = {0, 0};
+        monitor_rect[0].size = {1920, 1200};
+        EXPECT_CALL(display_buffer[0], view_area())
+            .WillRepeatedly(Return(monitor_rect[0]));
+
+        monitor_rect[1].top_left = {1920, 0};
+        monitor_rect[1].size = {1920, 1200};
+        EXPECT_CALL(display_buffer[1], view_area())
+            .WillRepeatedly(Return(monitor_rect[1]));
+    }
+
+    Rectangle monitor_rect[2];
+    MockDisplayBuffer display_buffer[2];
+};
+
+TEST_F(BypassFilterTest, nothing_matches_nothing)
+{
+    BypassFilter filter(display_buffer[0]);
+    BypassMatch match;
+
+    EXPECT_FALSE(filter.fullscreen_on_top());
+    EXPECT_FALSE(match.topmost_fullscreen());
+}
+
+TEST_F(BypassFilterTest, small_window_not_bypassed)
+{
+    BypassFilter filter(display_buffer[0]);
+
+    StubCompositingCriteria win(12, 34, 56, 78);
+
+    EXPECT_FALSE(filter(win));
+    EXPECT_FALSE(filter.fullscreen_on_top());
+}
+
+TEST_F(BypassFilterTest, single_fullscreen_window_bypassed)
+{
+    BypassFilter filter(display_buffer[0]);
+
+    StubCompositingCriteria win(0, 0, 1920, 1200);
+
+    EXPECT_TRUE(filter(win));
+    EXPECT_TRUE(filter.fullscreen_on_top());
+}
+
+TEST_F(BypassFilterTest, translucent_fullscreen_window_not_bypassed)
+{
+    BypassFilter filter(display_buffer[0]);
+
+    StubCompositingCriteria win(0, 0, 1920, 1200, 0.5f);
+
+    EXPECT_FALSE(filter(win));
+    EXPECT_FALSE(filter.fullscreen_on_top());
+}
+
+TEST_F(BypassFilterTest, offset_fullscreen_window_not_bypassed)
+{
+    BypassFilter filter(display_buffer[0]);
+
+    StubCompositingCriteria win(10, 50, 1920, 1200);
+
+    EXPECT_FALSE(filter(win));
+    EXPECT_FALSE(filter.fullscreen_on_top());
+}
+
+TEST_F(BypassFilterTest, obscured_fullscreen_window_not_bypassed)
+{
+    BypassFilter filter(display_buffer[0]);
+
+    StubCompositingCriteria fs(0, 0, 1920, 1200);
+    StubCompositingCriteria small(20, 30, 40, 50);
+
+    EXPECT_TRUE(filter(fs));
+    EXPECT_FALSE(filter(small));
+    EXPECT_FALSE(filter.fullscreen_on_top());
+}
+
+TEST_F(BypassFilterTest, unobscured_fullscreen_window_bypassed)
+{
+    BypassFilter filter(display_buffer[0]);
+
+    StubCompositingCriteria fs(0, 0, 1920, 1200);
+    StubCompositingCriteria small(20, 30, 40, 50);
+
+    EXPECT_FALSE(filter(small));
+    EXPECT_TRUE(filter(fs));
+    EXPECT_TRUE(filter.fullscreen_on_top());
+}
+
+TEST_F(BypassFilterTest, unobscured_fullscreen_alpha_window_not_bypassed)
+{
+    BypassFilter filter(display_buffer[0]);
+
+    StubCompositingCriteria fs(0, 0, 1920, 1200, 0.9f);
+    StubCompositingCriteria small(20, 30, 40, 50);
+
+    EXPECT_FALSE(filter(small));
+    EXPECT_FALSE(filter(fs));
+    EXPECT_FALSE(filter.fullscreen_on_top());
+}
+
+TEST_F(BypassFilterTest, many_fullscreen_windows_only_bypass_top)
+{
+    BypassFilter filter(display_buffer[0]);
+
+    StubCompositingCriteria a(0, 0, 1920, 1200);
+    EXPECT_TRUE(filter(a));
+    EXPECT_TRUE(filter.fullscreen_on_top());
+
+    StubCompositingCriteria b(1, 2, 3, 4);
+    EXPECT_FALSE(filter(b));
+    EXPECT_FALSE(filter.fullscreen_on_top());
+
+    StubCompositingCriteria c(0, 0, 1920, 1200);
+    EXPECT_TRUE(filter(c));
+    EXPECT_TRUE(filter.fullscreen_on_top());
+
+    StubCompositingCriteria d(5, 6, 7, 8);
+    EXPECT_FALSE(filter(d));
+    EXPECT_FALSE(filter.fullscreen_on_top());
+
+    StubCompositingCriteria e(0, 0, 1920, 1200);
+    EXPECT_TRUE(filter(e));
+    EXPECT_TRUE(filter.fullscreen_on_top());
+
+    StubCompositingCriteria f(9, 10, 11, 12);
+    EXPECT_FALSE(filter(f));
+    EXPECT_FALSE(filter.fullscreen_on_top());
+
+    StubCompositingCriteria g(0, 0, 1920, 1200);
+    EXPECT_TRUE(filter(g));
+    EXPECT_TRUE(filter.fullscreen_on_top());
+}
+
+TEST_F(BypassFilterTest, multimonitor_one_bypassed)
+{
+    BypassFilter left(display_buffer[0]);
+    BypassFilter right(display_buffer[1]);
+
+    StubCompositingCriteria fs(1920, 0, 1920, 1200);
+    StubCompositingCriteria small(20, 30, 40, 50);
+
+    EXPECT_FALSE(left(small));
+    EXPECT_FALSE(left.fullscreen_on_top());
+    EXPECT_FALSE(left(fs));
+    EXPECT_FALSE(left.fullscreen_on_top());
+
+    EXPECT_FALSE(right(small));
+    EXPECT_FALSE(right.fullscreen_on_top());
+    EXPECT_TRUE(right(fs));
+    EXPECT_TRUE(right.fullscreen_on_top());
+    EXPECT_FALSE(right(small));
+    EXPECT_TRUE(right.fullscreen_on_top());
+}
+
+TEST_F(BypassFilterTest, dual_bypass)
+{
+    BypassFilter left_filter(display_buffer[0]);
+    BypassFilter right_filter(display_buffer[1]);
+
+    StubCompositingCriteria left_win(0, 0, 1920, 1200);
+    StubCompositingCriteria right_win(1920, 0, 1920, 1200);
+
+    EXPECT_TRUE(left_filter(left_win));
+    EXPECT_TRUE(left_filter.fullscreen_on_top());
+    EXPECT_FALSE(left_filter(right_win));
+    EXPECT_TRUE(left_filter.fullscreen_on_top());
+
+    EXPECT_FALSE(right_filter(left_win));
+    EXPECT_FALSE(right_filter.fullscreen_on_top());
+    EXPECT_TRUE(right_filter(right_win));
+    EXPECT_TRUE(right_filter.fullscreen_on_top());
+}
+
+TEST_F(BypassFilterTest, multimonitor_oversized_no_bypass)
+{
+    BypassFilter left_filter(display_buffer[0]);
+    BypassFilter right_filter(display_buffer[1]);
+
+    StubCompositingCriteria big_win(0, 0, 3840, 1200);
+
+    EXPECT_FALSE(left_filter(big_win));
+    EXPECT_FALSE(left_filter.fullscreen_on_top());
+
+    EXPECT_FALSE(right_filter(big_win));
+    EXPECT_FALSE(right_filter.fullscreen_on_top());
+}
+
+TEST(BypassMatchTest, defaults_to_null)
+{
+    BypassMatch match;
+
+    EXPECT_EQ(nullptr, match.topmost_fullscreen());
+}
+
+TEST(BypassMatchTest, returns_one)
+{
+    BypassMatch match;
+    StubCompositingCriteria win(1, 2, 3, 4);
+    StubBufferStream bufs;
+
+    EXPECT_EQ(nullptr, match.topmost_fullscreen());
+    match(win, bufs);
+    EXPECT_EQ(&bufs, match.topmost_fullscreen());
+}
+
+TEST(BypassMatchTest, returns_latest)
+{
+    BypassMatch match;
+    StubCompositingCriteria a(1, 2, 3, 4), b(5, 6, 7, 8), c(9, 10, 11, 12);
+    StubBufferStream abuf, bbuf, cbuf;
+
+    EXPECT_EQ(nullptr, match.topmost_fullscreen());
+    match(a, abuf);
+    EXPECT_EQ(&abuf, match.topmost_fullscreen());
+    match(b, bbuf);
+    EXPECT_EQ(&bbuf, match.topmost_fullscreen());
+    match(c, cbuf);
+    EXPECT_EQ(&cbuf, match.topmost_fullscreen());
+    EXPECT_EQ(&cbuf, match.topmost_fullscreen());
+    EXPECT_EQ(&cbuf, match.topmost_fullscreen());
+}
+

=== modified file 'tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp'
--- tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2013-08-23 10:39:40 +0000
+++ tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2013-08-29 01:27:06 +0000
@@ -29,7 +29,9 @@
 #include "mir_test_doubles/mock_display_buffer.h"
 #include "mir_test_doubles/mock_buffer_stream.h"
 #include "mir_test_doubles/mock_compositing_criteria.h"
+#include "mir_test_doubles/stub_compositing_criteria.h"
 #include "mir_test_doubles/null_display_buffer.h"
+#include "mir_test_doubles/mock_buffer.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -76,6 +78,11 @@
 
     void set_change_callback(std::function<void()> const&) {}
 
+    void change(const std::vector<mc::CompositingCriteria*> &surfs)
+    {
+        surfaces = surfs;
+    }
+
     void lock() {}
     void unlock() {}
 
@@ -210,3 +217,287 @@
 
     comp->composite();
 }
+
+TEST(DefaultDisplayBufferCompositor, bypass_skips_composition)
+{
+    using namespace testing;
+
+    StubRendererFactory renderer_factory;
+    NiceMock<MockOverlayRenderer> overlay_renderer;
+
+    geom::Rectangle screen{{0, 0}, {1366, 768}};
+
+    mtd::MockDisplayBuffer display_buffer;
+    EXPECT_CALL(display_buffer, view_area())
+        .WillRepeatedly(Return(screen));
+    EXPECT_CALL(display_buffer, make_current())
+        .Times(0);
+    EXPECT_CALL(display_buffer, post_update())
+        .Times(0);
+    EXPECT_CALL(display_buffer, can_bypass())
+        .WillRepeatedly(Return(true));
+
+    mtd::StubCompositingCriteria small(10, 20, 30, 40);
+    mtd::StubCompositingCriteria fullscreen(0, 0, 1366, 768);
+
+    std::vector<mc::CompositingCriteria*> renderable_vec;
+    renderable_vec.push_back(&small);
+    renderable_vec.push_back(&fullscreen);
+
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
+        .Times(0);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
+        .Times(0);
+
+    FakeScene scene(renderable_vec);
+
+    auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
+    EXPECT_CALL(*compositor_buffer, can_bypass())
+        .WillOnce(Return(true));
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+        .WillOnce(Return(compositor_buffer));
+
+    mc::DefaultDisplayBufferCompositorFactory factory(
+        mt::fake_shared(scene),
+        mt::fake_shared(renderer_factory),
+        mt::fake_shared(overlay_renderer));
+
+    auto comp = factory.create_compositor_for(display_buffer);
+
+    comp->composite();
+}
+
+TEST(DefaultDisplayBufferCompositor, obscured_fullscreen_does_not_bypass)
+{
+    using namespace testing;
+
+    StubRendererFactory renderer_factory;
+    NiceMock<MockOverlayRenderer> overlay_renderer;
+
+    geom::Rectangle screen{{0, 0}, {1366, 768}};
+
+    mtd::MockDisplayBuffer display_buffer;
+    EXPECT_CALL(display_buffer, view_area())
+        .WillRepeatedly(Return(screen));
+    EXPECT_CALL(display_buffer, make_current())
+        .Times(1);
+    EXPECT_CALL(display_buffer, post_update())
+        .Times(1);
+    EXPECT_CALL(display_buffer, can_bypass())
+        .WillRepeatedly(Return(true));
+
+    mtd::StubCompositingCriteria fullscreen(0, 0, 1366, 768);
+    mtd::StubCompositingCriteria small(10, 20, 30, 40);
+
+    std::vector<mc::CompositingCriteria*> renderable_vec;
+    renderable_vec.push_back(&fullscreen);
+    renderable_vec.push_back(&small);
+
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
+        .Times(1);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
+        .Times(1);
+
+    FakeScene scene(renderable_vec);
+
+    auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
+    EXPECT_CALL(*compositor_buffer, can_bypass())
+        .Times(0);
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+        .Times(0);
+
+    mc::DefaultDisplayBufferCompositorFactory factory(
+        mt::fake_shared(scene),
+        mt::fake_shared(renderer_factory),
+        mt::fake_shared(overlay_renderer));
+
+    auto comp = factory.create_compositor_for(display_buffer);
+
+    comp->composite();
+}
+
+TEST(DefaultDisplayBufferCompositor, platform_does_not_support_bypass)
+{
+    using namespace testing;
+
+    StubRendererFactory renderer_factory;
+    NiceMock<MockOverlayRenderer> overlay_renderer;
+
+    geom::Rectangle screen{{0, 0}, {1366, 768}};
+
+    mtd::MockDisplayBuffer display_buffer;
+    EXPECT_CALL(display_buffer, view_area())
+        .WillRepeatedly(Return(screen));
+    EXPECT_CALL(display_buffer, make_current())
+        .Times(1);
+    EXPECT_CALL(display_buffer, post_update())
+        .Times(1);
+    EXPECT_CALL(display_buffer, can_bypass())
+        .WillRepeatedly(Return(false));
+
+    mtd::StubCompositingCriteria small(10, 20, 30, 40);
+    mtd::StubCompositingCriteria fullscreen(0, 0, 1366, 768);
+
+    std::vector<mc::CompositingCriteria*> renderable_vec;
+    renderable_vec.push_back(&small);
+    renderable_vec.push_back(&fullscreen);
+
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
+        .Times(1);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
+        .Times(1);
+
+    FakeScene scene(renderable_vec);
+
+    auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
+    EXPECT_CALL(*compositor_buffer, can_bypass())
+        .Times(0);
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+        .Times(0);
+
+    mc::DefaultDisplayBufferCompositorFactory factory(
+        mt::fake_shared(scene),
+        mt::fake_shared(renderer_factory),
+        mt::fake_shared(overlay_renderer));
+
+    auto comp = factory.create_compositor_for(display_buffer);
+
+    comp->composite();
+}
+
+TEST(DefaultDisplayBufferCompositor, bypass_aborted_for_incompatible_buffers)
+{
+    using namespace testing;
+
+    StubRendererFactory renderer_factory;
+    NiceMock<MockOverlayRenderer> overlay_renderer;
+
+    geom::Rectangle screen{{0, 0}, {1366, 768}};
+
+    mtd::MockDisplayBuffer display_buffer;
+    EXPECT_CALL(display_buffer, view_area())
+        .WillRepeatedly(Return(screen));
+    EXPECT_CALL(display_buffer, make_current())
+        .Times(1);
+    EXPECT_CALL(display_buffer, post_update())
+        .Times(1);
+    EXPECT_CALL(display_buffer, can_bypass())
+        .WillRepeatedly(Return(true));
+
+    mtd::StubCompositingCriteria small(10, 20, 30, 40);
+    mtd::StubCompositingCriteria fullscreen(0, 0, 1366, 768);
+
+    std::vector<mc::CompositingCriteria*> renderable_vec;
+    renderable_vec.push_back(&small);
+    renderable_vec.push_back(&fullscreen);
+
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
+        .Times(1);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
+        .Times(1);
+
+    FakeScene scene(renderable_vec);
+
+    auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+        .WillOnce(Return(compositor_buffer));
+    EXPECT_CALL(*compositor_buffer, can_bypass())
+        .WillRepeatedly(Return(false));
+
+    mc::DefaultDisplayBufferCompositorFactory factory(
+        mt::fake_shared(scene),
+        mt::fake_shared(renderer_factory),
+        mt::fake_shared(overlay_renderer));
+
+    auto comp = factory.create_compositor_for(display_buffer);
+
+    comp->composite();
+}
+
+TEST(DefaultDisplayBufferCompositor, bypass_toggles_seamlessly)
+{
+    using namespace testing;
+
+    StubRendererFactory renderer_factory;
+    NiceMock<MockOverlayRenderer> overlay_renderer;
+
+    geom::Rectangle screen{{0, 0}, {1366, 768}};
+
+    mtd::MockDisplayBuffer display_buffer;
+    EXPECT_CALL(display_buffer, view_area())
+        .WillRepeatedly(Return(screen));
+    EXPECT_CALL(display_buffer, make_current())
+        .Times(1);
+    EXPECT_CALL(display_buffer, post_update())
+        .Times(1);
+    EXPECT_CALL(display_buffer, can_bypass())
+        .WillRepeatedly(Return(true));
+
+    mtd::StubCompositingCriteria fullscreen(0, 0, 1366, 768);
+    mtd::StubCompositingCriteria small(10, 20, 30, 40);
+
+    std::vector<mc::CompositingCriteria*> renderable_vec;
+    renderable_vec.push_back(&fullscreen);
+    renderable_vec.push_back(&small);
+
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
+        .Times(1);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
+        .Times(1);
+
+    FakeScene scene(renderable_vec);
+
+    auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
+    EXPECT_CALL(*compositor_buffer, can_bypass())
+        .Times(0);
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+        .Times(0);
+
+    mc::DefaultDisplayBufferCompositorFactory factory(
+        mt::fake_shared(scene),
+        mt::fake_shared(renderer_factory),
+        mt::fake_shared(overlay_renderer));
+
+    auto comp = factory.create_compositor_for(display_buffer);
+
+    // Frame 1: small window over fullscreen = no bypass
+    comp->composite();
+
+    // Frame 2: fullscreen over small window = bypass
+    renderable_vec.resize(0);
+    renderable_vec.push_back(&small);
+    renderable_vec.push_back(&fullscreen);
+    scene.change(renderable_vec);
+    EXPECT_CALL(display_buffer, make_current())
+        .Times(0);
+    EXPECT_CALL(display_buffer, post_update())
+        .Times(0);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
+        .Times(0);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
+        .Times(0);
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+        .WillOnce(Return(compositor_buffer));
+    EXPECT_CALL(*compositor_buffer, can_bypass())
+        .WillOnce(Return(true));
+    comp->composite();
+
+    // Frame 3: only a small window = no bypass
+    renderable_vec.resize(0);
+    renderable_vec.push_back(&small);
+    scene.change(renderable_vec);
+    EXPECT_CALL(display_buffer, make_current())
+        .Times(1);
+    EXPECT_CALL(display_buffer, post_update())
+        .Times(1);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
+        .Times(1);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
+        .Times(0);
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+        .Times(0);
+    EXPECT_CALL(*compositor_buffer, can_bypass())
+        .Times(0);
+    comp->composite();
+}
+