Merge lp:~kdub/mir/receive-buffers-at-startup into lp:mir

[Kevin DuBois]

client: if not given a mp::Buffer at startup, use the allocate_buffer rpc call to generate buffers.

client: if not given a mp::Buffer at startup, use the allocate_buffer rpc call to generate buffers.

note: imo, mcl::BufferStream needs to be split up and refactored, as its servicing both the exchange/next buffer method and the submit method, as well as a "producer" and "consumer" mode...

Unmerged revisions

2785. By Kevin DuBois on 2015-07-23

reduce diff

2784. By Kevin DuBois on 2015-07-23

round of cleanups

2783. By Kevin DuBois on 2015-07-23

tests to pass

2782. By Kevin DuBois on 2015-07-23

merge in mir

2781. By Kevin DuBois on 2015-07-23

replumb sizes

2780. By Kevin DuBois on 2015-07-23

rethink size communication a bit in test

2779. By Kevin DuBois on 2015-07-23

add session mediator test to handle a nullptr return

2778. By Kevin DuBois on 2015-07-23

round of cleanups

2777. By Kevin DuBois on 2015-07-23

another test

2776. By Kevin DuBois on 2015-07-23

merge in mir

=== modified file 'include/server/mir/frontend/buffer_stream.h'
--- include/server/mir/frontend/buffer_stream.h	2015-06-18 02:46:16 +0000
+++ include/server/mir/frontend/buffer_stream.h	2015-07-23 19:11:05 +0000
@@ -20,7 +20,7 @@
 #define MIR_FRONTEND_BUFFER_STREAM_H_
 
 #include <mir_toolkit/common.h>
-
+#include "mir/graphics/buffer_id.h"
 #include <functional>
 #include <memory>
 
@@ -29,6 +29,7 @@
 namespace graphics
 {
 class Buffer;
+class BufferProperties;
 }
 namespace scene
 {
@@ -53,6 +54,8 @@
 
     virtual MirPixelFormat pixel_format() const = 0;
 
+    virtual void allocate_buffer(graphics::BufferProperties const&) = 0;
+    virtual void remove_buffer(graphics::BufferID) = 0;
 protected:
     BufferStream() = default;
     BufferStream(BufferStream const&) = delete;

=== modified file 'src/client/buffer_stream.cpp'
--- src/client/buffer_stream.cpp	2015-07-16 07:03:19 +0000
+++ src/client/buffer_stream.cpp	2015-07-23 19:11:05 +0000
@@ -93,7 +93,8 @@
     std::shared_ptr<mcl::ClientPlatform> const& client_platform,
     mp::BufferStream const& protobuf_bs,
     std::shared_ptr<mcl::PerfReport> const& perf_report,
-    std::string const& surface_name)
+    std::string const& surface_name,
+    geom::Size ideal_size)
     : connection(connection),
       display_server(server),
       mode(mode),
@@ -102,7 +103,8 @@
       buffer_depository{client_platform->create_buffer_factory(), mir::frontend::client_buffer_cache_size},
       swap_interval_(1),
       perf_report(perf_report),
-      protobuf_void{mcl::make_protobuf_object<mir::protobuf::Void>()}
+      protobuf_void{mcl::make_protobuf_object<mir::protobuf::Void>()},
+      ideal_buffer_size{ideal_size}
 {
     created(nullptr, nullptr);
     perf_report->name_surface(surface_name.c_str());
@@ -124,7 +126,8 @@
       buffer_depository{client_platform->create_buffer_factory(), mir::frontend::client_buffer_cache_size},
       swap_interval_(1),
       perf_report(perf_report),
-      protobuf_void{mcl::make_protobuf_object<mir::protobuf::Void>()}
+      protobuf_void{mcl::make_protobuf_object<mir::protobuf::Void>()},
+      ideal_buffer_size{parameters.width(), parameters.height()}
 {
     perf_report->name_surface(std::to_string(reinterpret_cast<long int>(this)).c_str());
 
@@ -146,10 +149,22 @@
 {
     if (!protobuf_bs->has_id() || protobuf_bs->has_error())
         BOOST_THROW_EXCEPTION(std::runtime_error("Can not create buffer stream: " + std::string(protobuf_bs->error())));
-    if (!protobuf_bs->has_buffer())
-        BOOST_THROW_EXCEPTION(std::runtime_error("Buffer stream did not come with a buffer"));
-
-    process_buffer(protobuf_bs->buffer());
+
+    if (protobuf_bs->has_buffer())
+    {
+        process_buffer(protobuf_bs->buffer());
+        finalize_initialization(callback, context);
+    }
+    else
+    {
+        alloc_buffers();
+        deferred_callback = callback;
+        deferred_context = context;
+    }
+}
+
+void mcl::BufferStream::finalize_initialization(mir_buffer_stream_callback callback, void *context)
+{
     egl_native_window_ = client_platform->create_egl_native_window(this);
 
     if (connection)
@@ -158,10 +173,24 @@
     if (callback)
         callback(reinterpret_cast<MirBufferStream*>(this), context);
     create_wait_handle.result_received();
+    was_created = true;
 }
 
-mcl::BufferStream::~BufferStream()
+void mcl::BufferStream::alloc_buffers()
 {
+    auto initial_nbuffers = 3u;
+    auto request = mcl::make_protobuf_object<mp::BufferAllocation>();
+    *request->mutable_id() = protobuf_bs->id();
+    for(auto i = 0u; i < initial_nbuffers; i++)
+    {
+        auto buf_params = request->add_buffer_requests();
+        buf_params->set_width(protobuf_bs->buffer().width());
+        buf_params->set_height(protobuf_bs->buffer().height());
+        buf_params->set_pixel_format(protobuf_bs->pixel_format());
+        buf_params->set_buffer_usage(protobuf_bs->buffer_usage());
+    }
+    display_server.allocate_buffers(nullptr, request.get(), protobuf_void.get(), 
+        google::protobuf::NewCallback(google::protobuf::DoNothing));
 }
 
 void mcl::BufferStream::process_buffer(mp::Buffer const& buffer)
@@ -421,6 +450,13 @@
 {
     std::unique_lock<decltype(mutex)> lock(mutex);
 
+    if (!was_created)
+    {
+        process_buffer(buffer, lock);
+        finalize_initialization(deferred_callback, deferred_context);
+        return;
+    }
+
     if (on_incoming_buffer)
     {
         process_buffer(buffer, lock);

=== modified file 'src/client/buffer_stream.h'
--- src/client/buffer_stream.h	2015-07-16 07:03:19 +0000
+++ src/client/buffer_stream.h	2015-07-23 19:11:05 +0000
@@ -65,7 +65,8 @@
         std::shared_ptr<ClientPlatform> const& native_window_factory,
         mir::protobuf::BufferStream const& protobuf_bs,
         std::shared_ptr<PerfReport> const& perf_report,
-        std::string const& surface_name);
+        std::string const& surface_name,
+        geometry::Size ideal_size);
     // For surfaceless buffer streams
     BufferStream(
         MirConnection* connection,
@@ -76,8 +77,6 @@
         mir_buffer_stream_callback callback,
         void *context);
         
-    virtual ~BufferStream();
-
     MirWaitHandle *get_create_wait_handle() override;
     MirWaitHandle *release(mir_buffer_stream_callback callback, void* context) override;
     
@@ -114,6 +113,7 @@
     BufferStream& operator=(BufferStream const&) = delete;
 
 private:
+    void alloc_buffers();
     void created(mir_buffer_stream_callback callback, void* context);
     void process_buffer(protobuf::Buffer const& buffer);
     void process_buffer(protobuf::Buffer const& buffer, std::unique_lock<std::mutex> const&);
@@ -122,6 +122,7 @@
     void on_configured();
     void release_cpu_region();
     MirWaitHandle* submit(std::function<void()> const& done, std::unique_lock<std::mutex> lk);
+    void finalize_initialization(mir_buffer_stream_callback callback, void *context);
 
     mutable std::mutex mutex; // Protects all members of *this
 
@@ -153,6 +154,10 @@
     std::shared_ptr<MemoryRegion> secured_region;
     
     geometry::Size cached_buffer_size;
+    geometry::Size ideal_buffer_size;
+    bool was_created = false;
+    mir_buffer_stream_callback deferred_callback;
+    void *deferred_context;
 };
 
 }

=== modified file 'src/client/client_buffer_stream_factory.h'
--- src/client/client_buffer_stream_factory.h	2015-06-18 02:46:16 +0000
+++ src/client/client_buffer_stream_factory.h	2015-07-23 19:11:05 +0000
@@ -22,7 +22,7 @@
 #include "mir_protobuf.pb.h"
 
 #include "mir_toolkit/client_types.h"
-
+#include "mir/geometry/size.h"
 #include <memory>
 
 class MirConnection;
@@ -37,10 +37,10 @@
 public:
     virtual std::shared_ptr<ClientBufferStream> make_consumer_stream(
         MirConnection*, protobuf::DisplayServer& server,
-        protobuf::BufferStream const& protobuf_bs, std::string const& surface_name) = 0;
+        protobuf::BufferStream const& protobuf_bs, std::string const& surface_name, geometry::Size) = 0;
     virtual std::shared_ptr<ClientBufferStream> make_producer_stream(
         MirConnection*, protobuf::DisplayServer& server,
-        protobuf::BufferStream const& protobuf_bs, std::string const& surface_name) = 0;
+        protobuf::BufferStream const& protobuf_bs, std::string const& surface_name, geometry::Size) = 0;
 
     // For creating buffer stream owned by client.
     virtual ClientBufferStream* make_producer_stream(

=== modified file 'src/client/default_client_buffer_stream_factory.cpp'
--- src/client/default_client_buffer_stream_factory.cpp	2015-06-18 02:46:16 +0000
+++ src/client/default_client_buffer_stream_factory.cpp	2015-07-23 19:11:05 +0000
@@ -59,20 +59,20 @@
 
 std::shared_ptr<mcl::ClientBufferStream> mcl::DefaultClientBufferStreamFactory::make_consumer_stream(
     MirConnection* connection, mp::DisplayServer& server,
-    mp::BufferStream const& protobuf_bs, std::string const& surface_name)
+    mp::BufferStream const& protobuf_bs, std::string const& surface_name, geometry::Size size)
 {
     return std::make_shared<mcl::BufferStream>(
         connection, server, mcl::BufferStreamMode::Consumer, client_platform,
-        protobuf_bs, make_perf_report(logger), surface_name);
+        protobuf_bs, make_perf_report(logger), surface_name, size);
 }
 
 std::shared_ptr<mcl::ClientBufferStream> mcl::DefaultClientBufferStreamFactory::make_producer_stream(
     MirConnection* connection, mp::DisplayServer& server,
-    mp::BufferStream const& protobuf_bs, std::string const& surface_name)
+    mp::BufferStream const& protobuf_bs, std::string const& surface_name, geometry::Size size)
 {
     return std::make_shared<mcl::BufferStream>(
         connection, server, mcl::BufferStreamMode::Producer, client_platform,
-        protobuf_bs, make_perf_report(logger), surface_name);
+        protobuf_bs, make_perf_report(logger), surface_name, size);
 }
 
 

=== modified file 'src/client/default_client_buffer_stream_factory.h'
--- src/client/default_client_buffer_stream_factory.h	2015-06-18 02:46:16 +0000
+++ src/client/default_client_buffer_stream_factory.h	2015-07-23 19:11:05 +0000
@@ -42,10 +42,10 @@
 
     std::shared_ptr<ClientBufferStream> make_consumer_stream(
         MirConnection*, protobuf::DisplayServer& server,
-        protobuf::BufferStream const& protobuf_bs, std::string const& surface_name) override;
+        protobuf::BufferStream const& protobuf_bs, std::string const& surface_name, geometry::Size) override;
     std::shared_ptr<ClientBufferStream> make_producer_stream(
         MirConnection*, protobuf::DisplayServer& server,
-        protobuf::BufferStream const& protobuf_bs, std::string const& surface_name) override;
+        protobuf::BufferStream const& protobuf_bs, std::string const& surface_name, geometry::Size) override;
 
     ClientBufferStream* make_producer_stream(
         MirConnection*,

=== modified file 'src/client/mir_connection.cpp'
--- src/client/mir_connection.cpp	2015-07-14 08:16:46 +0000
+++ src/client/mir_connection.cpp	2015-07-23 19:11:05 +0000
@@ -505,9 +505,9 @@
 }
 
 std::shared_ptr<mir::client::ClientBufferStream> MirConnection::make_consumer_stream(
-   mir::protobuf::BufferStream const& protobuf_bs, std::string const& surface_name)
+   mir::protobuf::BufferStream const& protobuf_bs, std::string const& surface_name, mir::geometry::Size size)
 {
-    return buffer_stream_factory->make_consumer_stream(this, server, protobuf_bs, surface_name);
+    return buffer_stream_factory->make_consumer_stream(this, server, protobuf_bs, surface_name, size);
 }
 
 EGLNativeDisplayType MirConnection::egl_native_display()

=== modified file 'src/client/mir_connection.h'
--- src/client/mir_connection.h	2015-07-14 08:16:46 +0000
+++ src/client/mir_connection.h	2015-07-23 19:11:05 +0000
@@ -30,6 +30,7 @@
 
 #include "mir_toolkit/mir_client_library.h"
 
+#include "mir/geometry/size.h"
 #include "mir/client_platform.h"
 #include "mir/client_context.h"
 
@@ -125,7 +126,7 @@
     std::shared_ptr<mir::client::ClientPlatform> get_client_platform();
 
     std::shared_ptr<mir::client::ClientBufferStream> make_consumer_stream(
-       mir::protobuf::BufferStream const& protobuf_bs, std::string const& surface_name);
+       mir::protobuf::BufferStream const& protobuf_bs, std::string const& surface_name, mir::geometry::Size);
 
     mir::client::ClientBufferStream* create_client_buffer_stream(
         int width, int height,

=== modified file 'src/client/mir_screencast.cpp'
--- src/client/mir_screencast.cpp	2015-06-18 02:46:16 +0000
+++ src/client/mir_screencast.cpp	2015-07-23 19:11:05 +0000
@@ -110,7 +110,7 @@
     if (!protobuf_screencast->has_error() && connection)
     {
         buffer_stream = connection->make_consumer_stream(
-            protobuf_screencast->buffer_stream(), "MirScreencast");
+            protobuf_screencast->buffer_stream(), "MirScreencast", output_size);
     }
 
     callback(this, context);

=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2015-07-23 02:39:20 +0000
+++ src/client/mir_surface.cpp	2015-07-23 19:11:05 +0000
@@ -324,8 +324,9 @@
         {
             std::lock_guard<decltype(mutex)> lock(mutex);
 
+            geom::Size size{surface->width(), surface->height()};
             buffer_stream = buffer_stream_factory->
-                make_producer_stream(connection, *server, surface->buffer_stream(), name);
+                make_producer_stream(connection, *server, surface->buffer_stream(), name, size); 
 
             for(int i = 0; i < surface->attributes_size(); i++)
             {

=== modified file 'src/protobuf/mir_protobuf.proto'
--- src/protobuf/mir_protobuf.proto	2015-07-23 02:39:20 +0000
+++ src/protobuf/mir_protobuf.proto	2015-07-23 19:11:05 +0000
@@ -117,6 +117,7 @@
 
 message BufferRelease {
   repeated Buffer buffers = 1;  
+  optional BufferStreamId id = 2;
 };
 
 message BufferRequest {

=== modified file 'src/server/compositor/buffer_stream_surfaces.cpp'
--- src/server/compositor/buffer_stream_surfaces.cpp	2015-06-18 14:33:10 +0000
+++ src/server/compositor/buffer_stream_surfaces.cpp	2015-07-23 19:11:05 +0000
@@ -22,6 +22,7 @@
 #include "mir/graphics/buffer_properties.h"
 
 #include "temporary_buffers.h"
+#include <boost/throw_exception.hpp>
 
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
@@ -135,3 +136,13 @@
     if (auto o = observer.lock())
         observers.remove(o);
 }
+
+void mc::BufferStreamSurfaces::allocate_buffer(graphics::BufferProperties const&)
+{
+    BOOST_THROW_EXCEPTION(std::runtime_error("not_supported"));
+}
+
+void mc::BufferStreamSurfaces::remove_buffer(graphics::BufferID)
+{
+    BOOST_THROW_EXCEPTION(std::runtime_error("not_supported"));
+}

=== modified file 'src/server/compositor/buffer_stream_surfaces.h'
--- src/server/compositor/buffer_stream_surfaces.h	2015-06-17 05:20:42 +0000
+++ src/server/compositor/buffer_stream_surfaces.h	2015-07-23 19:11:05 +0000
@@ -47,6 +47,8 @@
     MirPixelFormat pixel_format() const override;
     void add_observer(std::shared_ptr<scene::SurfaceObserver> const& observer) override;
     void remove_observer(std::weak_ptr<scene::SurfaceObserver> const& observer) override;
+    void allocate_buffer(graphics::BufferProperties const&) override;
+    void remove_buffer(graphics::BufferID) override;
 
     //from mc::BufferStream
     void acquire_client_buffer(std::function<void(graphics::Buffer* buffer)> complete);

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2015-07-23 02:39:20 +0000
+++ src/server/frontend/session_mediator.cpp	2015-07-23 19:11:05 +0000
@@ -160,6 +160,7 @@
         old_buffer,
         [this, stream_id, complete](mg::Buffer* new_buffer)
         {
+            if (!new_buffer) return;
             if (buffer_stream_tracker.track_buffer(stream_id, new_buffer))
                 complete(new_buffer, mg::BufferIpcMsgType::update_msg);
             else
@@ -298,10 +299,12 @@
         {
             response->mutable_buffer_stream()->mutable_id()->set_value(
                surf_id.as_value());
-            pack_protobuf_buffer(*response->mutable_buffer_stream()->mutable_buffer(),
-                         client_buffer,
-                         msg_type);
 
+            if (client_buffer)
+            {
+                pack_protobuf_buffer(
+                    *response->mutable_buffer_stream()->mutable_buffer(), client_buffer, msg_type);
+            }
             done->Run();
         });
 }
@@ -384,6 +387,7 @@
     stream->swap_buffers(old_buffer,
         [this, stream_id, done](mg::Buffer* new_buffer)
         {
+            if (!new_buffer) return;
             if (buffer_stream_tracker.track_buffer(stream_id, new_buffer))
                 event_sink->send_buffer(stream_id, *new_buffer, mg::BufferIpcMsgType::update_msg);
             else
@@ -395,20 +399,43 @@
 
 void mf::SessionMediator::allocate_buffers( 
     google::protobuf::RpcController*,
-    mir::protobuf::BufferAllocation const*,
+    mir::protobuf::BufferAllocation const* request,
     mir::protobuf::Void*,
-    google::protobuf::Closure*)
+    google::protobuf::Closure* done)
 {
-    BOOST_THROW_EXCEPTION(std::runtime_error("not supported yet"));
+    auto session = weak_session.lock();
+    if (!session)
+        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
+
+    mf::BufferStreamId stream_id{request->id().value()};
+    auto stream = session->get_buffer_stream(stream_id);
+    for (auto i = 0; i < request->buffer_requests().size(); i++)
+    {
+        auto const& req = request->buffer_requests(i);
+        mg::BufferProperties properties(
+            geom::Size{req.width(), req.height()},
+            static_cast<MirPixelFormat>(req.pixel_format()),
+            static_cast<mg::BufferUsage>(req.buffer_usage()));
+        stream->allocate_buffer(properties);
+    }
+    done->Run();
 }
 
 void mf::SessionMediator::release_buffers(
     google::protobuf::RpcController*,
-    mir::protobuf::BufferRelease const*,
+    mir::protobuf::BufferRelease const* request,
     mir::protobuf::Void*,
-    google::protobuf::Closure*)
+    google::protobuf::Closure* done)
 {
-    BOOST_THROW_EXCEPTION(std::runtime_error("not supported yet"));
+    auto session = weak_session.lock();
+    if (!session)
+        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
+
+    mf::BufferStreamId stream_id{request->id().value()};
+    auto stream = session->get_buffer_stream(stream_id);
+    for (auto i = 0; i < request->buffers().size(); i++)
+        stream->remove_buffer(mg::BufferID{static_cast<uint32_t>(request->buffers(i).buffer_id())});
+    done->Run();
 }
 
 void mf::SessionMediator::release_surface(
@@ -700,9 +727,11 @@
         [this, response, done, session]
         (graphics::Buffer* client_buffer, graphics::BufferIpcMsgType msg_type)
         {
-            auto buffer = response->mutable_buffer();
-            pack_protobuf_buffer(*buffer, client_buffer, msg_type);
-
+            if (client_buffer)
+            {
+                auto buffer = response->mutable_buffer();
+                pack_protobuf_buffer(*buffer, client_buffer, msg_type);
+            }
             done->Run();
         });
 }

=== modified file 'tests/include/mir/test/doubles/mock_buffer_stream.h'
--- tests/include/mir/test/doubles/mock_buffer_stream.h	2015-06-18 02:46:16 +0000
+++ tests/include/mir/test/doubles/mock_buffer_stream.h	2015-07-23 19:11:05 +0000
@@ -75,6 +75,8 @@
     MOCK_METHOD1(with_most_recent_buffer_do, void(std::function<void(graphics::Buffer&)> const&));
     MOCK_CONST_METHOD0(pixel_format, MirPixelFormat());
     MOCK_CONST_METHOD0(has_submitted_buffer, bool());
+    MOCK_METHOD1(allocate_buffer, void(graphics::BufferProperties const&));
+    MOCK_METHOD1(remove_buffer, void(graphics::BufferID));
 };
 }
 }

=== modified file 'tests/include/mir/test/doubles/mock_client_buffer_stream_factory.h'
--- tests/include/mir/test/doubles/mock_client_buffer_stream_factory.h	2015-06-18 02:46:16 +0000
+++ tests/include/mir/test/doubles/mock_client_buffer_stream_factory.h	2015-07-23 19:11:05 +0000
@@ -34,12 +34,12 @@
 
 struct MockClientBufferStreamFactory : public client::ClientBufferStreamFactory
 {
-    MOCK_METHOD4(make_consumer_stream, std::shared_ptr<client::ClientBufferStream>(
-        MirConnection*, protobuf::DisplayServer&,
-        protobuf::BufferStream const&, std::string const&));
-    MOCK_METHOD4(make_producer_stream, std::shared_ptr<client::ClientBufferStream>(
-        MirConnection*, protobuf::DisplayServer&,
-        protobuf::BufferStream const&, std::string const&));
+    MOCK_METHOD5(make_consumer_stream, std::shared_ptr<client::ClientBufferStream>(
+        MirConnection*, protobuf::DisplayServer&,
+        protobuf::BufferStream const&, std::string const&, geometry::Size));
+    MOCK_METHOD5(make_producer_stream, std::shared_ptr<client::ClientBufferStream>(
+        MirConnection*, protobuf::DisplayServer&,
+        protobuf::BufferStream const&, std::string const&, geometry::Size));
     MOCK_METHOD5(make_producer_stream, client::ClientBufferStream*(
         MirConnection*, protobuf::DisplayServer&,
         protobuf::BufferStreamParameters const&, mir_buffer_stream_callback callback, void* context));

=== modified file 'tests/include/mir/test/doubles/stub_buffer_stream.h'
--- tests/include/mir/test/doubles/stub_buffer_stream.h	2015-06-25 03:00:08 +0000
+++ tests/include/mir/test/doubles/stub_buffer_stream.h	2015-07-23 19:11:05 +0000
@@ -79,6 +79,8 @@
     void add_observer(std::shared_ptr<scene::SurfaceObserver> const&) {}
     void remove_observer(std::weak_ptr<scene::SurfaceObserver> const&) {}
     bool has_submitted_buffer() const { return true; }
+    void allocate_buffer(graphics::BufferProperties const&) {}
+    void remove_buffer(graphics::BufferID) {}
 
     StubBuffer stub_client_buffer;
     std::shared_ptr<graphics::Buffer> stub_compositor_buffer;

=== modified file 'tests/include/mir/test/doubles/stub_client_buffer_stream_factory.h'
--- tests/include/mir/test/doubles/stub_client_buffer_stream_factory.h	2015-06-18 02:46:16 +0000
+++ tests/include/mir/test/doubles/stub_client_buffer_stream_factory.h	2015-07-23 19:11:05 +0000
@@ -35,7 +35,8 @@
         MirConnection*,
         protobuf::DisplayServer& /* server */,
         protobuf::BufferStream const& /* protobuf_bs */,
-        std::string const& /* surface_name */) override
+        std::string const& /* surface_name */,
+        geometry::Size) override
     {
         return nullptr;
     }
@@ -44,7 +45,8 @@
         MirConnection*,
         protobuf::DisplayServer& /* server */,
         protobuf::BufferStream const& /* protobuf_bs */,
-        std::string const& /* surface_name */) override
+        std::string const& /* surface_name */,
+        geometry::Size) override
     {
         return nullptr;
     }

=== modified file 'tests/unit-tests/client/test_client_buffer_stream.cpp'
--- tests/unit-tests/client/test_client_buffer_stream.cpp	2015-07-16 08:13:28 +0000
+++ tests/unit-tests/client/test_client_buffer_stream.cpp	2015-07-23 19:11:05 +0000
@@ -61,6 +61,11 @@
                       mp::BufferRequest const* /*request*/,
                       mp::Buffer* /*response*/,
                       google::protobuf::Closure* /*done*/));
+    MOCK_METHOD4(allocate_buffers,
+                 void(google::protobuf::RpcController* /*controller*/,
+                      mp::BufferAllocation const* /*request*/,
+                      mp::Void* /*response*/,
+                      google::protobuf::Closure* /*done*/));
 };
 
 // TODO: Deduplicate this class
@@ -144,7 +149,7 @@
         mcl::BufferStreamMode mode=mcl::BufferStreamMode::Producer)
     {
         return std::make_shared<mcl::BufferStream>(nullptr, mock_protobuf_server, mode,
-            std::make_shared<StubClientPlatform>(mt::fake_shared(buffer_factory)), protobuf_bs, perf_report, "");
+            std::make_shared<StubClientPlatform>(mt::fake_shared(buffer_factory)), protobuf_bs, perf_report, "", geom::Size{});
     }
 };
 
@@ -257,12 +262,6 @@
         make_buffer_stream(no_id_bs);
     }, std::runtime_error);
 
-
-    auto no_buffer_bs = valid_bs;
-    no_buffer_bs.clear_buffer();
-    EXPECT_THROW({
-        make_buffer_stream(no_buffer_bs);
-    }, std::runtime_error);
 }
 
 TEST_F(ClientBufferStreamTest, uses_buffer_message_from_server)
@@ -465,7 +464,7 @@
     auto bs = std::make_shared<mcl::BufferStream>(
         nullptr, mock_protobuf_server, mcl::BufferStreamMode::Producer,
         std::make_shared<StubClientPlatform>(mt::fake_shared(stub_client_buffer_factory)),
-        protobuf_bs, mt::fake_shared(mock_perf_report), name);
+        protobuf_bs, mt::fake_shared(mock_perf_report), name, geom::Size{});
 }
 
 TEST_F(ClientBufferStreamTest, receives_unsolicited_buffer)
@@ -530,3 +529,26 @@
         bs->request_and_wait_for_next_buffer();
     }, std::runtime_error);
 }
+
+TEST_F(ClientBufferStreamTest, requests_buffers_if_not_given_buffers_at_startup)
+{
+    using namespace ::testing;
+    MockClientBuffer mock_client_buffer;
+    ON_CALL(mock_client_buffer_factory, create_buffer(_,_,_))
+        .WillByDefault(Return(mt::fake_shared(mock_client_buffer)));
+
+    EXPECT_CALL(mock_protobuf_server, allocate_buffers(_,_,_,_))
+        .WillOnce(RunProtobufClosure());
+
+    mp::BufferStream protobuf_bs;
+    mp::BufferStreamId bs_id;
+    bs_id.set_value(1);
+    *protobuf_bs.mutable_id() = bs_id;
+    auto bs = make_buffer_stream(protobuf_bs, mock_client_buffer_factory);
+
+    mp::Buffer buffer;
+    MirBufferPackage buffer_package = a_buffer_package();
+    fill_protobuf_buffer_from_package(&buffer, buffer_package);
+    bs->buffer_available(buffer);
+    EXPECT_THAT(bs->get_current_buffer(), NotNull());
+}

=== modified file 'tests/unit-tests/client/test_mir_screencast.cpp'
--- tests/unit-tests/client/test_mir_screencast.cpp	2015-06-26 08:00:59 +0000
+++ tests/unit-tests/client/test_mir_screencast.cpp	2015-07-23 19:11:05 +0000
@@ -166,7 +166,7 @@
         using namespace ::testing;
 
         ON_CALL(*mock_buffer_stream_factory,
-        make_consumer_stream(_,_,_,_)).WillByDefault(
+        make_consumer_stream(_,_,_,_,_)).WillByDefault(
             Return(mt::fake_shared(mock_bs)));
     }
 

=== modified file 'tests/unit-tests/compositor/test_buffer_stream.cpp'
--- tests/unit-tests/compositor/test_buffer_stream.cpp	2015-06-25 03:00:08 +0000
+++ tests/unit-tests/compositor/test_buffer_stream.cpp	2015-07-23 19:11:05 +0000
@@ -236,3 +236,15 @@
     buffer_stream.swap_buffers(buffer, complete);
     buffer_stream.swap_buffers(buffer, complete);
 }
+
+TEST_F(BufferStreamTest, allocate_and_release_not_supported)
+{
+    mg::BufferProperties properties;
+    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
+    EXPECT_THROW({
+        buffer_stream.allocate_buffer(properties);
+    }, std::runtime_error);
+    EXPECT_THROW({
+        buffer_stream.remove_buffer(mg::BufferID{3});
+    }, std::runtime_error);
+}

=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2015-06-25 19:29:44 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2015-07-23 19:11:05 +0000
@@ -1007,3 +1007,72 @@
 
     mediator.submit_buffer(nullptr, &request, &null, null_callback.get());
 }
+
+TEST_F(SessionMediator, allocates_from_the_correct_stream)
+{
+    using namespace testing;
+    auto num_requests = 3u;
+    mp::Void null;
+    mp::BufferStreamId id;
+    id.set_value(0);
+    mp::BufferAllocation request;
+    *request.mutable_id() = id;
+    mg::BufferProperties properties(geom::Size{34, 84}, mir_pixel_format_abgr_8888, mg::BufferUsage::hardware);
+    for(auto i = 0u; i < num_requests; i++)
+    {
+        auto buffer_request = request.add_buffer_requests();
+        buffer_request->set_width(properties.size.width.as_int());
+        buffer_request->set_height(properties.size.height.as_int());
+        buffer_request->set_pixel_format(properties.format);
+        buffer_request->set_buffer_usage((int)properties.usage);
+    }
+
+    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator.create_surface(nullptr, &surface_parameters, &surface_response, null_callback.get());
+
+    auto mock_stream = stubbed_session->mock_primary_stream_at(mf::SurfaceId{0});
+    EXPECT_CALL(*mock_stream, allocate_buffer(properties))
+        .Times(num_requests);
+
+    mediator.allocate_buffers(nullptr, &request, &null, null_callback.get());
+}
+
+TEST_F(SessionMediator, removes_buffer_from_the_correct_stream)
+{
+    using namespace testing;
+    auto num_requests = 3u;
+    mp::Void null;
+    mp::BufferStreamId id;
+    id.set_value(0);
+    mp::BufferRelease request;
+    *request.mutable_id() = id;
+    auto buffer_id = 442u;
+    for(auto i = 0u; i < num_requests; i++)
+    {
+        auto buffer_request = request.add_buffers();
+        buffer_request->set_buffer_id(buffer_id);
+    }
+
+    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator.create_surface(nullptr, &surface_parameters, &surface_response, null_callback.get());
+
+    auto mock_stream = stubbed_session->mock_primary_stream_at(mf::SurfaceId{0});
+    EXPECT_CALL(*mock_stream, remove_buffer(mg::BufferID{buffer_id}))
+        .Times(num_requests);
+
+    mediator.release_buffers(nullptr, &request, &null, null_callback.get());
+}
+
+TEST_F(SessionMediator, can_handle_if_swapbuffers_returns_nullptr)
+{ 
+    using namespace testing;
+    mf::SurfaceId surf_id{0};
+    auto stream = stubbed_session->mock_primary_stream_at(surf_id);
+    EXPECT_CALL(*stream, swap_buffers(_,_))
+        .WillOnce(InvokeArgument<1>(nullptr));
+
+    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator.create_surface(nullptr, &surface_parameters, &surface_response, null_callback.get());
+    EXPECT_FALSE(surface_response.has_buffer());
+    EXPECT_TRUE(surface_response.has_id());
+}