Merge lp:~cemil-azizoglu/mir/create-chain-from-render-surface into lp:mir

[Cemil Azizoglu]

Get presentation chain from a render surface.

Get presentation chain from a render surface.

I also modified the two presentation chain examples in the playground to use render surfaces.

=== modified file 'playground/mir_demo_client_chain_jumping_buffers.c'
--- playground/mir_demo_client_chain_jumping_buffers.c	2016-11-16 12:50:00 +0000
+++ playground/mir_demo_client_chain_jumping_buffers.c	2016-11-30 22:47:49 +0000
@@ -21,6 +21,7 @@
 #include <mir_toolkit/mir_buffer_stream.h>
 #include <mir_toolkit/mir_surface.h>
 #include <mir_toolkit/mir_presentation_chain.h>
+#include <mir_toolkit/mir_render_surface.h>
 #include <mir_toolkit/mir_buffer.h>
 #include <mir_toolkit/version.h>
 #include <sys/types.h>
@@ -174,9 +175,17 @@
     unsigned int spare_buffer = 0;
 
     MirPresentationChain* chain[num_chains];
+    MirRenderSurface* render_surface[num_chains];
     for(unsigned int i = 0u; i < num_chains; i++)
     {
-        chain[i] =  mir_connection_create_presentation_chain_sync(connection);
+        render_surface[i] = mir_connection_create_render_surface_sync(connection, chain_width, chain_height);
+        if (!mir_render_surface_is_valid(render_surface[i]))
+        {
+            printf("could not create render surface\n");
+            return -1;
+        }
+
+        chain[i] =  mir_render_surface_get_presentation_chain(render_surface[i]);
         if (!mir_presentation_chain_is_valid(chain[i]))
         {
             printf("could not create MirPresentationChain\n");
@@ -193,14 +202,14 @@
 
     //Arrange a 2x2 grid of chains within surface
     MirSurfaceSpec* spec = mir_connection_create_spec_for_normal_surface(connection, width, height, format);
-    mir_surface_spec_add_presentation_chain(
-        spec, chain_width, chain_height, displacement_x, displacement_y, chain[0]);
-    mir_surface_spec_add_presentation_chain(
-        spec, chain_width, chain_height, chain_width, displacement_y, chain[1]);
-    mir_surface_spec_add_presentation_chain(
-        spec, chain_width, chain_height, displacement_x, chain_height, chain[2]);
-    mir_surface_spec_add_presentation_chain(
-        spec, chain_width, chain_height, chain_width, chain_height, chain[3]);
+    mir_surface_spec_add_render_surface(
+        spec, render_surface[0], chain_width, chain_height, displacement_x, displacement_y);
+    mir_surface_spec_add_render_surface(
+        spec, render_surface[1], chain_width, chain_height, chain_width, displacement_y);
+    mir_surface_spec_add_render_surface(
+        spec, render_surface[2], chain_width, chain_height, displacement_x, chain_height);
+    mir_surface_spec_add_render_surface(
+        spec, render_surface[3], chain_width, chain_height, chain_width, chain_height);
     MirSurface* surface = mir_surface_create_sync(spec);
     mir_surface_spec_release(spec);
 
@@ -256,7 +265,7 @@
     for (unsigned int i = 0u; i < num_buffers; i++)
         mir_buffer_release(buffer_available[i].buffer);
     for (unsigned int i = 0u; i < num_chains; i++)
-        mir_presentation_chain_release(chain[i]);
+        mir_render_surface_release(render_surface[i]);
     mir_surface_release_sync(surface);
     mir_connection_release(connection);
     return 0;

=== modified file 'playground/mir_demo_client_prerendered_frames.c'
--- playground/mir_demo_client_prerendered_frames.c	2016-11-16 12:50:00 +0000
+++ playground/mir_demo_client_prerendered_frames.c	2016-11-30 22:47:49 +0000
@@ -21,6 +21,7 @@
 #include <mir_toolkit/mir_buffer_stream.h>
 #include <mir_toolkit/mir_surface.h>
 #include <mir_toolkit/mir_presentation_chain.h>
+#include <mir_toolkit/mir_render_surface.h>
 #include <mir_toolkit/mir_buffer.h>
 #include <mir_toolkit/version.h>
 #include <sys/types.h>
@@ -146,7 +147,14 @@
         return -1;
     }
 
-    MirPresentationChain* chain =  mir_connection_create_presentation_chain_sync(connection);
+    MirRenderSurface* render_surface = mir_connection_create_render_surface_sync(connection, width, height);
+    if (!mir_render_surface_is_valid(render_surface))
+    {
+        printf("could not create a render surface\n");
+        return -1;
+    }
+
+    MirPresentationChain* chain =  mir_render_surface_get_presentation_chain(render_surface);
     if (!mir_presentation_chain_is_valid(chain))
     {
         printf("could not create MirPresentationChain\n");
@@ -161,8 +169,8 @@
     }
 
     MirSurfaceSpec* spec = mir_connection_create_spec_for_normal_surface(connection, width, height, format);
-    mir_surface_spec_add_presentation_chain(
-        spec, width, height, displacement_x, displacement_y, chain);
+    mir_surface_spec_add_render_surface(
+        spec, render_surface, width, height, displacement_x, displacement_y);
     MirSurface* surface = mir_surface_create_sync(spec);
     if (!mir_surface_is_valid(surface))
     {
@@ -224,7 +232,7 @@
 
     for (i = 0u; i < num_prerendered_frames; i++)
         mir_buffer_release(buffer_available[i].buffer);
-    mir_presentation_chain_release(chain);
+    mir_render_surface_release(render_surface);
     mir_surface_release_sync(surface);
     mir_connection_release(connection);
     return 0;

=== modified file 'src/client/error_render_surface.cpp'
--- src/client/error_render_surface.cpp	2016-11-22 18:44:52 +0000
+++ src/client/error_render_surface.cpp	2016-11-30 22:47:49 +0000
@@ -60,6 +60,11 @@
     throw std::runtime_error(error);
 }
 
+MirPresentationChain* mcl::ErrorRenderSurface::get_presentation_chain()
+{
+    throw std::runtime_error(error);
+}
+
 char const* mcl::ErrorRenderSurface::get_error_message() const
 {
     return error.c_str();

=== modified file 'src/client/error_render_surface.h'
--- src/client/error_render_surface.h	2016-11-22 18:44:52 +0000
+++ src/client/error_render_surface.h	2016-11-30 22:47:49 +0000
@@ -41,6 +41,7 @@
         int width, int height,
         MirPixelFormat format,
         MirBufferUsage buffer_usage) override;
+    MirPresentationChain* get_presentation_chain() override;
 private:
     std::string const error;
     MirConnection* const connection_;

=== modified file 'src/client/mir_connection.cpp'
--- src/client/mir_connection.cpp	2016-11-22 18:18:59 +0000
+++ src/client/mir_connection.cpp	2016-11-30 22:47:49 +0000
@@ -1177,6 +1177,19 @@
     return display_configuration->take_snapshot();
 }
 
+std::shared_ptr<mcl::PresentationChain> MirConnection::create_presentation_chain_with_id(
+    MirRenderSurface* render_surface,
+    mir::protobuf::BufferStream const& a_protobuf_bs)
+{
+    if (!client_buffer_factory)
+        client_buffer_factory = platform->create_buffer_factory();
+    auto chain = std::make_shared<mcl::PresentationChain>(
+        this, a_protobuf_bs.id().value(), server, client_buffer_factory, buffer_factory);
+
+    surface_map->insert(render_surface->stream_id(), chain);
+    return chain;
+}
+
 void MirConnection::create_presentation_chain(
     mir_presentation_chain_callback callback,
     void *context)

=== modified file 'src/client/mir_connection.h'
--- src/client/mir_connection.h	2016-11-14 21:59:19 +0000
+++ src/client/mir_connection.h	2016-11-30 22:47:49 +0000
@@ -67,6 +67,7 @@
 class AsyncBufferFactory;
 class MirBuffer;
 class BufferStream;
+class PresentationChain;
 
 namespace rpc
 {
@@ -170,6 +171,9 @@
     void create_presentation_chain(
         mir_presentation_chain_callback callback,
         void *context);
+    std::shared_ptr<mir::client::PresentationChain> create_presentation_chain_with_id(
+        MirRenderSurface* render_surface,
+        mir::protobuf::BufferStream const& a_protobuf_bs);
     void release_presentation_chain(MirPresentationChain* context);
 
     void release_consumer_stream(mir::client::ClientBufferStream*);

=== modified file 'src/client/mir_render_surface.h'
--- src/client/mir_render_surface.h	2016-11-22 18:44:52 +0000
+++ src/client/mir_render_surface.h	2016-11-30 22:47:49 +0000
@@ -36,6 +36,7 @@
         int width, int height,
         MirPixelFormat format,
         MirBufferUsage buffer_usage) = 0;
+    virtual MirPresentationChain* get_presentation_chain() = 0;
     virtual char const* get_error_message() const = 0;
     virtual ~MirRenderSurface() = default;
 protected:

=== modified file 'src/client/mir_render_surface_api.cpp'
--- src/client/mir_render_surface_api.cpp	2016-11-22 18:44:52 +0000
+++ src/client/mir_render_surface_api.cpp	2016-11-30 22:47:49 +0000
@@ -189,6 +189,21 @@
     return nullptr;
 }
 
+MirPresentationChain* mir_render_surface_get_presentation_chain(
+    MirRenderSurface* render_surface)
+try
+{
+    mir::require(render_surface);
+    auto connection = connection_map.connection(static_cast<void*>(render_surface));
+    auto rs = connection->connection_surface_map()->render_surface(render_surface);
+    return rs->get_presentation_chain();
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+    return nullptr;
+}
+
 void mir_render_surface_get_size(MirRenderSurface* render_surface, int* width, int* height)
 {
     mir::require(render_surface && width && height);

=== modified file 'src/client/render_surface.cpp'
--- src/client/render_surface.cpp	2016-11-22 18:44:52 +0000
+++ src/client/render_surface.cpp	2016-11-30 22:47:49 +0000
@@ -61,6 +61,9 @@
     MirPixelFormat format,
     MirBufferUsage buffer_usage)
 {
+    if (chain_from_id)
+        BOOST_THROW_EXCEPTION(std::logic_error("Already contains a presentation chain"));
+
     if (!stream_from_id)
     {
         protobuf_bs->set_pixel_format(format);
@@ -80,6 +83,22 @@
         dynamic_cast<ClientBufferStream*>(stream_from_id.get()));
 }
 
+MirPresentationChain* mcl::RenderSurface::get_presentation_chain()
+{
+    if (stream_from_id)
+        BOOST_THROW_EXCEPTION(std::logic_error("Already contains a buffer stream"));
+
+    if (!chain_from_id)
+    {
+        chain_from_id = connection_->create_presentation_chain_with_id(this,
+                                                                       *protobuf_bs);
+        //TODO: Figure out how to handle mir_buffer_usage_hardware once
+        //      EGL is made to support RSs.
+    }
+
+    return reinterpret_cast<MirPresentationChain*>(chain_from_id.get());
+}
+
 geom::Size mcl::RenderSurface::size() const
 {
     std::lock_guard<decltype(size_mutex)> lk(size_mutex);

=== modified file 'src/client/render_surface.h'
--- src/client/render_surface.h	2016-11-22 18:44:52 +0000
+++ src/client/render_surface.h	2016-11-30 22:47:49 +0000
@@ -39,6 +39,7 @@
 {
 class ClientPlatform;
 class BufferStream;
+class PresentationChain;
 class RenderSurface : public MirRenderSurface
 {
 public:
@@ -57,6 +58,7 @@
         int width, int height,
         MirPixelFormat format,
         MirBufferUsage buffer_usage) override;
+    MirPresentationChain* get_presentation_chain() override;
 
 private:
     MirConnection* const connection_;
@@ -64,6 +66,7 @@
     std::shared_ptr<ClientPlatform> platform;
     std::shared_ptr<mir::protobuf::BufferStream> protobuf_bs;
     std::shared_ptr<mir::client::BufferStream> stream_from_id;
+    std::shared_ptr<mir::client::PresentationChain> chain_from_id;
 
     std::mutex mutable size_mutex;
     geometry::Size desired_size;

=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2016-11-30 11:38:41 +0000
+++ src/client/symbols.map	2016-11-30 22:47:49 +0000
@@ -388,6 +388,7 @@
     mir_connection_create_render_surface;
     mir_connection_create_render_surface_sync;
     mir_render_surface_get_buffer_stream;
+    mir_render_surface_get_presentation_chain;
     mir_render_surface_is_valid;
     mir_render_surface_get_error_message;
     mir_render_surface_get_size;

=== modified file 'src/include/client/mir_toolkit/mir_render_surface.h'
--- src/include/client/mir_toolkit/mir_render_surface.h	2016-11-14 22:39:13 +0000
+++ src/include/client/mir_toolkit/mir_render_surface.h	2016-11-30 22:47:49 +0000
@@ -133,6 +133,14 @@
     MirBufferUsage usage);
 
 /**
+ * Obtain the presentation chain backing a given render surface
+ *
+ * \return                       The chain contained in the given render surface
+ */
+MirPresentationChain* mir_render_surface_get_presentation_chain(
+    MirRenderSurface* render_surface);
+
+/**
  * Set the MirSurfaceSpec to display content contained in a render surface
  *
  * \warning: The initial call to mir_surface_spec_add_render_surface will set

=== modified file 'tests/acceptance-tests/staging/test_render_surface.cpp'
--- tests/acceptance-tests/staging/test_render_surface.cpp	2016-11-23 00:09:04 +0000
+++ tests/acceptance-tests/staging/test_render_surface.cpp	2016-11-30 22:47:49 +0000
@@ -18,6 +18,7 @@
 
 #include "mir_toolkit/mir_client_library.h"
 #include "mir_toolkit/mir_render_surface.h"
+#include "mir_toolkit/mir_presentation_chain.h"
 
 #include "mir/geometry/size.h"
 #include "mir_test_framework/headless_in_process_server.h"
@@ -57,7 +58,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(RenderSurfaceTest, can_hand_out_buffer_streams)
+TEST_F(RenderSurfaceTest, can_hand_out_buffer_stream)
 {
     auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
 
@@ -98,6 +99,7 @@
         physical_size.width.as_int(), physical_size.height.as_int(),
         mir_pixel_format_abgr_8888,
         mir_buffer_usage_hardware);
+
     ASSERT_THAT(bs, NotNull());
     EXPECT_TRUE(mir_buffer_stream_is_valid(bs));
     EXPECT_THAT(mir_buffer_stream_get_error_message(bs), StrEq(""));
@@ -109,32 +111,28 @@
 TEST_F(RenderSurfaceTest, render_surfaces_without_content_can_be_added_to_spec)
 {
     auto physical_size = logical_size;
-
     auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
 
     auto rs = mir_connection_create_render_surface_sync(
         connection, logical_size.width.as_int(), logical_size.height.as_int());
-
     auto spec = mir_connection_create_spec_for_normal_surface(
         connection,
         physical_size.width.as_int(), physical_size.height.as_int(),
         mir_pixel_format_invalid);
-
     mir_surface_spec_add_render_surface(
         spec, rs, logical_size.width.as_int(), logical_size.height.as_int(), 0, 0);
-
     auto surface = mir_surface_create_sync(spec);
     mir_surface_spec_release(spec);
 
     EXPECT_THAT(surface, IsValid());
-
     EXPECT_THAT(mir_surface_get_buffer_stream(surface), Eq(nullptr));
+
     mir_render_surface_release(rs);
     mir_surface_release_sync(surface);
     mir_connection_release(connection);
 }
 
-TEST_F(RenderSurfaceTest, content_can_be_constructed_after_surface_creation)
+TEST_F(RenderSurfaceTest, stream_can_be_constructed_after_surface_creation)
 {
     int const width{800}, height{600};
     MirPixelFormat const format{mir_pixel_format_abgr_8888};
@@ -143,26 +141,126 @@
     auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
 
     auto rs = mir_connection_create_render_surface_sync(
-            connection, logical_size.width.as_int(), logical_size.height.as_int());
+        connection, logical_size.width.as_int(), logical_size.height.as_int());
     auto spec = mir_connection_create_spec_for_normal_surface(connection,
                                                               width, height,
                                                               format);
-
     mir_surface_spec_add_render_surface(spec, rs, width, height, 0, 0);
-
     auto surface = mir_surface_create_sync(spec);
     mir_surface_spec_release(spec);
-
     auto bs = mir_render_surface_get_buffer_stream(rs,
                                                    640, 480,
                                                    format,
                                                    usage);
 
     EXPECT_THAT(surface, IsValid());
-
     EXPECT_THAT(mir_surface_get_buffer_stream(surface), Eq(nullptr));
     EXPECT_TRUE(mir_buffer_stream_is_valid(bs));
-    mir_render_surface_release(rs);
-    mir_surface_release_sync(surface);
+
+    mir_render_surface_release(rs);
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
+
+TEST_F(RenderSurfaceTest, can_hand_out_presentation_chain)
+{
+    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+
+    auto rs = mir_connection_create_render_surface_sync(
+        connection, logical_size.width.as_int(), logical_size.height.as_int());
+
+    auto pc = mir_render_surface_get_presentation_chain(rs);
+
+    ASSERT_THAT(pc, NotNull());
+    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
+
+    mir_render_surface_release(rs);
+    mir_connection_release(connection);
+}
+
+TEST_F(RenderSurfaceTest, chain_can_be_constructed_after_surface_creation)
+{
+    int const width{800}, height{600};
+    MirPixelFormat const format{mir_pixel_format_abgr_8888};
+
+    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+
+    auto rs = mir_connection_create_render_surface_sync(
+        connection, logical_size.width.as_int(), logical_size.height.as_int());
+    auto spec = mir_connection_create_spec_for_normal_surface(connection,
+                                                              width, height,
+                                                              format);
+    mir_surface_spec_add_render_surface(spec, rs, width, height, 0, 0);
+    auto surface = mir_surface_create_sync(spec);
+    mir_surface_spec_release(spec);
+    auto pc = mir_render_surface_get_presentation_chain(rs);
+
+    EXPECT_THAT(surface, IsValid());
+    EXPECT_THAT(mir_surface_get_buffer_stream(surface), Eq(nullptr));
+    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
+
+    mir_render_surface_release(rs);
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
+
+TEST_F(RenderSurfaceTest, dont_have_to_release_presentation_chain)
+{
+    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+
+    auto rs = mir_connection_create_render_surface_sync(
+        connection, logical_size.width.as_int(), logical_size.height.as_int());
+    auto pc = mir_render_surface_get_presentation_chain(rs);
+
+    ASSERT_THAT(pc, NotNull());
+    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
+
+    mir_render_surface_release(rs);
+    mir_connection_release(connection);
+}
+
+TEST_F(RenderSurfaceTest, can_hand_out_stream_or_chain_but_not_both)
+{
+    auto physical_size = logical_size;
+    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+
+    {
+        auto rs = mir_connection_create_render_surface_sync(
+            connection, logical_size.width.as_int(), logical_size.height.as_int());
+        auto pc = mir_render_surface_get_presentation_chain(rs);
+
+        ASSERT_THAT(pc, NotNull());
+        EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
+
+        auto bs = mir_render_surface_get_buffer_stream(
+            rs,
+            physical_size.width.as_int(), physical_size.height.as_int(),
+            mir_pixel_format_abgr_8888,
+            mir_buffer_usage_hardware);
+
+        EXPECT_THAT(bs, Eq(nullptr));
+
+        mir_render_surface_release(rs);
+    }
+
+    {
+        auto rs = mir_connection_create_render_surface_sync(
+            connection, logical_size.width.as_int(), logical_size.height.as_int());
+        auto bs = mir_render_surface_get_buffer_stream(
+            rs,
+            physical_size.width.as_int(), physical_size.height.as_int(),
+            mir_pixel_format_abgr_8888,
+            mir_buffer_usage_hardware);
+
+        ASSERT_THAT(bs, NotNull());
+        EXPECT_TRUE(mir_buffer_stream_is_valid(bs));
+
+        auto pc = mir_render_surface_get_presentation_chain(rs);
+
+        EXPECT_THAT(pc, Eq(nullptr));
+
+        mir_render_surface_release(rs);
+    }
+
     mir_connection_release(connection);
 }

=== modified file 'tests/unit-tests/client/CMakeLists.txt'
--- tests/unit-tests/client/CMakeLists.txt	2016-10-26 05:15:38 +0000
+++ tests/unit-tests/client/CMakeLists.txt	2016-11-30 22:47:49 +0000
@@ -23,6 +23,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_error_buffer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_client_mir_error.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_no_tls_future.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_mir_render_surface.cpp
 )
 
 if (NOT MIR_DISABLE_INPUT)

=== modified file 'tests/unit-tests/client/test_mir_connection.cpp'
--- tests/unit-tests/client/test_mir_connection.cpp	2016-11-23 00:09:04 +0000
+++ tests/unit-tests/client/test_mir_connection.cpp	2016-11-30 22:47:49 +0000
@@ -23,8 +23,6 @@
 #include "src/client/mir_surface.h"
 #include "src/client/buffer_factory.h"
 #include "src/client/presentation_chain.h"
-#include "src/client/render_surface.h"
-#include "src/client/connection_surface_map.h"
 
 #include "mir/client_platform.h"
 #include "mir/client_platform_factory.h"
@@ -36,7 +34,6 @@
 #include "mir_toolkit/mir_presentation_chain.h"
 
 #include "src/server/frontend/resource_cache.h" /* needed by test_server.h */
-#include "mir/test/fake_shared.h"
 #include "mir/test/test_protobuf_server.h"
 #include "mir/test/stub_server_tool.h"
 #include "mir/test/doubles/mock_mir_buffer.h"
@@ -57,31 +54,11 @@
 namespace mev = mir::events;
 namespace md = mir::dispatch;
 namespace geom = mir::geometry;
-namespace mt = mir::test;
-namespace mtd = mt::doubles;
+namespace mtd = mir::test::doubles;
 using namespace testing;
 
 namespace
 {
-
-void assign_result(void* result, void** context)
-{
-    if (context)
-        *context = result;
-}
-
-struct RenderSurfaceCallback
-{
-    static void created(MirRenderSurface* render_surface, void *client_context)
-    {
-        auto const context = reinterpret_cast<RenderSurfaceCallback*>(client_context);
-        context->invoked = true;
-        context->resulting_render_surface = render_surface;
-    }
-    bool invoked = false;
-    MirRenderSurface* resulting_render_surface = nullptr;
-};
-
 struct BufferStreamCallback
 {
     static void created(MirBufferStream* stream, void *client_context)
@@ -202,15 +179,12 @@
         auto native_display = std::make_shared<EGLNativeDisplayType>();
         *native_display = reinterpret_cast<EGLNativeDisplayType>(0x0);
 
-        auto native_window = std::make_shared<EGLNativeWindowType>();
-        *native_window = reinterpret_cast<EGLNativeWindowType>(0x12345678);
-
         ON_CALL(*this, create_egl_native_display())
             .WillByDefault(Return(native_display));
         ON_CALL(*this, create_buffer_factory())
             .WillByDefault(Return(std::make_shared<mtd::StubClientBufferFactory>()));
         ON_CALL(*this, create_egl_native_window(_))
-            .WillByDefault(Return(native_window));
+            .WillByDefault(Return(std::shared_ptr<EGLNativeWindowType>()));
         ON_CALL(*this, platform_operation(_))
             .WillByDefault(Return(nullptr));
     }
@@ -232,8 +206,7 @@
     MOCK_METHOD2(use_egl_native_window, void(std::shared_ptr<void>, mcl::EGLNativeSurface*));
     MOCK_METHOD1(create_egl_native_window, std::shared_ptr<void>(mcl::EGLNativeSurface*));
     MOCK_METHOD0(create_egl_native_display, std::shared_ptr<EGLNativeDisplayType>());
-    MOCK_CONST_METHOD2(get_egl_pixel_format,
-        MirPixelFormat(EGLDisplay, EGLConfig));
+    MOCK_CONST_METHOD2(get_egl_pixel_format, MirPixelFormat(EGLDisplay, EGLConfig));
     MOCK_METHOD2(request_interface, void*(char const*, int));
 
     mcl::ClientContext* client_context = nullptr;
@@ -877,208 +850,3 @@
 
     connection->release_buffer(&mock_buffer);
 }
-
-TEST_F(MirConnectionTest, render_surface_can_be_created_and_released)
-{
-    EXPECT_CALL(*mock_channel, on_buffer_stream_create(_,_))
-        .WillOnce(Invoke([](mp::BufferStream& stream, google::protobuf::Closure*)
-        {
-            stream.mutable_id()->set_value(1);
-        }));
-
-    connection->connect("MirConnectionTest", connected_callback, 0)->wait_for_all();
-
-    void* nw = nullptr;
-    MirRenderSurface* render_surface = nullptr;
-    connection->create_render_surface_with_content(
-        {10, 10},
-        reinterpret_cast<mir_render_surface_callback>(assign_result),
-        &render_surface,
-        &nw);
-    EXPECT_THAT(render_surface, NotNull());
-    EXPECT_THAT(nw, NotNull());
-    EXPECT_THAT(render_surface, Eq(nw));
-    EXPECT_NO_THROW(connection->release_render_surface_with_content(nw));
-
-    connection->disconnect();
-}
-
-TEST_F(MirConnectionTest, creation_of_render_surface_creates_egl_native_window)
-{
-    RenderSurfaceCallback callback;
-
-    connection->connect("MirConnectionTest", connected_callback, 0)->wait_for_all();
-
-    EXPECT_CALL(*mock_platform, create_egl_native_window(nullptr));
-    EXPECT_CALL(*mock_channel, on_buffer_stream_create(_,_))
-        .WillOnce(Invoke([](mp::BufferStream& stream, google::protobuf::Closure*)
-        {
-            stream.mutable_id()->set_value(1);
-        }));
-
-    void* nw = nullptr;
-    connection->create_render_surface_with_content(
-        {10, 10},
-        &RenderSurfaceCallback::created,
-        &callback,
-        &nw);
-    EXPECT_THAT(nw, NotNull());
-    EXPECT_TRUE(callback.invoked);
-    EXPECT_THAT(callback.resulting_render_surface, NotNull());
-    auto rs = connection->connection_surface_map()->render_surface(
-        static_cast<void*>(callback.resulting_render_surface));
-    EXPECT_TRUE(reinterpret_cast<mcl::RenderSurface*>(rs->valid()));
-}
-
-TEST_F(MirConnectionTest, render_surface_returns_connection)
-{
-    MirConnection* conn{ reinterpret_cast<MirConnection*>(0x12345678) };
-
-    mcl::RenderSurface rs(
-        conn, nullptr, nullptr, nullptr, {});
-    EXPECT_THAT(rs.connection(), Eq(conn));
-}
-
-TEST_F(MirConnectionTest, render_surface_has_correct_id_before_content_creation)
-{
-    MirConnection* conn{ reinterpret_cast<MirConnection*>(0x12345678) };
-    auto id = 123;
-
-    mp::BufferStream protobuf_bs;
-    mp::BufferStreamId bs_id;
-
-    bs_id.set_value(id);
-    *protobuf_bs.mutable_id() = bs_id;
-
-    mcl::RenderSurface rs(
-        conn, nullptr, nullptr, mt::fake_shared(protobuf_bs), {});
-    EXPECT_THAT(rs.stream_id().as_value(), Eq(id));
-}
-
-TEST_F(MirConnectionTest, render_surface_can_create_buffer_stream)
-{
-    connection->connect("MirConnectionTest", connected_callback, 0)->wait_for_all();
-    auto id = 123;
-
-    mp::BufferStream protobuf_bs;
-    mp::BufferStreamId bs_id;
-
-    bs_id.set_value(id);
-    *protobuf_bs.mutable_id() = bs_id;
-
-    auto native_window = mock_platform->create_egl_native_window(nullptr);
-
-    mcl::RenderSurface rs(
-        connection.get(), native_window, nullptr, mt::fake_shared(protobuf_bs), {});
-
-    auto bs = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
-        mir_buffer_usage_software);
-
-    EXPECT_THAT(bs, NotNull());
-}
-
-TEST_F(MirConnectionTest, render_surface_creation_of_buffer_stream_more_than_once_returns_same_object)
-{
-    connection->connect("MirConnectionTest", connected_callback, 0)->wait_for_all();
-    auto id = 123;
-
-    mp::BufferStream protobuf_bs;
-    mp::BufferStreamId bs_id;
-
-    bs_id.set_value(id);
-    *protobuf_bs.mutable_id() = bs_id;
-
-    auto native_window = mock_platform->create_egl_native_window(nullptr);
-
-    mcl::RenderSurface rs(
-        connection.get(), native_window, mock_platform, mt::fake_shared(protobuf_bs), {});
-
-    EXPECT_CALL(*mock_platform, use_egl_native_window(native_window,_));
-
-    auto bs1 = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
-        mir_buffer_usage_hardware);
-
-    auto bs2 = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
-        mir_buffer_usage_hardware);
-
-    EXPECT_THAT(bs1, NotNull());
-    EXPECT_THAT(bs2, NotNull());
-    EXPECT_THAT(bs1, Eq(bs2));
-}
-
-TEST_F(MirConnectionTest, render_surface_creation_of_buffer_stream_with_hardware_usage_installs_new_native_window)
-{
-    connection->connect("MirConnectionTest", connected_callback, 0)->wait_for_all();
-    auto id = 123;
-
-    mp::BufferStream protobuf_bs;
-    mp::BufferStreamId bs_id;
-
-    bs_id.set_value(id);
-    *protobuf_bs.mutable_id() = bs_id;
-
-    auto native_window = mock_platform->create_egl_native_window(nullptr);
-
-    mcl::RenderSurface rs(
-        connection.get(), native_window, mock_platform, mt::fake_shared(protobuf_bs), {});
-
-    EXPECT_CALL(*mock_platform, use_egl_native_window(native_window,_));
-
-    auto bs = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
-        mir_buffer_usage_hardware);
-
-    EXPECT_THAT(bs, NotNull());
-}
-
-TEST_F(MirConnectionTest, render_surface_creation_of_buffer_stream_with_software_usage_does_not_install_new_native_window)
-{
-    connection->connect("MirConnectionTest", connected_callback, 0)->wait_for_all();
-    auto id = 123;
-
-    mp::BufferStream protobuf_bs;
-    mp::BufferStreamId bs_id;
-
-    bs_id.set_value(id);
-    *protobuf_bs.mutable_id() = bs_id;
-
-    auto native_window = mock_platform->create_egl_native_window(nullptr);
-
-    mcl::RenderSurface rs(
-        connection.get(), native_window, mock_platform, mt::fake_shared(protobuf_bs), {});
-
-    EXPECT_CALL(*mock_platform, use_egl_native_window(_,_)).Times(0);
-
-    auto bs = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
-        mir_buffer_usage_software);
-
-    EXPECT_THAT(bs, NotNull());
-}
-
-TEST_F(MirConnectionTest, render_surface_object_is_invalid_after_creation_exception)
-{
-    RenderSurfaceCallback callback;
-
-    connection->connect("MirConnectionTest", connected_callback, 0)->wait_for_all();
-
-    EXPECT_CALL(*mock_channel, on_buffer_stream_create(_,_))
-        .WillOnce(DoAll(
-            Invoke([](mp::BufferStream&, google::protobuf::Closure* c){ c->Run(); }),
-            Throw(std::runtime_error("Eeek!"))));
-
-    void* nw = nullptr;
-    connection->create_render_surface_with_content(
-        {10, 10},
-        &RenderSurfaceCallback::created,
-        &callback,
-        &nw);
-
-    EXPECT_TRUE(callback.invoked);
-    EXPECT_THAT(callback.resulting_render_surface, NotNull());
-    auto rs = connection->connection_surface_map()->render_surface(
-        static_cast<void*>(callback.resulting_render_surface));
-
-    EXPECT_THAT(rs->get_error_message(),
-        StrEq("Error processing buffer stream response during render "
-              "surface creation: no ID in response (disconnected?)"));
-    EXPECT_FALSE(reinterpret_cast<mcl::RenderSurface*>(rs->valid()));
-}

=== added file 'tests/unit-tests/client/test_mir_render_surface.cpp'
--- tests/unit-tests/client/test_mir_render_surface.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/client/test_mir_render_surface.cpp	2016-11-30 22:47:49 +0000
@@ -0,0 +1,494 @@
+/*
+ * Copyright © 2016 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: Cemil Azizoglu <[e-mail]>
+ */
+
+#include "src/client/mir_connection.h"
+#include "src/client/default_connection_configuration.h"
+#include "src/client/rpc/mir_basic_rpc_channel.h"
+#include "src/client/render_surface.h"
+#include "src/client/connection_surface_map.h"
+
+#include "mir/client_platform_factory.h"
+#include "mir/dispatch/dispatchable.h"
+
+#include "mir/test/fake_shared.h"
+#include "mir/test/doubles/stub_client_buffer_factory.h"
+
+#include <sys/eventfd.h>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace mcl = mir::client;
+namespace mclr = mcl::rpc;
+namespace mp = mir::protobuf;
+namespace md = mir::dispatch;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
+
+using namespace testing;
+
+namespace
+{
+void assign_result(void* result, void** context)
+{
+    if (context)
+        *context = result;
+}
+
+struct RenderSurfaceCallback
+{
+    static void created(MirRenderSurface* render_surface, void *client_context)
+    {
+        auto const context = reinterpret_cast<RenderSurfaceCallback*>(client_context);
+        context->invoked = true;
+        context->resulting_render_surface = render_surface;
+    }
+    bool invoked = false;
+    MirRenderSurface* resulting_render_surface = nullptr;
+};
+
+struct MockRpcChannel : public mir::client::rpc::MirBasicRpcChannel,
+                        public mir::dispatch::Dispatchable
+{
+    MockRpcChannel()
+        : pollable_fd{eventfd(0, EFD_CLOEXEC)}
+    {
+        ON_CALL(*this, watch_fd()).WillByDefault(testing::Return(pollable_fd));
+    }
+
+    virtual void call_method(std::string const& name,
+                    google::protobuf::MessageLite const* /*parameters*/,
+                    google::protobuf::MessageLite* response,
+                    google::protobuf::Closure* complete)
+    {
+        if (name == "create_buffer_stream")
+        {
+            auto response_message = static_cast<mp::BufferStream*>(response);
+            on_buffer_stream_create(*response_message, complete);
+        }
+
+        complete->Run();
+    }
+
+    MOCK_METHOD2(on_buffer_stream_create, void(mp::BufferStream&, google::protobuf::Closure* complete));
+
+    MOCK_CONST_METHOD0(watch_fd, mir::Fd());
+    MOCK_METHOD1(dispatch, bool(md::FdEvents));
+    MOCK_CONST_METHOD0(relevant_events, md::FdEvents());
+private:
+    mir::Fd pollable_fd;
+};
+
+struct MockClientPlatform : public mcl::ClientPlatform
+{
+    MockClientPlatform()
+    {
+        auto native_window = std::make_shared<EGLNativeWindowType>();
+        *native_window = reinterpret_cast<EGLNativeWindowType>(0x12345678);
+
+        ON_CALL(*this, create_buffer_factory())
+            .WillByDefault(Return(std::make_shared<mtd::StubClientBufferFactory>()));
+        ON_CALL(*this, create_egl_native_window(_))
+            .WillByDefault(Return(native_window));
+    }
+
+    void set_client_context(mcl::ClientContext* ctx)
+    {
+        client_context = ctx;
+    }
+
+    void populate(MirPlatformPackage& pkg) const override
+    {
+        client_context->populate_server_package(pkg);
+    }
+
+    MOCK_CONST_METHOD1(convert_native_buffer, MirNativeBuffer*(mir::graphics::NativeBuffer*));
+    MOCK_CONST_METHOD0(platform_type, MirPlatformType());
+    MOCK_METHOD1(platform_operation, MirPlatformMessage*(MirPlatformMessage const*));
+    MOCK_METHOD0(create_buffer_factory, std::shared_ptr<mcl::ClientBufferFactory>());
+    MOCK_METHOD2(use_egl_native_window, void(std::shared_ptr<void>, mcl::EGLNativeSurface*));
+    MOCK_METHOD1(create_egl_native_window, std::shared_ptr<void>(mcl::EGLNativeSurface*));
+    MOCK_METHOD0(create_egl_native_display, std::shared_ptr<EGLNativeDisplayType>());
+    MOCK_CONST_METHOD2(get_egl_pixel_format, MirPixelFormat(EGLDisplay, EGLConfig));
+    MOCK_METHOD2(request_interface, void*(char const*, int));
+
+    mcl::ClientContext* client_context = nullptr;
+};
+
+struct StubClientPlatformFactory : public mcl::ClientPlatformFactory
+{
+    StubClientPlatformFactory(std::shared_ptr<mcl::ClientPlatform> const& platform)
+        : platform{platform}
+    {
+    }
+
+    std::shared_ptr<mcl::ClientPlatform> create_client_platform(mcl::ClientContext*)
+    {
+        return platform;
+    }
+
+    std::shared_ptr<mcl::ClientPlatform> platform;
+};
+
+void connected_callback(MirConnection* /*connection*/, void* /*client_context*/)
+{
+}
+
+class TestConnectionConfiguration : public mcl::DefaultConnectionConfiguration
+{
+public:
+    TestConnectionConfiguration(
+        std::shared_ptr<mcl::ClientPlatform> const& platform,
+        std::shared_ptr<mclr::MirBasicRpcChannel> const& channel)
+        : DefaultConnectionConfiguration(""),
+          platform{platform},
+          channel{channel}
+    {
+    }
+
+    std::shared_ptr<mclr::MirBasicRpcChannel> the_rpc_channel() override
+    {
+        return channel;
+    }
+
+    std::shared_ptr<mcl::ClientPlatformFactory> the_client_platform_factory() override
+    {
+        return std::make_shared<StubClientPlatformFactory>(platform);
+    }
+
+private:
+    std::shared_ptr<mcl::ClientPlatform> const platform;
+    std::shared_ptr<mclr::MirBasicRpcChannel> const channel;
+};
+}
+
+struct MirRenderSurfaceTest : public testing::Test
+{
+    MirRenderSurfaceTest()
+        : mock_platform{std::make_shared<testing::NiceMock<MockClientPlatform>>()},
+          mock_channel{std::make_shared<testing::NiceMock<MockRpcChannel>>()},
+          conf{mock_platform, mock_channel},
+          connection{std::make_shared<MirConnection>(conf)}
+    {
+        mock_platform->set_client_context(connection.get());
+    }
+
+    std::shared_ptr<testing::NiceMock<MockClientPlatform>> const mock_platform;
+    std::shared_ptr<testing::NiceMock<MockRpcChannel>> const mock_channel;
+    TestConnectionConfiguration conf;
+    std::shared_ptr<MirConnection> const connection;
+};
+
+TEST_F(MirRenderSurfaceTest, render_surface_can_be_created_and_released)
+{
+    EXPECT_CALL(*mock_channel, on_buffer_stream_create(_,_))
+        .WillOnce(Invoke([](mp::BufferStream& stream, google::protobuf::Closure*)
+        {
+            stream.mutable_id()->set_value(1);
+        }));
+
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+
+    void* nw = nullptr;
+    MirRenderSurface* render_surface = nullptr;
+    connection->create_render_surface_with_content(
+        {10, 10},
+        reinterpret_cast<mir_render_surface_callback>(assign_result),
+        &render_surface,
+        &nw);
+
+    EXPECT_THAT(render_surface, NotNull());
+    EXPECT_THAT(nw, NotNull());
+    EXPECT_THAT(render_surface, Eq(nw));
+    EXPECT_NO_THROW(connection->release_render_surface_with_content(nw));
+
+    connection->disconnect();
+}
+
+TEST_F(MirRenderSurfaceTest, creation_of_render_surface_creates_egl_native_window)
+{
+    RenderSurfaceCallback callback;
+
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+
+    EXPECT_CALL(*mock_platform, create_egl_native_window(nullptr));
+    EXPECT_CALL(*mock_channel, on_buffer_stream_create(_,_))
+        .WillOnce(Invoke([](mp::BufferStream& stream, google::protobuf::Closure*)
+        {
+            stream.mutable_id()->set_value(1);
+        }));
+
+    void* nw = nullptr;
+    connection->create_render_surface_with_content({10, 10},
+                                                   &RenderSurfaceCallback::created,
+                                                   &callback,
+                                                   &nw);
+
+    EXPECT_THAT(nw, NotNull());
+    EXPECT_TRUE(callback.invoked);
+    EXPECT_THAT(callback.resulting_render_surface, NotNull());
+
+    auto rs = connection->connection_surface_map()->render_surface(
+        static_cast<void*>(callback.resulting_render_surface));
+
+    EXPECT_TRUE(reinterpret_cast<mcl::RenderSurface*>(rs->valid()));
+}
+
+TEST_F(MirRenderSurfaceTest, render_surface_returns_connection)
+{
+    MirConnection* conn{ reinterpret_cast<MirConnection*>(0x12345678) };
+
+    mcl::RenderSurface rs(
+        conn, nullptr, nullptr, nullptr, {});
+
+    EXPECT_THAT(rs.connection(), Eq(conn));
+}
+
+TEST_F(MirRenderSurfaceTest, render_surface_has_correct_id_before_content_creation)
+{
+    MirConnection* conn{ reinterpret_cast<MirConnection*>(0x12345678) };
+    auto id = 123;
+
+    mp::BufferStream protobuf_bs;
+    mp::BufferStreamId bs_id;
+
+    bs_id.set_value(id);
+    *protobuf_bs.mutable_id() = bs_id;
+
+    mcl::RenderSurface rs(
+        conn, nullptr, nullptr, mt::fake_shared(protobuf_bs), {});
+
+    EXPECT_THAT(rs.stream_id().as_value(), Eq(id));
+}
+
+TEST_F(MirRenderSurfaceTest, render_surface_can_create_buffer_stream)
+{
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+    auto id = 123;
+
+    mp::BufferStream protobuf_bs;
+    mp::BufferStreamId bs_id;
+
+    bs_id.set_value(id);
+    *protobuf_bs.mutable_id() = bs_id;
+
+    auto native_window = mock_platform->create_egl_native_window(nullptr);
+
+    mcl::RenderSurface rs(
+        connection.get(), native_window, nullptr, mt::fake_shared(protobuf_bs), {});
+
+    auto bs = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
+        mir_buffer_usage_software);
+
+    EXPECT_THAT(bs, NotNull());
+}
+
+TEST_F(MirRenderSurfaceTest, render_surface_creation_of_buffer_stream_more_than_once_returns_same_object)
+{
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+    auto id = 123;
+
+    mp::BufferStream protobuf_bs;
+    mp::BufferStreamId bs_id;
+
+    bs_id.set_value(id);
+    *protobuf_bs.mutable_id() = bs_id;
+
+    auto native_window = mock_platform->create_egl_native_window(nullptr);
+
+    mcl::RenderSurface rs(
+        connection.get(), native_window, mock_platform, mt::fake_shared(protobuf_bs), {});
+
+    EXPECT_CALL(*mock_platform, use_egl_native_window(native_window,_));
+
+    auto bs1 = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
+        mir_buffer_usage_hardware);
+    auto bs2 = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
+        mir_buffer_usage_hardware);
+
+    EXPECT_THAT(bs1, NotNull());
+    EXPECT_THAT(bs2, NotNull());
+    EXPECT_THAT(bs1, Eq(bs2));
+}
+
+TEST_F(MirRenderSurfaceTest, render_surface_creation_of_buffer_stream_with_hardware_usage_installs_new_native_window)
+{
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+    auto id = 123;
+
+    mp::BufferStream protobuf_bs;
+    mp::BufferStreamId bs_id;
+
+    bs_id.set_value(id);
+    *protobuf_bs.mutable_id() = bs_id;
+
+    auto native_window = mock_platform->create_egl_native_window(nullptr);
+
+    mcl::RenderSurface rs(
+        connection.get(), native_window, mock_platform, mt::fake_shared(protobuf_bs), {});
+
+    EXPECT_CALL(*mock_platform, use_egl_native_window(native_window,_));
+
+    auto bs = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
+        mir_buffer_usage_hardware);
+
+    EXPECT_THAT(bs, NotNull());
+}
+
+TEST_F(MirRenderSurfaceTest, render_surface_creation_of_buffer_stream_with_software_usage_does_not_install_new_native_window)
+{
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+    auto id = 123;
+
+    mp::BufferStream protobuf_bs;
+    mp::BufferStreamId bs_id;
+
+    bs_id.set_value(id);
+    *protobuf_bs.mutable_id() = bs_id;
+
+    auto native_window = mock_platform->create_egl_native_window(nullptr);
+
+    mcl::RenderSurface rs(
+        connection.get(), native_window, mock_platform, mt::fake_shared(protobuf_bs), {});
+
+    EXPECT_CALL(*mock_platform, use_egl_native_window(_,_)).Times(0);
+
+    auto bs = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
+        mir_buffer_usage_software);
+
+    EXPECT_THAT(bs, NotNull());
+}
+
+TEST_F(MirRenderSurfaceTest, render_surface_object_is_invalid_after_creation_exception)
+{
+    RenderSurfaceCallback callback;
+
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+
+    EXPECT_CALL(*mock_channel, on_buffer_stream_create(_,_))
+        .WillOnce(DoAll(
+            Invoke([](mp::BufferStream&, google::protobuf::Closure* c){ c->Run(); }),
+            Throw(std::runtime_error("Eeek!"))));
+
+    void* nw = nullptr;
+    connection->create_render_surface_with_content({10, 10},
+                                                    &RenderSurfaceCallback::created,
+                                                    &callback,
+                                                    &nw);
+
+    EXPECT_TRUE(callback.invoked);
+    EXPECT_THAT(callback.resulting_render_surface, NotNull());
+    auto rs = connection->connection_surface_map()->render_surface(
+        static_cast<void*>(callback.resulting_render_surface));
+    EXPECT_THAT(rs->get_error_message(),
+        StrEq("Error processing buffer stream response during render "
+              "surface creation: no ID in response (disconnected?)"));
+    EXPECT_FALSE(reinterpret_cast<mcl::RenderSurface*>(rs->valid()));
+}
+
+TEST_F(MirRenderSurfaceTest, render_surface_can_create_presentation_chain)
+{
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+    auto id = 123;
+
+    mp::BufferStream protobuf_bs;
+    mp::BufferStreamId bs_id;
+
+    bs_id.set_value(id);
+    *protobuf_bs.mutable_id() = bs_id;
+
+    auto native_window = mock_platform->create_egl_native_window(nullptr);
+
+    mcl::RenderSurface rs(
+        connection.get(), native_window, nullptr, mt::fake_shared(protobuf_bs), {});
+
+    auto pc = rs.get_presentation_chain();
+
+    EXPECT_THAT(pc, NotNull());
+}
+
+TEST_F(MirRenderSurfaceTest, render_surface_creation_of_presentation_chain_more_than_once_returns_same_object)
+{
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+    auto id = 123;
+
+    mp::BufferStream protobuf_bs;
+    mp::BufferStreamId bs_id;
+
+    bs_id.set_value(id);
+    *protobuf_bs.mutable_id() = bs_id;
+
+    auto native_window = mock_platform->create_egl_native_window(nullptr);
+
+    mcl::RenderSurface rs(
+        connection.get(), native_window, mock_platform, mt::fake_shared(protobuf_bs), {});
+
+    auto pc1 = rs.get_presentation_chain();
+    auto pc2 = rs.get_presentation_chain();
+
+    EXPECT_THAT(pc1, NotNull());
+    EXPECT_THAT(pc2, NotNull());
+    EXPECT_THAT(pc1, Eq(pc2));
+}
+
+TEST_F(MirRenderSurfaceTest, can_create_chain_or_stream_but_not_both)
+{
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+    auto id = 123;
+
+    mp::BufferStream protobuf_bs;
+    mp::BufferStreamId bs_id;
+
+    bs_id.set_value(id);
+    *protobuf_bs.mutable_id() = bs_id;
+
+    auto native_window = mock_platform->create_egl_native_window(nullptr);
+
+    {
+        mcl::RenderSurface rs(connection.get(),
+                              native_window,
+                              mock_platform,
+                              mt::fake_shared(protobuf_bs),
+                              {});
+
+        auto bs = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
+            mir_buffer_usage_hardware);
+
+        EXPECT_THAT(bs, NotNull());
+        EXPECT_THROW(
+            { rs.get_presentation_chain(); },
+            std::logic_error);
+    }
+
+    {
+        mcl::RenderSurface rs(connection.get(),
+                              native_window,
+                              mock_platform,
+                              mt::fake_shared(protobuf_bs),
+                              {});
+
+        auto pc = rs.get_presentation_chain();
+
+        EXPECT_THAT(pc, NotNull());
+        EXPECT_THROW(
+            { rs.get_buffer_stream(2, 2,
+                                   mir_pixel_format_abgr_8888,
+                                   mir_buffer_usage_hardware); },
+            std::logic_error);
+    }
+}