Merge lp:~kdub/mir/post-if-optimizable into lp:mir

[Kevin DuBois]

graphics: change the DisplayBuffer::render_and_post_update() so that it can reject the list submitted to it (more like can_bypass). Have android scan over the list and reject lists that are not supportable by HWC

graphics: change the DisplayBuffer::render_and_post_update() so that it can reject the list submitted to it (more like can_bypass). Have android scan over the list and reject lists that are not supportable by HWC.

When I reintroduced Renderable, it was an interface that android could guarantee that it would render via HWC. It has morphed a bit since then, and will continue to morph as we go to support more GL shell stuff. Now the list has to be scanned so the platform can figure out if the image the RenderableList represents is applicable to the platform's capabilities.

Alberto asked on IRC what if the compositor writer wants to do something that can't be represented with a RenderableList, like spread or a window animation. The answer to this question is that the compositor writer knows that something complex is going on so they should just stick to post_update() for those complex frames and then try the optimization function again when the scene becomes simpler.

The compositor writer doesn't have to think about what's going on under the hood or what platform they are on, they just have to think about "can what I want on the screen be represented by a RenderableList". If it can, then they're doing something simple enough that we might know a way to optimize, and if it cannot be represented by a RenderableList, they have the OpenGL available to do whatever they want.

note1:
If you're interested in what this means for the DefaultDisplayBufferCompositor or mesa, take a look here:
http://bazaar.launchpad.net/~kdub/mir/future-default-display-buffer-compositor/view/head:/src/server/compositor/default_display_buffer_compositor.cpp#L64
http://bazaar.launchpad.net/~kdub/mir/future-default-display-buffer-compositor/view/head:/src/platform/graphics/mesa/display_buffer.cpp#L195

There's still that same optimized/not optimized code path in DefaultDisplayBufferCompositor, which is nice.

note2:
For the android platform, something like this could happen:
1) Scan list, list passes hwc check
2) hwc prepare() rejects some of the renderables
3) mir has to draw OpenGL via the fallback path
4) hwc set() will post the accepted renderables as overlays, along with the fallback, OpenGL renderables

note3:
For the mesa platform, I hope it improves so mesa scans the list, and figures if it can do 'hardware cursor + bypass' or "only bypass" or "only hardware cursor"

[Kevin DuBois (kdub)]

Also, this breaks API because of the change to DisplayBuffer (although that API is not really used in the wild yet). W.R.T the new versioning policies, maybe I should put that in the commit msg? the changelog?

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1596
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1484/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/9/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1484/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1597
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1486/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/5
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/6
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/6
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/3/console
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/3/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/3
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/3/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/11
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/11/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/1279
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/6676

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1486/rebuild

review: Needs Fixing (continuous-integration)

[Alexandros Frantzis (afrantzis)]

What if some of the renderables in the list can be rendered with optimization and others cannot? AFAICT from the description post_renderables_if_optimizable() is all or nothing (although it doesn't need to be), so we would miss the opportunity to render some of the renderables more efficiently.

review: Needs Information

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1597
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1500/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/20
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/21
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/21
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/17/console
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/17/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/17
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/17/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/27
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/27/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/1293
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/6699

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1500/rebuild

review: Needs Fixing (continuous-integration)

[Kevin DuBois (kdub)]

"hudson.util.IOException2: remote file operation failed", hopefully a retry will work

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1597
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1504/
Executed test runs:
    None: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/26/console
    None: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/27/console
    None: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/27/console
    None: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/21/console
    None: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/33/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1504/rebuild

review: Needs Fixing (continuous-integration)

[Kevin DuBois (kdub)]

> What if some of the renderables in the list can be rendered with optimization
> and others cannot? AFAICT from the description
> post_renderables_if_optimizable() is all or nothing (although it doesn't need
> to be), so we would miss the opportunity to render some of the renderables
> more efficiently.

So, we touched on this in this in the standup, but we were worried about the Nested communication of this list when we go to enable Nested optimizations (we don't want to have the render negotiated with IPC). If the DisplayBuffer wants to optimize any one of the renderables, will have to handle the list, which works for mesa or android.

[Chris Halse Rogers (raof)]

I thought that we were migrating the basic GL composition pass down into DisplayBuffer? So that if your scene is expressible exclusively in terms of a RenderableList then you can just dump it into render_and_post_update() and the DisplayBuffer will either GL or overlay?

This would satisfy the ‘needs no negotiation’ criterion, and would seem to make the higher levels a little bit less complex?

review: Needs Information

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1599
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1595/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/151
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/152
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/152
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/114
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/114/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/112
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/112/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/355
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/355/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/1411
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/7070

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1595/rebuild

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

> I thought that we were migrating the basic GL composition pass down into
> DisplayBuffer? So that if your scene is expressible exclusively in terms of a
> RenderableList then you can just dump it into render_and_post_update() and the
> DisplayBuffer will either GL or overlay?
>
> This would satisfy the ‘needs no negotiation’ criterion, and would seem to
> make the higher levels a little bit less complex?

So there's been a subtle shift since Renderable was reintroduced as it merged closer to the surface classes. Android can now know beforehand that it can reject the list (eg, if something is transformed to non-90degree).
The option to reject works nicely with mesa too, as mesa now does not have the burden of drawing with OpenGL, it can just reject, and the platform-independent GL compositor takes over.

So basically, the lp:~kdub/mir/overlay-gl-program branch just handles the quirky requirement that android has to draw the fallback with OpenGL. We do not require all the platforms to draw (just to reject), which is a bit nicer for the non-android DisplayBuffer implementations too.

[Chris Halse Rogers (raof)]

Ah. Let me see if I've got how the nested case will work:

The inner-Mir will always accept whatever renderable list you care to pass to post_renderables_if_optimizable() and send them down to the outer-Mir. The outer-Mir will then post_renderables_if_optimizable() and either go “yay!” or do a GL composition pass.

And we optimise further the implementation of post_renderables_if_optimizable() running on the hardware will only bail if none of the renderables are optimisable.

So this makes it easier to bring up platforms in the short term, and will probably be a no-op in the long term?

[Kevin DuBois (kdub)]

> Ah. Let me see if I've got how the nested case will work:
>
> The inner-Mir will always accept whatever renderable list you care to pass to
> post_renderables_if_optimizable() and send them down to the outer-Mir. The
> outer-Mir will then post_renderables_if_optimizable() and either go “yay!” or
> do a GL composition pass.
>
> And we optimise further the implementation of
> post_renderables_if_optimizable() running on the hardware will only bail if
> none of the renderables are optimisable.
>

Sounds right to me.

> So this makes it easier to bring up platforms in the short term, and will
> probably be a no-op in the long term?

I'm confused as what will 'be a no-op in the long term'. post_renderables_if_optimizable() will be the hardware optimized interface that compositors should try if they know they're doing something simple, and post_update() will be the interface that the compositors use to do anything they want with GL

[Chris Halse Rogers (raof)]

On Wed, May 14, 2014 at 3:54 AM, Kevin DuBois
<email address hidden> wrote:
>> So this makes it easier to bring up platforms in the short term,
>> and will
>> probably be a no-op in the long term?
>
> I'm confused as what will 'be a no-op in the long term'.
> post_renderables_if_optimizable() will be the hardware optimized
> interface that compositors should try if they know they're doing
> something simple, and post_update() will be the interface that the
> compositors use to do anything they want with GL

What I mean is - as a platform (and, conceivably, Renderable) grows in
sophistication, there will be fewer and fewer RenderableLists that
contain only unoptimisable Renderables. So what I mean by “no-op”
is that post_renderables_if_optimizable() will end up always returning
true.

Particularly since the cursor is one of those Renderables.

[Kevin DuBois (kdub)]

>
>
> On Wed, May 14, 2014 at 3:54 AM, Kevin DuBois
> <email address hidden> wrote:
> >> So this makes it easier to bring up platforms in the short term,
> >> and will
> >> probably be a no-op in the long term?
> >
> > I'm confused as what will 'be a no-op in the long term'.
> > post_renderables_if_optimizable() will be the hardware optimized
> > interface that compositors should try if they know they're doing
> > something simple, and post_update() will be the interface that the
> > compositors use to do anything they want with GL
>
> What I mean is - as a platform (and, conceivably, Renderable) grows in
> sophistication, there will be fewer and fewer RenderableLists that
> contain only unoptimisable Renderables. So what I mean by “no-op”
> is that post_renderables_if_optimizable() will end up always returning
> true.

sure, I hope that it returns true more often as time goes on. I think though that we'll always need the post_update() interface for the compositors who know beforehand that they're doing something like wobbly windows that isn't representable by a RenderableList.

[Chris Halse Rogers (raof)]

On Wed, May 14, 2014 at 10:49 AM, Kevin DuBois
<email address hidden> wrote:
>>
>>
>> On Wed, May 14, 2014 at 3:54 AM, Kevin DuBois
>> <email address hidden> wrote:
>> >> So this makes it easier to bring up platforms in the short term,
>> >> and will
>> >> probably be a no-op in the long term?
>> >
>> > I'm confused as what will 'be a no-op in the long term'.
>> > post_renderables_if_optimizable() will be the hardware optimized
>> > interface that compositors should try if they know they're doing
>> > something simple, and post_update() will be the interface that the
>> > compositors use to do anything they want with GL
>>
>> What I mean is - as a platform (and, conceivably, Renderable) grows
>> in
>> sophistication, there will be fewer and fewer RenderableLists that
>> contain only unoptimisable Renderables. So what I mean by
>> “no-op”
>> is that post_renderables_if_optimizable() will end up always
>> returning
>> true.
>
> sure, I hope that it returns true more often as time goes on. I think
> though that we'll always need the post_update() interface for the
> compositors who know beforehand that they're doing something like
> wobbly windows that isn't representable by a RenderableList.

It kinda is - the results of the GL composition as a Renedeable, plus a
Cursor Renderable.

This does suggest that maybe the interaction with cursor drawing needs
thinking.

None of this is blocking, just thinking.

[Alexandros Frantzis (afrantzis)]

Looks good codewise. I am confused about:

> So basically, the lp:~kdub/mir/overlay-gl-program branch just handles the quirky requirement that android has to draw the fallback with OpenGL

Why does Android have to use the internal fallback and not render with GL using the normal renderer, like Mesa is supposed to do in this scenario?

review: Needs Information

[Alexandros Frantzis (afrantzis)]

> Looks good codewise. I am confused about:
>
> > So basically, the lp:~kdub/mir/overlay-gl-program branch just handles the
> quirky requirement that android has to draw the fallback with OpenGL
>
> Why does Android have to use the internal fallback and not render with GL
> using the normal renderer, like Mesa is supposed to do in this scenario?

Never mind, I just reread the description of https://code.launchpad.net/~kdub/mir/overlay-gl-program/+merge/217153

review: Approve

[Kevin DuBois (kdub)]

> It kinda is - the results of the GL composition as a Renedeable, plus a
> Cursor Renderable.
>
> This does suggest that maybe the interaction with cursor drawing needs
> thinking.
>
> None of this is blocking, just thinking.

Yeah, there's some "abstraction-defense" that needs to be done with the mesa cursor, future steps.

[Andreas Pokorny (andreas-pokorny)]

I like the simplification of the interface. Just some small findings:

Any reason why you are not reusing the typedef RenderableList in + 1052 + 1056 + 1248 + 1251 and why you are not using operator== instead of the matcher in + 1029.

review: Approve

[Alberto Aguirre (albaguirre)]

LGTM

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1600
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1697/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/285/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/286
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/285/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/216/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/215/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/761/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1697/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'examples/render_overlays.cpp'
--- examples/render_overlays.cpp	2014-05-14 18:40:19 +0000
+++ examples/render_overlays.cpp	2014-05-21 17:27:23 +0000
@@ -198,8 +198,7 @@
             buffer.make_current();
             client1->update_green_channel();
             client2->update_green_channel();
-            auto render_fn = [](mg::Renderable const&) {};
-            buffer.render_and_post_update(renderlist, render_fn);
+            buffer.post_renderables_if_optimizable(renderlist);
         });
     }
    return 0;

=== modified file 'include/platform/mir/graphics/display_buffer.h'
--- include/platform/mir/graphics/display_buffer.h	2014-03-26 05:48:59 +0000
+++ include/platform/mir/graphics/display_buffer.h	2014-05-21 17:27:23 +0000
@@ -24,7 +24,6 @@
 #include <mir_toolkit/common.h>
 
 #include <memory>
-#include <functional>
 
 namespace mir
 {
@@ -51,13 +50,22 @@
     /** This will trigger OpenGL rendering and post the result to the screen. */
     virtual void post_update() = 0;
 
-    /** This will render renderlist to the screen and post the result to the screen.
-        For each renderable, the DisplayBuffer will decide if its more efficient to render
-        that Renderable via OpenGL, or via another method. If the Renderable is to be rendered
-        via OpenGL, render_fn will be invoked on that Renderable. */
-    virtual void render_and_post_update(
-        RenderableList const& renderlist,
-        std::function<void(Renderable const&)> const& render_fn) = 0;
+    /** 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 
+     *      The renderables that should appear on the screen if the hardware
+     *      is capable of optmizing that list somehow. If what you want
+     *      displayed on the screen cannot be represented by a RenderableList,
+     *      then you should draw using OpenGL and use post_update()
+     *  \returns
+     *      true if the hardware can optimize the rendering of the list.
+     *      When this call completes, the renderlist will have been posted
+     *      to the screen.
+     *      false if the hardware platform cannot optimize the list. The screen
+     *      will not be updated. The caller should render the list another way,
+     *      and post using post_update()
+    **/
+    virtual bool post_renderables_if_optimizable(RenderableList const& renderlist) = 0;
 
     /** to be deprecated */
     virtual bool can_bypass() const = 0;

=== modified file 'include/test/mir_test_doubles/mock_display_buffer.h'
--- include/test/mir_test_doubles/mock_display_buffer.h	2014-03-26 05:48:59 +0000
+++ include/test/mir_test_doubles/mock_display_buffer.h	2014-05-21 17:27:23 +0000
@@ -46,8 +46,7 @@
     MOCK_METHOD0(release_current, void());
     MOCK_METHOD0(post_update, void());
     MOCK_CONST_METHOD0(can_bypass, bool());
-    MOCK_METHOD2(render_and_post_update, void(graphics::RenderableList const&, 
-                                   std::function<void(graphics::Renderable const&)> const&));
+    MOCK_METHOD1(post_renderables_if_optimizable, bool(graphics::RenderableList const&)); 
     MOCK_CONST_METHOD0(orientation, MirOrientation());
 };
 

=== removed file 'include/test/mir_test_doubles/mock_render_function.h'
--- include/test/mir_test_doubles/mock_render_function.h	2014-02-18 16:48:24 +0000
+++ include/test/mir_test_doubles/mock_render_function.h	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-/*
- * Copyright © 2014 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_MOCK_RENDER_FUNCTION_H_
-#define MIR_TEST_DOUBLES_MOCK_RENDER_FUNCTION_H_
-
-#include <mir/graphics/renderable.h>
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-struct MockRenderFunction
-{
-    MOCK_METHOD1(called, void(graphics::Renderable const&));
-};
-
-}
-}
-}
-
-#endif /* MIR_TEST_DOUBLES_MOCK_RENDER_FUNCTION_H_ */

=== modified file 'include/test/mir_test_doubles/null_display_buffer.h'
--- include/test/mir_test_doubles/null_display_buffer.h	2014-03-26 05:48:59 +0000
+++ include/test/mir_test_doubles/null_display_buffer.h	2014-05-21 17:27:23 +0000
@@ -36,9 +36,7 @@
     void release_current() {}
     void post_update() {}
     bool can_bypass() const override { return false; }
-    void render_and_post_update(
-        graphics::RenderableList const&,
-        std::function<void(graphics::Renderable const&)> const&) {}
+    bool post_renderables_if_optimizable(graphics::RenderableList const&) { return false; }
     MirOrientation orientation() const override { return mir_orientation_normal; }
 };
 

=== modified file 'include/test/mir_test_doubles/stub_display_builder.h'
--- include/test/mir_test_doubles/stub_display_builder.h	2014-05-01 07:13:02 +0000
+++ include/test/mir_test_doubles/stub_display_builder.h	2014-05-21 17:27:23 +0000
@@ -42,9 +42,7 @@
     void release_current() {}
     void post_update() {}
     bool can_bypass() const override { return false; }
-    void render_and_post_update(
-        graphics::RenderableList const&,
-        std::function<void(graphics::Renderable const&)> const&) {}
+    bool post_renderables_if_optimizable(graphics::RenderableList const&) { return false; }
     MirOrientation orientation() const override { return mir_orientation_normal; }
     void configure(graphics::DisplayConfigurationOutput const&) {} 
     graphics::DisplayConfigurationOutput configuration() const

=== modified file 'src/platform/graphics/android/display_buffer.cpp'
--- src/platform/graphics/android/display_buffer.cpp	2014-05-19 02:55:29 +0000
+++ src/platform/graphics/android/display_buffer.cpp	2014-05-21 17:27:23 +0000
@@ -30,6 +30,28 @@
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
 
+namespace
+{
+bool renderable_list_is_hwc_incompatible(mg::RenderableList const& list)
+{
+    if (list.empty())
+        return true;
+
+    for(auto const& renderable : list)
+    {
+        //TODO: enable alpha, 90 deg rotation
+        static glm::mat4 const identity;
+        if (renderable->shaped() ||
+            renderable->alpha_enabled() ||
+            (renderable->transformation() != identity))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+}
+
 mga::DisplayBuffer::DisplayBuffer(
     std::shared_ptr<FramebufferBundle> const& fb_bundle,
     std::shared_ptr<DisplayDevice> const& display_device,
@@ -86,20 +108,14 @@
     gl_context.release_current();
 }
 
-void mga::DisplayBuffer::render_and_post_update(
-    RenderableList const& renderlist,
-    std::function<void(Renderable const&)> const&)
+bool mga::DisplayBuffer::post_renderables_if_optimizable(RenderableList const& renderlist)
 {
-    if (renderlist.empty())
-    {
-        display_device->render_gl(gl_context);
-    }
-    else
-    {
-        display_device->prepare_overlays(gl_context, renderlist, overlay_program);
-    }
+    if (renderable_list_is_hwc_incompatible(renderlist))
+        return false;
 
+    display_device->prepare_overlays(gl_context, renderlist, overlay_program);
     post();
+    return true;
 }
 
 void mga::DisplayBuffer::post_update()

=== modified file 'src/platform/graphics/android/display_buffer.h'
--- src/platform/graphics/android/display_buffer.h	2014-05-01 07:13:02 +0000
+++ src/platform/graphics/android/display_buffer.h	2014-05-21 17:27:23 +0000
@@ -52,9 +52,7 @@
     void post_update();
     bool can_bypass() const override;
 
-    void render_and_post_update(
-        RenderableList const& renderlist,
-        std::function<void(Renderable const&)> const& render_fn);
+    bool post_renderables_if_optimizable(RenderableList const& renderlist);
     MirOrientation orientation() const override;
 
     DisplayConfigurationOutput configuration() const;

=== modified file 'src/platform/graphics/mesa/display_buffer.cpp'
--- src/platform/graphics/mesa/display_buffer.cpp	2014-05-05 03:36:45 +0000
+++ src/platform/graphics/mesa/display_buffer.cpp	2014-05-21 17:27:23 +0000
@@ -197,11 +197,9 @@
     return rotation;
 }
 
-void mgm::DisplayBuffer::render_and_post_update(
-    RenderableList const&,
-    std::function<void(Renderable const&)> const&)
+bool mgm::DisplayBuffer::post_renderables_if_optimizable(RenderableList const&)
 {
-    post_update(nullptr); 
+    return false;
 }
 
 void mgm::DisplayBuffer::post_update()

=== modified file 'src/platform/graphics/mesa/display_buffer.h'
--- src/platform/graphics/mesa/display_buffer.h	2014-03-27 09:52:04 +0000
+++ src/platform/graphics/mesa/display_buffer.h	2014-05-21 17:27:23 +0000
@@ -61,8 +61,7 @@
 
     bool can_bypass() const override;
     void post_update(std::shared_ptr<graphics::Buffer> bypass_buf) override;
-    void render_and_post_update(RenderableList const& renderlist,
-                                std::function<void(Renderable const&)> const& render_fn);
+    bool post_renderables_if_optimizable(RenderableList const& renderlist) override;
     MirOrientation orientation() const override;
     void schedule_set_crtc();
     void wait_for_page_flip();

=== modified file 'src/server/compositor/screencast_display_buffer.cpp'
--- src/server/compositor/screencast_display_buffer.cpp	2014-03-26 05:48:59 +0000
+++ src/server/compositor/screencast_display_buffer.cpp	2014-05-21 17:27:23 +0000
@@ -85,14 +85,9 @@
                old_viewport[2], old_viewport[3]);
 }
 
-void mc::ScreencastDisplayBuffer::render_and_post_update(
-    mg::RenderableList const& renderables,
-    std::function<void(mg::Renderable const&)> const& render)
+bool mc::ScreencastDisplayBuffer::post_renderables_if_optimizable(mg::RenderableList const&)
 {
-    for (auto const& renderable : renderables)
-        render(*renderable);
-
-    post_update();
+    return false;
 }
 
 void mc::ScreencastDisplayBuffer::post_update()

=== modified file 'src/server/compositor/screencast_display_buffer.h'
--- src/server/compositor/screencast_display_buffer.h	2014-03-26 05:48:59 +0000
+++ src/server/compositor/screencast_display_buffer.h	2014-05-21 17:27:23 +0000
@@ -59,9 +59,7 @@
 
     void release_current();
 
-    void render_and_post_update(
-        graphics::RenderableList const&,
-        std::function<void(graphics::Renderable const&)> const&);
+    bool post_renderables_if_optimizable(graphics::RenderableList const&);
 
     void post_update();
 

=== modified file 'src/server/graphics/nested/nested_output.cpp'
--- src/server/graphics/nested/nested_output.cpp	2014-05-08 11:02:47 +0000
+++ src/server/graphics/nested/nested_output.cpp	2014-05-21 17:27:23 +0000
@@ -71,10 +71,9 @@
     return false;
 }
 
-void mgn::detail::NestedOutput::render_and_post_update(
-    RenderableList const&,
-    std::function<void(Renderable const&)> const&)
+bool mgn::detail::NestedOutput::post_renderables_if_optimizable(RenderableList const&)
 {
+    return false;
 }
 
 MirOrientation mgn::detail::NestedOutput::orientation() const

=== modified file 'src/server/graphics/nested/nested_output.h'
--- src/server/graphics/nested/nested_output.h	2014-05-08 11:02:47 +0000
+++ src/server/graphics/nested/nested_output.h	2014-05-21 17:27:23 +0000
@@ -51,9 +51,7 @@
     virtual bool can_bypass() const override;
     MirOrientation orientation() const override;
 
-    void render_and_post_update(
-        RenderableList const& renderlist,
-        std::function<void(Renderable const&)> const& render_fn);
+    bool post_renderables_if_optimizable(RenderableList const& renderlist);
 
     NestedOutput(NestedOutput const&) = delete;
     NestedOutput operator=(NestedOutput const&) = delete;

=== modified file 'src/server/graphics/offscreen/display_buffer.cpp'
--- src/server/graphics/offscreen/display_buffer.cpp	2014-03-26 05:48:59 +0000
+++ src/server/graphics/offscreen/display_buffer.cpp	2014-05-21 17:27:23 +0000
@@ -149,10 +149,9 @@
     return false;
 }
 
-void mgo::DisplayBuffer::render_and_post_update(
-        RenderableList const&,
-        std::function<void(Renderable const&)> const&)
+bool mgo::DisplayBuffer::post_renderables_if_optimizable(RenderableList const&)
 {
+    return false;
 }
 
 MirOrientation mgo::DisplayBuffer::orientation() const

=== modified file 'src/server/graphics/offscreen/display_buffer.h'
--- src/server/graphics/offscreen/display_buffer.h	2014-03-26 05:48:59 +0000
+++ src/server/graphics/offscreen/display_buffer.h	2014-05-21 17:27:23 +0000
@@ -70,9 +70,7 @@
     bool can_bypass() const;
     MirOrientation orientation() const override;
 
-    void render_and_post_update(
-        RenderableList const& renderlist,
-        std::function<void(Renderable const&)> const& render_fn);
+    bool post_renderables_if_optimizable(RenderableList const& renderlist) override; 
 
 private:
     SurfacelessEGLContext const egl_context;

=== modified file 'tests/integration-tests/test_surface_stack_with_compositor.cpp'
--- tests/integration-tests/test_surface_stack_with_compositor.cpp	2014-05-19 02:55:29 +0000
+++ tests/integration-tests/test_surface_stack_with_compositor.cpp	2014-05-21 17:27:23 +0000
@@ -66,11 +66,10 @@
         return true;
     }
 
-    void render_and_post_update(
-        mg::RenderableList const&,
-        std::function<void(mg::Renderable const&)> const&) override
+    bool post_renderables_if_optimizable(mg::RenderableList const&)
     {
         increment_post_count();
+        return true;
     }
 
     void post_update() override

=== modified file 'tests/unit-tests/compositor/test_screencast_display_buffer.cpp'
--- tests/unit-tests/compositor/test_screencast_display_buffer.cpp	2014-03-05 07:02:29 +0000
+++ tests/unit-tests/compositor/test_screencast_display_buffer.cpp	2014-05-21 17:27:23 +0000
@@ -34,16 +34,6 @@
 namespace
 {
 
-struct MockRenderFunctor
-{
-    void operator()(mg::Renderable const& r)
-    {
-        operator_call(&r);
-    }
-
-    MOCK_METHOD1(operator_call, void(mg::Renderable const*));
-};
-
 struct ScreencastDisplayBufferTest : testing::Test
 {
     testing::NiceMock<mtd::MockGL> mock_gl;
@@ -158,10 +148,8 @@
     db.post_update();
 }
 
-TEST_F(ScreencastDisplayBufferTest, renders_renderables_on_render_and_post_update)
+TEST_F(ScreencastDisplayBufferTest, rejects_attempt_to_optimize)
 {
-    using namespace testing;
-
     geom::Rectangle const rect{{100,100}, {800,600}};
     mtd::StubBuffer stub_buffer;
 
@@ -172,15 +160,5 @@
 
     mc::ScreencastDisplayBuffer db{rect, stub_buffer};
 
-    Mock::VerifyAndClearExpectations(&mock_gl);
-    MockRenderFunctor mock_render_functor;
-
-    InSequence s;
-
-    for (auto const& renderable : renderables)
-        EXPECT_CALL(mock_render_functor, operator_call(renderable.get()));
-
-    EXPECT_CALL(mock_gl, glFinish());
-
-    db.render_and_post_update(renderables, std::ref(mock_render_functor));
+    EXPECT_FALSE(db.post_renderables_if_optimizable(renderables));
 }

=== modified file 'tests/unit-tests/graphics/android/test_fb_device.cpp'
--- tests/unit-tests/graphics/android/test_fb_device.cpp	2014-05-19 02:55:29 +0000
+++ tests/unit-tests/graphics/android/test_fb_device.cpp	2014-05-21 17:27:23 +0000
@@ -26,7 +26,6 @@
 #include "mir_test_doubles/stub_buffer.h"
 #include "mir_test_doubles/stub_renderable.h"
 #include "mir_test_doubles/mock_android_native_buffer.h"
-#include "mir_test_doubles/mock_render_function.h"
 #include "mir_test_doubles/mock_swapping_gl_context.h"
 #include "mir_test_doubles/stub_renderable_list_compositor.h"
 #include "mir_test_doubles/mock_renderable_list_compositor.h"

=== modified file 'tests/unit-tests/graphics/android/test_hwc_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc_device.cpp	2014-05-19 02:55:29 +0000
+++ tests/unit-tests/graphics/android/test_hwc_device.cpp	2014-05-21 17:27:23 +0000
@@ -31,7 +31,6 @@
 #include "mir_test_doubles/mock_hwc_device_wrapper.h"
 #include "mir_test/fake_shared.h"
 #include "hwc_struct_helpers.h"
-#include "mir_test_doubles/mock_render_function.h"
 #include "mir_test_doubles/mock_swapping_gl_context.h"
 #include "mir_test_doubles/stub_swapping_gl_context.h"
 #include "mir_test_doubles/stub_renderable_list_compositor.h"
@@ -252,36 +251,16 @@
     device.render_gl(stub_context);
 }
 
-namespace
-{
-MATCHER_P(MatchesRenderableList, value, std::string(""))
-{
-    if (value.size() != arg.size())
-        return false;
-
-    bool match{true};
-    auto it = value.begin();
-    for(auto const& a : arg)
-    {
-        if (a != *it)
-            match = false;
-        it++;
-    }
-    return match; 
-}
-
-}
-
 TEST_F(HwcDevice, calls_render_with_list_of_rejected_overlays)
 {
     using namespace testing;
     mtd::MockRenderableListCompositor mock_compositor;
 
-    std::list<std::shared_ptr<mg::Renderable>> updated_list({
+    mg::RenderableList updated_list({
         stub_renderable1,
         stub_renderable2
     });
-    std::list<std::shared_ptr<mg::Renderable>> expected_renderable_list({
+    mg::RenderableList expected_renderable_list({
         stub_renderable2
     });
 
@@ -303,7 +282,7 @@
             contents.hwLayers[2].compositionType = HWC_FRAMEBUFFER_TARGET;
         }));
 
-    EXPECT_CALL(mock_compositor, render(MatchesRenderableList(expected_renderable_list),Ref(mock_context)))
+    EXPECT_CALL(mock_compositor, render(expected_renderable_list,Ref(mock_context)))
         .InSequence(seq);
 
     mga::HwcDevice device(mock_device, mock_hwc_device_wrapper, mock_vsync, mock_file_ops);
@@ -333,7 +312,7 @@
         .InSequence(seq);
     mga::HwcDevice device(mock_device, mock_hwc_device_wrapper, mock_vsync, mock_file_ops);
 
-    std::list<std::shared_ptr<mg::Renderable>> updated_list({
+    mg::RenderableList updated_list({
         stub_renderable1,
         stub_renderable2
     });
@@ -408,7 +387,7 @@
     };
 
     /* set non-default renderlist */
-    std::list<std::shared_ptr<mg::Renderable>> updated_list({
+    mg::RenderableList updated_list({
         stub_renderable1,
         stub_renderable1
     });
@@ -491,7 +470,7 @@
 TEST_F(HwcDevice, discards_second_set_if_all_overlays_and_nothing_has_changed)
 {
     using namespace testing;
-    std::list<std::shared_ptr<mg::Renderable>> updated_list({
+    mg::RenderableList updated_list({
         stub_renderable1,
         stub_renderable2
     });
@@ -519,7 +498,7 @@
 TEST_F(HwcDevice, submits_every_time_if_at_least_one_layer_is_gl_rendered)
 {
     using namespace testing;
-    std::list<std::shared_ptr<mg::Renderable>> updated_list({
+    mg::RenderableList updated_list({
         stub_renderable1,
         stub_renderable2
     });
@@ -562,7 +541,7 @@
         .WillOnce(Return(native_handle_2))
         .WillOnce(Return(native_handle_3));
 
-    std::list<std::shared_ptr<mg::Renderable>> updated_list({stub_renderable1});
+    mg::RenderableList updated_list({stub_renderable1});
 
     mga::HwcDevice device(mock_device, mock_hwc_device_wrapper, mock_vsync, mock_file_ops);
 

=== modified file 'tests/unit-tests/graphics/android/test_hwc_display.cpp'
--- tests/unit-tests/graphics/android/test_hwc_display.cpp	2014-05-19 02:55:29 +0000
+++ tests/unit-tests/graphics/android/test_hwc_display.cpp	2014-05-21 17:27:23 +0000
@@ -31,6 +31,11 @@
 #include "mir_test_doubles/stub_gl_config.h"
 #include "mir_test_doubles/mock_framebuffer_bundle.h"
 #include "mir_test_doubles/stub_gl_program_factory.h"
+#define GLM_FORCE_RADIANS
+#define GLM_PRECISION_MEDIUMP_FLOAT
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
 #include <memory>
 
 namespace geom=mir::geometry;
@@ -38,6 +43,36 @@
 namespace mga=mir::graphics::android;
 namespace mtd=mir::test::doubles;
 
+namespace
+{
+struct TransformedRenderable : public mtd::StubRenderable
+{
+    glm::mat4 transformation() const override
+    {
+        glm::mat4 transform(1.0);
+        glm::vec3 vec(1.0, 0.0, 0.0);
+        transform = glm::rotate(transform, 33.0f, vec);
+        return transform;
+    }
+};
+
+//hopefully the alpha representation gets condensed at some point
+struct ShapedRenderable : public mtd::StubRenderable
+{
+    bool shaped() const override
+    {
+        return true;
+    }
+};
+
+struct TranslucentRenderable : public mtd::StubRenderable
+{
+    bool alpha_enabled() const override
+    {
+        return true;
+    }
+};
+
 class AndroidDisplayBuffer : public ::testing::Test
 {
 protected:
@@ -83,7 +118,7 @@
     geom::Size const display_size{433,232};
     double const refresh_rate{60.0};
 };
-
+}
 TEST_F(AndroidDisplayBuffer, can_post_update_with_gl_only)
 {
     using namespace testing;
@@ -97,40 +132,57 @@
     EXPECT_CALL(*mock_display_device, post(Ref(*stub_buffer)))
         .Times(1);
 
-    std::list<std::shared_ptr<mg::Renderable>> renderlist{};
+    mg::RenderableList renderlist{};
     mga::DisplayBuffer db(
         mock_fb_bundle, mock_display_device, native_window, *gl_context, stub_program_factory);
     db.post_update();
 }
 
-TEST_F(AndroidDisplayBuffer, performs_default_post_if_empty_list)
-{
-    using namespace testing;
-
-    mga::DisplayBuffer db(
-        mock_fb_bundle, mock_display_device, native_window, *gl_context, stub_program_factory);
-
-    InSequence seq;
-    EXPECT_CALL(*mock_display_device, render_gl(_))
-        .Times(1);
-    EXPECT_CALL(*mock_fb_bundle, last_rendered_buffer())
-        .Times(1)
-        .WillOnce(Return(stub_buffer));
-    EXPECT_CALL(*mock_display_device, post(Ref(*stub_buffer)))
-        .Times(1);
-
-    std::list<std::shared_ptr<mg::Renderable>> renderlist{};
-    auto render_fn = [] (mg::Renderable const&) {};
-    db.render_and_post_update(renderlist, render_fn);
+TEST_F(AndroidDisplayBuffer, rejects_empty_list)
+{
+    using namespace testing;
+
+    mga::DisplayBuffer db(
+        mock_fb_bundle, mock_display_device, native_window, *gl_context, stub_program_factory);
+
+    mg::RenderableList renderlist{};
+    EXPECT_FALSE(db.post_renderables_if_optimizable(renderlist));
+}
+
+//TODO: we could accept a 90 degree transform
+TEST_F(AndroidDisplayBuffer, rejects_list_containing_transformed)
+{
+    using namespace testing;
+
+    mga::DisplayBuffer db(
+        mock_fb_bundle, mock_display_device, native_window, *gl_context, stub_program_factory);
+
+    auto renderable = std::make_shared<TransformedRenderable>();
+    mg::RenderableList renderlist{renderable};
+    EXPECT_FALSE(db.post_renderables_if_optimizable(renderlist));
+}
+
+//TODO: remove once alpha+HWC is turned on
+TEST_F(AndroidDisplayBuffer, rejects_list_containing_alpha)
+{
+    using namespace testing;
+
+    mga::DisplayBuffer db(
+        mock_fb_bundle, mock_display_device, native_window, *gl_context, stub_program_factory);
+
+    mg::RenderableList renderlist{std::make_shared<TranslucentRenderable>()};
+    EXPECT_FALSE(db.post_renderables_if_optimizable(renderlist));
+
+    mg::RenderableList renderlist2{std::make_shared<ShapedRenderable>()};
+    EXPECT_FALSE(db.post_renderables_if_optimizable(renderlist2));
 }
 
 TEST_F(AndroidDisplayBuffer, posts_overlay_list)
 {
     using namespace testing;
-    std::list<std::shared_ptr<mg::Renderable>> renderlist{
+    mg::RenderableList renderlist{
         std::make_shared<mtd::StubRenderable>(),
         std::make_shared<mtd::StubRenderable>()};
-    std::function<void(mg::Renderable const&)> render_fn;
 
     InSequence seq;
     EXPECT_CALL(*mock_display_device, prepare_overlays(_, Ref(renderlist), _))
@@ -143,7 +195,7 @@
 
     mga::DisplayBuffer db(
         mock_fb_bundle, mock_display_device, native_window, *gl_context, stub_program_factory);
-    db.render_and_post_update(renderlist, render_fn); 
+    EXPECT_TRUE(db.post_renderables_if_optimizable(renderlist)); 
 }
 
 TEST_F(AndroidDisplayBuffer, defaults_to_normal_orientation)

=== modified file 'tests/unit-tests/graphics/android/test_hwc_fb_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc_fb_device.cpp	2014-05-19 02:55:29 +0000
+++ tests/unit-tests/graphics/android/test_hwc_fb_device.cpp	2014-05-21 17:27:23 +0000
@@ -25,10 +25,10 @@
 #include "mir_test_doubles/mock_framebuffer_bundle.h"
 #include "mir_test_doubles/mock_fb_hal_device.h"
 #include "mir_test_doubles/stub_renderable.h"
-#include "mir_test_doubles/mock_render_function.h"
 #include "mir_test_doubles/stub_swapping_gl_context.h"
 #include "mir_test_doubles/mock_egl.h"
 #include "mir_test_doubles/mock_hwc_device_wrapper.h"
+#include "mir_test_doubles/stub_renderable_list_compositor.h"
 #include "mir_test_doubles/mock_renderable_list_compositor.h"
 #include "src/platform/graphics/android/overlay_gl_compositor.h"
 #include "hwc_struct_helpers.h"