Merge lp:~kdub/mir/mesa-display-group into lp:mir

[Kevin DuBois]

mesa: split the mgm::DisplayBuffer into mgm::DisplayGroup, which handles posting to screen, and mgm::DisplayBuffer, which tracks the intended content.

mesa: split the mgm::DisplayBuffer into mgm::DisplayGroup, which handles posting to screen, and mgm::DisplayBuffer, which tracks the intended content.

notes: This is mostly splitting the code into two different classes. DisplayGroup is now nicely concerned only with posting, and DisplayBuffer is now nicely concerned only with the content.

lines 252-284 were moved to buffer_object.cpp and buffer_object.h
lines 289-542 were moved to display_group.cpp and display_group.h

[lp:~kdub/mir/mesa-display-group]

2292. By Kevin DuBois on 2015-02-10

merge base

[Daniel van Vugt (vanvugt)]

I had planned to split Mesa DisplayBuffer into a generic DRMDisplayBuffer and MesaDisplayBuffer. So it's then obvious and demonstrated that Mir doesn't need any OpenGL to work. And Mir could be run without any GL support at all (e.g. fullscreen system compositors without effects).

But this might make that more difficult...?

Not sure yet, but make sure not to create any coupling between swap buffers and posting. I've been slowly teasing them apart and will continue to do so more clearly in future.

review: Needs Information

Unmerged revisions

2292. By Kevin DuBois on 2015-02-10

merge base

2291. By Kevin DuBois on 2015-02-10

add back some code that helps with rotation

2290. By Kevin DuBois on 2015-02-09

split out classes and headers as needed

2289. By Kevin DuBois on 2015-02-09

split out displaybuffer from displaygroup on mesa

=== modified file 'src/platforms/mesa/server/CMakeLists.txt'
--- src/platforms/mesa/server/CMakeLists.txt	2015-02-04 08:45:38 +0000
+++ src/platforms/mesa/server/CMakeLists.txt	2015-02-10 18:28:23 +0000
@@ -27,6 +27,7 @@
   real_kms_display_configuration.cpp
   drm_mode_resources.cpp
   display_buffer.cpp
+  display_group.cpp
   real_kms_output.cpp
   real_kms_output_container.cpp
   kms_page_flipper.cpp
@@ -38,6 +39,7 @@
   bypass.cpp
   ipc_operations.cpp
   nested_authentication.cpp
+  buffer_object.cpp
 )
 
 add_library(
 
=== added file 'src/platforms/mesa/server/buffer_object.cpp'
--- src/platforms/mesa/server/buffer_object.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mesa/server/buffer_object.cpp	2015-02-10 18:28:23 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "buffer_object.h"
+#include <xf86drmMode.h>
+
+namespace mgm = mir::graphics::mesa;
+
+mgm::BufferObject::BufferObject(gbm_surface* surface, gbm_bo* bo, uint32_t drm_fb_id) :
+    surface{surface}, bo{bo}, drm_fb_id{drm_fb_id}
+{
+}
+
+mgm::BufferObject::~BufferObject()
+{
+    if (drm_fb_id)
+    {
+        int drm_fd = gbm_device_get_fd(gbm_bo_get_device(bo));
+        drmModeRmFB(drm_fd, drm_fb_id);
+    }
+}
+
+void mgm::BufferObject::release() const
+{
+    gbm_surface_release_buffer(surface, bo);
+}
+
+uint32_t mgm::BufferObject::get_drm_fb_id() const
+{
+    return drm_fb_id;
+}
 
=== added file 'src/platforms/mesa/server/buffer_object.h'
--- src/platforms/mesa/server/buffer_object.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mesa/server/buffer_object.h	2015-02-10 18:28:23 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_MESA_BUFFER_OBJECT_H_
+#define MIR_GRAPHICS_MESA_BUFFER_OBJECT_H_
+
+#include <stddef.h>
+#include <gbm.h>
+
+namespace mir
+{
+namespace graphics
+{
+namespace mesa
+{
+class BufferObject
+{
+public:
+    BufferObject(gbm_surface* surface, gbm_bo* bo, uint32_t drm_fb_id);
+    ~BufferObject();
+
+    void release() const;
+    uint32_t get_drm_fb_id() const;
+private:
+    BufferObject(BufferObject const&) = delete;
+    BufferObject& operator=(BufferObject const&) = delete;
+
+    gbm_surface *surface;
+    gbm_bo *bo;
+    uint32_t drm_fb_id;
+};
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_MESA_BUFFER_OBJECT_H_ */
 
=== modified file 'src/platforms/mesa/server/display.cpp'
--- src/platforms/mesa/server/display.cpp	2015-02-10 18:28:22 +0000
+++ src/platforms/mesa/server/display.cpp	2015-02-10 18:28:23 +0000
@@ -19,7 +19,7 @@
 #include "display.h"
 #include "cursor.h"
 #include "platform.h"
-#include "display_buffer.h"
+#include "display_group.h"
 #include "kms_display_configuration.h"
 #include "kms_output.h"
 #include "kms_page_flipper.h"
@@ -118,8 +118,8 @@
 {
     std::lock_guard<std::mutex> lg{configuration_mutex};
 
-    for (auto& db_ptr : display_buffers)
-        f(*db_ptr);
+    for (auto& dg_ptr : display_groups)
+        f(*dg_ptr);
 }
 
 std::unique_ptr<mg::DisplayConfiguration> mgm::Display::configuration() const
@@ -149,7 +149,7 @@
         // before it's fully constructed, to force proper initialization.
         bool const comp{(&conf != &current_display_configuration) &&
                         compatible(kms_conf, current_display_configuration)};
-        std::vector<std::unique_ptr<DisplayBuffer>> display_buffers_new;
+        std::vector<std::unique_ptr<DisplayGroup>> display_groups_new;
 
         if (!comp)
         {
@@ -161,8 +161,8 @@
              * sure we wait for all pending page flips to finish before the
              * display_buffers_new are created and take control of the outputs.
              */
-            for (auto& db : display_buffers)
-                db->wait_for_page_flip();
+            for (auto& dg : display_groups)
+                dg->wait_for_page_flip();
 
             /* Reset the state of all outputs */
             kms_conf.for_each_output([&](DisplayConfigurationOutput const& conf_output)
@@ -207,7 +207,7 @@
 
             if (comp)
             {
-                display_buffers[group_idx++]->set_orientation(orientation, bounding_rect);
+                display_groups[group_idx++]->set_orientation(orientation, bounding_rect);
             }
             else
             {
@@ -221,8 +221,8 @@
 
                 auto surface = platform->gbm.create_scanout_surface(width, height);
 
-                std::unique_ptr<DisplayBuffer> db{
-                    new DisplayBuffer{platform, listener,
+                std::unique_ptr<DisplayGroup> dg{
+                    new DisplayGroup{platform, listener,
                                       kms_outputs,
                                       std::move(surface),
                                       bounding_rect,
@@ -230,12 +230,12 @@
                                       *gl_config,
                                       shared_egl.context()}};
 
-                display_buffers_new.push_back(std::move(db));
+                display_groups_new.push_back(std::move(dg));
             }
         });
 
         if (!comp)
-            display_buffers = std::move(display_buffers_new);
+            display_groups = std::move(display_groups_new);
 
         /* Store applied configuration */
         current_display_configuration = kms_conf;
@@ -307,7 +307,7 @@
          * we need to reset the CRTCs. For active displays we schedule a CRTC reset
          * on the next swap. For connected but unused outputs we clear the CRTC.
          */
-        for (auto& db_ptr : display_buffers)
+        for (auto& db_ptr : display_groups)
             db_ptr->schedule_set_crtc();
 
         clear_connected_unused_outputs();
 
=== modified file 'src/platforms/mesa/server/display.h'
--- src/platforms/mesa/server/display.h	2015-02-10 18:28:22 +0000
+++ src/platforms/mesa/server/display.h	2015-02-10 18:28:23 +0000
@@ -23,6 +23,7 @@
 #include "real_kms_output_container.h"
 #include "real_kms_display_configuration.h"
 #include "display_helpers.h"
+#include "display_group.h"
 
 #include <mutex>
 
@@ -90,7 +91,7 @@
     std::shared_ptr<DisplayReport> const listener;
     mir::udev::Monitor monitor;
     helpers::EGLHelper shared_egl;
-    std::vector<std::unique_ptr<DisplayBuffer>> display_buffers;
+    std::vector<std::unique_ptr<DisplayGroup>> display_groups;
     RealKMSOutputContainer output_container;
     mutable RealKMSDisplayConfiguration current_display_configuration;
     
 
=== modified file 'src/platforms/mesa/server/display_buffer.cpp'
--- src/platforms/mesa/server/display_buffer.cpp	2015-02-10 18:28:22 +0000
+++ src/platforms/mesa/server/display_buffer.cpp	2015-02-10 18:28:23 +0000
@@ -22,6 +22,7 @@
 #include "mir/graphics/display_report.h"
 #include "bypass.h"
 #include "gbm_buffer.h"
+#include "buffer_object.h"
 #include "mir/fatal.h"
 
 #include <boost/throw_exception.hpp>
@@ -32,39 +33,6 @@
 namespace mgm = mir::graphics::mesa;
 namespace geom = mir::geometry;
 
-class mgm::BufferObject
-{
-public:
-    BufferObject(gbm_surface* surface, gbm_bo* bo, uint32_t drm_fb_id)
-        : surface{surface}, bo{bo}, drm_fb_id{drm_fb_id}
-    {
-    }
-
-    ~BufferObject()
-    {
-        if (drm_fb_id)
-        {
-            int drm_fd = gbm_device_get_fd(gbm_bo_get_device(bo));
-            drmModeRmFB(drm_fd, drm_fb_id);
-        }
-    }
-
-    void release() const
-    {
-        gbm_surface_release_buffer(surface, bo);
-    }
-
-    uint32_t get_drm_fb_id() const
-    {
-        return drm_fb_id;
-    }
-
-private:
-    gbm_surface *surface;
-    gbm_bo *bo;
-    uint32_t drm_fb_id;
-};
-
 namespace
 {
 
@@ -90,24 +58,17 @@
 mgm::DisplayBuffer::DisplayBuffer(
     std::shared_ptr<Platform> const& platform,
     std::shared_ptr<DisplayReport> const& listener,
-    std::vector<std::shared_ptr<KMSOutput>> const& outputs,
     GBMSurfaceUPtr surface_gbm_param,
     geom::Rectangle const& area,
     MirOrientation rot,
     GLConfig const& gl_config,
-    EGLContext shared_context)
-    : last_flipped_bufobj{nullptr},
-      scheduled_bufobj{nullptr},
-      platform(platform),
-      listener(listener),
-      drm(*platform->drm),
-      outputs(outputs),
-      surface_gbm{std::move(surface_gbm_param)},
-      egl{gl_config},
-      area(area),
-      rotation(rot),
-      needs_set_crtc{false},
-      page_flips_pending{false}
+    EGLContext shared_context) :
+    platform_bypass_option{platform->bypass_option()},
+    drm(*platform->drm),
+    surface_gbm{std::move(surface_gbm_param)},
+    egl{gl_config},
+    area(area),
+    rotation(rot)
 {
     uint32_t area_width = area.size.width.as_uint32_t();
     uint32_t area_height = area.size.height.as_uint32_t();
@@ -139,16 +100,6 @@
 
     listener->report_successful_egl_buffer_swap_on_construction();
 
-    scheduled_bufobj = get_front_buffer_object();
-    if (!scheduled_bufobj)
-        fatal_error("Failed to get frontbuffer");
-
-    for (auto& output : outputs)
-    {
-        if (!output->set_crtc(scheduled_bufobj->get_drm_fb_id()))
-            fatal_error("Failed to set DRM crtc");
-    }
-
     egl.release_current();
 
     listener->report_successful_drm_mode_set_crtc_on_construction();
@@ -160,19 +111,6 @@
         });
 }
 
-mgm::DisplayBuffer::~DisplayBuffer()
-{
-    /*
-     * There is no need to destroy last_flipped_bufobj manually.
-     * It will be destroyed when its gbm_surface gets destroyed.
-     */
-    if (last_flipped_bufobj)
-        last_flipped_bufobj->release();
-
-    if (scheduled_bufobj)
-        scheduled_bufobj->release();
-}
-
 geom::Rectangle mgm::DisplayBuffer::view_area() const
 {
     return area;
@@ -198,7 +136,7 @@
 bool mgm::DisplayBuffer::post_renderables_if_optimizable(RenderableList const& renderable_list)
 {
     if ((rotation == mir_orientation_normal) &&
-       (platform->bypass_option() == mgm::BypassOption::allowed))
+        (platform_bypass_option == mgm::BypassOption::allowed))
     {
         mgm::BypassMatch bypass_match(area);
         auto bypass_it = std::find_if(renderable_list.rbegin(), renderable_list.rend(), bypass_match);
@@ -227,12 +165,6 @@
     return false;
 }
 
-void mgm::DisplayBuffer::for_each_display_buffer(
-    std::function<void(graphics::DisplayBuffer&)> const& f)
-{
-    f(*this);
-}
-
 void mgm::DisplayBuffer::gl_swap_buffers()
 {
     if (!egl.swap_buffers())
@@ -241,120 +173,6 @@
     bypass_bufobj = nullptr;
 }
 
-void mgm::DisplayBuffer::post()
-{
-    /*
-     * We might not have waited for the previous frame to page flip yet.
-     * This is good because it maximizes the time available to spend rendering
-     * each frame. Just remember wait_for_page_flip() must be called at some
-     * point before the next schedule_page_flip().
-     */
-    wait_for_page_flip();
-
-    /*
-     * Switching from bypass to compositing? Now is the earliest safe time
-     * we can unreference the bypass buffer...
-     */
-    if (scheduled_bufobj)
-        last_flipped_bypass_buf = nullptr;
-    /*
-     * Release the last flipped buffer object (which is not displayed anymore)
-     * to make it available for future rendering.
-     */
-    if (last_flipped_bufobj)
-        last_flipped_bufobj->release();
-
-    last_flipped_bufobj = scheduled_bufobj;
-    scheduled_bufobj = nullptr;
-
-    mgm::BufferObject *bufobj;
-    if (bypass_buf)
-    {
-        bufobj = bypass_bufobj;
-    }
-    else
-    {
-        bufobj = get_front_buffer_object();
-        if (!bufobj)
-            fatal_error("Failed to get front buffer object");
-    }
-
-    /*
-     * Schedule the current front buffer object for display, and wait
-     * for it to be actually displayed (flipped).
-     *
-     * If the flip fails, release the buffer object to make it available
-     * for future rendering.
-     */
-    if (!needs_set_crtc && !schedule_page_flip(bufobj))
-    {
-        if (!bypass_buf)
-            bufobj->release();
-        fatal_error("Failed to schedule page flip");
-    }
-    else if (needs_set_crtc)
-    {
-        for (auto& output : outputs)
-        {
-            if (!output->set_crtc(bufobj->get_drm_fb_id()))
-                fatal_error("Failed to set DRM crtc");
-        }
-        needs_set_crtc = false;
-    }
-
-    if (bypass_buf)
-    {
-        /*
-         * For composited frames we defer wait_for_page_flip till just before
-         * the next frame, but not for bypass frames. Deferring the flip of
-         * bypass frames would increase the time we held
-         * last_flipped_bypass_buf unacceptably, resulting in client stuttering
-         * unless we allocate more buffers (which I'm trying to avoid).
-         * Also, bypass does not need the deferred page flip because it has
-         * no compositing/rendering step for which to save time for.
-         */
-        wait_for_page_flip();
-        scheduled_bufobj = nullptr;
-
-        /*
-         * 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 while its on-screen, which would be seen as tearing or
-         * worse.
-         */
-        last_flipped_bypass_buf = bypass_buf;
-    }
-    else
-    {
-        /*
-         * Not in clone mode? We can afford to wait for the page flip then,
-         * making us double-buffered (noticeably less laggy than the triple
-         * buffering that clone mode requires).
-         */
-        if (outputs.size() == 1)
-        {
-            wait_for_page_flip();
-
-            /*
-             * bufobj is now physically on screen. Release the old frame...
-             */
-            if (last_flipped_bufobj)
-            {
-                last_flipped_bufobj->release();
-                last_flipped_bufobj = nullptr;
-            }
-
-            /*
-             * last_flipped_bufobj will be set correctly on the next iteration
-             * Don't do it here or else bufobj would be released while still
-             * on screen (hence tearing and artefacts).
-             */
-        }
-
-        scheduled_bufobj = bufobj;
-    }
-}
-
 mgm::BufferObject* mgm::DisplayBuffer::get_front_buffer_object()
 {
     auto front = gbm_surface_lock_front_buffer(surface_gbm.get());
@@ -408,33 +226,6 @@
     return bufobj;
 }
 
-
-bool mgm::DisplayBuffer::schedule_page_flip(BufferObject* bufobj)
-{
-    /*
-     * Schedule the current front buffer object for display. Note that
-     * the page flip is asynchronous and synchronized with vertical refresh.
-     */
-    for (auto& output : outputs)
-    {
-        if (output->schedule_page_flip(bufobj->get_drm_fb_id()))
-            page_flips_pending = true;
-    }
-
-    return page_flips_pending;
-}
-
-void mgm::DisplayBuffer::wait_for_page_flip()
-{
-    if (page_flips_pending)
-    {
-        for (auto& output : outputs)
-            output->wait_for_page_flip();
-
-        page_flips_pending = false;
-    }
-}
-
 void mgm::DisplayBuffer::make_current()
 {
     if (!egl.make_current())
@@ -448,8 +239,23 @@
     egl.release_current();
 }
 
-void mgm::DisplayBuffer::schedule_set_crtc()
-{
-    needs_set_crtc = true;
-}
-
+
+std::shared_ptr<mir::graphics::Buffer> mgm::DisplayBuffer::bypass_buffer()
+{
+    return bypass_buf;
+}
+
+mgm::BufferObject* mgm::DisplayBuffer::buffer_obj_to_be_posted()
+{
+    if (bypass_buf)
+    {
+        return bypass_bufobj;
+    }
+    else
+    {
+        auto bufobj = get_front_buffer_object();
+        if (!bufobj)
+            fatal_error("Failed to get front buffer object");
+        return bufobj;
+    }
+}
 
=== modified file 'src/platforms/mesa/server/display_buffer.h'
--- src/platforms/mesa/server/display_buffer.h	2015-02-10 18:28:22 +0000
+++ src/platforms/mesa/server/display_buffer.h	2015-02-10 18:28:23 +0000
@@ -22,10 +22,10 @@
 #include "mir/graphics/display_buffer.h"
 #include "mir/graphics/display.h"
 #include "display_helpers.h"
+#include "platform.h"
 
 #include <vector>
 #include <memory>
-#include <atomic>
 
 namespace mir
 {
@@ -40,21 +40,17 @@
 
 class Platform;
 class BufferObject;
-class KMSOutput;
 
-class DisplayBuffer : public graphics::DisplayBuffer,
-                      public graphics::DisplayGroup
+class DisplayBuffer : public graphics::DisplayBuffer
 {
 public:
     DisplayBuffer(std::shared_ptr<Platform> const& platform,
                   std::shared_ptr<DisplayReport> const& listener,
-                  std::vector<std::shared_ptr<KMSOutput>> const& outputs,
                   GBMSurfaceUPtr surface_gbm,
                   geometry::Rectangle const& area,
                   MirOrientation rot,
                   GLConfig const& gl_config,
                   EGLContext shared_context);
-    ~DisplayBuffer();
 
     geometry::Rectangle view_area() const override;
     void make_current() override;
@@ -62,38 +58,29 @@
     void gl_swap_buffers() override;
     bool post_renderables_if_optimizable(RenderableList const& renderlist) override;
 
-    void for_each_display_buffer(
-        std::function<void(graphics::DisplayBuffer&)> const& f) override;
-    void post() override;
-
     MirOrientation orientation() const override;
     void set_orientation(MirOrientation const rot, geometry::Rectangle const& a);
     bool uses_alpha() const override;
-    void schedule_set_crtc();
-    void wait_for_page_flip();
+
+    std::shared_ptr<graphics::Buffer> bypass_buffer();
+    BufferObject* buffer_obj_to_be_posted();
 
 private:
     BufferObject* get_front_buffer_object();
     BufferObject* get_buffer_object(struct gbm_bo *bo);
-    bool schedule_page_flip(BufferObject* bufobj);
 
-    BufferObject* last_flipped_bufobj;
-    BufferObject* scheduled_bufobj;
-    std::shared_ptr<graphics::Buffer> last_flipped_bypass_buf;
     std::shared_ptr<Buffer> bypass_buf{nullptr};
     BufferObject* bypass_bufobj{nullptr};
-    std::shared_ptr<Platform> const platform;
-    std::shared_ptr<DisplayReport> const listener;
+
+    BypassOption platform_bypass_option;
+
     /* DRM helper from mgm::Platform */
     helpers::DRMHelper& drm;
-    std::vector<std::shared_ptr<KMSOutput>> outputs;
     GBMSurfaceUPtr surface_gbm;
     helpers::EGLHelper egl;
     geometry::Rectangle area;
     uint32_t fb_width, fb_height;
     MirOrientation rotation;
-    std::atomic<bool> needs_set_crtc;
-    bool page_flips_pending;
 };
 
 }
 
=== added file 'src/platforms/mesa/server/display_group.cpp'
--- src/platforms/mesa/server/display_group.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mesa/server/display_group.cpp	2015-02-10 18:28:23 +0000
@@ -0,0 +1,219 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "display_group.h"
+#include "buffer_object.h"
+
+#include "platform.h"
+#include "kms_output.h"
+#include "mir/graphics/display_report.h"
+#include "bypass.h"
+#include "gbm_buffer.h"
+#include "mir/fatal.h"
+#include <boost/throw_exception.hpp>
+#include <GLES2/gl2.h>
+
+#include <stdexcept>
+
+namespace mgm = mir::graphics::mesa;
+namespace geom = mir::geometry;
+
+mgm::DisplayGroup::DisplayGroup(
+    std::shared_ptr<Platform> const& platform,
+    std::shared_ptr<DisplayReport> const& listener,
+    std::vector<std::shared_ptr<KMSOutput>> const& outputs,
+    GBMSurfaceUPtr surface_gbm,
+    geometry::Rectangle const& area,
+    MirOrientation rot,
+    GLConfig const& gl_config,
+    EGLContext shared_context) :
+    db{platform, listener, std::move(surface_gbm), area, rot, gl_config, shared_context},
+    platform(platform),
+    listener(listener),
+    needs_set_crtc{false},
+    page_flips_pending{false},
+    outputs(outputs),
+    last_flipped_bufobj{nullptr},
+    scheduled_bufobj{db.buffer_obj_to_be_posted()},
+    last_flipped_bypass_buf{nullptr}
+{
+    for (auto& output : outputs)
+    {
+        if (!output->set_crtc(scheduled_bufobj->get_drm_fb_id()))
+            fatal_error("Failed to set DRM crtc");
+    }
+}
+
+mgm::DisplayGroup::~DisplayGroup()
+{
+    /*
+     * There is no need to destroy last_flipped_bufobj manually.
+     * It will be destroyed when its gbm_surface gets destroyed.
+     */
+    if (last_flipped_bufobj)
+        last_flipped_bufobj->release();
+
+    if (scheduled_bufobj)
+        scheduled_bufobj->release();
+}
+
+void mgm::DisplayGroup::for_each_display_buffer(
+    std::function<void(graphics::DisplayBuffer&)> const& f)
+{
+    f(db);
+}
+
+void mgm::DisplayGroup::post()
+{
+    /*
+     * We might not have waited for the previous frame to page flip yet.
+     * This is good because it maximizes the time available to spend rendering
+     * each frame. Just remember wait_for_page_flip() must be called at some
+     * point before the next schedule_page_flip().
+     */
+    wait_for_page_flip();
+
+    /*
+     * Switching from bypass to compositing? Now is the earliest safe time
+     * we can unreference the bypass buffer...
+     */
+    if (scheduled_bufobj)
+        last_flipped_bypass_buf = nullptr;
+    /*
+     * Release the last flipped buffer object (which is not displayed anymore)
+     * to make it available for future rendering.
+     */
+    if (last_flipped_bufobj)
+        last_flipped_bufobj->release();
+
+    last_flipped_bufobj = scheduled_bufobj;
+    scheduled_bufobj = nullptr;
+
+    mgm::BufferObject *bufobj = db.buffer_obj_to_be_posted();
+    auto bypass_buffer = db.bypass_buffer();
+    /*
+     * Schedule the current front buffer object for display, and wait
+     * for it to be actually displayed (flipped).
+     *
+     * If the flip fails, release the buffer object to make it available
+     * for future rendering.
+     */
+    if (!needs_set_crtc && !schedule_page_flip(bufobj))
+    {
+        if (!bypass_buffer)
+            bufobj->release();
+        fatal_error("Failed to schedule page flip");
+    }
+    else if (needs_set_crtc)
+    {
+        for (auto& output : outputs)
+        {
+            if (!output->set_crtc(bufobj->get_drm_fb_id()))
+                fatal_error("Failed to set DRM crtc");
+        }
+        needs_set_crtc = false;
+    }
+
+    if (bypass_buffer)
+    {
+        /*
+         * For composited frames we defer wait_for_page_flip till just before
+         * the next frame, but not for bypass frames. Deferring the flip of
+         * bypass frames would increase the time we held
+         * last_flipped_bypass_buf unacceptably, resulting in client stuttering
+         * unless we allocate more buffers (which I'm trying to avoid).
+         * Also, bypass does not need the deferred page flip because it has
+         * no compositing/rendering step for which to save time for.
+         */
+        wait_for_page_flip();
+        scheduled_bufobj = nullptr;
+
+        /*
+         * 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 while its on-screen, which would be seen as tearing or
+         * worse.
+         */
+        last_flipped_bypass_buf = db.bypass_buffer();
+    }
+    else
+    {
+        /*
+         * Not in clone mode? We can afford to wait for the page flip then,
+         * making us double-buffered (noticeably less laggy than the triple
+         * buffering that clone mode requires).
+         */
+        if (outputs.size() == 1)
+        {
+            wait_for_page_flip();
+
+            /*
+             * bufobj is now physically on screen. Release the old frame...
+             */
+            if (last_flipped_bufobj)
+            {
+                last_flipped_bufobj->release();
+                last_flipped_bufobj = nullptr;
+            }
+
+            /*
+             * last_flipped_bufobj will be set correctly on the next iteration
+             * Don't do it here or else bufobj would be released while still
+             * on screen (hence tearing and artefacts).
+             */
+        }
+
+        scheduled_bufobj = bufobj;
+    }
+}
+
+void mgm::DisplayGroup::schedule_set_crtc()
+{
+    needs_set_crtc = true;
+}
+
+bool mgm::DisplayGroup::schedule_page_flip(BufferObject* bufobj)
+{
+    /*
+     * Schedule the current front buffer object for display. Note that
+     * the page flip is asynchronous and synchronized with vertical refresh.
+     */
+    for (auto& output : outputs)
+    {
+        if (output->schedule_page_flip(bufobj->get_drm_fb_id()))
+            page_flips_pending = true;
+    }
+
+    return page_flips_pending;
+}
+
+void mgm::DisplayGroup::wait_for_page_flip()
+{
+    if (page_flips_pending)
+    {
+        for (auto& output : outputs)
+            output->wait_for_page_flip();
+
+        page_flips_pending = false;
+    }
+}
+
+void mgm::DisplayGroup::set_orientation(MirOrientation const rot, geometry::Rectangle const& a)
+{
+    db.set_orientation(rot, a);
+}
 
=== added file 'src/platforms/mesa/server/display_group.h'
--- src/platforms/mesa/server/display_group.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mesa/server/display_group.h	2015-02-10 18:28:23 +0000
@@ -0,0 +1,86 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_MESA_DISPLAY_GROUP_H_
+#define MIR_GRAPHICS_MESA_DISPLAY_GROUP_H_
+
+#include "mir/graphics/display.h"
+#include "display_buffer.h"
+
+#include <vector>
+#include <memory>
+#include <atomic>
+
+namespace mir
+{
+namespace graphics
+{
+
+class DisplayReport;
+class GLConfig;
+
+namespace mesa
+{
+
+class Platform;
+class BufferObject;
+class KMSOutput;
+
+class DisplayGroup : public graphics::DisplayGroup
+{
+public:
+    DisplayGroup(
+        std::shared_ptr<Platform> const& platform,
+        std::shared_ptr<DisplayReport> const& listener,
+        std::vector<std::shared_ptr<KMSOutput>> const& outputs,
+        GBMSurfaceUPtr surface_gbm,
+        geometry::Rectangle const& area,
+        MirOrientation rot,
+        GLConfig const& gl_config,
+        EGLContext shared_context);
+    ~DisplayGroup();
+
+    void for_each_display_buffer(
+        std::function<void(graphics::DisplayBuffer&)> const& f) override;
+    void post() override;
+
+    void schedule_set_crtc();
+    void wait_for_page_flip();
+    void set_orientation(MirOrientation const rot, geometry::Rectangle const& a);
+
+private:
+    bool schedule_page_flip(BufferObject* bufobj);
+
+    DisplayBuffer db;
+    std::shared_ptr<Platform> const platform;
+    std::shared_ptr<DisplayReport> const listener;
+
+    std::atomic<bool> needs_set_crtc;
+    bool page_flips_pending;
+    std::vector<std::shared_ptr<KMSOutput>> outputs;
+
+    BufferObject* last_flipped_bufobj;
+    BufferObject* scheduled_bufobj;
+    std::shared_ptr<graphics::Buffer> last_flipped_bypass_buf;
+};
+
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_MESA_DISPLAY_GROUP_H_ */
 
=== modified file 'tests/unit-tests/graphics/mesa/CMakeLists.txt'
--- tests/unit-tests/graphics/mesa/CMakeLists.txt	2015-01-21 07:34:50 +0000
+++ tests/unit-tests/graphics/mesa/CMakeLists.txt	2015-02-10 18:28:23 +0000
@@ -17,6 +17,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_bypass.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_ipc_operations.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_nested_authentication.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_display_group.cpp
   $<TARGET_OBJECTS:mirplatformgraphicsmesaobjects>
 )
 
 
=== modified file 'tests/unit-tests/graphics/mesa/test_display_buffer.cpp'
--- tests/unit-tests/graphics/mesa/test_display_buffer.cpp	2015-02-10 18:28:22 +0000
+++ tests/unit-tests/graphics/mesa/test_display_buffer.cpp	2015-02-10 18:28:23 +0000
@@ -28,7 +28,6 @@
 #include "mir_test_doubles/stub_gbm_native_buffer.h"
 #include "mir_test_framework/udev_environment.h"
 #include "mir_test_doubles/fake_renderable.h"
-#include "mock_kms_output.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -73,12 +72,6 @@
 
         fake_devices.add_standard_device("standard-drm-devices");
 
-        mock_kms_output = std::make_shared<NiceMock<MockKMSOutput>>();
-        ON_CALL(*mock_kms_output, set_crtc(_))
-            .WillByDefault(Return(true));
-        ON_CALL(*mock_kms_output, schedule_page_flip(_))
-            .WillByDefault(Return(true));
-
         ON_CALL(*mock_bypassable_buffer, size())
             .WillByDefault(Return(display_area.size));
         ON_CALL(*mock_bypassable_buffer, can_bypass())
@@ -109,7 +102,6 @@
     gbm_bo*           fake_bo;
     gbm_bo_handle     fake_handle;
     UdevEnvironment   fake_devices;
-    std::shared_ptr<MockKMSOutput> mock_kms_output;
     StubGLConfig gl_config;
     mir::graphics::RenderableList const bypassable_list;
 
@@ -120,7 +112,6 @@
     graphics::mesa::DisplayBuffer db(
         create_platform(),
         null_display_report(),
-        {},
         nullptr,
         display_area,
         mir_orientation_normal,
@@ -135,7 +126,6 @@
     graphics::mesa::DisplayBuffer db(
         create_platform(),
         null_display_report(),
-        {mock_kms_output},
         nullptr,
         display_area,
         mir_orientation_normal,
@@ -148,20 +138,20 @@
 TEST_F(MesaDisplayBufferTest, failed_bypass_falls_back_gracefully)
 {  // Regression test for LP: #1398296
     EXPECT_CALL(mock_drm, drmModeAddFB2(_, _, _, _, _, _, _, _, _))
-        .WillOnce(Return(0))    // During the DisplayBuffer constructor
-        .WillOnce(Return(-22))  // Fail first bypass attempt
-        .WillOnce(Return(0));   // Succeed second bypass attempt
+        .WillOnce(Return(0))
+        .WillOnce(Return(-22))
+        .WillOnce(Return(0));
 
     graphics::mesa::DisplayBuffer db(
         create_platform(),
         null_display_report(),
-        {mock_kms_output},
         nullptr,
         display_area,
         mir_orientation_normal,
         gl_config,
         mock_egl.fake_egl_context);
 
+    EXPECT_TRUE(db.post_renderables_if_optimizable(bypassable_list));
     EXPECT_FALSE(db.post_renderables_if_optimizable(bypassable_list));
     // And then we recover. DRM finds enough resources to AddFB ...
     EXPECT_TRUE(db.post_renderables_if_optimizable(bypassable_list));
@@ -184,7 +174,6 @@
     graphics::mesa::DisplayBuffer db(
         create_platform(),
         null_display_report(),
-        {mock_kms_output},
         nullptr,
         display_area,
         mir_orientation_normal,
@@ -199,7 +188,6 @@
     graphics::mesa::DisplayBuffer db(
         create_platform(),
         null_display_report(),
-        {},
         nullptr,
         display_area,
         mir_orientation_right,
@@ -214,7 +202,6 @@
     graphics::mesa::DisplayBuffer db(
         create_platform(),
         null_display_report(),
-        {},
         nullptr,
         display_area,
         mir_orientation_left,
@@ -224,153 +211,6 @@
     EXPECT_EQ(mir_orientation_left, db.orientation());
 }
 
-TEST_F(MesaDisplayBufferTest, normal_rotation_constructs_normal_fb)
-{
-    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
-        .WillOnce(Return((void*)0));
-    EXPECT_CALL(mock_drm, drmModeAddFB2(_, width, height, _, _, _, _, _, _))
-        .Times(1);
-
-    graphics::mesa::DisplayBuffer db(
-        create_platform(),
-        null_display_report(),
-        {},
-        nullptr,
-        display_area,
-        mir_orientation_normal,
-        gl_config,
-        mock_egl.fake_egl_context);
-}
-
-TEST_F(MesaDisplayBufferTest, left_rotation_constructs_transposed_fb)
-{
-    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
-        .WillOnce(Return((void*)0));
-    EXPECT_CALL(mock_drm, drmModeAddFB2(_, height, width, _, _, _, _, _, _))
-        .Times(1);
-
-    graphics::mesa::DisplayBuffer db(
-        create_platform(),
-        null_display_report(),
-        {},
-        nullptr,
-        display_area,
-        mir_orientation_left,
-        gl_config,
-        mock_egl.fake_egl_context);
-}
-
-TEST_F(MesaDisplayBufferTest, inverted_rotation_constructs_normal_fb)
-{
-    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
-        .WillOnce(Return((void*)0));
-    EXPECT_CALL(mock_drm, drmModeAddFB2(_, width, height, _, _, _, _, _, _))
-        .Times(1);
-
-    graphics::mesa::DisplayBuffer db(
-        create_platform(),
-        null_display_report(),
-        {},
-        nullptr,
-        display_area,
-        mir_orientation_inverted,
-        gl_config,
-        mock_egl.fake_egl_context);
-}
-
-TEST_F(MesaDisplayBufferTest, right_rotation_constructs_transposed_fb)
-{
-    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
-        .WillOnce(Return((void*)0));
-    EXPECT_CALL(mock_drm, drmModeAddFB2(_, height, width, _, _, _, _, _, _))
-        .Times(1);
-
-    graphics::mesa::DisplayBuffer db(
-        create_platform(),
-        null_display_report(),
-        {},
-        nullptr,
-        display_area,
-        mir_orientation_right,
-        gl_config,
-        mock_egl.fake_egl_context);
-}
-
-TEST_F(MesaDisplayBufferTest, clone_mode_first_flip_flips_but_no_wait)
-{
-    // Ensure clone mode can do multiple page flips in parallel without
-    // blocking on either (at least till the second post)
-    EXPECT_CALL(*mock_kms_output, schedule_page_flip(_))
-        .Times(2);
-    EXPECT_CALL(*mock_kms_output, wait_for_page_flip())
-        .Times(0);
-
-    graphics::mesa::DisplayBuffer db(
-        create_platform(),
-        null_display_report(),
-        {mock_kms_output, mock_kms_output},
-        nullptr,
-        display_area,
-        mir_orientation_normal,
-        gl_config,
-        mock_egl.fake_egl_context);
-
-    db.gl_swap_buffers();
-    db.post();
-}
-
-TEST_F(MesaDisplayBufferTest, single_mode_first_post_flips_with_wait)
-{
-    EXPECT_CALL(*mock_kms_output, schedule_page_flip(_))
-        .Times(1);
-    EXPECT_CALL(*mock_kms_output, wait_for_page_flip())
-        .Times(1);
-
-    graphics::mesa::DisplayBuffer db(
-        create_platform(),
-        null_display_report(),
-        {mock_kms_output},
-        nullptr,
-        display_area,
-        mir_orientation_normal,
-        gl_config,
-        mock_egl.fake_egl_context);
-
-    db.gl_swap_buffers();
-    db.post();
-}
-
-TEST_F(MesaDisplayBufferTest, clone_mode_waits_for_page_flip_on_second_flip)
-{
-    InSequence seq;
-
-    EXPECT_CALL(*mock_kms_output, wait_for_page_flip())
-        .Times(0);
-    EXPECT_CALL(*mock_kms_output, schedule_page_flip(_))
-        .Times(2);
-    EXPECT_CALL(*mock_kms_output, wait_for_page_flip())
-        .Times(2);
-    EXPECT_CALL(*mock_kms_output, schedule_page_flip(_))
-        .Times(2);
-    EXPECT_CALL(*mock_kms_output, wait_for_page_flip())
-        .Times(0);
-
-    graphics::mesa::DisplayBuffer db(
-        create_platform(),
-        null_display_report(),
-        {mock_kms_output, mock_kms_output},
-        nullptr,
-        display_area,
-        mir_orientation_normal,
-        gl_config,
-        mock_egl.fake_egl_context);
-
-    db.gl_swap_buffers();
-    db.post();
-
-    db.gl_swap_buffers();
-    db.post();
-}
 
 TEST_F(MesaDisplayBufferTest, skips_bypass_because_of_incompatible_list)
 {
@@ -382,7 +222,6 @@
     graphics::mesa::DisplayBuffer db(
         create_platform(),
         null_display_report(),
-        {mock_kms_output},
         nullptr,
         display_area,
         mir_orientation_normal,
@@ -406,7 +245,6 @@
     graphics::mesa::DisplayBuffer db(
         create_platform(),
         null_display_report(),
-        {mock_kms_output},
         nullptr,
         display_area,
         mir_orientation_normal,
@@ -423,7 +261,6 @@
     graphics::mesa::DisplayBuffer db(
         create_platform(),
         null_display_report(),
-        {mock_kms_output},
         nullptr,
         area,
         mir_orientation_normal,
 
=== added file 'tests/unit-tests/graphics/mesa/test_display_group.cpp'
--- tests/unit-tests/graphics/mesa/test_display_group.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/mesa/test_display_group.cpp	2015-02-10 18:28:23 +0000
@@ -0,0 +1,247 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "src/platforms/mesa/server/platform.h"
+#include "src/platforms/mesa/server/display_group.h"
+#include "src/server/report/null_report_factory.h"
+#include "mir_test_doubles/mock_egl.h"
+#include "mir_test_doubles/mock_gl.h"
+#include "mir_test_doubles/mock_drm.h"
+#include "mir_test_doubles/mock_buffer.h"
+#include "mir_test_doubles/mock_gbm.h"
+#include "mir_test_doubles/stub_gl_config.h"
+#include "mir_test_doubles/platform_factory.h"
+#include "mir_test_doubles/stub_gbm_native_buffer.h"
+#include "mir_test_framework/udev_environment.h"
+#include "mir_test_doubles/fake_renderable.h"
+#include "mock_kms_output.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;
+using namespace mir::test::doubles;
+using namespace mir_test_framework;
+using namespace mir::graphics;
+using mir::report::null_display_report;
+
+class MesaDisplayGroup : public Test
+{
+public:
+    MesaDisplayGroup()
+        : mock_bypassable_buffer{std::make_shared<NiceMock<MockBuffer>>()}
+        , stub_gbm_native_buffer{
+             std::make_shared<StubGBMNativeBuffer>(display_area.size)}
+    {
+        ON_CALL(mock_egl, eglChooseConfig(_,_,_,1,_))
+            .WillByDefault(DoAll(SetArgPointee<2>(mock_egl.fake_configs[0]),
+                                 SetArgPointee<4>(1),
+                                 Return(EGL_TRUE)));
+
+        mock_egl.provide_egl_extensions();
+        mock_gl.provide_gles_extensions();
+
+        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_device("standard-drm-devices");
+
+        mock_kms_output = std::make_shared<NiceMock<MockKMSOutput>>();
+        ON_CALL(*mock_kms_output, set_crtc(_))
+            .WillByDefault(Return(true));
+        ON_CALL(*mock_kms_output, schedule_page_flip(_))
+            .WillByDefault(Return(true));
+    }
+
+    // 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 mir::test::doubles::create_mesa_platform_with_null_dependencies();
+    }
+
+protected:
+    int const width{56};
+    int const height{78};
+    mir::geometry::Rectangle const display_area{{12,34}, {width,height}};
+    NiceMock<MockGBM> mock_gbm;
+    NiceMock<MockEGL> mock_egl;
+    NiceMock<MockGL>  mock_gl;
+    NiceMock<MockDRM> mock_drm; 
+    std::shared_ptr<MockBuffer> mock_bypassable_buffer;
+    std::shared_ptr<mesa::GBMNativeBuffer> stub_gbm_native_buffer;
+    gbm_bo*           fake_bo;
+    gbm_bo_handle     fake_handle;
+    UdevEnvironment   fake_devices;
+    std::shared_ptr<MockKMSOutput> mock_kms_output;
+    StubGLConfig gl_config;
+
+};
+
+TEST_F(MesaDisplayGroup, clone_mode_first_flip_flips_but_no_wait)
+{
+    // Ensure clone mode can do multiple page flips in parallel without
+    // blocking on either (at least till the second post)
+    EXPECT_CALL(*mock_kms_output, schedule_page_flip(_))
+        .Times(2);
+    EXPECT_CALL(*mock_kms_output, wait_for_page_flip())
+        .Times(0);
+
+    graphics::mesa::DisplayGroup dg(
+        create_platform(),
+        null_display_report(),
+        {mock_kms_output, mock_kms_output},
+        nullptr,
+        display_area,
+        mir_orientation_normal,
+        gl_config,
+        mock_egl.fake_egl_context);
+
+    dg.post();
+}
+
+TEST_F(MesaDisplayGroup, single_mode_first_post_flips_with_wait)
+{
+    EXPECT_CALL(*mock_kms_output, schedule_page_flip(_))
+        .Times(1);
+    EXPECT_CALL(*mock_kms_output, wait_for_page_flip())
+        .Times(1);
+
+    graphics::mesa::DisplayGroup dg(
+        create_platform(),
+        null_display_report(),
+        {mock_kms_output},
+        nullptr,
+        display_area,
+        mir_orientation_normal,
+        gl_config,
+        mock_egl.fake_egl_context);
+
+    dg.post();
+}
+
+TEST_F(MesaDisplayGroup, clone_mode_waits_for_page_flip_on_second_flip)
+{
+    InSequence seq;
+
+    EXPECT_CALL(*mock_kms_output, wait_for_page_flip())
+        .Times(0);
+    EXPECT_CALL(*mock_kms_output, schedule_page_flip(_))
+        .Times(2);
+    EXPECT_CALL(*mock_kms_output, wait_for_page_flip())
+        .Times(2);
+    EXPECT_CALL(*mock_kms_output, schedule_page_flip(_))
+        .Times(2);
+    EXPECT_CALL(*mock_kms_output, wait_for_page_flip())
+        .Times(0);
+
+    graphics::mesa::DisplayGroup dg(
+        create_platform(),
+        null_display_report(),
+        {mock_kms_output, mock_kms_output},
+        nullptr,
+        display_area,
+        mir_orientation_normal,
+        gl_config,
+        mock_egl.fake_egl_context);
+
+    dg.post();
+    dg.post();
+}
+
+TEST_F(MesaDisplayGroup, normal_rotation_constructs_normal_fb)
+{
+    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
+        .WillOnce(Return((void*)0));
+    EXPECT_CALL(mock_drm, drmModeAddFB2(_, width, height, _, _, _, _, _, _))
+        .Times(1);
+
+    graphics::mesa::DisplayGroup dg(
+        create_platform(),
+        null_display_report(),
+        {},
+        nullptr,
+        display_area,
+        mir_orientation_normal,
+        gl_config,
+        mock_egl.fake_egl_context);
+}
+
+TEST_F(MesaDisplayGroup, left_rotation_constructs_transposed_fb)
+{
+    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
+        .WillOnce(Return((void*)0));
+    EXPECT_CALL(mock_drm, drmModeAddFB2(_, height, width, _, _, _, _, _, _))
+        .Times(1);
+
+    graphics::mesa::DisplayGroup dg(
+        create_platform(),
+        null_display_report(),
+        {},
+        nullptr,
+        display_area,
+        mir_orientation_left,
+        gl_config,
+        mock_egl.fake_egl_context);
+}
+
+TEST_F(MesaDisplayGroup, inverted_rotation_constructs_normal_fb)
+{
+    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
+        .WillOnce(Return((void*)0));
+    EXPECT_CALL(mock_drm, drmModeAddFB2(_, width, height, _, _, _, _, _, _))
+        .Times(1);
+
+    graphics::mesa::DisplayGroup dg(
+        create_platform(),
+        null_display_report(),
+        {},
+        nullptr,
+        display_area,
+        mir_orientation_inverted,
+        gl_config,
+        mock_egl.fake_egl_context);
+}
+
+TEST_F(MesaDisplayGroup, right_rotation_constructs_transposed_fb)
+{
+    EXPECT_CALL(mock_gbm, gbm_bo_get_user_data(_))
+        .WillOnce(Return((void*)0));
+    EXPECT_CALL(mock_drm, drmModeAddFB2(_, height, width, _, _, _, _, _, _))
+        .Times(1);
+
+    graphics::mesa::DisplayGroup dg(
+        create_platform(),
+        null_display_report(),
+        {},
+        nullptr,
+        display_area,
+        mir_orientation_right,
+        gl_config,
+        mock_egl.fake_egl_context);
+}