Merge lp:~albaguirre/mir/ci-debug-1499229 into lp:mir

[Alberto Aguirre]

DO NOT MERGE,

just debugging lp:1499229

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3470
https://mir-jenkins.ubuntu.com/job/mir-ci/873/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/894/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/931
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/922
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/922
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/904/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/904/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/904/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/904/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/904/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/873/rebuild

review: Needs Fixing (continuous-integration)

[lp:~albaguirre/mir/ci-debug-1499229]

3471. By Alberto Aguirre on 2016-04-20

more debug

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3471
https://mir-jenkins.ubuntu.com/job/mir-ci/875/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/896/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/933
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/924
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/924
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/906/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/906/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/906
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/906/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/906/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/906/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/875/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

3471. By Alberto Aguirre on 2016-04-20

more debug

3470. By Alberto Aguirre on 2016-04-20

Add some diagnostics to ThreadedDispatcherTest

=== modified file 'include/client/mir_toolkit/mir_screencast.h'
--- include/client/mir_toolkit/mir_screencast.h	2016-03-23 22:04:19 +0000
+++ include/client/mir_toolkit/mir_screencast.h	2016-04-20 18:34:35 +0000
@@ -78,6 +78,24 @@
 void mir_screencast_spec_set_capture_region(MirScreencastSpec* spec, MirRectangle const* region);
 
 /**
+ * Set the requested mirror mode.
+ *
+ * \param [in] spec     Specification to mutate
+ * \param [in] mode     The mirroring mode to apply when screencasting
+ *
+ */
+void mir_screencast_spec_set_mirror_mode(MirScreencastSpec* spec, MirMirrorMode mode);
+
+/**
+ * Set the requested number of buffers to use.
+ *
+ * \param [in] spec     Specification to mutate
+ * \param [in] nbuffers The number of buffers to allocate for screencasting
+ *
+ */
+void mir_screencast_spec_set_number_of_buffers(MirScreencastSpec* spec, int nbuffers);
+
+/**
  * Release the resources held by a MirScreencastSpec.
  *
  * \param [in] spec     Specification to release

=== modified file 'include/renderers/gl/mir/renderer/gl/render_target.h'
--- include/renderers/gl/mir/renderer/gl/render_target.h	2015-10-01 08:58:30 +0000
+++ include/renderers/gl/mir/renderer/gl/render_target.h	2016-04-20 18:34:35 +0000
@@ -31,7 +31,7 @@
 public:
     virtual ~RenderTarget() = default;
 
-    /** Makes the the current GL render target. */
+    /** Makes GL render target current to calling thread */
     virtual void make_current() = 0;
     /** Releases the current GL render target. */
     virtual void release_current() = 0;
@@ -41,6 +41,10 @@
      * free GL-related resources such as textures and buffers.
      */
     virtual void swap_buffers() = 0;
+    /** Binds any necessary resources (fbos, textures if any)
+     * in preparation for drawing.
+     */
+    virtual void bind() = 0;
 
 protected:
     RenderTarget() = default;

=== modified file 'src/client/mir_connection.cpp'
--- src/client/mir_connection.cpp	2016-04-14 05:37:22 +0000
+++ src/client/mir_connection.cpp	2016-04-20 18:34:35 +0000
@@ -896,7 +896,7 @@
 }
 
 std::shared_ptr<mir::client::ClientBufferStream> MirConnection::make_consumer_stream(
-   mp::BufferStream const& protobuf_bs, mir::geometry::Size)
+   mp::BufferStream const& protobuf_bs)
 {
     return std::make_shared<mcl::ScreencastStream>(
         this, server, platform, protobuf_bs);

=== modified file 'src/client/mir_connection.h'
--- src/client/mir_connection.h	2016-03-30 01:12:38 +0000
+++ src/client/mir_connection.h	2016-04-20 18:34:35 +0000
@@ -145,7 +145,7 @@
                                    unsigned int formats_size, unsigned int& valid_formats);
 
     std::shared_ptr<mir::client::ClientBufferStream> make_consumer_stream(
-       mir::protobuf::BufferStream const& protobuf_bs, mir::geometry::Size);
+       mir::protobuf::BufferStream const& protobuf_bs);
 
     MirWaitHandle* create_client_buffer_stream(
         int width, int height,

=== modified file 'src/client/mir_screencast.cpp'
--- src/client/mir_screencast.cpp	2016-03-28 17:37:35 +0000
+++ src/client/mir_screencast.cpp	2016-04-20 18:34:35 +0000
@@ -43,6 +43,8 @@
     SERIALIZE_OPTION_IF_SET(width);
     SERIALIZE_OPTION_IF_SET(height);
     SERIALIZE_OPTION_IF_SET(pixel_format);
+    SERIALIZE_OPTION_IF_SET(mirror_mode);
+    SERIALIZE_OPTION_IF_SET(num_buffers);
 
     if (spec.capture_region.is_set())
     {
@@ -182,7 +184,7 @@
     {
         std::lock_guard<decltype(mutex)> lock(mutex);
         buffer_stream = connection->make_consumer_stream(
-            protobuf_screencast->buffer_stream(), {});
+            protobuf_screencast->buffer_stream());
     }
 
     callback(this, context);

=== modified file 'src/client/mir_screencast.h'
--- src/client/mir_screencast.h	2016-03-25 20:24:48 +0000
+++ src/client/mir_screencast.h	2016-04-20 18:34:35 +0000
@@ -61,6 +61,9 @@
     mir::optional_value<unsigned int> height;
     mir::optional_value<MirPixelFormat> pixel_format;
     mir::optional_value<MirRectangle> capture_region;
+
+    mir::optional_value<MirMirrorMode> mirror_mode;
+    mir::optional_value<int> num_buffers;
 };
 
 struct MirScreencast

=== modified file 'src/client/mir_screencast_api.cpp'
--- src/client/mir_screencast_api.cpp	2016-03-23 22:04:19 +0000
+++ src/client/mir_screencast_api.cpp	2016-04-20 18:34:35 +0000
@@ -69,6 +69,16 @@
     spec->capture_region = *region;
 }
 
+void mir_screencast_spec_set_mirror_mode(MirScreencastSpec* spec, MirMirrorMode mode)
+{
+    spec->mirror_mode = mode;
+}
+
+void mir_screencast_spec_set_number_of_buffers(MirScreencastSpec* spec, int nbuffers)
+{
+    spec->num_buffers = nbuffers;
+}
+
 void mir_screencast_spec_release(MirScreencastSpec* spec)
 {
     delete spec;

=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2016-04-13 01:34:20 +0000
+++ src/client/symbols.map	2016-04-20 18:34:35 +0000
@@ -290,6 +290,8 @@
     mir_screencast_spec_release;
     mir_screencast_spec_set_capture_region;
     mir_screencast_spec_set_height;
+    mir_screencast_spec_set_mirror_mode;
+    mir_screencast_spec_set_number_of_buffers;
     mir_screencast_spec_set_pixel_format;
     mir_screencast_spec_set_width;
 } MIR_CLIENT_0.21;

=== modified file 'src/include/server/mir/frontend/screencast.h'
--- src/include/server/mir/frontend/screencast.h	2015-02-22 07:46:25 +0000
+++ src/include/server/mir/frontend/screencast.h	2016-04-20 18:34:35 +0000
@@ -41,7 +41,9 @@
     virtual ScreencastSessionId create_session(
         mir::geometry::Rectangle const& region,
         mir::geometry::Size const& size,
-        MirPixelFormat pixel_format) = 0;
+        MirPixelFormat pixel_format,
+        int nbuffers,
+        MirMirrorMode mirror_mode) = 0;
     virtual void destroy_session(ScreencastSessionId id) = 0;
     virtual std::shared_ptr<graphics::Buffer> capture(ScreencastSessionId id) = 0;
 

=== modified file 'src/platforms/android/server/display_buffer.cpp'
--- src/platforms/android/server/display_buffer.cpp	2016-03-28 23:15:00 +0000
+++ src/platforms/android/server/display_buffer.cpp	2016-04-20 18:34:35 +0000
@@ -103,6 +103,10 @@
         gl_context.swap_buffers();
 }
 
+void mga::DisplayBuffer::bind()
+{
+}
+
 MirOrientation mga::DisplayBuffer::orientation() const
 {
     /*

=== modified file 'src/platforms/android/server/display_buffer.h'
--- src/platforms/android/server/display_buffer.h	2016-03-28 23:15:00 +0000
+++ src/platforms/android/server/display_buffer.h	2016-04-20 18:34:35 +0000
@@ -64,6 +64,7 @@
     void release_current() override;
     void swap_buffers() override;
     bool post_renderables_if_optimizable(RenderableList const& renderlist) override;
+    void bind() override;
 
     MirOrientation orientation() const override;
     MirMirrorMode mirror_mode() const override;

=== modified file 'src/platforms/mesa/server/kms/display_buffer.cpp'
--- src/platforms/mesa/server/kms/display_buffer.cpp	2016-03-28 23:15:00 +0000
+++ src/platforms/mesa/server/kms/display_buffer.cpp	2016-04-20 18:34:35 +0000
@@ -456,6 +456,10 @@
     }
 }
 
+void mgm::DisplayBuffer::bind()
+{
+}
+
 void mgm::DisplayBuffer::release_current()
 {
     egl.release_current();

=== modified file 'src/platforms/mesa/server/kms/display_buffer.h'
--- src/platforms/mesa/server/kms/display_buffer.h	2016-03-28 23:15:00 +0000
+++ src/platforms/mesa/server/kms/display_buffer.h	2016-04-20 18:34:35 +0000
@@ -67,6 +67,7 @@
     void release_current() override;
     void swap_buffers() override;
     bool post_renderables_if_optimizable(RenderableList const& renderlist) override;
+    void bind() override;
 
     void for_each_display_buffer(
         std::function<void(graphics::DisplayBuffer&)> const& f) override;

=== modified file 'src/platforms/mesa/server/x11/graphics/display_buffer.cpp'
--- src/platforms/mesa/server/x11/graphics/display_buffer.cpp	2016-03-28 23:15:00 +0000
+++ src/platforms/mesa/server/x11/graphics/display_buffer.cpp	2016-04-20 18:34:35 +0000
@@ -67,6 +67,10 @@
         BOOST_THROW_EXCEPTION(mg::egl_error("Cannot swap"));
 }
 
+void mgx::DisplayBuffer::bind()
+{
+}
+
 MirOrientation mgx::DisplayBuffer::orientation() const
 {
     return orientation_;

=== modified file 'src/platforms/mesa/server/x11/graphics/display_buffer.h'
--- src/platforms/mesa/server/x11/graphics/display_buffer.h	2016-03-28 23:15:00 +0000
+++ src/platforms/mesa/server/x11/graphics/display_buffer.h	2016-04-20 18:34:35 +0000
@@ -49,6 +49,7 @@
     void make_current() override;
     void release_current() override;
     void swap_buffers() override;
+    void bind() override;
     bool post_renderables_if_optimizable(RenderableList const& renderlist) override;
     void set_orientation(MirOrientation const new_orientation);
 

=== modified file 'src/protobuf/mir_protobuf.proto'
--- src/protobuf/mir_protobuf.proto	2016-04-14 05:37:22 +0000
+++ src/protobuf/mir_protobuf.proto	2016-04-20 18:34:35 +0000
@@ -313,6 +313,8 @@
   required uint32 width = 2;
   required uint32 height = 3;
   required int32 pixel_format = 4;
+  optional uint32 num_buffers = 5;
+  optional int32 mirror_mode = 6;
 }
 
 message ScreencastId {

=== modified file 'src/renderers/gl/renderer.cpp'
--- src/renderers/gl/renderer.cpp	2016-03-29 17:48:07 +0000
+++ src/renderers/gl/renderer.cpp	2016-04-20 18:34:35 +0000
@@ -97,6 +97,12 @@
     render_target->make_current();
 }
 
+void mrg::CurrentRenderTarget::bind()
+{
+    ensure_current();
+    render_target->bind();
+}
+
 void mrg::CurrentRenderTarget::swap_buffers()
 {
     render_target->swap_buffers();
@@ -228,7 +234,7 @@
 
 void mrg::Renderer::render(mg::RenderableList const& renderables) const
 {
-    render_target.ensure_current();
+    render_target.bind();
 
     glClearColor(clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

=== modified file 'src/renderers/gl/renderer.h'
--- src/renderers/gl/renderer.h	2016-03-28 23:15:00 +0000
+++ src/renderers/gl/renderer.h	2016-04-20 18:34:35 +0000
@@ -49,6 +49,7 @@
     ~CurrentRenderTarget();
 
     void ensure_current();
+    void bind();
     void swap_buffers();
 
 private:

=== modified file 'src/server/compositor/compositing_screencast.cpp'
--- src/server/compositor/compositing_screencast.cpp	2016-01-27 16:32:36 +0000
+++ src/server/compositor/compositing_screencast.cpp	2016-04-20 18:34:35 +0000
@@ -18,6 +18,7 @@
 
 #include "compositing_screencast.h"
 #include "screencast_display_buffer.h"
+#include "queueing_schedule.h"
 #include "mir/graphics/buffer.h"
 #include "mir/graphics/buffer_properties.h"
 #include "mir/graphics/display.h"
@@ -65,22 +66,28 @@
 }
 }
 
-struct mc::detail::ScreencastSessionContext
+class mc::detail::ScreencastSessionContext
 {
+public:
     ScreencastSessionContext(
         std::shared_ptr<Scene> const& scene,
-        std::shared_ptr<graphics::Buffer> const& buffer,
-        std::unique_ptr<graphics::GLContext> gl_context,
-        std::unique_ptr<graphics::DisplayBuffer> display_buffer,
-        std::unique_ptr<compositor::DisplayBufferCompositor> display_buffer_compositor,
-        std::unique_ptr<graphics::VirtualOutput> a_virtual_output) :
-    scene{scene},
-    buffer{buffer},
-    gl_context{std::move(gl_context)},
-    display_buffer{std::move(display_buffer)},
-    display_buffer_compositor{std::move(display_buffer_compositor)},
-    virtual_output{std::move(a_virtual_output)}
+        mg::Display& display,
+        mg::GraphicBufferAllocator& buffer_allocator,
+        DisplayBufferCompositorFactory& db_compositor_factory,
+        geom::Rectangle const& capture_region,
+        geom::Size const& capture_size,
+        MirPixelFormat pixel_format,
+        int nbuffers,
+        MirMirrorMode mirror_mode)
+    : scene{scene},
+      display_buffer{std::make_unique<ScreencastDisplayBuffer>(capture_region, capture_size, mirror_mode, free_queue, ready_queue, display)},
+      display_buffer_compositor{db_compositor_factory.create_compositor_for(*display_buffer)},
+      virtual_output{make_virtual_output(display, capture_region)}
     {
+        mg::BufferProperties const buffer_properties{capture_size, pixel_format, mg::BufferUsage::hardware};
+        for (int i = 0; i < nbuffers; i++)
+            free_queue.schedule(buffer_allocator.alloc_buffer(buffer_properties));
+
         scene->register_compositor(this);
         if (virtual_output)
             virtual_output->enable();
@@ -90,12 +97,28 @@
         scene->unregister_compositor(this);
     }
 
+    std::shared_ptr<mg::Buffer> capture()
+    {
+        //FIXME:: the client needs a better way to express it is no longer
+        //using the last captured buffer
+        if (last_captured_buffer)
+            free_queue.schedule(last_captured_buffer);
+
+        display_buffer_compositor->composite(scene->scene_elements_for(this));
+
+        last_captured_buffer = ready_queue.next_buffer();
+        return last_captured_buffer;
+    }
+
+private:
     std::shared_ptr<Scene> const scene;
-    std::shared_ptr<graphics::Buffer> buffer;
-    std::unique_ptr<graphics::GLContext> gl_context;
-    std::unique_ptr<graphics::DisplayBuffer> display_buffer;
+    QueueingSchedule free_queue;
+    QueueingSchedule ready_queue;
+    std::unique_ptr<ScreencastDisplayBuffer> display_buffer;
+
     std::unique_ptr<compositor::DisplayBufferCompositor> display_buffer_compositor;
     std::unique_ptr<graphics::VirtualOutput> virtual_output;
+    std::shared_ptr<mg::Buffer> last_captured_buffer;
 };
 
 
@@ -114,19 +137,22 @@
 mf::ScreencastSessionId mc::CompositingScreencast::create_session(
     geom::Rectangle const& region,
     geom::Size const& size,
-    MirPixelFormat const pixel_format)
+    MirPixelFormat const pixel_format,
+    int nbuffers,
+    MirMirrorMode mirror_mode)
 {
     if (size.width.as_int() == 0 ||
         size.height.as_int() == 0 ||
         region.size.width.as_int() == 0 ||
         region.size.height.as_int() == 0 ||
-        pixel_format == mir_pixel_format_invalid)
+        pixel_format == mir_pixel_format_invalid ||
+        nbuffers < 1)
     {
         BOOST_THROW_EXCEPTION(std::runtime_error("Invalid parameters"));
     }
     std::lock_guard<decltype(session_mutex)> lock{session_mutex};
     auto const id = next_available_session_id();
-    session_contexts[id] = create_session_context(region, size, pixel_format);
+    session_contexts[id] = create_session_context(region, size, pixel_format, nbuffers, mirror_mode);
 
     return id;
 }
@@ -134,12 +160,6 @@
 void mc::CompositingScreencast::destroy_session(mf::ScreencastSessionId id)
 {
     std::lock_guard<decltype(session_mutex)> lock{session_mutex};
-    auto gl_context = std::move(session_contexts.at(id)->gl_context);
-
-    auto using_gl_context = mir::raii::paired_calls(
-        [&] { gl_context->make_current(); },
-        [&] { gl_context->release_current(); });
-
     session_contexts.erase(id);
 }
 
@@ -152,14 +172,7 @@
         session_context = session_contexts.at(id);
     }
 
-    auto using_gl_context = mir::raii::paired_calls(
-        [&] { session_context->gl_context->make_current(); },
-        [&] { session_context->gl_context->release_current(); });
-
-    session_context->display_buffer_compositor->composite(
-        session_context->scene->scene_elements_for(session_context.get()));
-
-    return session_context->buffer;
+    return session_context->capture();
 }
 
 mf::ScreencastSessionId mc::CompositingScreencast::next_available_session_id()
@@ -178,30 +191,12 @@
 mc::CompositingScreencast::create_session_context(
     geometry::Rectangle const& rect,
     geometry::Size const& size,
-    MirPixelFormat pixel_format)
+    MirPixelFormat pixel_format,
+    int nbuffers,
+    MirMirrorMode mirror_mode)
 {
-    mg::BufferProperties buffer_properties{
-        size,
-        pixel_format,
-        mg::BufferUsage::hardware};
-
-    auto gl_context = display->create_gl_context();
-    auto gl_context_raw = gl_context.get();
-
-    auto using_gl_context = mir::raii::paired_calls(
-        [&] { gl_context_raw->make_current(); },
-        [&] { gl_context_raw->release_current(); });
-
-    auto buffer = buffer_allocator->alloc_buffer(buffer_properties);
-    auto display_buffer = std::make_unique<ScreencastDisplayBuffer>(rect, *buffer);
-    auto db_compositor = db_compositor_factory->create_compositor_for(*display_buffer);
-    auto virtual_output = make_virtual_output(*display, rect);
-    return std::shared_ptr<detail::ScreencastSessionContext>(
-        new detail::ScreencastSessionContext{
-            scene,
-            buffer,
-            std::move(gl_context),
-            std::move(display_buffer),
-            std::move(db_compositor),
-            std::move(virtual_output)});
+
+    return std::make_shared<detail::ScreencastSessionContext>(
+        scene, *display, *buffer_allocator, *db_compositor_factory,
+        rect, size, pixel_format, nbuffers, mirror_mode);
 }

=== modified file 'src/server/compositor/compositing_screencast.h'
--- src/server/compositor/compositing_screencast.h	2014-10-17 18:03:54 +0000
+++ src/server/compositor/compositing_screencast.h	2016-04-20 18:34:35 +0000
@@ -52,16 +52,20 @@
     frontend::ScreencastSessionId create_session(
         geometry::Rectangle const& region,
         geometry::Size const& size,
-        MirPixelFormat pixel_format);
-    void destroy_session(frontend::ScreencastSessionId id);
-    std::shared_ptr<graphics::Buffer> capture(frontend::ScreencastSessionId id);
+        MirPixelFormat pixel_format,
+        int nbuffers,
+        MirMirrorMode mirror_mode) override;
+    void destroy_session(frontend::ScreencastSessionId id) override;
+    std::shared_ptr<graphics::Buffer> capture(frontend::ScreencastSessionId id) override;
 
 private:
     frontend::ScreencastSessionId next_available_session_id();
     std::shared_ptr<detail::ScreencastSessionContext>
         create_session_context(geometry::Rectangle const& rect,
             geometry::Size const& size,
-            MirPixelFormat pixel_format);
+            MirPixelFormat pixel_format,
+            int nbuffers,
+            MirMirrorMode mirror_mode);
 
     std::mutex session_mutex;
     std::shared_ptr<Scene> const scene;

=== modified file 'src/server/compositor/screencast_display_buffer.cpp'
--- src/server/compositor/screencast_display_buffer.cpp	2016-03-28 23:15:00 +0000
+++ src/server/compositor/screencast_display_buffer.cpp	2016-04-20 18:34:35 +0000
@@ -17,53 +17,94 @@
  */
 
 #include "screencast_display_buffer.h"
+#include "schedule.h"
+
 #include "mir/graphics/buffer.h"
+#include "mir/graphics/display.h"
+#include "mir/graphics/gl_context.h"
 #include "mir/renderer/gl/texture_source.h"
+#include "mir/raii.h"
 
 #include <boost/throw_exception.hpp>
 
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
+namespace mrgl = mir::renderer::gl;
 namespace geom = mir::geometry;
 
+namespace
+{
+auto as_texture_source(mg::Buffer* buffer)
+{
+    auto tex = dynamic_cast<mrgl::TextureSource*>(buffer->native_buffer_base());
+    if (!tex)
+        BOOST_THROW_EXCEPTION(std::logic_error("Buffer does not support GL rendering"));
+    return tex;
+}
+
+template <void (*Generate)(GLsizei,GLuint*), void (*Delete)(GLsizei,GLuint const*)>
+mc::detail::GLResource<Delete> allocate_gl_resource()
+{
+    GLuint resource;
+    Generate(1, &resource);
+    return mc::detail::GLResource<Delete>{resource};
+}
+}
+
 mc::ScreencastDisplayBuffer::ScreencastDisplayBuffer(
     geom::Rectangle const& rect,
-    mg::Buffer& buffer)
-    : rect(rect), buffer(buffer),
-      texture_source(
-          dynamic_cast<mir::renderer::gl::TextureSource*>(
-              buffer.native_buffer_base())),
+    geom::Size const& size,
+    MirMirrorMode mirror_mode,
+    Schedule& free_queue,
+    Schedule& ready_queue,
+    mg::Display& display)
+    : gl_context(display.create_gl_context()),
+      rect(rect), mirror_mode_(mirror_mode),
+      free_queue(free_queue), ready_queue(ready_queue),
       old_fbo(), old_viewport()
 {
-    if (!texture_source)
-        BOOST_THROW_EXCEPTION(std::logic_error("Buffer does not support GL rendering"));
+    auto const gl_context_raii = mir::raii::paired_calls(
+        [this] { gl_context->make_current(); },
+        [this] { gl_context->release_current(); });
+
     glGetIntegerv(GL_VIEWPORT, old_viewport);
     glGetIntegerv(GL_FRAMEBUFFER_BINDING, &old_fbo);
 
-    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+    auto texture = allocate_gl_resource<glGenTextures, glDeleteTextures>();
+    auto depth_buffer = allocate_gl_resource<glGenRenderbuffers, glDeleteRenderbuffers>();
+    auto framebuffer = allocate_gl_resource<glGenFramebuffers, glDeleteFramebuffers>();
+
+    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
 
     /* Set up the color buffer... */
-    glBindTexture(GL_TEXTURE_2D, color_tex);
+    glBindTexture(GL_TEXTURE_2D, texture);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
     /* and the depth buffer */
-    auto const buf_size = buffer.size();
-    glBindRenderbuffer(GL_RENDERBUFFER, depth_rbo);
+    glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer);
     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16,
-                          buf_size.width.as_uint32_t(),
-                          buf_size.height.as_uint32_t());
+                          size.width.as_uint32_t(),
+                          size.height.as_uint32_t());
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
-                              GL_RENDERBUFFER, depth_rbo);
+                              GL_RENDERBUFFER, depth_buffer);
 
     if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
         BOOST_THROW_EXCEPTION(std::runtime_error("Failed to create FBO for buffer"));
+
+    color_tex = std::move(texture);
+    depth_rbo =  std::move(depth_buffer);
+    fbo =  std::move(framebuffer);
 }
 
 mc::ScreencastDisplayBuffer::~ScreencastDisplayBuffer()
 {
+    make_current();
+    color_tex.reset();
+    depth_rbo.reset();
+    fbo.reset();
     release_current();
 }
 
@@ -74,12 +115,21 @@
 
 void mc::ScreencastDisplayBuffer::make_current()
 {
+    gl_context->make_current();
+}
+
+void mc::ScreencastDisplayBuffer::bind()
+{
+    if (!current_buffer)
+        current_buffer = free_queue.next_buffer();
+
+    auto texture_source = as_texture_source(current_buffer.get());
     glBindTexture(GL_TEXTURE_2D, color_tex);
-    texture_source->gl_bind_to_texture();
+    texture_source->bind();
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                            GL_TEXTURE_2D, color_tex, 0);
 
-    auto const buf_size = buffer.size();
+    auto const buf_size = current_buffer->size();
 
     glBindFramebuffer(GL_FRAMEBUFFER, fbo);
     glViewport(0, 0, buf_size.width.as_uint32_t(), buf_size.height.as_uint32_t());
@@ -90,6 +140,8 @@
     glBindFramebuffer(GL_FRAMEBUFFER, old_fbo);
     glViewport(old_viewport[0], old_viewport[1],
                old_viewport[2], old_viewport[3]);
+
+    gl_context->release_current();
 }
 
 bool mc::ScreencastDisplayBuffer::post_renderables_if_optimizable(mg::RenderableList const&)
@@ -99,7 +151,16 @@
 
 void mc::ScreencastDisplayBuffer::swap_buffers()
 {
-    glFinish();
+    if (current_buffer)
+    {
+
+        //TODO: replace this with a fence which the client could use
+        //to wait for rendering completion
+        glFinish();
+
+        ready_queue.schedule(current_buffer);
+        current_buffer = nullptr;
+    }
 }
 
 MirOrientation mc::ScreencastDisplayBuffer::orientation() const
@@ -109,7 +170,7 @@
 
 MirMirrorMode mc::ScreencastDisplayBuffer::mirror_mode() const
 {
-    return mir_mirror_mode_none;
+    return mirror_mode_;
 }
 
 mg::NativeDisplayBuffer* mc::ScreencastDisplayBuffer::native_display_buffer()

=== modified file 'src/server/compositor/screencast_display_buffer.h'
--- src/server/compositor/screencast_display_buffer.h	2016-03-28 23:15:00 +0000
+++ src/server/compositor/screencast_display_buffer.h	2016-04-20 18:34:35 +0000
@@ -26,27 +26,57 @@
 
 namespace mir
 {
+namespace graphics
+{
+class Display;
+class GLContext;
+}
 namespace renderer { namespace gl { class TextureSource; }}
 namespace compositor
 {
+
 namespace detail
 {
 
-template <void (*Generate)(GLsizei,GLuint*), void (*Delete)(GLsizei,GLuint const*)>
+template <void (*Delete)(GLsizei,GLuint const*)>
 class GLResource
 {
 public:
-    GLResource() { Generate(1, &resource); }
-    ~GLResource() { Delete(1, &resource); }
+    GLResource() {}
+    GLResource(GLuint resource) : resource{resource} {}
+    ~GLResource() { reset(); }
+
     operator GLuint() const { return resource; }
 
+    void reset()
+    {
+        if (resource)
+        {
+            Delete(1, &resource);
+            resource = 0;
+        }
+    }
+
+    GLResource(GLResource&& other) : resource {other.resource}
+    {
+        other.resource = 0;
+    }
+
+    GLResource& operator=(GLResource&& other)
+    {
+        resource = other.resource;
+        other.resource = 0;
+        return *this;
+    }
+
 private:
     GLResource(GLResource const&) = delete;
     GLResource& operator=(GLResource const&) = delete;
-    GLuint resource = 0;
+    GLuint resource{0};
 };
 }
 
+class Schedule;
 class ScreencastDisplayBuffer : public graphics::DisplayBuffer,
                                 public graphics::NativeDisplayBuffer,
                                 public renderer::gl::RenderTarget
@@ -54,13 +84,19 @@
 public:
     ScreencastDisplayBuffer(
         geometry::Rectangle const& rect,
-        graphics::Buffer& buffer);
+        geometry::Size const& size,
+        MirMirrorMode mirror_mode,
+        Schedule& free_queue,
+        Schedule& ready_queue,
+        graphics::Display& display);
     ~ScreencastDisplayBuffer();
 
     geometry::Rectangle view_area() const override;
 
     void make_current() override;
 
+    void bind() override;
+
     void release_current() override;
 
     bool post_renderables_if_optimizable(graphics::RenderableList const&) override;
@@ -74,14 +110,20 @@
     NativeDisplayBuffer* native_display_buffer() override;
 
 private:
+    std::unique_ptr<graphics::GLContext> gl_context;
     geometry::Rectangle const rect;
-    graphics::Buffer& buffer;
-    renderer::gl::TextureSource* texture_source;
+    MirMirrorMode const mirror_mode_;
+
+    Schedule& free_queue;
+    Schedule& ready_queue;
+    std::shared_ptr<graphics::Buffer> current_buffer;
+
     GLint old_fbo;
     GLint old_viewport[4];
-    detail::GLResource<glGenTextures,glDeleteTextures> const color_tex;
-    detail::GLResource<glGenRenderbuffers,glDeleteRenderbuffers> const depth_rbo;
-    detail::GLResource<glGenFramebuffers,glDeleteFramebuffers> const fbo;
+
+    detail::GLResource<glDeleteTextures> color_tex;
+    detail::GLResource<glDeleteRenderbuffers> depth_rbo;
+    detail::GLResource<glDeleteFramebuffers> fbo;
 };
 
 }

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2016-04-15 03:41:28 +0000
+++ src/server/frontend/session_mediator.cpp	2016-04-20 18:34:35 +0000
@@ -755,7 +755,15 @@
     geom::Size const size{parameters->width(), parameters->height()};
     MirPixelFormat const pixel_format = static_cast<MirPixelFormat>(parameters->pixel_format());
 
-    auto screencast_session_id = screencast->create_session(region, size, pixel_format);
+    int nbuffers = 1;
+    if (parameters->has_num_buffers())
+        nbuffers = parameters->num_buffers();
+
+    MirMirrorMode mirror_mode = mir_mirror_mode_none;
+    if (parameters->has_mirror_mode())
+        mirror_mode = static_cast<MirMirrorMode>(parameters->mirror_mode());
+
+    auto screencast_session_id = screencast->create_session(region, size, pixel_format, nbuffers, mirror_mode);
     auto buffer = screencast->capture(screencast_session_id);
 
     protobuf_screencast->mutable_screencast_id()->set_value(
@@ -786,7 +794,7 @@
     mir::protobuf::Buffer* protobuf_buffer,
     google::protobuf::Closure* done)
 {
-    static auto const msg_type = mg::BufferIpcMsgType::update_msg;
+    static auto const msg_type = mg::BufferIpcMsgType::full_msg;
     ScreencastSessionId const screencast_session_id{
         protobuf_screencast_id->value()};
 

=== modified file 'src/server/frontend/unauthorized_screencast.cpp'
--- src/server/frontend/unauthorized_screencast.cpp	2014-03-20 09:36:44 +0000
+++ src/server/frontend/unauthorized_screencast.cpp	2016-04-20 18:34:35 +0000
@@ -24,9 +24,9 @@
 namespace mf = mir::frontend;
 
 mf::ScreencastSessionId mf::UnauthorizedScreencast::create_session(
-    geometry::Rectangle const&,
-    geometry::Size const&,
-    MirPixelFormat)
+    mir::geometry::Rectangle const&,
+    mir::geometry::Size const&,
+    MirPixelFormat, int, MirMirrorMode)
 {
     BOOST_THROW_EXCEPTION(
         std::runtime_error("Process is not authorized to capture screencasts"));

=== modified file 'src/server/frontend/unauthorized_screencast.h'
--- src/server/frontend/unauthorized_screencast.h	2014-03-20 09:36:44 +0000
+++ src/server/frontend/unauthorized_screencast.h	2016-04-20 18:34:35 +0000
@@ -30,9 +30,11 @@
 {
 public:
     ScreencastSessionId create_session(
-        geometry::Rectangle const& region,
-        geometry::Size const& size,
-        MirPixelFormat pixel_format) override;
+        mir::geometry::Rectangle const& region,
+        mir::geometry::Size const& size,
+        MirPixelFormat pixel_format,
+        int nbuffers,
+        MirMirrorMode mirror_mode) override;
     void destroy_session(frontend::ScreencastSessionId id) override;
     std::shared_ptr<graphics::Buffer> capture(frontend::ScreencastSessionId id) override;
 };

=== modified file 'src/server/graphics/nested/display_buffer.cpp'
--- src/server/graphics/nested/display_buffer.cpp	2016-04-04 03:30:04 +0000
+++ src/server/graphics/nested/display_buffer.cpp	2016-04-20 18:34:35 +0000
@@ -73,6 +73,10 @@
     eglSwapBuffers(egl_display, egl_surface);
 }
 
+void mgn::detail::DisplayBuffer::bind()
+{
+}
+
 bool mgn::detail::DisplayBuffer::post_renderables_if_optimizable(RenderableList const&)
 {
     return false;

=== modified file 'src/server/graphics/nested/display_buffer.h'
--- src/server/graphics/nested/display_buffer.h	2016-03-28 23:15:00 +0000
+++ src/server/graphics/nested/display_buffer.h	2016-04-20 18:34:35 +0000
@@ -60,6 +60,7 @@
     void make_current() override;
     void release_current() override;
     void swap_buffers() override;
+    void bind() override;
     MirOrientation orientation() const override;
     MirMirrorMode mirror_mode() const override;
 

=== modified file 'src/server/graphics/offscreen/display_buffer.cpp'
--- src/server/graphics/offscreen/display_buffer.cpp	2016-03-28 23:15:00 +0000
+++ src/server/graphics/offscreen/display_buffer.cpp	2016-04-20 18:34:35 +0000
@@ -130,6 +130,10 @@
 void mgo::DisplayBuffer::make_current()
 {
     egl_context.make_current();
+}
+
+void mgo::DisplayBuffer::bind()
+{
     fbo.bind();
 }
 

=== modified file 'src/server/graphics/offscreen/display_buffer.h'
--- src/server/graphics/offscreen/display_buffer.h	2016-03-28 23:15:00 +0000
+++ src/server/graphics/offscreen/display_buffer.h	2016-04-20 18:34:35 +0000
@@ -67,6 +67,7 @@
 
     geometry::Rectangle view_area() const override;
     void make_current() override;
+    void bind() override;
     void release_current() override;
     void swap_buffers() override;
 

=== modified file 'tests/include/mir/test/doubles/mock_gl_display_buffer.h'
--- tests/include/mir/test/doubles/mock_gl_display_buffer.h	2015-10-01 08:58:30 +0000
+++ tests/include/mir/test/doubles/mock_gl_display_buffer.h	2016-04-20 18:34:35 +0000
@@ -36,6 +36,7 @@
     MOCK_METHOD0(make_current, void());
     MOCK_METHOD0(release_current, void());
     MOCK_METHOD0(swap_buffers, void());
+    MOCK_METHOD0(bind, void());
 };
 
 }

=== modified file 'tests/include/mir/test/doubles/mock_screencast.h'
--- tests/include/mir/test/doubles/mock_screencast.h	2014-03-05 21:12:05 +0000
+++ tests/include/mir/test/doubles/mock_screencast.h	2016-04-20 18:34:35 +0000
@@ -33,11 +33,13 @@
 class MockScreencast : public frontend::Screencast
 {
 public:
-    MOCK_METHOD3(create_session,
+    MOCK_METHOD5(create_session,
                  frontend::ScreencastSessionId(
                      geometry::Rectangle const&,
                      geometry::Size const&,
-                     MirPixelFormat));
+                     MirPixelFormat,
+                     int,
+                     MirMirrorMode));
     MOCK_METHOD1(destroy_session, void(frontend::ScreencastSessionId));
     MOCK_METHOD1(capture,
                  std::shared_ptr<graphics::Buffer>(

=== modified file 'tests/include/mir/test/doubles/null_screencast.h'
--- tests/include/mir/test/doubles/null_screencast.h	2014-03-05 21:12:05 +0000
+++ tests/include/mir/test/doubles/null_screencast.h	2016-04-20 18:34:35 +0000
@@ -34,7 +34,9 @@
     frontend::ScreencastSessionId create_session(
         geometry::Rectangle const&,
         geometry::Size const&,
-        MirPixelFormat)
+        MirPixelFormat,
+        int,
+        MirMirrorMode)
     {
         return frontend::ScreencastSessionId{1};
     }

=== modified file 'tests/include/mir/test/doubles/stub_gl_display_buffer.h'
--- tests/include/mir/test/doubles/stub_gl_display_buffer.h	2015-10-01 08:58:30 +0000
+++ tests/include/mir/test/doubles/stub_gl_display_buffer.h	2016-04-20 18:34:35 +0000
@@ -38,6 +38,7 @@
     void make_current() override {}
     void release_current() override {}
     void swap_buffers() override {}
+    void bind() override {}
 };
 
 }

=== modified file 'tests/integration-tests/test_client_screencast.cpp'
--- tests/integration-tests/test_client_screencast.cpp	2016-03-25 20:24:48 +0000
+++ tests/integration-tests/test_client_screencast.cpp	2016-04-20 18:34:35 +0000
@@ -107,7 +107,7 @@
     InSequence seq;
 
     EXPECT_CALL(mock_screencast(),
-                create_session(_, _, _))
+                create_session(_, _, _, _, _))
         .WillOnce(Return(screencast_session_id));
 
     EXPECT_CALL(mock_screencast(), capture(screencast_session_id))
@@ -137,7 +137,7 @@
     InSequence seq;
 
     EXPECT_CALL(mock_screencast(),
-                create_session(region, size, pixel_format))
+                create_session(region, size, pixel_format,_,_))
         .WillOnce(Return(screencast_session_id));
 
     EXPECT_CALL(mock_screencast(), capture(_))
@@ -159,7 +159,7 @@
     mf::ScreencastSessionId const screencast_session_id{99};
 
     InSequence seq;
-    EXPECT_CALL(mock_screencast(), create_session(_, _, _))
+    EXPECT_CALL(mock_screencast(), create_session(_, _, _, _, _))
         .WillOnce(Return(screencast_session_id));
     EXPECT_CALL(mock_screencast(), capture(_))
         .WillOnce(Return(std::make_shared<mtd::StubBuffer>()));
@@ -180,7 +180,7 @@
 {
     using namespace testing;
     std::string const an_error_message{"boring error message"};
-    EXPECT_CALL(mock_screencast(), create_session(_, _, _))
+    EXPECT_CALL(mock_screencast(), create_session(_, _, _, _, _))
         .WillOnce(Throw(std::runtime_error(an_error_message)));
 
     auto screencast = mir_connection_create_screencast_sync(connection, &default_screencast_params);
@@ -202,11 +202,13 @@
         {default_screencast_params.region.left, default_screencast_params.region.top},
         {default_screencast_params.region.width, default_screencast_params.region.height}};
     MirPixelFormat const pixel_format {default_screencast_params.pixel_format};
+    int const num_buffers{3};
+    MirMirrorMode const mirror_mode{mir_mirror_mode_vertical};
 
     InSequence seq;
 
     EXPECT_CALL(mock_screencast(),
-                create_session(region, size, pixel_format))
+                create_session(region, size, pixel_format, num_buffers, mirror_mode))
         .WillOnce(Return(screencast_session_id));
 
     EXPECT_CALL(mock_screencast(), capture(_))
@@ -222,6 +224,9 @@
     MirRectangle const capture_region = as_mir_rect(region);
     mir_screencast_spec_set_capture_region(spec, &capture_region);
 
+    mir_screencast_spec_set_number_of_buffers(spec, num_buffers);
+    mir_screencast_spec_set_mirror_mode(spec, mirror_mode);
+
     auto screencast = mir_screencast_create_sync(spec);
     ASSERT_NE(nullptr, screencast);
     ASSERT_TRUE(mir_screencast_is_valid(screencast));

=== modified file 'tests/mir_test/test_dispatchable.cpp'
--- tests/mir_test/test_dispatchable.cpp	2015-06-25 03:00:08 +0000
+++ tests/mir_test/test_dispatchable.cpp	2016-04-20 18:34:35 +0000
@@ -24,6 +24,8 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
+#include <system_error>
+
 namespace mt = mir::test;
 namespace md = mir::dispatch;
 
@@ -72,9 +74,21 @@
 
 void mt::TestDispatchable::trigger()
 {
+    std::cerr << "mt::TestDispatchable::trigger " << std::endl;
     using namespace testing;
     char dummy{0};
-    EXPECT_THAT(::write(write_fd, &dummy, sizeof(dummy)), Eq(sizeof(dummy)));
+    auto expected_size = sizeof(dummy);
+    auto written_size = ::write(write_fd, &dummy, expected_size);
+    if (written_size < 0)
+    {
+        std::system_error e{errno, std::system_category()};
+        std::cerr << "Failed to write dummy data: " << e.what() << std::endl;
+    }
+    else if (written_size != sizeof(dummy))
+    {
+        std::cerr << "Failed to write dummy data" << std::endl;
+    }
+    EXPECT_THAT(written_size, Eq(expected_size));
 }
 
 void mt::TestDispatchable::untrigger()

=== modified file 'tests/unit-tests/compositor/test_compositing_screencast.cpp'
--- tests/unit-tests/compositor/test_compositing_screencast.cpp	2016-02-01 22:53:06 +0000
+++ tests/unit-tests/compositor/test_compositing_screencast.cpp	2016-04-20 18:34:35 +0000
@@ -24,6 +24,7 @@
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/geometry/rectangle.h"
 #include "mir/geometry/rectangles.h"
+#include "mir/renderer/gl/render_target.h"
 
 #include "mir/test/doubles/null_display.h"
 #include "mir/test/doubles/null_display_buffer_compositor_factory.h"
@@ -35,6 +36,7 @@
 #include "mir/test/doubles/stub_scene_element.h"
 #include "mir/test/doubles/mock_scene.h"
 
+#include "mir/test/as_render_target.h"
 #include "mir/test/fake_shared.h"
 
 #include <boost/throw_exception.hpp>
@@ -49,6 +51,7 @@
 namespace mf = mir::frontend;
 namespace mtd = mir::test::doubles;
 namespace mt = mir::test;
+namespace mrgl = mir::renderer::gl;
 namespace geom = mir::geometry;
 
 namespace
@@ -129,21 +132,27 @@
 class WrappingDisplayBufferCompositor : public mc::DisplayBufferCompositor
 {
 public:
-    WrappingDisplayBufferCompositor(mc::DisplayBufferCompositor& comp)
-        : comp(comp)
+    WrappingDisplayBufferCompositor(mc::DisplayBufferCompositor& comp, mg::DisplayBuffer& db)
+        : comp(comp),
+          render_target(mt::as_render_target(db))
     {
+        //TODO: we shouldn't need to care if the display buffer is GL capable
+        if (!render_target)
+            BOOST_THROW_EXCEPTION(std::logic_error("Display Buffer does not support GL rendering"));
     }
 
     void composite(mc::SceneElementSequence&& elements)
     {
+        render_target->bind();
         comp.composite(std::move(elements));
+        render_target->swap_buffers();
     }
 
 private:
     mc::DisplayBufferCompositor& comp;
+    mrgl::RenderTarget* render_target;
 };
 
-
 struct MockBufferAllocator : mg::GraphicBufferAllocator
 {
     MOCK_METHOD1(alloc_buffer,
@@ -154,11 +163,10 @@
 
 struct MockDisplayBufferCompositorFactory : mc::DisplayBufferCompositorFactory
 {
-    std::unique_ptr<mc::DisplayBufferCompositor> create_compositor_for(mg::DisplayBuffer& db)
+    std::unique_ptr<mc::DisplayBufferCompositor> create_compositor_for(mg::DisplayBuffer& db) override
     {
         create_compositor_mock(db);
-        return std::unique_ptr<WrappingDisplayBufferCompositor>(
-            new WrappingDisplayBufferCompositor{mock_db_compositor});
+        return std::make_unique<WrappingDisplayBufferCompositor>(mock_db_compositor, db);
     }
 
     MockDisplayBufferCompositor mock_db_compositor;
@@ -166,6 +174,20 @@
     MOCK_METHOD1(create_compositor_mock, void(mg::DisplayBuffer&));
 };
 
+struct StubDisplayBufferCompositor : mc::DisplayBufferCompositor
+{
+    void composite(mc::SceneElementSequence&&) override {}
+};
+
+struct StubDisplayBufferCompositorFactory : mc::DisplayBufferCompositorFactory
+{
+    std::unique_ptr<mc::DisplayBufferCompositor> create_compositor_for(mg::DisplayBuffer& db) override
+    {
+        return std::make_unique<WrappingDisplayBufferCompositor>(stub_db_compositor, db);
+    }
+    StubDisplayBufferCompositor stub_db_compositor;
+};
+
 MATCHER_P(DisplayBufferCoversArea, output_extents, "")
 {
     return arg.view_area() == output_extents;
@@ -193,11 +215,13 @@
     mtd::StubScene stub_scene;
     StubDisplay stub_display;
     mtd::StubGLBufferAllocator stub_buffer_allocator;
-    mtd::NullDisplayBufferCompositorFactory stub_db_compositor_factory;
+    StubDisplayBufferCompositorFactory stub_db_compositor_factory;
     mc::CompositingScreencast screencast;
     geom::Size const default_size;
     geom::Rectangle const default_region;
-    MirPixelFormat default_pixel_format;
+    MirPixelFormat const default_pixel_format;
+    int const default_num_buffers{2};
+    MirMirrorMode const default_mirror_mode{mir_mirror_mode_vertical};
 };
 
 }
@@ -208,7 +232,9 @@
 
     for (int i = 0; i != 10; ++i)
     {
-        auto session_id = screencast.create_session(default_region, default_size, default_pixel_format);
+        auto session_id = screencast.create_session(
+            default_region, default_size, default_pixel_format,
+            default_num_buffers, default_mirror_mode);
         ASSERT_TRUE(session_ids.find(session_id) == session_ids.end())
             << "session_id: " << session_id << " iter: " << i;
         session_ids.insert(session_id);
@@ -221,9 +247,10 @@
     geom::Size invalid_size{0, 0};
     geom::Rectangle invalid_region{{0, 0}, {0, 0}};
 
-    EXPECT_THROW(screencast.create_session(invalid_region, default_size, default_pixel_format), std::runtime_error);
-    EXPECT_THROW(screencast.create_session(default_region, invalid_size, default_pixel_format), std::runtime_error);
-    EXPECT_THROW(screencast.create_session(default_region, default_size, mir_pixel_format_invalid), std::runtime_error);
+    EXPECT_THROW(screencast.create_session(invalid_region, default_size, default_pixel_format, default_num_buffers, default_mirror_mode), std::runtime_error);
+    EXPECT_THROW(screencast.create_session(default_region, invalid_size, default_pixel_format, default_num_buffers, default_mirror_mode), std::runtime_error);
+    EXPECT_THROW(screencast.create_session(default_region, default_size, mir_pixel_format_invalid, default_num_buffers, default_mirror_mode), std::runtime_error);
+    EXPECT_THROW(screencast.create_session(default_region, default_size, mir_pixel_format_invalid, 0, default_mirror_mode), std::runtime_error);
 }
 
 TEST_F(CompositingScreencastTest, throws_on_capture_with_invalid_session_id)
@@ -234,7 +261,9 @@
 
 TEST_F(CompositingScreencastTest, throws_on_capture_with_destroyed_session_id)
 {
-    auto session_id = screencast.create_session(default_region, default_size, default_pixel_format);
+    auto session_id = screencast.create_session(
+        default_region, default_size, default_pixel_format,
+        default_num_buffers, default_mirror_mode);
     screencast.destroy_session(session_id);
     EXPECT_THROW(screencast.capture(session_id), std::logic_error);
 }
@@ -262,7 +291,9 @@
         mt::fake_shared(stub_buffer_allocator),
         mt::fake_shared(mock_db_compositor_factory)};
 
-    auto session_id = screencast_local.create_session(default_region, default_size, default_pixel_format);
+    auto session_id = screencast_local.create_session(
+        default_region, default_size, default_pixel_format,
+        default_num_buffers, default_mirror_mode);
 
     screencast_local.capture(session_id);
 }
@@ -285,13 +316,15 @@
         mt::fake_shared(mock_buffer_allocator),
         mt::fake_shared(stub_db_compositor_factory)};
 
-    auto session_id = screencast_local.create_session(default_region, default_size, default_pixel_format);
+    auto session_id = screencast_local.create_session(
+        default_region, default_size, default_pixel_format,
+        1, default_mirror_mode);
 
     auto buffer = screencast_local.capture(session_id);
     ASSERT_EQ(&stub_buffer, buffer.get());
 }
 
-TEST_F(CompositingScreencastTest, uses_one_buffer_per_session)
+TEST_F(CompositingScreencastTest, allocates_different_buffers_per_session)
 {
     using namespace testing;
 
@@ -309,13 +342,17 @@
         mt::fake_shared(mock_buffer_allocator),
         mt::fake_shared(stub_db_compositor_factory)};
 
-    auto session_id1 = screencast_local.create_session(default_region, default_size, default_pixel_format);
+    auto session_id1 = screencast_local.create_session(
+        default_region, default_size, default_pixel_format,
+        1, default_mirror_mode);
     auto buffer1 = screencast_local.capture(session_id1);
     ASSERT_EQ(&stub_buffer1, buffer1.get());
     buffer1 = screencast_local.capture(session_id1);
     ASSERT_EQ(&stub_buffer1, buffer1.get());
 
-    auto session_id2 = screencast_local.create_session(default_region, default_size, default_pixel_format);
+    auto session_id2 = screencast_local.create_session(
+        default_region, default_size, default_pixel_format,
+        1, default_mirror_mode);
     auto buffer2 = screencast_local.capture(session_id2);
     ASSERT_EQ(&stub_buffer2, buffer2.get());
     buffer2 = screencast_local.capture(session_id2);
@@ -327,6 +364,7 @@
     using namespace testing;
     NiceMock<mtd::MockScene> mock_scene;
     NiceMock<MockBufferAllocator> mock_buffer_allocator;
+
     ON_CALL(mock_buffer_allocator, alloc_buffer(_))
         .WillByDefault(Return(std::make_shared<mtd::StubGLBuffer>()));
 
@@ -341,7 +379,9 @@
         mt::fake_shared(mock_buffer_allocator),
         mt::fake_shared(stub_db_compositor_factory)};
 
-    auto session_id = screencast_local.create_session(default_region, default_size, default_pixel_format);
+    auto session_id = screencast_local.create_session(
+        default_region, default_size, default_pixel_format,
+        default_num_buffers, default_mirror_mode);
     screencast_local.destroy_session(session_id);
 }
 
@@ -357,7 +397,9 @@
         mt::fake_shared(stub_buffer_allocator),
         mt::fake_shared(stub_db_compositor_factory)};
 
-    auto session_id = screencast_local.create_session(region_outside_display, default_size, default_pixel_format);
+    auto session_id = screencast_local.create_session(
+            region_outside_display, default_size, default_pixel_format,
+            default_num_buffers, default_mirror_mode);
     screencast_local.destroy_session(session_id);
 
     EXPECT_TRUE(stub_display.virtual_output_created);
@@ -376,7 +418,9 @@
         mt::fake_shared(stub_buffer_allocator),
         mt::fake_shared(stub_db_compositor_factory)};
 
-    auto session_id = screencast_local.create_session(region_inside_display, default_size, default_pixel_format);
+    auto session_id = screencast_local.create_session(
+            region_inside_display, default_size, default_pixel_format,
+            default_num_buffers, default_mirror_mode);
     screencast_local.destroy_session(session_id);
 
     EXPECT_FALSE(stub_display.virtual_output_created);
@@ -384,3 +428,36 @@
 }
 
 
+TEST_F(CompositingScreencastTest, uses_requested_number_of_buffers)
+{
+    using namespace testing;
+
+    MockBufferAllocator mock_buffer_allocator;
+    int const expected_num_buffers = 4;
+    std::vector<mtd::StubGLBuffer> buffers(expected_num_buffers);
+
+
+    EXPECT_CALL(mock_buffer_allocator, alloc_buffer(_))
+        .WillOnce(Return(mt::fake_shared(buffers[0])))
+        .WillOnce(Return(mt::fake_shared(buffers[1])))
+        .WillOnce(Return(mt::fake_shared(buffers[2])))
+        .WillOnce(Return(mt::fake_shared(buffers[3])));
+
+    mc::CompositingScreencast screencast_local{
+        mt::fake_shared(stub_scene),
+        mt::fake_shared(stub_display),
+        mt::fake_shared(mock_buffer_allocator),
+        mt::fake_shared(stub_db_compositor_factory)};
+
+    auto session_id = screencast_local.create_session(
+        default_region, default_size, default_pixel_format,
+        expected_num_buffers, default_mirror_mode);
+
+    for (int i = 0; i < expected_num_buffers; i++)
+    {
+        auto buffer = screencast_local.capture(session_id);
+        ASSERT_EQ(&buffers[i], buffer.get());
+    }
+}
+
+

=== modified file 'tests/unit-tests/compositor/test_screencast_display_buffer.cpp'
--- tests/unit-tests/compositor/test_screencast_display_buffer.cpp	2016-01-29 08:18:22 +0000
+++ tests/unit-tests/compositor/test_screencast_display_buffer.cpp	2016-04-20 18:34:35 +0000
@@ -17,33 +17,50 @@
  */
 
 #include "src/server/compositor/screencast_display_buffer.h"
+#include "src/server/compositor/queueing_schedule.h"
 
+#include "mir/test/fake_shared.h"
 #include "mir/test/doubles/mock_gl_buffer.h"
 #include "mir/test/doubles/stub_gl_buffer.h"
 #include "mir/test/doubles/mock_gl.h"
 #include "mir/test/doubles/stub_renderable.h"
+#include "mir/test/doubles/stub_display.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
 namespace mc = mir::compositor;
+namespace mt = mir::test;
 namespace mtd = mir::test::doubles;
 namespace geom = mir::geometry;
 namespace mg = mir::graphics;
 
+using namespace testing;
+
 namespace
 {
 
 struct ScreencastDisplayBufferTest : testing::Test
 {
+    void SetUp() override
+    {
+        free_queue.schedule(mt::fake_shared(stub_buffer));
+    }
+
     testing::NiceMock<mtd::MockGL> mock_gl;
+    mc::QueueingSchedule free_queue;
+    mc::QueueingSchedule ready_queue;
+    mtd::StubGLBuffer stub_buffer;
+    mtd::StubDisplay stub_display{1};
+    geom::Size const default_size{300,400};
+    geom::Rectangle const default_rect{{100,100}, {800,600}};
+    MirMirrorMode const default_mirror_mode{mir_mirror_mode_vertical};
 };
 
 }
 
 TEST_F(ScreencastDisplayBufferTest, cleans_up_gl_resources)
 {
-    using namespace testing;
     GLuint const texture{11};
     GLuint const renderbuffer{12};
     GLuint const framebuffer{13};
@@ -59,15 +76,13 @@
     EXPECT_CALL(mock_gl, glDeleteRenderbuffers(1,Pointee(renderbuffer)));
     EXPECT_CALL(mock_gl, glDeleteFramebuffers(1,Pointee(framebuffer)));
 
-    geom::Rectangle const rect{{100,100}, {800,600}};
-    mtd::StubGLBuffer stub_buffer;
-
-    mc::ScreencastDisplayBuffer db{rect, stub_buffer};
+    mc::ScreencastDisplayBuffer db{default_rect, default_size,
+                                   default_mirror_mode, free_queue,
+                                   ready_queue, stub_display};
 }
 
 TEST_F(ScreencastDisplayBufferTest, cleans_up_gl_resources_on_construction_failure)
 {
-    using namespace testing;
     GLuint const texture{11};
     GLuint const renderbuffer{12};
     GLuint const framebuffer{13};
@@ -86,42 +101,37 @@
     EXPECT_CALL(mock_gl, glDeleteRenderbuffers(1,Pointee(renderbuffer)));
     EXPECT_CALL(mock_gl, glDeleteFramebuffers(1,Pointee(framebuffer)));
 
-    geom::Rectangle const rect{{100,100}, {800,600}};
-    mtd::StubGLBuffer stub_buffer;
-
     EXPECT_THROW({
-        mc::ScreencastDisplayBuffer db(rect, stub_buffer);
+        mc::ScreencastDisplayBuffer db(default_rect, default_size,
+                                       default_mirror_mode, free_queue,
+                                       ready_queue, stub_display);
     }, std::runtime_error);
 }
 
-TEST_F(ScreencastDisplayBufferTest, sets_render_buffer_size_to_supplied_buffer_size)
+TEST_F(ScreencastDisplayBufferTest, sets_render_buffer_size_to_supplied_size)
 {
-    using namespace testing;
-
-    geom::Rectangle const rect{{100,100}, {800,600}};
-    testing::NiceMock<mtd::MockGLBuffer> mock_buffer{
-        rect.size, geom::Stride{100}, mir_pixel_format_xbgr_8888};
-
     /* Set the buffer as rendering target */
     EXPECT_CALL(mock_gl,
-                glRenderbufferStorage(_, _,
-                           mock_buffer.size().width.as_int(),
-                           mock_buffer.size().height.as_int()));
+                    glRenderbufferStorage(_, _,
+                        default_size.width.as_int(),
+                        default_size.height.as_int()));
 
-    mc::ScreencastDisplayBuffer db{rect, mock_buffer};
+    mc::ScreencastDisplayBuffer db{default_rect, default_size,
+                                   default_mirror_mode, free_queue,
+                                   ready_queue, stub_display};
 }
 
 TEST_F(ScreencastDisplayBufferTest, renders_to_supplied_buffer)
 {
-    using namespace testing;
-
-    geom::Rectangle const rect{{100,100}, {800,600}};
     testing::NiceMock<mtd::MockGLBuffer> mock_buffer{
-        rect.size, geom::Stride{100}, mir_pixel_format_xbgr_8888};
+        default_rect.size, geom::Stride{100}, mir_pixel_format_xbgr_8888};
+
+    mc::QueueingSchedule free_queue;
+    free_queue.schedule(mt::fake_shared(mock_buffer));
 
     InSequence s;
     /* Set the buffer as rendering target */
-    EXPECT_CALL(mock_buffer, gl_bind_to_texture());
+    EXPECT_CALL(mock_buffer, bind());
     EXPECT_CALL(mock_gl,
                 glViewport(0, 0,
                            mock_buffer.size().width.as_int(),
@@ -129,37 +139,73 @@
     /* Restore previous viewport on exit */
     EXPECT_CALL(mock_gl, glViewport(0, 0, 0, 0));
 
-    mc::ScreencastDisplayBuffer db{rect, mock_buffer};
-    db.make_current();
+    mc::ScreencastDisplayBuffer db{default_rect, default_size,
+                                   default_mirror_mode, free_queue,
+                                   ready_queue, stub_display};
+    db.bind();
 }
 
 TEST_F(ScreencastDisplayBufferTest, forces_rendering_to_complete_on_swap)
 {
-    using namespace testing;
-
-    geom::Rectangle const rect{{100,100}, {800,600}};
-    mtd::StubGLBuffer stub_buffer;
-
-    mc::ScreencastDisplayBuffer db{rect, stub_buffer};
+    mc::ScreencastDisplayBuffer db{default_rect, default_size,
+                                   default_mirror_mode, free_queue,
+                                   ready_queue, stub_display};
 
     Mock::VerifyAndClearExpectations(&mock_gl);
     EXPECT_CALL(mock_gl, glFinish());
 
+    db.bind();
     db.swap_buffers();
 }
 
 TEST_F(ScreencastDisplayBufferTest, rejects_attempt_to_optimize)
 {
-    geom::Rectangle const rect{{100,100}, {800,600}};
-    mtd::StubGLBuffer stub_buffer;
-
     mg::RenderableList renderables{
         std::make_shared<mtd::StubRenderable>(),
         std::make_shared<mtd::StubRenderable>(),
         std::make_shared<mtd::StubRenderable>()};
 
-    mc::ScreencastDisplayBuffer db{rect, stub_buffer};
+    mc::ScreencastDisplayBuffer db{default_rect, default_size,
+                                   default_mirror_mode, free_queue,
+                                   ready_queue, stub_display};
 
     EXPECT_FALSE(db.post_renderables_if_optimizable(renderables));
 }
 
+TEST_F(ScreencastDisplayBufferTest, does_not_throw_on_multiple_make_current_calls)
+{
+    mc::ScreencastDisplayBuffer db{default_rect, default_size,
+                                   default_mirror_mode, free_queue,
+                                   ready_queue, stub_display};
+
+    EXPECT_NO_THROW(db.make_current());
+    EXPECT_NO_THROW(db.make_current());
+}
+
+TEST_F(ScreencastDisplayBufferTest, schedules_onto_ready_queue)
+{
+    mc::ScreencastDisplayBuffer db{default_rect, default_size,
+                                   default_mirror_mode, free_queue,
+                                   ready_queue, stub_display};
+
+    db.bind();
+    db.swap_buffers();
+
+    ASSERT_THAT(ready_queue.num_scheduled(), Gt(0));
+
+    auto ready_buffer = ready_queue.next_buffer();
+    auto const expected_buffer = mt::fake_shared(stub_buffer);
+
+    EXPECT_THAT(ready_buffer, Eq(expected_buffer));
+}
+
+TEST_F(ScreencastDisplayBufferTest, uses_requested_mirror_mode)
+{
+    MirMirrorMode const expected_mirror_mode{mir_mirror_mode_horizontal};
+    mc::ScreencastDisplayBuffer db{default_rect, default_size,
+                                   expected_mirror_mode, free_queue,
+                                   ready_queue, stub_display};
+
+    EXPECT_THAT(db.mirror_mode(), Eq(expected_mirror_mode));
+}
+

=== modified file 'tests/unit-tests/dispatch/test_threaded_dispatcher.cpp'
--- tests/unit-tests/dispatch/test_threaded_dispatcher.cpp	2016-03-23 06:39:56 +0000
+++ tests/unit-tests/dispatch/test_threaded_dispatcher.cpp	2016-04-20 18:34:35 +0000
@@ -36,9 +36,37 @@
 
 namespace md = mir::dispatch;
 namespace mt = mir::test;
+namespace mtf = mir_test_framework;
 
 namespace
 {
+
+std::ostream& operator << (std::ostream& os, mtf::TerminationReason const& reason)
+{
+    switch(reason)
+    {
+    case mtf::TerminationReason::unknown:
+        os << "unknown";
+        break;
+    case mtf::TerminationReason::child_terminated_normally:
+        os << "child_terminated_normally";
+        break;
+    case mtf::TerminationReason::child_terminated_by_signal:
+        os << "child_terminated_by_signal";
+        break;
+    case mtf::TerminationReason::child_terminated_with_core_dump:
+        os << "child_terminated_with_core_dump";
+        break;
+    case mtf::TerminationReason::child_stopped_by_signal:
+        os << "child_stopped_by_signal";
+        break;
+    case mtf::TerminationReason::child_resumed_by_signal:
+        os << "child_resumed_by_signal";
+        break;
+    }
+    return os;
+}
+
 class ThreadedDispatcherTest : public ::testing::Test
 {
 public:
@@ -331,10 +359,19 @@
         [&]
         {
             {
-                auto dispatched = std::make_shared<mt::Signal>();
+                auto dispatched_signal = std::make_shared<mt::Signal>();
                 auto dispatchable = std::make_shared<mt::TestDispatchable>(
-                    [dispatched]() { dispatched->raise(); });
-
+                    [dispatched_signal]() { dispatched_signal->raise(); });
+                auto exception_handler = [] {
+                    try
+                    {
+                        throw;
+                    }
+                    catch(std::exception const& e)
+                    {
+                        std::cerr << "error: " << e.what() << std::endl;
+                    }
+                };
                 /* When there's no SIGCONT handler installed a SIGSTOP/SIGCONT
                  * pair POSIX mandates that a SIGSTOP/SIGCONT pair will *not*
                  * result in blocked syscalls returning EINTR.
@@ -348,17 +385,23 @@
                  */
                 signal(SIGCONT, &sigcont_handler);
 
-                md::ThreadedDispatcher dispatcher{"Test thread", dispatchable};
+                md::ThreadedDispatcher dispatcher{"Test thread", dispatchable, exception_handler};
                 // Ensure the dispatcher has started
                 dispatchable->trigger();
-                EXPECT_TRUE(dispatched->wait_for(1s));
+                bool dispatched = dispatched_signal->wait_for(1s);
+                if (!dispatched)
+                    std::cerr << "Timed out waiting for dispatcher to start" << std::endl;
+                EXPECT_TRUE(dispatched);
 
                 stop_and_restart_process();
 
-                dispatched->reset();
+                dispatched_signal->reset();
                 // The dispatcher shouldn't have been affected by the signal
                 dispatchable->trigger();
-                EXPECT_TRUE(dispatched->wait_for(5s));
+                dispatched = dispatched_signal->wait_for(5s);
+                if (!dispatched)
+                    std::cerr << "Timed out waiting for dispatch" << std::endl;
+                EXPECT_TRUE(dispatched);
 
                 // Because we terminate this process with an explicit call to
                 // exit(), objects on the stack are not destroyed.
@@ -367,7 +410,9 @@
                 stop_and_restart_process.~CrossProcessAction();
             }
 
-            exit(HasFailure() ? EXIT_FAILURE : EXIT_SUCCESS);
+            auto exit_code = HasFailure() ? EXIT_FAILURE : EXIT_SUCCESS;
+            std::cerr << "exiting child process with code: " << exit_code << std::endl;
+            exit(exit_code);
         },
         []{ return 1; });
 
@@ -383,6 +428,8 @@
         });
 
     auto const result = child->wait_for_termination(30s);
+    std::cerr << "child exit - reason: " << result.reason;
+    std::cerr << " - exit code: " << result.exit_code << std::endl;
     EXPECT_TRUE(result.succeeded());
 }
 

=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2016-04-15 03:41:28 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2016-04-20 18:34:35 +0000
@@ -599,7 +599,7 @@
     EXPECT_EQ(stub_buffer.id().as_value(), screencast.buffer_stream().buffer().buffer_id());
 }
 
-TEST_F(SessionMediator, partially_packs_buffer_for_screencast_buffer)
+TEST_F(SessionMediator, fully_packs_screencast_buffer)
 {
     using namespace testing;
 
@@ -608,7 +608,7 @@
     auto const& stub_buffer = stub_screencast->stub_buffer;
 
     EXPECT_CALL(mock_ipc_operations,
-        pack_buffer(_, Ref(stub_buffer), mg::BufferIpcMsgType::update_msg))
+        pack_buffer(_, Ref(stub_buffer), mg::BufferIpcMsgType::full_msg))
         .Times(1);
 
     mediator.screencast_buffer(&screencast_id,

=== modified file 'tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp'
--- tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp	2016-01-29 08:18:22 +0000
+++ tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp	2016-04-20 18:34:35 +0000
@@ -132,6 +132,7 @@
             EXPECT_CALL(mock_gl, glBindFramebuffer(_,Ne(0)));
 
             mt::as_render_target(db)->make_current();
+            mt::as_render_target(db)->bind();
 
             Mock::VerifyAndClearExpectations(&mock_egl);
             Mock::VerifyAndClearExpectations(&mock_gl);