Merge lp:~vanvugt/mir/rotate-display-buffer into lp:mir

[Daniel van Vugt]

Add DisplayBuffer::orientation(), to tell the Renderer if we need it to do
screen rotation in GL (for platforms which don't implement rotation natively)

Another stepping stone on the path to screen rotation. The aforementioned Renderer work will be proposed separately, to keep reviews simple. Although some of this proposal may not make sense to the reader without it, so if you really desperately want me to then I will merge the Renderer work into this.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1370
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/686/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/673
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/669
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-trusty-touch/275
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/416/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/420
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/420/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/275
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/275/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/291
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/3201

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

review: Needs Fixing (continuous-integration)

[Andreas Pokorny (andreas-pokorny)]

I have only two minor changes of improvement that would make the intent clearer and be less verbose:

168 + std::swap(width,height);

204 + fb_width = area.size.width.as_uint32_t();
205 + fb_height = area.size.height.as_uint32_t();
206 + if (rotation == mir_orientation_left || rotation == mir_orientation_right)
207 + std::swap(fb_width, fb_height);

But no blocker compared to the unit test issues on mesa.

[Kevin DuBois (kdub)]

I'd like to avoid the dynamic_cast in l75 if possible...

Perhaps we could just keep the state of the orientation in mga::AndroidDisplay (and the android display configuration class). Seems a bit more palatable until the android classes improve here. Don't want to block though, abstaining.

review: Abstain

[Daniel van Vugt (vanvugt)]

All fixed.

Kevin:
I prototyped orient() in the DisplayBuffer interface to avoid the dynamic cast. Unfortunately that creates a bigger problem of then "contractually" having to implement orient() for the more complex mesa::DisplayBuffer, which is otherwise unnecessary. The problem only exists because AndroidDisplay refuses to admit its display_buffer is android::DisplayBuffer, for the purposes of stubbing in tests. Though you can see AndroidDisplay already employs dynamic_cast...
  Also, putting orientation() in AndroidDisplay would not work. The Renderer only has access to the DisplayBuffer interface. Which is clean and I'd like to keep it that way.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1374
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/691/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/679
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/675
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-trusty-touch/281
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/421
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/421/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/425
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/425/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/281
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/281/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/296
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/3212

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1376
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/693/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/682
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/678
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-trusty-touch/284
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/423
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/423/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/427
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/427/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/284
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/284/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/297
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/3214

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

7 #include <mir/geometry/rectangle.h>
8 +#include <mir_toolkit/common.h>

This include style is in a small minority:

$ grep "#include <mir" `find include -name \*.h` | wc -l
15
$ grep "#include \"mir" `find include -name \*.h` | wc -l
212

[Alan Griffiths (alan-griffiths)]

OK

review: Approve

[Kevin DuBois (kdub)]

> All fixed.
>
> Kevin:
> I prototyped orient() in the DisplayBuffer interface to avoid the dynamic
> cast. Unfortunately that creates a bigger problem of then "contractually"
> having to implement orient() for the more complex mesa::DisplayBuffer, which
> is otherwise unnecessary. The problem only exists because AndroidDisplay
> refuses to admit its display_buffer is android::DisplayBuffer, for the
> purposes of stubbing in tests. Though you can see AndroidDisplay already
> employs dynamic_cast...
> Also, putting orientation() in AndroidDisplay would not work. The Renderer
> only has access to the DisplayBuffer interface. Which is clean and I'd like to
> keep it that way.

After seeing the other MP's today, I see why it wouldn't work.
In as far as reconfiguring the display goes, the android classes need a bit of work with the already-in-place mode() function, so I don't object to doing this with the orientation. (although I might redo the orientation and mode state to live solely within the DisplayDevice classes in the future.)

review: Approve (ok for now)

[Chris Halse Rogers (raof)]

Looks fine to me

review: Approve

=== modified file 'include/platform/mir/graphics/display_buffer.h'
--- include/platform/mir/graphics/display_buffer.h	2014-01-17 23:07:03 +0000
+++ include/platform/mir/graphics/display_buffer.h	2014-01-21 07:20:58 +0000
@@ -21,6 +21,7 @@
 
 #include "renderable.h"
 #include <mir/geometry/rectangle.h>
+#include <mir_toolkit/common.h>
 
 #include <memory>
 #include <functional>
@@ -63,6 +64,15 @@
     virtual bool can_bypass() const = 0;
     virtual void post_update(std::shared_ptr<Buffer> /* bypass_buf */) {}
 
+    /** Returns the orientation of the display buffer relative to how the
+     *  user should see it (the orientation of the output).
+     *  This tells us how much (if any) rotation the renderer needs to do.
+     *  If your DisplayBuffer can do the rotation itself then this will
+     *  always return mir_orientation_normal. If the DisplayBuffer does not
+     *  implement the rotation itself then this function will return the
+     *  amount of rotation the renderer must do to make things "look right".
+     */
+    virtual MirOrientation orientation() const = 0;
 
 protected:
     DisplayBuffer() = default;

=== modified file 'include/test/mir_test_doubles/mock_display_buffer.h'
--- include/test/mir_test_doubles/mock_display_buffer.h	2014-01-17 19:42:09 +0000
+++ include/test/mir_test_doubles/mock_display_buffer.h	2014-01-21 07:20:58 +0000
@@ -40,6 +40,7 @@
     MOCK_CONST_METHOD0(can_bypass, bool());
     MOCK_METHOD2(render_and_post_update, void(std::list<graphics::Renderable> const&, 
                                    std::function<void(graphics::Renderable const&)> const&));
+    MOCK_CONST_METHOD0(orientation, MirOrientation());
 };
 
 }

=== modified file 'include/test/mir_test_doubles/null_display_buffer.h'
--- include/test/mir_test_doubles/null_display_buffer.h	2014-01-17 19:42:09 +0000
+++ include/test/mir_test_doubles/null_display_buffer.h	2014-01-21 07:20:58 +0000
@@ -39,6 +39,7 @@
     void render_and_post_update(
         std::list<graphics::Renderable> const&,
         std::function<void(graphics::Renderable const&)> const&) {}
+    MirOrientation orientation() const override { return mir_orientation_normal; }
 };
 
 }

=== modified file 'src/platform/graphics/android/android_display.cpp'
--- src/platform/graphics/android/android_display.cpp	2014-01-13 06:12:33 +0000
+++ src/platform/graphics/android/android_display.cpp	2014-01-21 07:20:58 +0000
@@ -59,12 +59,25 @@
 
 void mga::AndroidDisplay::configure(mg::DisplayConfiguration const& configuration)
 {
+    MirOrientation orientation = mir_orientation_normal;
+
     configuration.for_each_output([&](mg::DisplayConfigurationOutput const& output)
     {
         // TODO: Properly support multiple outputs
         display_device->mode(output.power_mode);
+        orientation = output.orientation;
     });
     current_configuration = dynamic_cast<mga::AndroidDisplayConfiguration const&>(configuration);
+
+    /*
+     * It's tempting to put orient() into the base class and so avoid this
+     * cast, but we only need it in the Android implementation right now.
+     */
+    if (android::DisplayBuffer* db =
+            dynamic_cast<mga::DisplayBuffer*>(display_buffer.get()))
+    {
+        db->orient(orientation);
+    }
 }
 
 void mga::AndroidDisplay::register_configuration_change_handler(

=== modified file 'src/platform/graphics/android/display_buffer.cpp'
--- src/platform/graphics/android/display_buffer.cpp	2014-01-20 16:38:54 +0000
+++ src/platform/graphics/android/display_buffer.cpp	2014-01-21 07:20:58 +0000
@@ -23,6 +23,7 @@
 #include <functional>
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
+#include <algorithm>
 
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
@@ -35,13 +36,21 @@
     : fb_bundle{fb_bundle},
       display_device{display_device},
       native_window{native_window},
-      gl_context{shared_gl_context, std::bind(mga::create_window_surface, std::placeholders::_1, std::placeholders::_2, native_window.get())}
+      gl_context{shared_gl_context, std::bind(mga::create_window_surface, std::placeholders::_1, std::placeholders::_2, native_window.get())},
+      rotation{mir_orientation_normal}
 {
 }
 
 geom::Rectangle mga::DisplayBuffer::view_area() const
 {
-    return {geom::Point{}, fb_bundle->fb_size()};
+    auto const& size = fb_bundle->fb_size();
+    int width = size.width.as_int();
+    int height = size.height.as_int();
+
+    if (rotation == mir_orientation_left || rotation == mir_orientation_right)
+        std::swap(width, height);
+
+    return {{0,0}, {width,height}};
 }
 
 void mga::DisplayBuffer::make_current()
@@ -92,3 +101,19 @@
 {
     return false;
 }
+
+MirOrientation mga::DisplayBuffer::orientation() const
+{
+    /*
+     * android::DisplayBuffer is aways created with physical width/height
+     * (not rotated). So we just need to pass through the desired rotation
+     * and let the renderer do it.
+     * If and when we choose to implement HWC rotation, this may change.
+     */
+    return rotation;
+}
+
+void mga::DisplayBuffer::orient(MirOrientation rot)
+{
+    rotation = rot;
+}

=== modified file 'src/platform/graphics/android/display_buffer.h'
--- src/platform/graphics/android/display_buffer.h	2014-01-20 16:38:54 +0000
+++ src/platform/graphics/android/display_buffer.h	2014-01-21 07:20:58 +0000
@@ -50,6 +50,8 @@
     void render_and_post_update(
         std::list<Renderable> const& renderlist,
         std::function<void(Renderable const&)> const& render_fn);
+    MirOrientation orientation() const override;
+    void orient(MirOrientation);
 
 private:
     void render_and_post();
@@ -59,6 +61,7 @@
     std::shared_ptr<ANativeWindow> const native_window;
     GLContext gl_context;
     bool prepared;
+    MirOrientation rotation;
 };
 
 }

=== modified file 'src/platform/graphics/mesa/display.cpp'
--- src/platform/graphics/mesa/display.cpp	2014-01-13 06:12:33 +0000
+++ src/platform/graphics/mesa/display.cpp	2014-01-21 07:20:58 +0000
@@ -36,6 +36,7 @@
 #include <boost/exception/errinfo_errno.hpp>
 
 #include <stdexcept>
+#include <algorithm>
 
 namespace mgm = mir::graphics::mesa;
 namespace mg = mir::graphics;
@@ -147,6 +148,7 @@
         {
             auto bounding_rect = group.bounding_rectangle();
             std::vector<std::shared_ptr<KMSOutput>> kms_outputs;
+            MirOrientation orientation = mir_orientation_normal;
 
             group.for_each_output([&](DisplayConfigurationOutput const& conf_output)
             {
@@ -158,17 +160,30 @@
                 kms_output->configure(conf_output.top_left - bounding_rect.top_left, mode_index);
                 kms_output->set_power_mode(conf_output.power_mode);
                 kms_outputs.push_back(kms_output);
+
+                /*
+                 * Presently OverlappingOutputGroup guarantees all grouped
+                 * outputs have the same orientation.
+                 */
+                orientation = conf_output.orientation;
             });
 
-            auto surface =
-                platform->gbm.create_scanout_surface(bounding_rect.size.width.as_uint32_t(),
-                                                     bounding_rect.size.height.as_uint32_t());
+            uint32_t width = bounding_rect.size.width.as_uint32_t();
+            uint32_t height = bounding_rect.size.height.as_uint32_t();
+            if (orientation == mir_orientation_left ||
+                orientation == mir_orientation_right)
+            {
+                std::swap(width, height);
+            }
+
+            auto surface = platform->gbm.create_scanout_surface(width, height);
 
             std::unique_ptr<DisplayBuffer> db{
                 new DisplayBuffer{platform, listener,
                                   kms_outputs,
                                   std::move(surface),
                                   bounding_rect,
+                                  orientation,
                                   shared_egl.context()}};
 
             display_buffers_new.push_back(std::move(db));

=== modified file 'src/platform/graphics/mesa/display_buffer.cpp'
--- src/platform/graphics/mesa/display_buffer.cpp	2014-01-20 16:38:54 +0000
+++ src/platform/graphics/mesa/display_buffer.cpp	2014-01-21 07:20:58 +0000
@@ -100,6 +100,7 @@
     std::vector<std::shared_ptr<KMSOutput>> const& outputs,
     GBMSurfaceUPtr surface_gbm_param,
     geom::Rectangle const& area,
+    MirOrientation rot,
     EGLContext shared_context)
     : last_flipped_bufobj{nullptr},
       platform(platform),
@@ -108,8 +109,22 @@
       outputs(outputs),
       surface_gbm{std::move(surface_gbm_param)},
       area(area),
+      rotation(rot),
       needs_set_crtc{false}
 {
+    uint32_t area_width = area.size.width.as_uint32_t();
+    uint32_t area_height = area.size.height.as_uint32_t();
+    if (rotation == mir_orientation_left || rotation == mir_orientation_right)
+    {
+        fb_width = area_height;
+        fb_height = area_width;
+    }
+    else
+    {
+        fb_width = area_width;
+        fb_height = area_height;
+    }
+
     egl.setup(platform->gbm, surface_gbm.get(), shared_context);
 
     listener->report_successful_setup_of_native_resources();
@@ -165,7 +180,14 @@
 
 bool mgm::DisplayBuffer::can_bypass() const
 {
-    return true;
+    return (rotation == mir_orientation_normal);
+}
+
+
+MirOrientation mgm::DisplayBuffer::orientation() const
+{
+    // Tell the renderer to do the rotation, since we're not doing it here.
+    return rotation;
 }
 
 void mgm::DisplayBuffer::render_and_post_update(
@@ -276,7 +298,7 @@
     auto stride = gbm_bo_get_stride(bo);
 
     /* Create a KMS FB object with the gbm_bo attached to it. */
-    auto ret = drmModeAddFB(drm.fd, area.size.width.as_uint32_t(), area.size.height.as_uint32_t(),
+    auto ret = drmModeAddFB(drm.fd, fb_width, fb_height,
                             24, 32, stride, handle, &fb_id);
     if (ret)
         return nullptr;
@@ -331,3 +353,4 @@
 {
     needs_set_crtc = true;
 }
+

=== modified file 'src/platform/graphics/mesa/display_buffer.h'
--- src/platform/graphics/mesa/display_buffer.h	2014-01-20 16:38:54 +0000
+++ src/platform/graphics/mesa/display_buffer.h	2014-01-21 07:20:58 +0000
@@ -48,6 +48,7 @@
                   std::vector<std::shared_ptr<KMSOutput>> const& outputs,
                   GBMSurfaceUPtr surface_gbm,
                   geometry::Rectangle const& area,
+                  MirOrientation rot,
                   EGLContext shared_context);
     ~DisplayBuffer();
 
@@ -60,6 +61,7 @@
     void post_update(std::shared_ptr<graphics::Buffer> bypass_buf) override;
     void render_and_post_update(std::list<Renderable> const& renderlist,
                                 std::function<void(Renderable const&)> const& render_fn);
+    MirOrientation orientation() const override;
     void schedule_set_crtc();
 
 private:
@@ -77,6 +79,8 @@
     GBMSurfaceUPtr surface_gbm;
     helpers::EGLHelper egl;
     geometry::Rectangle area;
+    uint32_t fb_width, fb_height;
+    MirOrientation rotation;
     std::atomic<bool> needs_set_crtc;
 };
 

=== modified file 'src/server/graphics/nested/nested_output.cpp'
--- src/server/graphics/nested/nested_output.cpp	2014-01-20 16:38:54 +0000
+++ src/server/graphics/nested/nested_output.cpp	2014-01-21 07:20:58 +0000
@@ -86,7 +86,16 @@
     std::list<Renderable> const&,
     std::function<void(Renderable const&)> const&)
 {
-} 
+}
+
+MirOrientation mgn::detail::NestedOutput::orientation() const
+{
+    /*
+     * Always normal orientation. The real rotation is handled by the
+     * native display.
+     */
+    return mir_orientation_normal;
+}
 
 mgn::detail::NestedOutput::~NestedOutput() noexcept
 {

=== modified file 'src/server/graphics/nested/nested_output.h'
--- src/server/graphics/nested/nested_output.h	2014-01-20 16:38:54 +0000
+++ src/server/graphics/nested/nested_output.h	2014-01-21 07:20:58 +0000
@@ -64,6 +64,7 @@
     void release_current() override;
     void post_update() override;
     virtual bool can_bypass() const override;
+    MirOrientation orientation() const override;
 
     void render_and_post_update(
         std::list<Renderable> const& renderlist,

=== modified file 'src/server/graphics/offscreen/display_buffer.cpp'
--- src/server/graphics/offscreen/display_buffer.cpp	2014-01-20 16:38:54 +0000
+++ src/server/graphics/offscreen/display_buffer.cpp	2014-01-21 07:20:58 +0000
@@ -153,4 +153,13 @@
         std::list<Renderable> const&,
         std::function<void(Renderable const&)> const&)
 {
-} 
+}
+
+MirOrientation mgo::DisplayBuffer::orientation() const
+{
+    /*
+     * The display buffer's already constructed with rotated dimensions,
+     * so nothing more to do.
+     */
+    return mir_orientation_normal;
+}

=== modified file 'src/server/graphics/offscreen/display_buffer.h'
--- src/server/graphics/offscreen/display_buffer.h	2014-01-17 19:42:09 +0000
+++ src/server/graphics/offscreen/display_buffer.h	2014-01-21 07:20:58 +0000
@@ -68,6 +68,7 @@
     void post_update();
 
     bool can_bypass() const;
+    MirOrientation orientation() const override;
 
     void render_and_post_update(
         std::list<Renderable> const& renderlist,

=== modified file 'tests/unit-tests/graphics/android/test_hwc_display.cpp'
--- tests/unit-tests/graphics/android/test_hwc_display.cpp	2014-01-20 16:38:54 +0000
+++ tests/unit-tests/graphics/android/test_hwc_display.cpp	2014-01-21 07:20:58 +0000
@@ -142,6 +142,56 @@
     });
 }
 
+TEST_F(AndroidDisplayBufferTest, defaults_to_normal_orientation)
+{
+    mga::DisplayBuffer db(mock_fb_bundle, mock_display_device, native_window,
+                          *gl_context);
+
+    EXPECT_EQ(mir_orientation_normal, db.orientation());
+}
+
+TEST_F(AndroidDisplayBufferTest, orientation_is_passed_through)
+{
+    mga::DisplayBuffer db(mock_fb_bundle, mock_display_device, native_window,
+                          *gl_context);
+
+    for (auto const& ori : {mir_orientation_normal,
+                            mir_orientation_left,
+                            mir_orientation_right,
+                            mir_orientation_inverted})
+    {
+        db.orient(ori);
+        EXPECT_EQ(ori, db.orientation());
+    }
+}
+
+TEST_F(AndroidDisplayBufferTest, rotation_transposes_dimensions)
+{
+    using namespace testing;
+
+    int const width = 123;
+    int const height = 456;
+    geom::Size const normal{width, height};
+    geom::Size const transposed{height, width};
+
+    EXPECT_CALL(*mock_fb_bundle, fb_size())
+        .WillRepeatedly(Return(normal));
+
+    mga::DisplayBuffer db(mock_fb_bundle, mock_display_device, native_window,
+                          *gl_context);
+
+    EXPECT_EQ(normal, db.view_area().size);
+
+    db.orient(mir_orientation_right);
+    EXPECT_EQ(transposed, db.view_area().size);
+
+    db.orient(mir_orientation_inverted);
+    EXPECT_EQ(normal, db.view_area().size);
+
+    db.orient(mir_orientation_left);
+    EXPECT_EQ(transposed, db.view_area().size);
+}
+
 TEST_F(AndroidDisplayBufferTest, test_db_forwards_size_along)
 {
     using namespace testing;

=== modified file 'tests/unit-tests/graphics/mesa/CMakeLists.txt'
--- tests/unit-tests/graphics/mesa/CMakeLists.txt	2014-01-13 06:12:33 +0000
+++ tests/unit-tests/graphics/mesa/CMakeLists.txt	2014-01-21 07:20:58 +0000
@@ -3,6 +3,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_gbm_buffer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_allocator.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_display.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_display_buffer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_display_multi_monitor.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_display_configuration.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_internal_client.cpp

=== added file 'tests/unit-tests/graphics/mesa/test_display_buffer.cpp'
--- tests/unit-tests/graphics/mesa/test_display_buffer.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/mesa/test_display_buffer.cpp	2014-01-21 07:20:58 +0000
@@ -0,0 +1,236 @@
+/*
+ * 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: Daniel van Vugt <[e-mail]>
+ */
+#include "src/platform/graphics/mesa/platform.h"
+#include "src/platform/graphics/mesa/display_buffer.h"
+#include "mir/graphics/null_display_report.h"
+#include "mir_test_doubles/mock_egl.h"
+#include "mir_test_doubles/mock_gl.h"
+#include "mir_test_doubles/null_platform.h"
+#include "mir_test_doubles/null_virtual_terminal.h"
+#include "mir_test_doubles/mock_drm.h"
+#include "mir_test_doubles/mock_gbm.h"
+#include "mir_test_framework/udev_environment.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <gbm.h>
+
+using namespace testing;
+using namespace mir;
+using namespace std;
+using namespace mir::test::doubles;
+using namespace mir::mir_test_framework;
+
+class MesaDisplayBufferTest : public Test
+{
+public:
+    MesaDisplayBufferTest()
+    {
+        ON_CALL(mock_egl, eglChooseConfig(_,_,_,1,_))
+            .WillByDefault(DoAll(SetArgPointee<2>(mock_egl.fake_configs[0]),
+                                 SetArgPointee<4>(1),
+                                 Return(EGL_TRUE)));
+
+        ON_CALL(mock_egl, eglQueryString(_,EGL_EXTENSIONS))
+            .WillByDefault(Return("EGL_KHR_image "
+                                  "EGL_KHR_image_base "
+                                  "EGL_MESA_drm_image"));
+
+        ON_CALL(mock_gl, glGetString(GL_EXTENSIONS))
+            .WillByDefault(Return(reinterpret_cast<const GLubyte*>(
+                                  "GL_OES_texture_npot "
+                                  "GL_OES_EGL_image")));
+
+        fake_bo = reinterpret_cast<gbm_bo*>(123);
+        ON_CALL(mock_gbm, gbm_surface_lock_front_buffer(_))
+            .WillByDefault(Return(fake_bo));
+        fake_handle.u32 = 123;
+        ON_CALL(mock_gbm, gbm_bo_get_handle(_))
+            .WillByDefault(Return(fake_handle));
+        ON_CALL(mock_gbm, gbm_bo_get_stride(_))
+            .WillByDefault(Return(456));
+
+        fake_devices.add_standard_drm_devices();
+    }
+
+    // The platform has an implicit dependency on mock_gbm etc so must be
+    // reconstructed locally to ensure its lifetime is shorter than mock_gbm.
+    shared_ptr<graphics::mesa::Platform> create_platform()
+    {
+        return make_shared<graphics::mesa::Platform>(
+                      make_shared<graphics::NullDisplayReport>(),
+                      make_shared<NullVirtualTerminal>());
+    }
+
+protected:
+    NiceMock<MockGBM> mock_gbm;
+    NiceMock<MockEGL> mock_egl;
+    NiceMock<MockGL>  mock_gl;
+    NiceMock<MockDRM> mock_drm; 
+    gbm_bo*           fake_bo;
+    gbm_bo_handle     fake_handle;
+    UdevEnvironment   fake_devices;
+};
+
+TEST_F(MesaDisplayBufferTest, unrotated_view_area_is_untouched)
+{
+    geometry::Rectangle const area{{12,34}, {56,78}};
+
+    graphics::mesa::DisplayBuffer db(
+        create_platform(),
+        make_shared<graphics::NullDisplayReport>(),
+        {},
+        nullptr,
+        area,
+        mir_orientation_normal,
+        mock_egl.fake_egl_context);
+
+    EXPECT_EQ(area, db.view_area());
+}
+
+TEST_F(MesaDisplayBufferTest, normal_orientation_can_bypass)
+{
+    geometry::Rectangle const area{{12,34}, {56,78}};
+
+    graphics::mesa::DisplayBuffer db(
+        create_platform(),
+        make_shared<graphics::NullDisplayReport>(),
+        {},
+        nullptr,
+        area,
+        mir_orientation_normal,
+        mock_egl.fake_egl_context);
+
+    EXPECT_TRUE(db.can_bypass());
+}
+
+TEST_F(MesaDisplayBufferTest, rotated_cannot_bypass)
+{
+    geometry::Rectangle const area{{12,34}, {56,78}};
+
+    graphics::mesa::DisplayBuffer db(
+        create_platform(),
+        make_shared<graphics::NullDisplayReport>(),
+        {},
+        nullptr,
+        area,
+        mir_orientation_right,
+        mock_egl.fake_egl_context);
+
+    EXPECT_FALSE(db.can_bypass());
+}
+
+TEST_F(MesaDisplayBufferTest, orientation_not_implemented_internally)
+{
+    geometry::Rectangle const area{{12,34}, {56,78}};
+
+    graphics::mesa::DisplayBuffer db(
+        create_platform(),
+        make_shared<graphics::NullDisplayReport>(),
+        {},
+        nullptr,
+        area,
+        mir_orientation_left,
+        mock_egl.fake_egl_context);
+
+    EXPECT_EQ(mir_orientation_left, db.orientation());
+}
+
+TEST_F(MesaDisplayBufferTest, normal_rotation_constructs_normal_fb)
+{
+    int const width = 56;
+    int const height = 78;
+    geometry::Rectangle const area{{12,34}, {width,height}};
+
+    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
+        .WillOnce(Return((void*)0));
+    EXPECT_CALL(mock_drm, drmModeAddFB(_, width, height, _, _, _, _, _))
+        .Times(1);
+
+    graphics::mesa::DisplayBuffer db(
+        create_platform(),
+        make_shared<graphics::NullDisplayReport>(),
+        {},
+        nullptr,
+        area,
+        mir_orientation_normal,
+        mock_egl.fake_egl_context);
+}
+
+TEST_F(MesaDisplayBufferTest, left_rotation_constructs_transposed_fb)
+{
+    int const width = 56;
+    int const height = 78;
+    geometry::Rectangle const area{{12,34}, {width,height}};
+
+    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
+        .WillOnce(Return((void*)0));
+    EXPECT_CALL(mock_drm, drmModeAddFB(_, height, width, _, _, _, _, _))
+        .Times(1);
+
+    graphics::mesa::DisplayBuffer db(
+        create_platform(),
+        make_shared<graphics::NullDisplayReport>(),
+        {},
+        nullptr,
+        area,
+        mir_orientation_left,
+        mock_egl.fake_egl_context);
+}
+
+TEST_F(MesaDisplayBufferTest, inverted_rotation_constructs_normal_fb)
+{
+    int const width = 56;
+    int const height = 78;
+    geometry::Rectangle const area{{12,34}, {width,height}};
+
+    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
+        .WillOnce(Return((void*)0));
+    EXPECT_CALL(mock_drm, drmModeAddFB(_, width, height, _, _, _, _, _))
+        .Times(1);
+
+    graphics::mesa::DisplayBuffer db(
+        create_platform(),
+        make_shared<graphics::NullDisplayReport>(),
+        {},
+        nullptr,
+        area,
+        mir_orientation_inverted,
+        mock_egl.fake_egl_context);
+}
+
+TEST_F(MesaDisplayBufferTest, right_rotation_constructs_transposed_fb)
+{
+    int const width = 56;
+    int const height = 78;
+    geometry::Rectangle const area{{12,34}, {width,height}};
+
+    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
+        .WillOnce(Return((void*)0));
+    EXPECT_CALL(mock_drm, drmModeAddFB(_, height, width, _, _, _, _, _))
+        .Times(1);
+
+    graphics::mesa::DisplayBuffer db(
+        create_platform(),
+        make_shared<graphics::NullDisplayReport>(),
+        {},
+        nullptr,
+        area,
+        mir_orientation_right,
+        mock_egl.fake_egl_context);
+}

=== modified file 'tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp'
--- tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp	2013-11-18 12:35:14 +0000
+++ tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp	2014-01-21 07:20:58 +0000
@@ -83,6 +83,29 @@
         std::make_shared<mg::NullDisplayReport>()};
 }
 
+TEST_F(OffscreenDisplayTest, orientation_normal)
+{
+    using namespace ::testing;
+
+    EGLNativeDisplayType const native_display{
+        reinterpret_cast<EGLNativeDisplayType>(0x12345)};
+
+    mgo::Display display{
+        std::make_shared<StubBasicPlatform>(native_display),
+        std::make_shared<mg::DefaultDisplayConfigurationPolicy>(),
+        std::make_shared<mg::NullDisplayReport>()};
+
+    int count = 0;
+    display.for_each_display_buffer(
+        [&](mg::DisplayBuffer& db)
+        {
+            ++count;
+            EXPECT_EQ(mir_orientation_normal, db.orientation());
+        });
+
+    EXPECT_TRUE(count);
+}
+
 TEST_F(OffscreenDisplayTest, makes_fbo_current_rendering_target)
 {
     using namespace ::testing;