Merge lp:~raof/mir/further-buffer-plumbing-cleanup into lp:mir

[Chris Halse Rogers]

Remove even more manual reference counting of mg::Buffer-s.

=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2017-05-08 03:04:26 +0000
+++ examples/render_surfaces.cpp	2017-07-07 07:27:48 +0000
@@ -34,7 +34,6 @@
 #include "mir/scene/surface_factory.h"
 #include "mir/shell/surface_stack.h"
 #include "mir/frontend/buffer_sink.h"
-#include "mir/frontend/client_buffers.h"
 #include "mir/server.h"
 #include "mir/report_exception.h"
 #include "mir/renderer/gl/context.h"
@@ -396,8 +395,7 @@
                 void error_buffer(geom::Size, MirPixelFormat, std::string const&) override {}
             };
 
-            auto buffers = buffer_stream_factory->create_buffer_map(std::make_shared<NullBufferSink>());
-            auto const stream = buffer_stream_factory->create_buffer_stream({}, buffers, properties);
+            auto const stream = buffer_stream_factory->create_buffer_stream({}, properties);
             auto const surface = surface_factory->create_surface(
                 {ms::StreamInfo{stream, {}, {}}}, params);
             surface_stack->add_surface(surface, params.input_mode);

=== modified file 'examples/server_example_canonical_window_manager.cpp'
--- examples/server_example_canonical_window_manager.cpp	2017-05-25 04:33:43 +0000
+++ examples/server_example_canonical_window_manager.cpp	2017-07-07 07:27:48 +0000
@@ -54,9 +54,11 @@
 
 me::CanonicalWindowManagerPolicyCopy::CanonicalWindowManagerPolicyCopy(
     WindowManagerTools* const tools,
-    std::shared_ptr<shell::DisplayLayout> const& display_layout) :
+    std::shared_ptr<shell::DisplayLayout> const& display_layout,
+    std::shared_ptr<graphics::GraphicBufferAllocator> const& allocator) :
     tools{tools},
-    display_layout{display_layout}
+    display_layout{display_layout},
+    allocator{allocator}
 {
 }
 
@@ -276,7 +278,7 @@
             surface_map.emplace(titlebar, SurfaceInfo{session, titlebar, {}}).first->second;
     titlebar_info.is_titlebar = true;
     titlebar_info.parent = surface;
-    titlebar_info.init_titlebar(session, titlebar);
+    titlebar_info.init_titlebar(*allocator, titlebar);
 }
 
 void me::CanonicalWindowManagerPolicyCopy::handle_new_surface(std::shared_ptr<ms::Session> const& session, std::shared_ptr<ms::Surface> const& surface)

=== modified file 'examples/server_example_canonical_window_manager.h'
--- examples/server_example_canonical_window_manager.h	2017-05-08 03:04:26 +0000
+++ examples/server_example_canonical_window_manager.h	2017-07-07 07:27:48 +0000
@@ -32,6 +32,10 @@
 namespace mir
 {
 namespace shell { class DisplayLayout; }
+namespace graphics
+{
+class GraphicBufferAllocator;
+}
 namespace examples
 {
 // standard window management algorithm:
@@ -48,7 +52,8 @@
 
     explicit CanonicalWindowManagerPolicyCopy(
         WindowManagerTools* const tools,
-        std::shared_ptr<shell::DisplayLayout> const& display_layout);
+        std::shared_ptr<shell::DisplayLayout> const& display_layout,
+        std::shared_ptr<graphics::GraphicBufferAllocator> const& allocator);
 
     void click(geometry::Point cursor);
 
@@ -118,6 +123,7 @@
 
     WindowManagerTools* const tools;
     std::shared_ptr<shell::DisplayLayout> const display_layout;
+    std::shared_ptr<graphics::GraphicBufferAllocator> const allocator;
 
     geometry::Rectangle display_area;
     geometry::Point old_cursor{};

=== modified file 'examples/server_example_window_management.cpp'
--- examples/server_example_window_management.cpp	2017-05-08 03:04:26 +0000
+++ examples/server_example_window_management.cpp	2017-07-07 07:27:48 +0000
@@ -28,6 +28,8 @@
 #include "mir/scene/surface_creation_parameters.h"
 #include "mir/shell/display_layout.h"
 #include "mir/shell/system_compositor_window_manager.h"
+#include "mir/graphics/platform.h"
+#include "mir/graphics/graphic_buffer_allocator.h"
 
 namespace me = mir::examples;
 namespace mf = mir::frontend;
@@ -134,7 +136,10 @@
             }
             else if (selection == wm_canonical)
             {
-                return std::make_shared<CanonicalWindowManager>(focus_controller, server.the_shell_display_layout());
+                return std::make_shared<CanonicalWindowManager>(
+                    focus_controller,
+                    server.the_shell_display_layout(),
+                    server.the_graphics_platform()->create_buffer_allocator());
             }
             else if (selection == wm_system_compositor)
             {

=== removed file 'include/server/mir/frontend/client_buffers.h'
--- include/server/mir/frontend/client_buffers.h	2017-05-08 03:04:26 +0000
+++ include/server/mir/frontend/client_buffers.h	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-/*
- * Copyright © 2015 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_FRONTEND_CLIENT_BUFFERS_H_
-#define MIR_FRONTEND_CLIENT_BUFFERS_H_
-
-#include "mir/graphics/buffer_id.h"
-#include <memory>
-
-namespace mir
-{
-namespace graphics { class Buffer; }
-namespace frontend
-{
-class ClientBuffers
-{
-public:
-    virtual graphics::BufferID add_buffer(std::shared_ptr<graphics::Buffer> const& properties) = 0;
-    virtual void remove_buffer(graphics::BufferID id) = 0;
-    virtual std::shared_ptr<graphics::Buffer> get(graphics::BufferID) const = 0;
-    virtual void send_buffer(graphics::BufferID id) = 0;
-    virtual void receive_buffer(graphics::BufferID id) = 0;
-
-    ClientBuffers(ClientBuffers const&) = delete;
-    ClientBuffers& operator=(ClientBuffers const&) = delete;
-    virtual ~ClientBuffers() = default;
-    ClientBuffers() = default;
-};
-}
-}
-#endif /* MIR_FRONTEND_CLIENT_BUFFERS_H_ */

=== modified file 'include/server/mir/frontend/session.h'
--- include/server/mir/frontend/session.h	2017-05-08 03:04:26 +0000
+++ include/server/mir/frontend/session.h	2017-07-07 07:27:48 +0000
@@ -57,12 +57,6 @@
     virtual BufferStreamId create_buffer_stream(graphics::BufferProperties const& props) = 0;
     virtual void destroy_buffer_stream(BufferStreamId stream) = 0;
 
-    virtual graphics::BufferID create_buffer(graphics::BufferProperties const& properties) = 0;
-    virtual graphics::BufferID create_buffer(geometry::Size, MirPixelFormat) = 0;
-    virtual graphics::BufferID create_buffer(geometry::Size, uint32_t native_format, uint32_t native_flags) = 0;
-    virtual void destroy_buffer(graphics::BufferID) = 0;
-    virtual std::shared_ptr<graphics::Buffer> get_buffer(graphics::BufferID) = 0;
-
     virtual std::string name() const = 0;
 
     virtual void send_display_config(graphics::DisplayConfiguration const&) = 0;

=== modified file 'include/server/mir/scene/buffer_stream_factory.h'
--- include/server/mir/scene/buffer_stream_factory.h	2017-05-08 03:04:26 +0000
+++ include/server/mir/scene/buffer_stream_factory.h	2017-07-07 07:27:48 +0000
@@ -28,7 +28,6 @@
 {
 namespace compositor { class BufferStream; }
 namespace graphics { struct BufferProperties; }
-namespace frontend { class ClientBuffers; class BufferSink; }
 namespace scene
 {
 class BufferStreamFactory
@@ -37,13 +36,12 @@
     virtual ~BufferStreamFactory() = default;
 
     virtual std::shared_ptr<compositor::BufferStream> create_buffer_stream(
-        frontend::BufferStreamId, std::shared_ptr<frontend::ClientBuffers> const& sink,
-        int nbuffers, graphics::BufferProperties const& buffer_properties) = 0;
+        frontend::BufferStreamId,
+        int nbuffers,
+        graphics::BufferProperties const& buffer_properties) = 0;
     virtual std::shared_ptr<compositor::BufferStream> create_buffer_stream(
-        frontend::BufferStreamId, std::shared_ptr<frontend::ClientBuffers> const& sink,
+        frontend::BufferStreamId,
         graphics::BufferProperties const& buffer_properties) = 0;
-    virtual std::shared_ptr<frontend::ClientBuffers> create_buffer_map(
-        std::shared_ptr<frontend::BufferSink> const& sink) = 0;
 
 protected:
     BufferStreamFactory() = default;

=== modified file 'include/server/mir/scene/session.h'
--- include/server/mir/scene/session.h	2017-05-08 03:04:26 +0000
+++ include/server/mir/scene/session.h	2017-07-07 07:27:48 +0000
@@ -65,12 +65,6 @@
     virtual void destroy_buffer_stream(frontend::BufferStreamId stream) = 0;
     virtual void configure_streams(Surface& surface, std::vector<shell::StreamSpecification> const& config) = 0;
     virtual void destroy_surface(std::weak_ptr<Surface> const& surface) = 0;
-
-    virtual graphics::BufferID create_buffer(graphics::BufferProperties const& properties) = 0;
-    virtual graphics::BufferID create_buffer(geometry::Size, MirPixelFormat) = 0;
-    virtual graphics::BufferID create_buffer(geometry::Size, uint32_t native_format, uint32_t native_flags) = 0;
-    virtual void destroy_buffer(graphics::BufferID) = 0;
-    virtual std::shared_ptr<graphics::Buffer> get_buffer(graphics::BufferID) = 0;
 };
 }
 }

=== modified file 'include/server/mir/shell/window_management_info.h'
--- include/server/mir/shell/window_management_info.h	2017-05-08 03:04:26 +0000
+++ include/server/mir/shell/window_management_info.h	2017-07-07 07:27:48 +0000
@@ -28,6 +28,10 @@
 namespace mir
 {
 namespace scene { class Session; class Surface; struct SurfaceCreationParameters; }
+namespace graphics
+{
+class GraphicBufferAllocator;
+}
 namespace shell
 {
 struct SurfaceInfo
@@ -78,7 +82,7 @@
     mir::optional_value<graphics::DisplayConfigurationOutputId> output_id;
     mir::optional_value<MirPointerConfinementState> confine_pointer;
 
-    void init_titlebar(std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface);
+    void init_titlebar(graphics::GraphicBufferAllocator& allocator, std::shared_ptr<scene::Surface> const& surface);
     void paint_titlebar(int intensity);
 
 private:

=== modified file 'include/test/mir/test/doubles/stub_session.h'
--- include/test/mir/test/doubles/stub_session.h	2017-05-08 03:04:26 +0000
+++ include/test/mir/test/doubles/stub_session.h	2017-07-07 07:27:48 +0000
@@ -89,12 +89,6 @@
 
     void send_input_config(MirInputConfig const& config) override;
 
-    graphics::BufferID create_buffer(graphics::BufferProperties const& properties) override;
-    graphics::BufferID create_buffer(geometry::Size, MirPixelFormat) override;
-    graphics::BufferID create_buffer(geometry::Size, uint32_t native_format, uint32_t native_flags) override;
-    void destroy_buffer(graphics::BufferID) override;
-    std::shared_ptr<graphics::Buffer> get_buffer(graphics::BufferID) override;
-
     pid_t pid;
 };
 }

=== modified file 'src/server/compositor/CMakeLists.txt'
--- src/server/compositor/CMakeLists.txt	2017-05-08 03:04:26 +0000
+++ src/server/compositor/CMakeLists.txt	2017-07-07 07:27:48 +0000
@@ -9,7 +9,6 @@
 
   default_display_buffer_compositor.cpp
   default_display_buffer_compositor_factory.cpp
-  temporary_buffers.cpp
   buffer_stream_factory.cpp
   multi_threaded_compositor.cpp
   occlusion.cpp
@@ -18,7 +17,6 @@
   compositing_screencast.cpp
   stream.cpp
   multi_monitor_arbiter.cpp
-  buffer_map.cpp
   dropping_schedule.cpp
   queueing_schedule.cpp
 )

=== modified file 'src/server/compositor/buffer_acquisition.h'
--- src/server/compositor/buffer_acquisition.h	2017-05-25 05:49:36 +0000
+++ src/server/compositor/buffer_acquisition.h	2017-07-07 07:27:48 +0000
@@ -36,6 +36,11 @@
     /**
      * Acquire the next buffer that's ready to display/composite.
      *
+     * \note    The returned buffer is considered in-use until the its
+     *          use-count reaches 0. In-use buffers will not be returned
+     *          to the client, so for best performance it is important to
+     *          release the returned buffer as soon as possible.
+     *
      * \param [in] user_id A unique identifier of who is going to use the
      *                     buffer, to ensure that separate users representing
      *                     separate monitors who need the same frame will get
@@ -46,9 +51,19 @@
      */
     virtual std::shared_ptr<graphics::Buffer>
         compositor_acquire(void const* user_id) = 0;
-    virtual void compositor_release(std::shared_ptr<graphics::Buffer> const&) = 0;
+
+    /**
+     * Acquire the most recently displayed buffer.
+     *
+     * In contrast with compositor_acquire() this does not consume a client
+     * buffer.
+     *
+     * Like compositor_acquire(), you should release your reference to the
+     * returned buffer as soon as possible.
+     *
+     * \return A shared reference to the most recent visible client buffer.
+     */
     virtual std::shared_ptr<graphics::Buffer> snapshot_acquire() = 0;
-    virtual void snapshot_release(std::shared_ptr<graphics::Buffer> const&) = 0;
     virtual ~BufferAcquisition() = default;
 
 protected:

=== removed file 'src/server/compositor/buffer_map.cpp'
--- src/server/compositor/buffer_map.cpp	2017-05-08 03:04:26 +0000
+++ src/server/compositor/buffer_map.cpp	1970-01-01 00:00:00 +0000
@@ -1,116 +0,0 @@
-/*
- * Copyright © 2015 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#include "mir/graphics/buffer.h"
-#include "mir/frontend/buffer_sink.h"
-#include "buffer_map.h"
-#include <boost/throw_exception.hpp>
-#include <algorithm>
-
-namespace mc = mir::compositor;
-namespace mf = mir::frontend;
-namespace mg = mir::graphics;
-
-namespace mir
-{
-namespace compositor
-{
-enum class BufferMap::Owner
-{
-    server,
-    client
-};
-}
-}
-
-mc::BufferMap::BufferMap(std::shared_ptr<mf::BufferSink> const& sink) :
-    sink(sink)
-{
-}
-
-mg::BufferID mc::BufferMap::add_buffer(std::shared_ptr<mg::Buffer> const& buffer)
-{
-    try
-    {
-        std::unique_lock<decltype(mutex)> lk(mutex);
-        buffers[buffer->id()] = {buffer, Owner::client};
-        if (auto s = sink.lock())
-            s->add_buffer(*buffer);
-        return buffer->id();
-    } catch (std::exception& e)
-    {
-        if (auto s = sink.lock())
-            s->error_buffer(buffer->size(), buffer->pixel_format(), e.what());
-        throw;
-    }
-}
-
-void mc::BufferMap::remove_buffer(mg::BufferID id)
-{
-    std::unique_lock<decltype(mutex)> lk(mutex);
-    auto it = checked_buffers_find(id, lk);
-    if (auto s = sink.lock())
-        s->remove_buffer(*it->second.buffer);
-    buffers.erase(it); 
-}
-
-void mc::BufferMap::send_buffer(mg::BufferID id)
-{
-    std::unique_lock<decltype(mutex)> lk(mutex);
-    auto it = buffers.find(id);
-    if (it != buffers.end())
-    {
-        auto buffer = it->second.buffer;
-        it->second.owner = Owner::client;
-        lk.unlock();
-        if (auto s = sink.lock())
-            s->update_buffer(*buffer);
-    }
-}
-
-void mc::BufferMap::receive_buffer(graphics::BufferID id)
-{
-    std::unique_lock<decltype(mutex)> lk(mutex);
-    auto it = buffers.find(id);
-    if (it != buffers.end())
-        it->second.owner = Owner::server;
-}
-
-std::shared_ptr<mg::Buffer> mc::BufferMap::get(mg::BufferID id) const
-{
-    std::unique_lock<decltype(mutex)> lk(mutex);
-    return checked_buffers_find(id, lk)->second.buffer;
-}
-
-mc::BufferMap::Map::iterator mc::BufferMap::checked_buffers_find(
-    mg::BufferID id, std::unique_lock<std::mutex> const&)
-{
-    auto it = buffers.find(id);
-    if (it == buffers.end())
-        BOOST_THROW_EXCEPTION(std::logic_error("cannot find buffer by id"));
-    return it;
-}
-
-mc::BufferMap::Map::const_iterator mc::BufferMap::checked_buffers_find(
-    mg::BufferID id, std::unique_lock<std::mutex> const&) const
-{
-    auto it = buffers.find(id);
-    if (it == buffers.end())
-        BOOST_THROW_EXCEPTION(std::logic_error("cannot find buffer by id"));
-    return it;
-}

=== removed file 'src/server/compositor/buffer_map.h'
--- src/server/compositor/buffer_map.h	2017-05-08 03:04:26 +0000
+++ src/server/compositor/buffer_map.h	1970-01-01 00:00:00 +0000
@@ -1,65 +0,0 @@
-/*
- * Copyright © 2015 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_COMPOSITOR_BUFFER_MAP_H_
-#define MIR_COMPOSITOR_BUFFER_MAP_H_
-
-#include "mir/frontend/client_buffers.h"
-#include <mutex>
-#include <map>
-
-namespace mir
-{
-namespace frontend { class BufferSink; }
-namespace compositor
-{
-class BufferMap : public frontend::ClientBuffers
-{
-public:
-    BufferMap(std::shared_ptr<frontend::BufferSink> const& sink);
-
-    graphics::BufferID add_buffer(std::shared_ptr<graphics::Buffer> const& buffer) override;
-    void remove_buffer(graphics::BufferID id) override;
-
-    void receive_buffer(graphics::BufferID id) override;
-    void send_buffer(graphics::BufferID id) override;
-
-    std::shared_ptr<graphics::Buffer> get(graphics::BufferID) const override;
-    
-private:
-    std::mutex mutable mutex;
-
-    enum class Owner;
-    struct MapEntry
-    {
-        std::shared_ptr<graphics::Buffer> buffer;
-        Owner owner;
-    };
-    typedef std::map<graphics::BufferID, MapEntry> Map;
-    //used to keep strong reference
-    Map buffers;
-    Map::iterator checked_buffers_find(graphics::BufferID, std::unique_lock<std::mutex> const&);
-    Map::const_iterator checked_buffers_find(graphics::BufferID, std::unique_lock<std::mutex> const&) const;
-
-    //would be better to schedule the async buffer callbacks in the ipc subsystem,
-    //instead of driving from within the compositor threads (LP: #1395421)
-    std::weak_ptr<frontend::BufferSink> const sink;
-};
-}
-}
-#endif /* MIR_COMPOSITOR_BUFFER_MAP_H_ */

=== modified file 'src/server/compositor/buffer_stream_factory.cpp'
--- src/server/compositor/buffer_stream_factory.cpp	2017-05-08 03:04:26 +0000
+++ src/server/compositor/buffer_stream_factory.cpp	2017-07-07 07:27:48 +0000
@@ -21,7 +21,6 @@
 #include "buffer_stream_factory.h"
 #include "mir/graphics/buffer_properties.h"
 #include "stream.h"
-#include "buffer_map.h"
 #include "mir/graphics/buffer.h"
 #include "mir/graphics/buffer_id.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
@@ -40,23 +39,17 @@
 }
 
 std::shared_ptr<mc::BufferStream> mc::BufferStreamFactory::create_buffer_stream(
-    mf::BufferStreamId id, std::shared_ptr<mf::ClientBuffers> const& buffers,
+    mf::BufferStreamId id,
     mg::BufferProperties const& buffer_properties)
 {
-    return create_buffer_stream(id, buffers, 0, buffer_properties);
+    return create_buffer_stream(id, 0, buffer_properties);
 }
 
 std::shared_ptr<mc::BufferStream> mc::BufferStreamFactory::create_buffer_stream(
-    mf::BufferStreamId, std::shared_ptr<mf::ClientBuffers> const& buffers,
-    int, mg::BufferProperties const& buffer_properties)
+    mf::BufferStreamId,
+    int,
+    mg::BufferProperties const& buffer_properties)
 {
     return std::make_shared<mc::Stream>(
-        buffers,
         buffer_properties.size, buffer_properties.format);
 }
-
-std::shared_ptr<mf::ClientBuffers> mc::BufferStreamFactory::create_buffer_map(
-        std::shared_ptr<mf::BufferSink> const& sink)
-{
-    return std::make_shared<mc::BufferMap>(sink);
-}

=== modified file 'src/server/compositor/buffer_stream_factory.h'
--- src/server/compositor/buffer_stream_factory.h	2017-05-08 03:04:26 +0000
+++ src/server/compositor/buffer_stream_factory.h	2017-07-07 07:27:48 +0000
@@ -42,13 +42,12 @@
     virtual ~BufferStreamFactory() {}
 
     virtual std::shared_ptr<compositor::BufferStream> create_buffer_stream(
-        frontend::BufferStreamId, std::shared_ptr<frontend::ClientBuffers> const& sink,
-        int nbuffers, graphics::BufferProperties const& buffer_properties) override;
+        frontend::BufferStreamId,
+        int nbuffers,
+        graphics::BufferProperties const& buffer_properties) override;
     virtual std::shared_ptr<BufferStream> create_buffer_stream(
-        frontend::BufferStreamId, std::shared_ptr<frontend::ClientBuffers> const& sink,
+        frontend::BufferStreamId,
         graphics::BufferProperties const&) override;
-    virtual std::shared_ptr<frontend::ClientBuffers> create_buffer_map(
-        std::shared_ptr<frontend::BufferSink> const& sink) override;
 };
 
 }

=== modified file 'src/server/compositor/dropping_schedule.cpp'
--- src/server/compositor/dropping_schedule.cpp	2017-05-08 03:04:26 +0000
+++ src/server/compositor/dropping_schedule.cpp	2017-07-07 07:27:48 +0000
@@ -17,41 +17,20 @@
  */
 
 #include "dropping_schedule.h"
-#include "mir/frontend/client_buffers.h"
 #include "mir/graphics/buffer.h"
 
 #include <boost/throw_exception.hpp>
-namespace mf = mir::frontend;
 namespace mg = mir::graphics;
 namespace mc = mir::compositor;
 
-mc::DroppingSchedule::DroppingSchedule(std::shared_ptr<mf::ClientBuffers> const& client_buffers) :
-    sender(client_buffers)
+mc::DroppingSchedule::DroppingSchedule()
 {
 }
 
 void mc::DroppingSchedule::schedule(std::shared_ptr<mg::Buffer> const& buffer)
 {
-    auto drop = schedule_nonblocking(buffer);
-    if (drop.valid())
-        drop.wait();
-}
-
-std::future<void> mc::DroppingSchedule::schedule_nonblocking(
-    std::shared_ptr<mg::Buffer> const& buffer)
-{
-    std::future<void> drop;
     std::lock_guard<decltype(mutex)> lk(mutex);
-    if ((the_only_buffer != buffer) && the_only_buffer)
-    {
-        drop = std::async(std::launch::deferred,
-            [sender=sender, dropped=the_only_buffer]()
-            {
-                sender->send_buffer(dropped->id());
-            });
-    }
     the_only_buffer = buffer;
-    return drop;
 }
 
 unsigned int mc::DroppingSchedule::num_scheduled()

=== modified file 'src/server/compositor/dropping_schedule.h'
--- src/server/compositor/dropping_schedule.h	2017-05-08 03:04:26 +0000
+++ src/server/compositor/dropping_schedule.h	2017-07-07 07:27:48 +0000
@@ -25,22 +25,18 @@
 namespace mir
 {
 namespace graphics { class Buffer; }
-namespace frontend { class ClientBuffers; }
 namespace compositor
 {
 class DroppingSchedule : public Schedule
 {
 public:
-    DroppingSchedule(std::shared_ptr<frontend::ClientBuffers> const&);
+    DroppingSchedule();
     void schedule(std::shared_ptr<graphics::Buffer> const& buffer) override;
-    std::future<void> schedule_nonblocking(
-        std::shared_ptr<graphics::Buffer> const& buffer) override;
     unsigned int num_scheduled() override;
     std::shared_ptr<graphics::Buffer> next_buffer() override;
 
 private:
     std::mutex mutable mutex;
-    std::shared_ptr<frontend::ClientBuffers> const sender;
     std::shared_ptr<graphics::Buffer> the_only_buffer;
 };
 }

=== modified file 'src/server/compositor/multi_monitor_arbiter.cpp'
--- src/server/compositor/multi_monitor_arbiter.cpp	2017-05-26 12:45:45 +0000
+++ src/server/compositor/multi_monitor_arbiter.cpp	2017-07-07 07:27:48 +0000
@@ -20,7 +20,6 @@
 #include "mir/graphics/buffer.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/frontend/event_sink.h"
-#include "mir/frontend/client_buffers.h"
 #include "schedule.h"
 #include <boost/throw_exception.hpp>
 #include <algorithm>
@@ -30,105 +29,47 @@
 namespace mf = mir::frontend;
 
 mc::MultiMonitorArbiter::MultiMonitorArbiter(
-    std::shared_ptr<frontend::ClientBuffers> const& map,
     std::shared_ptr<Schedule> const& schedule) :
-    map(map),
     schedule(schedule)
 {
 }
 
 mc::MultiMonitorArbiter::~MultiMonitorArbiter()
 {
-    std::lock_guard<decltype(mutex)> lk(mutex);
-    for(auto it = onscreen_buffers.begin(); it != onscreen_buffers.end(); it++)
-    {
-        if (it->use_count == 0)
-            map->send_buffer(it->buffer->id());
-    }
-
 }
 
 std::shared_ptr<mg::Buffer> mc::MultiMonitorArbiter::compositor_acquire(compositor::CompositorID id)
 {
     std::lock_guard<decltype(mutex)> lk(mutex);
 
-    if (onscreen_buffers.empty() && !schedule->num_scheduled())
+    if (!current_buffer && !schedule->num_scheduled())
         BOOST_THROW_EXCEPTION(std::logic_error("no buffer to give to compositor"));
 
-    if (current_buffer_users.find(id) != current_buffer_users.end() || onscreen_buffers.empty())
+    if (current_buffer_users.find(id) != current_buffer_users.end() || !current_buffer)
     {
         if (schedule->num_scheduled())
-            onscreen_buffers.emplace_front(schedule->next_buffer(), 0);
+            current_buffer = schedule->next_buffer();
         current_buffer_users.clear();
     }
     current_buffer_users.insert(id);
 
-    auto& last_entry = onscreen_buffers.front();
-    last_entry.use_count++;
-    auto last_entry_buffer = last_entry.buffer;
-    clean_onscreen_buffers(lk);
-    return last_entry_buffer;
-}
-
-void mc::MultiMonitorArbiter::compositor_release(std::shared_ptr<mg::Buffer> const& buffer)
-{
-    std::lock_guard<decltype(mutex)> lk(mutex);
-
-    decrease_refcount_for(buffer->id(), lk);
-
-    if (onscreen_buffers.begin()->buffer != buffer)
-        clean_onscreen_buffers(lk);
-}
-
-void mc::MultiMonitorArbiter::decrease_refcount_for(mg::BufferID id, std::lock_guard<std::mutex> const&)
-{
-    auto it = std::find_if(onscreen_buffers.begin(), onscreen_buffers.end(),
-        [&id](ScheduleEntry const& s) { return s.buffer->id() == id; });
-    if (it == onscreen_buffers.end())
-        BOOST_THROW_EXCEPTION(std::logic_error("buffer not scheduled"));
-    it->use_count--;
-}
-
-void mc::MultiMonitorArbiter::clean_onscreen_buffers(std::lock_guard<std::mutex> const&)
-{
-    for(auto it = onscreen_buffers.begin(); it != onscreen_buffers.end();)
-    {
-        if ((it->use_count == 0) &&
-            (it != onscreen_buffers.begin() || schedule->num_scheduled())) //ensure monitors always have a buffer
-        {
-            map->send_buffer(it->buffer->id());
-            it = onscreen_buffers.erase(it);
-        }
-        else
-        {
-            it++;
-        } 
-    }
+    return current_buffer;
 }
 
 std::shared_ptr<mg::Buffer> mc::MultiMonitorArbiter::snapshot_acquire()
 {
     std::lock_guard<decltype(mutex)> lk(mutex);
 
-    if (onscreen_buffers.empty() && !schedule->num_scheduled())
+    if (!current_buffer && !schedule->num_scheduled())
         BOOST_THROW_EXCEPTION(std::logic_error("no buffer to give to snapshotter"));
 
-    if (onscreen_buffers.empty())
+    if (!current_buffer)
     {
         if (schedule->num_scheduled())
-            onscreen_buffers.emplace_front(schedule->next_buffer(), 0);
+            current_buffer = schedule->next_buffer();
     }
 
-    auto& last_entry = onscreen_buffers.front();
-    last_entry.use_count++;
-    return last_entry.buffer;
-}
-
-void mc::MultiMonitorArbiter::snapshot_release(std::shared_ptr<mg::Buffer> const& buffer)
-{
-    std::lock_guard<decltype(mutex)> lk(mutex);
-    decrease_refcount_for(buffer->id(), lk);
-    clean_onscreen_buffers(lk);
+    return current_buffer;
 }
 
 void mc::MultiMonitorArbiter::set_schedule(std::shared_ptr<Schedule> const& new_schedule)
@@ -141,13 +82,13 @@
 {
     std::lock_guard<decltype(mutex)> lk(mutex);
     return schedule->num_scheduled() ||
-       ((current_buffer_users.find(id) == current_buffer_users.end()) && !onscreen_buffers.empty());
+       ((current_buffer_users.find(id) == current_buffer_users.end()) && current_buffer);
 }
 
 bool mc::MultiMonitorArbiter::has_buffer()
 {
     std::lock_guard<decltype(mutex)> lk(mutex);
-    return !onscreen_buffers.empty();
+    return static_cast<bool>(current_buffer);
 }
 
 void mc::MultiMonitorArbiter::advance_schedule()
@@ -155,7 +96,7 @@
     std::lock_guard<decltype(mutex)> lk(mutex);
     if (schedule->num_scheduled())
     {
-        onscreen_buffers.emplace_front(schedule->next_buffer(), 0);
+        current_buffer = schedule->next_buffer();
         current_buffer_users.clear();
     } 
 }

=== modified file 'src/server/compositor/multi_monitor_arbiter.h'
--- src/server/compositor/multi_monitor_arbiter.h	2017-05-25 05:49:36 +0000
+++ src/server/compositor/multi_monitor_arbiter.h	2017-07-07 07:27:48 +0000
@@ -38,36 +38,19 @@
 {
 public:
     MultiMonitorArbiter(
-        std::shared_ptr<frontend::ClientBuffers> const& map,
         std::shared_ptr<Schedule> const& schedule);
     ~MultiMonitorArbiter();
 
     std::shared_ptr<graphics::Buffer> compositor_acquire(compositor::CompositorID id) override;
-    void compositor_release(std::shared_ptr<graphics::Buffer> const&) override;
     std::shared_ptr<graphics::Buffer> snapshot_acquire() override;
-    void snapshot_release(std::shared_ptr<graphics::Buffer> const&) override;
     void set_schedule(std::shared_ptr<Schedule> const& schedule);
     bool buffer_ready_for(compositor::CompositorID id);
     bool has_buffer();
     void advance_schedule();
 
 private:
-    void decrease_refcount_for(graphics::BufferID id, std::lock_guard<std::mutex> const&);
-    void clean_onscreen_buffers(std::lock_guard<std::mutex> const&);
-
     std::mutex mutable mutex;
-    std::shared_ptr<frontend::ClientBuffers> const map;
-    struct ScheduleEntry
-    {
-        ScheduleEntry(std::shared_ptr<graphics::Buffer> const& buffer, unsigned int use_count) :
-            buffer(buffer),
-            use_count(use_count)
-        {
-        }
-        std::shared_ptr<graphics::Buffer> buffer;
-        unsigned int use_count;
-    };
-    std::deque<ScheduleEntry> onscreen_buffers;
+    std::shared_ptr<graphics::Buffer> current_buffer;
     std::set<compositor::CompositorID> current_buffer_users;
     std::shared_ptr<Schedule> schedule;
 };

=== modified file 'src/server/compositor/queueing_schedule.cpp'
--- src/server/compositor/queueing_schedule.cpp	2017-05-08 03:04:26 +0000
+++ src/server/compositor/queueing_schedule.cpp	2017-07-07 07:27:48 +0000
@@ -32,13 +32,6 @@
     queue.emplace_back(buffer);
 }
 
-std::future<void> mc::QueueingSchedule::schedule_nonblocking(
-    std::shared_ptr<graphics::Buffer> const& buffer)
-{
-    schedule(buffer);
-    return {};
-}
-
 unsigned int mc::QueueingSchedule::num_scheduled()
 {
     std::lock_guard<decltype(mutex)> lk(mutex);

=== modified file 'src/server/compositor/queueing_schedule.h'
--- src/server/compositor/queueing_schedule.h	2017-05-08 03:04:26 +0000
+++ src/server/compositor/queueing_schedule.h	2017-07-07 07:27:48 +0000
@@ -32,8 +32,6 @@
 {
 public:
     void schedule(std::shared_ptr<graphics::Buffer> const& buffer) override;
-    std::future<void> schedule_nonblocking(
-        std::shared_ptr<graphics::Buffer> const& buffer) override;
     unsigned int num_scheduled() override;
     std::shared_ptr<graphics::Buffer> next_buffer() override;
 

=== modified file 'src/server/compositor/schedule.h'
--- src/server/compositor/schedule.h	2017-05-08 03:04:26 +0000
+++ src/server/compositor/schedule.h	2017-07-07 07:27:48 +0000
@@ -19,7 +19,6 @@
 #define MIR_COMPOSITOR_SCHEDULE_H_
 
 #include <memory>
-#include <future>
 
 namespace mir
 {
@@ -31,8 +30,6 @@
 {
 public:
     virtual void schedule(std::shared_ptr<graphics::Buffer> const& buffer) = 0;
-    virtual std::future<void> schedule_nonblocking(
-        std::shared_ptr<graphics::Buffer> const& buffer) = 0;
     virtual unsigned int num_scheduled() = 0;
     virtual std::shared_ptr<graphics::Buffer> next_buffer() = 0;
 

=== modified file 'src/server/compositor/stream.cpp'
--- src/server/compositor/stream.cpp	2017-05-25 05:49:36 +0000
+++ src/server/compositor/stream.cpp	2017-07-07 07:27:48 +0000
@@ -20,8 +20,6 @@
 #include "stream.h"
 #include "queueing_schedule.h"
 #include "dropping_schedule.h"
-#include "temporary_buffers.h"
-#include "mir/frontend/client_buffers.h"
 #include "mir/graphics/buffer.h"
 #include <boost/throw_exception.hpp>
 
@@ -37,22 +35,17 @@
 };
 
 mc::Stream::Stream(
-    std::shared_ptr<frontend::ClientBuffers> map, geom::Size size, MirPixelFormat pf) :
+    geom::Size size, MirPixelFormat pf) :
     schedule_mode(ScheduleMode::Queueing),
     schedule(std::make_shared<mc::QueueingSchedule>()),
-    buffers(map),
-    arbiter(std::make_shared<mc::MultiMonitorArbiter>(buffers, schedule)),
+    arbiter(std::make_shared<mc::MultiMonitorArbiter>(schedule)),
     size(size),
     pf(pf),
     first_frame_posted(false)
 {
 }
 
-mc::Stream::~Stream()
-{
-    while(schedule->num_scheduled())
-        buffers->send_buffer(schedule->next_buffer()->id());
-}
+mc::Stream::~Stream() = default;
 
 unsigned int mc::Stream::client_owned_buffer_count(std::lock_guard<decltype(mutex)> const&) const
 {
@@ -64,34 +57,22 @@
 
 void mc::Stream::submit_buffer(std::shared_ptr<mg::Buffer> const& buffer)
 {
-    std::future<void> deferred_io;
-
     if (!buffer)
         BOOST_THROW_EXCEPTION(std::invalid_argument("cannot submit null buffer"));
 
     {
         std::lock_guard<decltype(mutex)> lk(mutex); 
         first_frame_posted = true;
-        buffers->receive_buffer(buffer->id());
-        deferred_io = schedule->schedule_nonblocking(buffers->get(buffer->id()));
         pf = buffer->pixel_format();
+        schedule->schedule(buffer);
     }
     observers.frame_posted(1, buffer->size());
-
-    // Ensure that mutex is not locked while we do this (synchronous!) socket
-    // IO. Holding it locked blocks the compositor thread(s) from rendering.
-    if (deferred_io.valid())
-    {
-        // TODO: Throttling of GPU hogs goes here (LP: #1211700, LP: #1665802)
-        deferred_io.wait();
-    }
 }
 
 void mc::Stream::with_most_recent_buffer_do(std::function<void(mg::Buffer&)> const& fn)
 {
     std::lock_guard<decltype(mutex)> lk(mutex); 
-    TemporarySnapshotBuffer buffer(arbiter);
-    fn(buffer);
+    fn(*arbiter->snapshot_acquire());
 }
 
 MirPixelFormat mc::Stream::pixel_format() const
@@ -113,7 +94,7 @@
 
 std::shared_ptr<mg::Buffer> mc::Stream::lock_compositor_buffer(void const* id)
 {
-    return std::make_shared<mc::TemporaryCompositorBuffer>(arbiter, id);
+    return arbiter->compositor_acquire(id);
 }
 
 geom::Size mc::Stream::stream_size()
@@ -134,7 +115,7 @@
     std::lock_guard<decltype(mutex)> lk(mutex); 
     if (dropping && schedule_mode == ScheduleMode::Queueing)
     {
-        transition_schedule(std::make_shared<mc::DroppingSchedule>(buffers), lk);
+        transition_schedule(std::make_shared<mc::DroppingSchedule>(), lk);
         schedule_mode = ScheduleMode::Dropping;
     }
     else if (!dropping && schedule_mode == ScheduleMode::Dropping)
@@ -182,9 +163,6 @@
         transferred_buffers.pop_back();
     }
 
-    for (auto &buffer : transferred_buffers)
-        buffers->send_buffer(buffer->id());
-
     arbiter->advance_schedule();
 }
 
@@ -214,15 +192,7 @@
 
 bool mc::Stream::suitable_for_cursor() const
 {
-    if (associated_buffers.empty())
-    {
-        return true;
-    }
-    else
-    {
-        for (auto it : associated_buffers)
-            if (buffers->get(it)->pixel_format() != mir_pixel_format_argb_8888)
-                return false;
-    }
+    // We can't reasonably answer this question -
+    // Suitability for cursor use is a per-buffer property, not a per-stream property.
     return true;
 }

=== modified file 'src/server/compositor/stream.h'
--- src/server/compositor/stream.h	2017-05-22 11:53:51 +0000
+++ src/server/compositor/stream.h	2017-07-07 07:27:48 +0000
@@ -39,7 +39,7 @@
 class Stream : public BufferStream
 {
 public:
-    Stream(std::shared_ptr<frontend::ClientBuffers>, geometry::Size sz, MirPixelFormat format);
+    Stream(geometry::Size sz, MirPixelFormat format);
     ~Stream();
 
     void submit_buffer(std::shared_ptr<graphics::Buffer> const& buffer) override;
@@ -68,7 +68,6 @@
     std::mutex mutable mutex;
     ScheduleMode schedule_mode;
     std::shared_ptr<Schedule> schedule;
-    std::shared_ptr<frontend::ClientBuffers> const buffers;
     std::shared_ptr<MultiMonitorArbiter> const arbiter;
     geometry::Size size; 
     MirPixelFormat pf;

=== removed file 'src/server/compositor/temporary_buffers.cpp'
--- src/server/compositor/temporary_buffers.cpp	2016-10-03 13:55:29 +0000
+++ src/server/compositor/temporary_buffers.cpp	1970-01-01 00:00:00 +0000
@@ -1,81 +0,0 @@
-/*
- * Copyright © 2012 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#include "buffer_acquisition.h"
-#include "temporary_buffers.h"
-
-#include <boost/throw_exception.hpp>
-#include <stdexcept>
-
-namespace mc=mir::compositor;
-namespace mg=mir::graphics;
-namespace geom=mir::geometry;
-
-mc::TemporaryBuffer::TemporaryBuffer(std::shared_ptr<mg::Buffer> const& real_buffer)
-    : buffer(real_buffer)
-{
-}
-
-mc::TemporaryCompositorBuffer::TemporaryCompositorBuffer(
-    std::shared_ptr<BufferAcquisition> const& acquisition, void const* user_id)
-    : TemporaryBuffer(acquisition->compositor_acquire(user_id)),
-      acquisition(acquisition)
-{
-}
-
-mc::TemporaryCompositorBuffer::~TemporaryCompositorBuffer()
-{
-    acquisition->compositor_release(buffer);
-}
-
-mc::TemporarySnapshotBuffer::TemporarySnapshotBuffer(
-    std::shared_ptr<BufferAcquisition> const& acquisition)
-    : TemporaryBuffer(acquisition->snapshot_acquire()),
-      acquisition(acquisition)
-{
-}
-
-mc::TemporarySnapshotBuffer::~TemporarySnapshotBuffer()
-{
-    acquisition->snapshot_release(buffer);
-}
-
-geom::Size mc::TemporaryBuffer::size() const
-{
-    return buffer->size();
-}
-
-MirPixelFormat mc::TemporaryBuffer::pixel_format() const
-{
-    return buffer->pixel_format();
-}
-
-mg::BufferID mc::TemporaryBuffer::id() const
-{
-    return buffer->id();
-}
-
-std::shared_ptr<mg::NativeBuffer> mc::TemporaryBuffer::native_buffer_handle() const
-{
-    return buffer->native_buffer_handle();
-}
-
-mg::NativeBufferBase* mc::TemporaryBuffer::native_buffer_base()
-{
-    return buffer->native_buffer_base();
-}

=== removed file 'src/server/compositor/temporary_buffers.h'
--- src/server/compositor/temporary_buffers.h	2016-08-22 13:25:21 +0000
+++ src/server/compositor/temporary_buffers.h	1970-01-01 00:00:00 +0000
@@ -1,74 +0,0 @@
-/*
- * Copyright © 2012 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_COMPOSITOR_TEMPORARY_BUFFERS_H_
-#define MIR_COMPOSITOR_TEMPORARY_BUFFERS_H_
-
-#include "mir/graphics/buffer.h"
-#include "mir/graphics/buffer_id.h"
-
-namespace mg = mir::graphics;
-
-namespace mir
-{
-namespace compositor
-{
-
-class BufferAcquisition;
-class BackBufferStrategy;
-
-class TemporaryBuffer : public mg::Buffer
-{
-public:
-    geometry::Size size() const override;
-    MirPixelFormat pixel_format() const override;
-    mg::BufferID id() const override;
-    std::shared_ptr<mg::NativeBuffer> native_buffer_handle() const override;
-    graphics::NativeBufferBase* native_buffer_base() override;
-
-protected:
-    explicit TemporaryBuffer(std::shared_ptr<mg::Buffer> const& real_buffer);
-    std::shared_ptr<mg::Buffer> const buffer;
-};
-
-class TemporaryCompositorBuffer : public TemporaryBuffer
-{
-public:
-    explicit TemporaryCompositorBuffer(
-        std::shared_ptr<BufferAcquisition> const& acquisition, void const* user_id);
-    ~TemporaryCompositorBuffer();
-
-private:
-    std::shared_ptr<BufferAcquisition> const acquisition;
-};
-
-class TemporarySnapshotBuffer : public TemporaryBuffer
-{
-public:
-    explicit TemporarySnapshotBuffer(
-        std::shared_ptr<BufferAcquisition> const& acquisition);
-    ~TemporarySnapshotBuffer();
-
-private:
-    std::shared_ptr<BufferAcquisition> const acquisition;
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_TEMPORARY_BUFFERS_H_ */

=== modified file 'src/server/frontend/default_ipc_factory.cpp'
--- src/server/frontend/default_ipc_factory.cpp	2017-05-08 03:04:26 +0000
+++ src/server/frontend/default_ipc_factory.cpp	2017-07-07 07:27:48 +0000
@@ -26,14 +26,75 @@
 #include "resource_cache.h"
 #include "mir/frontend/session_authorizer.h"
 #include "mir/frontend/event_sink.h"
+#include "event_sink_factory.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/cookie/authority.h"
+#include "mir/executor.h"
+
+#include <deque>
 
 namespace mf = mir::frontend;
 namespace mg = mir::graphics;
 namespace mi = mir::input;
 namespace ms = mir::scene;
 
+namespace
+{
+class ThreadExecutor : public mir::Executor
+{
+public:
+    ThreadExecutor()
+        : shutdown{false}
+    {
+        dispatch_thread = std::thread{
+            [this]()
+            {
+                while (!shutdown)
+                {
+                    std::unique_lock<std::mutex> lock{queue_mutex};
+                    queue_notifier.wait(lock, [this]() { return shutdown || !tasks.empty(); });
+                    if (!tasks.empty())
+                    {
+                        tasks.front()();
+                        tasks.pop_front();
+                    }
+                }
+            }
+        };
+    }
+
+    ~ThreadExecutor()
+    {
+        {
+            std::lock_guard<std::mutex> lock{queue_mutex};
+            shutdown = true;
+        }
+        queue_notifier.notify_all();
+        if (dispatch_thread.joinable())
+        {
+            dispatch_thread.join();
+        }
+    }
+
+    void spawn(std::function<void()>&& work) override
+    {
+        {
+            std::lock_guard<std::mutex> lock{queue_mutex};
+            tasks.emplace_back(std::move(work));
+        }
+        queue_notifier.notify_all();
+    }
+
+private:
+    std::thread dispatch_thread;
+
+    std::mutex queue_mutex;
+    bool shutdown;
+    std::condition_variable queue_notifier;
+    std::deque<std::function<void()>> tasks;
+};
+}
+
 mf::DefaultIpcFactory::DefaultIpcFactory(
     std::shared_ptr<Shell> const& shell,
     std::shared_ptr<SessionMediatorObserver> const& sm_observer,
@@ -62,7 +123,8 @@
     anr_detector{anr_detector},
     cookie_authority(cookie_authority),
     input_changer(input_changer),
-    extensions(extensions)
+    extensions(extensions),
+    execution_queue{std::make_shared<ThreadExecutor>()}
 {
 }
 
@@ -150,5 +212,7 @@
         anr_detector,
         cookie_authority,
         input_changer,
-        extensions);
+        extensions,
+        buffer_allocator,
+        execution_queue);
 }

=== modified file 'src/server/frontend/default_ipc_factory.h'
--- src/server/frontend/default_ipc_factory.h	2017-05-08 03:04:26 +0000
+++ src/server/frontend/default_ipc_factory.h	2017-07-07 07:27:48 +0000
@@ -24,6 +24,9 @@
 
 namespace mir
 {
+
+class Executor;
+
 namespace cookie
 {
 class Authority;
@@ -109,6 +112,7 @@
     std::shared_ptr<cookie::Authority> const cookie_authority;
     std::shared_ptr<InputConfigurationChanger> const input_changer;
     std::vector<mir::ExtensionDescription> const extensions;
+    std::shared_ptr<mir::Executor> const execution_queue;
 };
 }
 }

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2017-06-01 13:04:37 +0000
+++ src/server/frontend/session_mediator.cpp	2017-07-07 07:27:48 +0000
@@ -59,6 +59,8 @@
 #include "mir/fd.h"
 #include "mir/cookie/authority.h"
 #include "mir/module_properties.h"
+#include "mir/graphics/graphic_buffer_allocator.h"
+#include "mir/executor.h"
 
 #include "mir/geometry/rectangles.h"
 #include "protobuf_buffer_packer.h"
@@ -110,7 +112,9 @@
     std::shared_ptr<scene::ApplicationNotRespondingDetector> const& anr_detector,
     std::shared_ptr<mir::cookie::Authority> const& cookie_authority,
     std::shared_ptr<mf::InputConfigurationChanger> const& input_changer,
-    std::vector<mir::ExtensionDescription> const& extensions) :
+    std::vector<mir::ExtensionDescription> const& extensions,
+    std::shared_ptr<mg::GraphicBufferAllocator> const& allocator,
+    std::shared_ptr<mir::Executor> const& executor) :
     client_pid_(0),
     shell(shell),
     ipc_operations(ipc_operations),
@@ -128,7 +132,9 @@
     anr_detector{anr_detector},
     cookie_authority(cookie_authority),
     input_changer(input_changer),
-    extensions(extensions)
+    extensions(extensions),
+    allocator{allocator},
+    executor{executor}
 {
 }
 
@@ -374,6 +380,66 @@
     buffering_sender->uncork();
 }
 
+namespace
+{
+    class AutoSendBuffer : public mg::Buffer
+    {
+    public:
+        AutoSendBuffer(
+            std::shared_ptr<mg::Buffer> const& wrapped,
+            std::shared_ptr<mir::Executor> const& executor,
+            std::weak_ptr<mf::BufferSink> const& sink)
+            : buffer{wrapped},
+              executor{executor},
+              sink{sink}
+        {
+        }
+        ~AutoSendBuffer()
+        {
+            if (auto live_sink = sink.lock())
+            {
+                // Ensure we send buffer events from a dedicated thread.
+                executor->spawn(
+                    [live_sink, to_send = buffer]()
+                    {
+                        live_sink->update_buffer(*to_send);
+                    });
+            }
+        }
+
+        std::shared_ptr<mir::graphics::NativeBuffer> native_buffer_handle() const override
+        {
+            return buffer->native_buffer_handle();
+        }
+
+        mir::graphics::BufferID id() const override
+        {
+            return buffer->id();
+        }
+
+        mir::geometry::Size size() const override
+        {
+            return buffer->size();
+        }
+
+        MirPixelFormat pixel_format() const override
+        {
+            return buffer->pixel_format();
+        }
+
+        mir::graphics::NativeBufferBase *native_buffer_base() override
+        {
+            return buffer->native_buffer_base();
+        }
+
+    private:
+        std::shared_ptr<mg::Buffer> const buffer;
+        std::shared_ptr<mir::Executor> executor;
+        std::weak_ptr<mf::BufferSink> const sink;
+    };
+
+}
+
 void mf::SessionMediator::submit_buffer(
     mir::protobuf::BufferRequest const* request,
     mir::protobuf::Void*,
@@ -388,15 +454,15 @@
     auto stream = session->get_buffer_stream(stream_id);
 
     mfd::ProtobufBufferPacker request_msg{const_cast<mir::protobuf::Buffer*>(&request->buffer())};
-    auto b = session->get_buffer(buffer_id);
+    auto b = buffer_cache.at(buffer_id);
     ipc_operations->unpack_buffer(request_msg, *b);
 
-    stream->submit_buffer(b);
+    stream->submit_buffer(std::make_shared<AutoSendBuffer>(b, executor, event_sink));
 
     done->Run();
 }
 
-void mf::SessionMediator::allocate_buffers( 
+void mf::SessionMediator::allocate_buffers(
     mir::protobuf::BufferAllocation const* request,
     mir::protobuf::Void*,
     google::protobuf::Closure* done)
@@ -410,35 +476,53 @@
     {
         auto const& req = request->buffer_requests(i);
 
-        mg::BufferID id;
-        if (req.has_flags() && req.has_native_format())
-        {
-            id = session->create_buffer({req.width(), req.height()}, req.native_format(), req.flags());
-        }
-        else if (req.has_buffer_usage() && req.has_pixel_format())
-        {
-            auto const usage = static_cast<mg::BufferUsage>(req.buffer_usage());
-            geom::Size const size{req.width(), req.height()};
-            auto const pf = static_cast<MirPixelFormat>(req.pixel_format());
-            if (usage == mg::BufferUsage::software)
-            {
-                id = session->create_buffer(size, pf); 
+        std::shared_ptr<mg::Buffer> buffer;
+        try
+        {
+            if (req.has_flags() && req.has_native_format())
+            {
+                buffer = allocator->alloc_buffer(
+                    {req.width(), req.height()},
+                    req.native_format(),
+                    req.flags());
+            }
+            else if (req.has_buffer_usage() && req.has_pixel_format())
+            {
+                auto const usage = static_cast<mg::BufferUsage>(req.buffer_usage());
+                geom::Size const size{req.width(), req.height()};
+                auto const pf = static_cast<MirPixelFormat>(req.pixel_format());
+                if (usage == mg::BufferUsage::software)
+                {
+                    buffer = allocator->alloc_software_buffer(size, pf);
+                }
+                else
+                {
+                    //legacy route, server-selected pf and usage
+                    buffer =
+                        allocator->alloc_buffer(mg::BufferProperties{size, pf, mg::BufferUsage::hardware});
+                }
             }
             else
             {
-                //legacy route, server-selected pf and usage
-                id = session->create_buffer(mg::BufferProperties{size, pf, mg::BufferUsage::hardware});
-            }
-        }
-        else
-        {
-            BOOST_THROW_EXCEPTION(std::logic_error("Invalid buffer request"));
-        }
-
-        if (request->has_id())
-        {
-            auto stream = session->get_buffer_stream(mf::BufferStreamId(request->id().value()));
-            stream->associate_buffer(id);
+                BOOST_THROW_EXCEPTION(std::logic_error("Invalid buffer request"));
+            }
+
+            // TODO: Throw if insert fails (duplicate ID)?
+            buffer_cache.insert(std::make_pair(buffer->id(), buffer));
+            event_sink->add_buffer(*buffer);
+
+            if (request->has_id())
+            {
+                auto stream = session->get_buffer_stream(mf::BufferStreamId(request->id().value()));
+                stream->associate_buffer(buffer->id());
+            }
+        }
+        catch (std::runtime_error const& err)
+        {
+            event_sink->error_buffer(
+                geom::Size{req.width(), req.height()},
+                static_cast<MirPixelFormat>(req.pixel_format()),
+                err.what());
         }
     }
     done->Run();
@@ -473,7 +557,7 @@
     for (auto i = 0; i < request->buffers().size(); i++)
     {
         mg::BufferID buffer_id{static_cast<uint32_t>(request->buffers(i).buffer_id())};
-        session->destroy_buffer(buffer_id);
+        buffer_cache.erase(buffer_id);
     }
    done->Run();
 }
@@ -869,7 +953,7 @@
 {
     auto session = weak_session.lock();
     ScreencastSessionId const screencast_session_id{request->id().value()};
-    auto buffer = session->get_buffer(mg::BufferID{request->buffer_id()});
+    auto buffer = buffer_cache.at(mg::BufferID{request->buffer_id()});
     screencast->capture(screencast_session_id, buffer);
     done->Run();
 }

=== modified file 'src/server/frontend/session_mediator.h'
--- src/server/frontend/session_mediator.h	2017-05-08 03:04:26 +0000
+++ src/server/frontend/session_mediator.h	2017-07-07 07:27:48 +0000
@@ -28,6 +28,7 @@
 #include "mir/frontend/surface_id.h"
 #include "mir/frontend/buffer_stream_id.h"
 #include "mir/graphics/platform_ipc_operations.h"
+#include "mir/graphics/buffer_id.h"
 #include "mir/protobuf/display_server_debug.h"
 #include "mir_toolkit/common.h"
 
@@ -39,6 +40,8 @@
 
 namespace mir
 {
+class Executor;
+
 namespace cookie
 {
 class Authority;
@@ -77,6 +80,7 @@
 class PromptSession;
 class BufferStream;
 class InputConfigurationChanger;
+class BufferMap;
 
 namespace detail
 {
@@ -124,8 +128,9 @@
         std::shared_ptr<scene::ApplicationNotRespondingDetector> const& anr_detector,
         std::shared_ptr<cookie::Authority> const& cookie_authority,
         std::shared_ptr<InputConfigurationChanger> const& input_changer,
-        std::vector<mir::ExtensionDescription> const& extensions
-        );
+        std::vector<mir::ExtensionDescription> const& extensions,
+        std::shared_ptr<graphics::GraphicBufferAllocator> const& allocator,
+        std::shared_ptr<mir::Executor> const& executor);
 
     ~SessionMediator() noexcept;
 
@@ -299,6 +304,9 @@
     std::shared_ptr<cookie::Authority> const cookie_authority;
     std::shared_ptr<InputConfigurationChanger> const input_changer;
     std::vector<mir::ExtensionDescription> const extensions;
+    std::unordered_map<graphics::BufferID, std::shared_ptr<graphics::Buffer>> buffer_cache;
+    std::shared_ptr<graphics::GraphicBufferAllocator> const allocator;
+    std::shared_ptr<mir::Executor> const executor;
 
     ScreencastBufferTracker screencast_buffer_tracker;
 

=== modified file 'src/server/scene/application_session.cpp'
--- src/server/scene/application_session.cpp	2017-05-25 08:58:03 +0000
+++ src/server/scene/application_session.cpp	2017-07-07 07:27:48 +0000
@@ -20,7 +20,6 @@
 #include "snapshot_strategy.h"
 #include "default_session_container.h"
 #include "output_properties_cache.h"
-#include "../compositor/buffer_map.h"
 
 #include "mir/scene/surface.h"
 #include "mir/scene/surface_event_source.h"
@@ -68,7 +67,6 @@
     snapshot_strategy(snapshot_strategy),
     session_listener(session_listener),
     event_sink(sink),
-    buffers(buffer_stream_factory->create_buffer_map(sink)),
     gralloc(gralloc),
     next_surface_id(0)
 {
@@ -372,7 +370,7 @@
 mf::BufferStreamId ms::ApplicationSession::create_buffer_stream(mg::BufferProperties const& props)
 {
     auto const id = static_cast<mf::BufferStreamId>(next_id().as_value());
-    auto stream = buffer_stream_factory->create_buffer_stream(id, buffers, props);
+    auto stream = buffer_stream_factory->create_buffer_stream(id, props);
     
     std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
     streams[id] = stream;
@@ -429,56 +427,6 @@
     surface_stack->remove_surface(surface);
 }
 
-mg::BufferID ms::ApplicationSession::create_buffer(mg::BufferProperties const& properties)
-{
-    try
-    {
-        return buffers->add_buffer(gralloc->alloc_buffer(properties));
-    }
-    catch (std::exception& e)
-    {
-        event_sink->error_buffer(properties.size, properties.format, e.what());
-        throw;
-    }
-}
-
-mg::BufferID ms::ApplicationSession::create_buffer(mir::geometry::Size size, MirPixelFormat format)
-{
-    try
-    {
-        return buffers->add_buffer(gralloc->alloc_software_buffer(size, format));
-    }
-    catch (std::exception& e)
-    {
-        event_sink->error_buffer(size, format, e.what());
-        throw;
-    }
-}
-
-mg::BufferID ms::ApplicationSession::create_buffer(
-    mir::geometry::Size size, uint32_t native_format, uint32_t native_flags)
-{
-    try
-    {
-        return buffers->add_buffer(gralloc->alloc_buffer(size, native_format, native_flags));
-    }
-    catch (std::exception& e)
-    {
-        event_sink->error_buffer(size, static_cast<MirPixelFormat>(native_format), e.what());
-        throw;
-    }
-}
-
-void ms::ApplicationSession::destroy_buffer(mg::BufferID id)
-{
-    buffers->remove_buffer(id);
-}
-
-std::shared_ptr<mg::Buffer> ms::ApplicationSession::get_buffer(mg::BufferID id)
-{
-    return buffers->get(id);
-}
-
 void ms::ApplicationSession::send_error(mir::ClientVisibleError const& error)
 {
     event_sink->handle_error(error);

=== modified file 'src/server/scene/application_session.h'
--- src/server/scene/application_session.h	2017-05-08 03:04:26 +0000
+++ src/server/scene/application_session.h	2017-07-07 07:27:48 +0000
@@ -100,12 +100,6 @@
     void destroy_buffer_stream(frontend::BufferStreamId stream) override;
     void configure_streams(Surface& surface, std::vector<shell::StreamSpecification> const& config) override;
     void destroy_surface(std::weak_ptr<Surface> const& surface) override;
-
-    graphics::BufferID create_buffer(graphics::BufferProperties const& properties) override;
-    graphics::BufferID create_buffer(geometry::Size, MirPixelFormat) override;
-    graphics::BufferID create_buffer(geometry::Size, uint32_t native_format, uint32_t native_flags) override;
-    void destroy_buffer(graphics::BufferID) override;
-    std::shared_ptr<graphics::Buffer> get_buffer(graphics::BufferID) override;
 protected:
     ApplicationSession(ApplicationSession const&) = delete;
     ApplicationSession& operator=(ApplicationSession const&) = delete;
@@ -119,7 +113,6 @@
     std::shared_ptr<SnapshotStrategy> const snapshot_strategy;
     std::shared_ptr<SessionListener> const session_listener;
     std::shared_ptr<frontend::EventSink> const event_sink;
-    std::shared_ptr<frontend::ClientBuffers> const buffers;
     std::shared_ptr<graphics::GraphicBufferAllocator> const gralloc;
 
     frontend::SurfaceId next_id();

=== modified file 'src/server/shell/window_management_info.cpp'
--- src/server/shell/window_management_info.cpp	2017-05-08 03:04:26 +0000
+++ src/server/shell/window_management_info.cpp	2017-07-07 07:27:48 +0000
@@ -24,6 +24,7 @@
 
 #include "mir/graphics/buffer.h"
 #include "mir/renderer/sw/pixel_source.h"
+#include "mir/graphics/graphic_buffer_allocator.h"
 
 #include <atomic>
 
@@ -173,54 +174,40 @@
 {
     AllocatingPainter(
         std::shared_ptr<frontend::BufferStream> const& buffer_stream,
-        std::shared_ptr<scene::Session> const& session,
+        mg::GraphicBufferAllocator& allocator,
         Size size) :
         buffer_stream(buffer_stream),
-        session(session),
-        properties({
-            size,
-            buffer_stream->pixel_format(),
-            mg::BufferUsage::software
-        }),
-        front_buffer(session->create_buffer(properties)),
-        back_buffer(session->create_buffer(properties))
+        front_buffer{allocator.alloc_software_buffer(size, buffer_stream->pixel_format())},
+        back_buffer{allocator.alloc_software_buffer(size, buffer_stream->pixel_format())}
     {
     }
 
     void paint(int intensity) override
     {
-        auto buffer = session->get_buffer(back_buffer);
-
-        auto const format = buffer->pixel_format();
-        auto const sz = buffer->size().height.as_int() *
-                        buffer->size().width.as_int() * MIR_BYTES_PER_PIXEL(format);
+        auto const format = back_buffer->pixel_format();
+        auto const sz = back_buffer->size().height.as_int() *
+            back_buffer->size().width.as_int() * MIR_BYTES_PER_PIXEL(format);
         std::vector<unsigned char> pixels(sz, intensity);
-        if (auto pixel_source = dynamic_cast<mrs::PixelSource*>(buffer->native_buffer_base()))
+        if (auto pixel_source = dynamic_cast<mrs::PixelSource*>(back_buffer->native_buffer_base()))
             pixel_source->write(pixels.data(), sz);
-        buffer_stream->submit_buffer(buffer);
+        buffer_stream->submit_buffer(back_buffer);
 
         std::swap(front_buffer, back_buffer);
     }
 
-    ~AllocatingPainter()
-    {
-        session->destroy_buffer(front_buffer);
-        session->destroy_buffer(back_buffer);
-    }
-
     std::shared_ptr<frontend::BufferStream> const buffer_stream;
     std::shared_ptr<scene::Session> const session;
     mg::BufferProperties properties;
-    mg::BufferID front_buffer; 
-    mg::BufferID back_buffer; 
+    std::shared_ptr<mg::Buffer> front_buffer;
+    std::shared_ptr<mg::Buffer> back_buffer;
 };
 
 void msh::SurfaceInfo::init_titlebar(
-    std::shared_ptr<scene::Session> const& session,
+    mg::GraphicBufferAllocator& allocator,
     std::shared_ptr<scene::Surface> const& surface)
 {
     auto stream = surface->primary_buffer_stream();
-    stream_painter = std::make_shared<AllocatingPainter>(stream, session, surface->size());
+    stream_painter = std::make_shared<AllocatingPainter>(stream, allocator, surface->size());
 }
 
 void msh::SurfaceInfo::paint_titlebar(int intensity)

=== modified file 'tests/include/mir/test/doubles/stub_buffer_stream_factory.h'
--- tests/include/mir/test/doubles/stub_buffer_stream_factory.h	2017-05-08 03:04:26 +0000
+++ tests/include/mir/test/doubles/stub_buffer_stream_factory.h	2017-07-07 07:27:48 +0000
@@ -19,7 +19,6 @@
 #ifndef MIR_TEST_DOUBLES_STUB_BUFFER_STREAM_FACTORY_H_
 #define MIR_TEST_DOUBLES_STUB_BUFFER_STREAM_FACTORY_H_
 
-#include "mir/frontend/client_buffers.h"
 #include "mir/scene/buffer_stream_factory.h"
 #include "stub_buffer_stream.h"
 
@@ -30,40 +29,20 @@
 namespace doubles
 {
 
-struct StubClientBuffers : frontend::ClientBuffers
-{
-    graphics::BufferID add_buffer(std::shared_ptr<graphics::Buffer> const&) override
-    {
-        return {};
-    }
-    void remove_buffer(graphics::BufferID) override
-    {
-    }
-    std::shared_ptr<graphics::Buffer> get(graphics::BufferID) const override
-    {
-        return buffer;
-    }
-    void send_buffer(graphics::BufferID) override
-    {
-    }
-    void receive_buffer(graphics::BufferID) override
-    {
-    }
-    std::shared_ptr<graphics::Buffer> buffer;
-};
-
 struct StubBufferStreamFactory : public scene::BufferStreamFactory
 {
     std::shared_ptr<compositor::BufferStream> create_buffer_stream(
-        frontend::BufferStreamId i, std::shared_ptr<frontend::ClientBuffers> const& s,
-        int, graphics::BufferProperties const& p) { return create_buffer_stream(i, s, p); }
+        frontend::BufferStreamId i,
+        int,
+        graphics::BufferProperties const& p)
+    {
+        return create_buffer_stream(i, p);
+    }
     std::shared_ptr<compositor::BufferStream> create_buffer_stream(
-        frontend::BufferStreamId, std::shared_ptr<frontend::ClientBuffers> const&,
-        graphics::BufferProperties const&) { return std::make_shared<StubBufferStream>(); }
-    std::shared_ptr<frontend::ClientBuffers> create_buffer_map(
-        std::shared_ptr<frontend::BufferSink> const&)
+        frontend::BufferStreamId,
+        graphics::BufferProperties const&)
     {
-        return std::make_shared<StubClientBuffers>();
+        return std::make_shared<StubBufferStream>();
     }
 };
 }

=== modified file 'tests/integration-tests/compositor/test_swapping_swappers.cpp'
--- tests/integration-tests/compositor/test_swapping_swappers.cpp	2017-05-08 03:04:26 +0000
+++ tests/integration-tests/compositor/test_swapping_swappers.cpp	2017-07-07 07:27:48 +0000
@@ -19,7 +19,6 @@
 #include "multithread_harness.h"
 
 #include "src/server/compositor/stream.h"
-#include "src/server/compositor/buffer_map.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
 
 #include <gmock/gmock.h>
@@ -30,6 +29,7 @@
 #include <atomic>
 
 namespace mc = mir::compositor;
+namespace mf = mir::frontend;
 namespace mg = mir::graphics;
 namespace mt = mir::testing;
 namespace geom = mir::geometry;
@@ -42,7 +42,6 @@
     void SetUp()
     {
         stream = std::make_shared<mc::Stream>(
-            std::make_shared<mc::BufferMap>(nullptr),
             geom::Size{380, 210}, mir_pixel_format_abgr_8888);
     }
 

=== modified file 'tests/integration-tests/test_buffer_scheduling.cpp'
--- tests/integration-tests/test_buffer_scheduling.cpp	2017-05-25 05:49:36 +0000
+++ tests/integration-tests/test_buffer_scheduling.cpp	2017-07-07 07:27:48 +0000
@@ -16,17 +16,14 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#include "mir/frontend/client_buffers.h"
 #include "mir/frontend/event_sink.h"
 #include "mir/frontend/buffer_sink.h"
 #include "mir/renderer/sw/pixel_source.h"
 #include "src/client/buffer_vault.h"
 #include "src/client/buffer_factory.h"
-#include "src/client/buffer_factory.h"
 #include "src/client/protobuf_to_native_buffer.h"
 #include "src/client/connection_surface_map.h"
 #include "src/server/compositor/stream.h"
-#include "src/server/compositor/buffer_map.h"
 #include "mir/test/doubles/stub_client_buffer_factory.h"
 #include "mir/test/doubles/mock_client_buffer_factory.h"
 #include "mir/test/doubles/stub_buffer_allocator.h"
@@ -48,12 +45,6 @@
 namespace
 {
 
-enum class TestType
-{
-    ExchangeSemantics,
-    SubmitSemantics
-};
-
 enum class Access
 {
     blocked,
@@ -462,6 +453,51 @@
     return never_blocks; 
 }
 
+class AutoSendBuffer : public mg::Buffer
+{
+public:
+    AutoSendBuffer(
+        std::shared_ptr<mg::Buffer> const& wrapped,
+        std::shared_ptr<mf::BufferSink> const& sink)
+        : wrapped{wrapped},
+          sink{sink}
+    {
+    }
+
+    ~AutoSendBuffer()
+    {
+        sink->update_buffer(*wrapped);
+    }
+
+    std::shared_ptr<mg::NativeBuffer> native_buffer_handle() const override
+    {
+        return wrapped->native_buffer_handle();
+    }
+
+    mg::BufferID id() const override
+    {
+        return wrapped->id();
+    }
+
+    geom::Size size() const override
+    {
+        return wrapped->size();
+    }
+
+    MirPixelFormat pixel_format() const override
+    {
+        return wrapped->pixel_format();
+    }
+
+    mg::NativeBufferBase *native_buffer_base() override
+    {
+        return wrapped->native_buffer_base();
+    }
+
+private:
+    std::shared_ptr<mg::Buffer> const wrapped;
+    std::shared_ptr<mf::BufferSink> const sink;
+};
 
 //test infrastructure
 struct BufferScheduling : public Test, ::testing::WithParamInterface<int>
@@ -470,9 +506,7 @@
     {
         ipc = std::make_shared<StubIpcSystem>();
         sink = std::make_shared<StubEventSink>(ipc);
-        map = std::make_shared<mc::BufferMap>(sink);
         auto submit_stream = std::make_shared<mc::Stream>(
-            map,
             geom::Size{100,100},
             mir_pixel_format_abgr_8888);
         auto weak_stream = std::weak_ptr<mc::Stream>(submit_stream);
@@ -483,12 +517,15 @@
                 if (!submit_stream)
                     return;
                 mg::BufferID id{static_cast<unsigned int>(buffer.buffer_id())};
-                submit_stream->submit_buffer(map->get(id));
+                submit_stream->submit_buffer(
+                    std::make_shared<AutoSendBuffer>(map.at(id), sink));
             });
         ipc->on_allocate(
             [this](geom::Size sz)
             {
-                map->add_buffer(std::make_shared<mtd::StubBuffer>(sz));
+                auto const buffer = std::make_shared<mtd::StubBuffer>(sz);
+                map[buffer->id()] = buffer;
+                sink->add_buffer(*buffer);
             });
 
         consumer = std::make_unique<ScheduledConsumer>(submit_stream);
@@ -529,7 +566,7 @@
     std::unique_ptr<ConsumerSystem> consumer;
     std::unique_ptr<ConsumerSystem> second_consumer;
     std::unique_ptr<ConsumerSystem> third_consumer;
-    std::shared_ptr<mc::BufferMap> map;
+    std::unordered_map<mg::BufferID, std::shared_ptr<mg::Buffer>> map;
 };
 
 struct WithAnyNumberOfBuffers : BufferScheduling {};
@@ -1164,7 +1201,6 @@
         producer->produce();
         a = consumer->consume_resource();
         b = consumer->consume_resource();
-        EXPECT_THAT(a, Ne(b));
     }
     a.reset();
     b.reset();
@@ -1203,7 +1239,6 @@
     {
         first = consumer->consume_resource();
         second = consumer->consume_resource();
-        EXPECT_THAT(first, Ne(second)); 
         producer->produce();
     }
 

=== modified file 'tests/integration-tests/test_session.cpp'
--- tests/integration-tests/test_session.cpp	2017-05-08 03:04:26 +0000
+++ tests/integration-tests/test_session.cpp	2017-07-07 07:27:48 +0000
@@ -80,7 +80,7 @@
 struct StubGLBufferStreamFactory : public mtd::StubBufferStreamFactory
 {
     std::shared_ptr<mc::BufferStream> create_buffer_stream(
-        mf::BufferStreamId, std::shared_ptr<mf::ClientBuffers> const&,
+        mf::BufferStreamId,
         mg::BufferProperties const&) override
     {
         return std::make_shared<StubGLBufferStream>();

=== modified file 'tests/integration-tests/test_submit_buffer.cpp'
--- tests/integration-tests/test_submit_buffer.cpp	2017-05-08 03:04:26 +0000
+++ tests/integration-tests/test_submit_buffer.cpp	2017-07-07 07:27:48 +0000
@@ -32,7 +32,6 @@
 #include "mir/frontend/event_sink.h"
 #include "mir/compositor/buffer_stream.h"
 #include "src/server/compositor/stream.h"
-#include "src/server/compositor/buffer_map.h"
 #include "mir_toolkit/mir_client_library.h"
 #include "mir_toolkit/debug/surface.h"
 #include "src/client/mir_connection.h"
@@ -70,96 +69,17 @@
     {}
 
     std::shared_ptr<mc::BufferStream> create_buffer_stream(
-        mf::BufferStreamId i, std::shared_ptr<mf::ClientBuffers> const& s,
+        mf::BufferStreamId i,
         int, mg::BufferProperties const& p) override
     {
-        return create_buffer_stream(i, s, p);
+        return create_buffer_stream(i, p);
     }
 
     std::shared_ptr<mc::BufferStream> create_buffer_stream(
-        mf::BufferStreamId, std::shared_ptr<mf::ClientBuffers> const& sink,
+        mf::BufferStreamId,
         mg::BufferProperties const& properties) override
     {
-        return std::make_shared<mc::Stream>(sink, properties.size, properties.format);
-    }
-
-    std::shared_ptr<mf::ClientBuffers> create_buffer_map(std::shared_ptr<mf::BufferSink> const& sink) override
-    {
-        struct BufferMap : mf::ClientBuffers
-        {
-            BufferMap(
-                std::shared_ptr<mf::BufferSink> const& sink,
-                std::vector<mg::BufferID> const& ids) :
-                sink(sink),
-                buffer_id_seq(ids)
-            {
-                std::reverse(buffer_id_seq.begin(), buffer_id_seq.end());
-            }
-
-            mg::BufferID add_buffer(std::shared_ptr<mg::Buffer> const& buffer) override
-            {
-                struct BufferIdWrapper : mg::Buffer
-                {
-                    BufferIdWrapper(std::shared_ptr<mg::Buffer> const& b, mg::BufferID id) :
-                        wrapped(b),
-                        id_(id)
-                    {
-                    }
-                
-                    std::shared_ptr<mg::NativeBuffer> native_buffer_handle() const override
-                    {
-                        return wrapped->native_buffer_handle();
-                    }
-                    mg::BufferID id() const override
-                    {
-                        return id_;
-                    }
-                    geom::Size size() const override
-                    {
-                        return wrapped->size();
-                    }
-                    MirPixelFormat pixel_format() const override
-                    {
-                        return wrapped->pixel_format();
-                    }
-                    mg::NativeBufferBase* native_buffer_base() override
-                    {
-                        return wrapped->native_buffer_base();
-                    }
-                    std::shared_ptr<mg::Buffer> const wrapped;
-                    mg::BufferID const id_;
-                };
-
-                auto id = buffer_id_seq.back();
-                buffer_id_seq.pop_back();
-                b = std::make_shared<BufferIdWrapper>(buffer, id);
-                sink->add_buffer(*b);
-                return id; 
-            }
-
-            void remove_buffer(mg::BufferID) override
-            {
-            } 
-
-            std::shared_ptr<mg::Buffer> get(mg::BufferID) const override
-            {
-                return b;
-            }
-
-            void send_buffer(mg::BufferID) override
-            {
-            }
-
-            void receive_buffer(mg::BufferID) override
-            {
-            }
-
-            std::shared_ptr<mg::Buffer> b;
-            std::shared_ptr<mf::BufferSink> const sink;
-            std::shared_ptr<mtd::StubBufferAllocator> alloc{std::make_shared<mtd::StubBufferAllocator>()};
-            std::vector<mg::BufferID> buffer_id_seq;
-        };
-        return std::make_shared<BufferMap>(sink, buffer_id_seq);
+        return std::make_shared<mc::Stream>(properties.size, properties.format);
     }
 
     std::vector<mg::BufferID> const buffer_id_seq;
@@ -204,6 +124,66 @@
     std::shared_ptr<mg::PlatformIpcOperations> const underlying_ops;
 };
 
+class RecordingBufferAllocator : public mg::GraphicBufferAllocator
+{
+public:
+    RecordingBufferAllocator(
+        std::shared_ptr<mg::GraphicBufferAllocator> const& wrapped,
+        std::vector<std::weak_ptr<mg::Buffer>>& allocated_buffers,
+        std::mutex& buffer_mutex)
+        : allocated_buffers{allocated_buffers},
+          underlying_allocator{wrapped},
+          buffer_mutex{buffer_mutex}
+    {
+    }
+
+    std::shared_ptr<mg::Buffer> alloc_buffer(
+        mg::BufferProperties const& buffer_properties) override
+    {
+        auto const buf = underlying_allocator->alloc_buffer(buffer_properties);
+        {
+            std::lock_guard<std::mutex> lock{buffer_mutex};
+            allocated_buffers.push_back(buf);
+        }
+        return buf;
+    }
+
+    std::vector<MirPixelFormat> supported_pixel_formats() override
+    {
+        return underlying_allocator->supported_pixel_formats();
+    }
+
+    std::shared_ptr<mg::Buffer> alloc_buffer(
+        geom::Size size,
+        uint32_t native_format,
+        uint32_t native_flags) override
+    {
+        auto const buf = underlying_allocator->alloc_buffer(size, native_format, native_flags);
+        {
+            std::lock_guard<std::mutex> lock{buffer_mutex};
+            allocated_buffers.push_back(buf);
+        }
+        return buf;
+    }
+
+    std::shared_ptr<mg::Buffer> alloc_software_buffer(
+        geom::Size size,
+        MirPixelFormat format) override
+    {
+        auto const buf = underlying_allocator->alloc_software_buffer(size, format);
+        {
+            std::lock_guard<std::mutex> lock{buffer_mutex};
+            allocated_buffers.push_back(buf);
+        }
+        return buf;
+    }
+
+    std::vector<std::weak_ptr<mg::Buffer>>& allocated_buffers;
+private:
+    std::shared_ptr<mg::GraphicBufferAllocator> const underlying_allocator;
+    std::mutex& buffer_mutex;
+};
+
 struct StubPlatform : public mg::Platform
 {
     StubPlatform(std::shared_ptr<mir::Fd> const& last_fd)
@@ -214,7 +194,10 @@
 
     mir::UniqueModulePtr<mg::GraphicBufferAllocator> create_buffer_allocator() override
     {
-        return underlying_platform->create_buffer_allocator();
+        return mir::make_module_ptr<RecordingBufferAllocator>(
+            underlying_platform->create_buffer_allocator(),
+            allocated_buffers,
+            buffer_mutex);
     }
 
     mir::UniqueModulePtr<mg::PlatformIpcOperations> make_ipc_operations() const override
@@ -231,20 +214,28 @@
         return underlying_platform->create_display(policy, config);
     }
 
+    std::vector<std::weak_ptr<mg::Buffer>> get_allocated_buffers()
+    {
+        std::lock_guard<std::mutex> lock{buffer_mutex};
+        return allocated_buffers;
+    }
+
     mg::NativeRenderingPlatform* native_rendering_platform() override { return nullptr; }
     mg::NativeDisplayPlatform* native_display_platform() override { return nullptr; }
     std::vector<mir::ExtensionDescription> extensions() const override { return {}; }
 
     std::shared_ptr<mir::Fd> const last_fd;
     std::shared_ptr<mg::Platform> const underlying_platform;
+
+private:
+    std::mutex buffer_mutex;
+    std::vector<std::weak_ptr<mg::Buffer>> allocated_buffers;
 };
 
 struct ExchangeServerConfiguration : mtf::StubbedServerConfiguration
 {
     ExchangeServerConfiguration(
-        std::vector<mg::BufferID> const& id_seq,
         std::shared_ptr<mir::Fd> const& last_unpacked_fd) :
-        stream_factory{std::make_shared<StubStreamFactory>(id_seq)},
         platform{std::make_shared<StubPlatform>(last_unpacked_fd)}
     {
     }
@@ -254,24 +245,20 @@
         return platform;
     }
 
-    std::shared_ptr<msc::BufferStreamFactory> the_buffer_stream_factory() override
-    {
-        return stream_factory;
-    }
-
-    std::shared_ptr<StubStreamFactory> const stream_factory;
-    std::shared_ptr<mg::Platform> const platform;
+    std::shared_ptr<StubPlatform> const platform;
 };
 
 struct SubmitBuffer : mir_test_framework::InProcessServer
 {
-    std::vector<mg::BufferID> const buffer_id_exchange_seq{
-        mg::BufferID{4}, mg::BufferID{8}, mg::BufferID{9}, mg::BufferID{3}, mg::BufferID{4}};
-
     std::shared_ptr<mir::Fd> last_unpacked_fd{std::make_shared<mir::Fd>()};
-    ExchangeServerConfiguration server_configuration{buffer_id_exchange_seq, last_unpacked_fd};
+    ExchangeServerConfiguration server_configuration{last_unpacked_fd};
     mir::DefaultServerConfiguration& server_config() override { return server_configuration; }
 
+    std::vector<std::weak_ptr<mg::Buffer>> get_allocated_buffers()
+    {
+        return server_configuration.platform->get_allocated_buffers();
+    }
+
     void request_completed()
     {
         std::unique_lock<decltype(mutex)> lk(mutex);
@@ -287,7 +274,7 @@
             google::protobuf::NewCallback(this, &SubmitBuffer::request_completed));
         
         arrived = false;
-        return cv.wait_for(lk, std::chrono::seconds(5), [this]() {return arrived;});
+        return cv.wait_for(lk, std::chrono::seconds(500), [this]() {return arrived;});
     }
 
     bool allocate_buffers(mclr::DisplayServer& server, mp::BufferAllocation& request)
@@ -318,13 +305,18 @@
     mp::BufferRequest buffer_request; 
 };
 template<class Clock>
-bool spin_wait_for_id(mg::BufferID id, MirWindow* window, std::chrono::time_point<Clock> const& pt)
+bool spin_wait_for_id(
+    std::function<std::vector<mg::BufferID>()> const& id_generator,
+    MirWindow* window,
+    std::chrono::time_point<Clock> const& pt)
 {
     while(Clock::now() < pt)
     {
-        //auto z = mir_debug_window_current_buffer_id(window);
-        if (mir_debug_window_current_buffer_id(window) == id.as_value())
-            return true;
+        for (auto const& id : id_generator())
+        {
+            if (mir_debug_window_current_buffer_id(window) == id.as_value())
+                return true;
+        }
         std::this_thread::yield();
     }
     return false;
@@ -353,7 +345,17 @@
     for (auto i = 0; i < buffer_request.buffer().fd().size(); i++)
         ::close(buffer_request.buffer().fd(i));
 
-    buffer_request.mutable_buffer()->set_buffer_id(buffer_id_exchange_seq.begin()->as_value());
+    mp::BufferAllocation allocation_request;
+    auto allocate = allocation_request.add_buffer_requests();
+    allocate->set_buffer_usage(static_cast<int32_t>(mg::BufferUsage::software));
+    allocate->set_pixel_format(mir_pixel_format_abgr_8888);
+    allocate->set_width(320);
+    allocate->set_height(240);
+
+    ASSERT_THAT(allocate_buffers(server, allocation_request), DidNotTimeOut());
+
+    buffer_request.mutable_buffer()->set_buffer_id(
+        get_allocated_buffers().back().lock()->id().as_value());
     buffer_request.mutable_buffer()->add_fd(file);
 
     ASSERT_THAT(submit_buffer(server, buffer_request), DidNotTimeOut());
@@ -377,10 +379,22 @@
     auto rpc_channel = connection->rpc_channel();
     mclr::DisplayServer server(rpc_channel);
 
+    for(int i = 0; i < 5; ++i)
+    {
+        mp::BufferAllocation allocation_request;
+        auto allocate = allocation_request.add_buffer_requests();
+        allocate->set_buffer_usage(static_cast<int32_t>(mg::BufferUsage::software));
+        allocate->set_pixel_format(mir_pixel_format_abgr_8888);
+        allocate->set_width(320);
+        allocate->set_height(240);
+
+        allocate_buffers(server, allocation_request);
+    }
+
     mp::BufferRequest request;
-    for (auto const& id : buffer_id_exchange_seq)
+    for (auto weak_buffer : get_allocated_buffers())
     {
-        buffer_request.mutable_buffer()->set_buffer_id(id.as_value());
+        buffer_request.mutable_buffer()->set_buffer_id(weak_buffer.lock()->id().as_value());
         ASSERT_THAT(submit_buffer(server, buffer_request), DidNotTimeOut());
     }
 
@@ -396,8 +410,32 @@
     auto window = mtf::make_any_surface(connection);
 
     auto timeout = std::chrono::steady_clock::now() + 5s;
-    EXPECT_TRUE(spin_wait_for_id(buffer_id_exchange_seq.back(), window, timeout))
-        << "failed to see the last scheduled buffer become the current one";
+
+    EXPECT_TRUE(
+        spin_wait_for_id(
+            [this]()
+            {
+                /* We expect to receive one of the implicitly allocated buffers
+                 * We don't care which one we get.
+                 *
+                 * We need to repeatedly check the allocated buffers, because
+                 * buffer allocation is asynchronous WRT window creation.
+                 */
+                std::vector<mg::BufferID> candidate_ids;
+                for (auto const weak_buffer : get_allocated_buffers())
+                {
+                    auto const buffer = weak_buffer.lock();
+                    if (buffer)
+                    {
+                        // If there are any expired buffers we don't care about them
+                        candidate_ids.push_back(buffer->id());
+                    }
+                }
+                return candidate_ids;
+            },
+            window,
+            timeout))
+        << "failed to see buffer";
 
     mir_window_release_sync(window);
     mir_connection_release(connection);

=== modified file 'tests/integration-tests/test_surface_stack_with_compositor.cpp'
--- tests/integration-tests/test_surface_stack_with_compositor.cpp	2017-05-08 03:04:26 +0000
+++ tests/integration-tests/test_surface_stack_with_compositor.cpp	2017-07-07 07:27:48 +0000
@@ -24,7 +24,6 @@
 #include "src/server/scene/basic_surface.h"
 #include "src/server/compositor/default_display_buffer_compositor_factory.h"
 #include "src/server/compositor/multi_threaded_compositor.h"
-#include "src/server/compositor/buffer_map.h"
 #include "src/server/compositor/stream.h"
 #include "mir/test/fake_shared.h"
 #include "mir/test/doubles/mock_buffer_stream.h"
@@ -47,6 +46,7 @@
 namespace mr = mir::report;
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
+namespace mf = mir::frontend;
 namespace geom = mir::geometry;
 using namespace testing;
 
@@ -123,8 +123,7 @@
 {
     SurfaceStackCompositor() :
         timeout{std::chrono::system_clock::now() + std::chrono::seconds(5)},
-        buffers(std::make_shared<mc::BufferMap>(std::make_shared<NiceMock<mtd::MockEventSink>>())),
-        stream(std::make_shared<mc::Stream>(buffers, geom::Size{ 1, 1 }, mir_pixel_format_abgr_8888 )),
+        stream(std::make_shared<mc::Stream>(geom::Size{ 1, 1 }, mir_pixel_format_abgr_8888 )),
         mock_buffer_stream(std::make_shared<NiceMock<mtd::MockBufferStream>>()),
         streams({ { stream, {0,0}, {} } }),
         stub_surface{std::make_shared<ms::BasicSurface>(
@@ -136,7 +135,6 @@
             null_scene_report)},
         stub_buffer(std::make_shared<mtd::StubBuffer>())
     {
-        buffers->add_buffer(stub_buffer);
         ON_CALL(*mock_buffer_stream, lock_compositor_buffer(_))
             .WillByDefault(Return(mt::fake_shared(*stub_buffer)));
     }
@@ -145,7 +143,6 @@
     std::shared_ptr<mc::CompositorReport> null_comp_report{mr::null_compositor_report()};
     StubRendererFactory renderer_factory;
     std::chrono::system_clock::time_point timeout;
-    std::shared_ptr<mc::BufferMap> buffers;
     std::shared_ptr<mc::Stream> stream;
     std::shared_ptr<mtd::MockBufferStream> mock_buffer_stream;
     std::list<ms::StreamInfo> const streams;

=== modified file 'tests/integration-tests/test_swapinterval.cpp'
--- tests/integration-tests/test_swapinterval.cpp	2017-05-08 03:04:26 +0000
+++ tests/integration-tests/test_swapinterval.cpp	2017-07-07 07:27:48 +0000
@@ -67,24 +67,19 @@
     }
 
     std::shared_ptr<mc::BufferStream> create_buffer_stream(
-        mf::BufferStreamId id, std::shared_ptr<mf::ClientBuffers> const& sink,
+        mf::BufferStreamId id,
         int, mg::BufferProperties const& p) override
     {
-        return create_buffer_stream(id, sink, p);
+        return create_buffer_stream(id, p);
     }
 
     std::shared_ptr<mc::BufferStream> create_buffer_stream(
-        mf::BufferStreamId, std::shared_ptr<mf::ClientBuffers> const&,
+        mf::BufferStreamId,
         mg::BufferProperties const&) override
     {
         return std::make_shared<StubBufferStream>(framedropping_enabled);
     }
 
-    std::shared_ptr<mf::ClientBuffers> create_buffer_map(std::shared_ptr<mf::BufferSink> const&) override
-    {
-        return std::make_shared<mtd::StubClientBuffers>();
-    }
-
 private:
     std::atomic<bool>& framedropping_enabled;
 };

=== modified file 'tests/mir_test_framework/stub_session.cpp'
--- tests/mir_test_framework/stub_session.cpp	2017-05-08 03:04:26 +0000
+++ tests/mir_test_framework/stub_session.cpp	2017-07-07 07:27:48 +0000
@@ -143,31 +143,6 @@
 {
 }
 
-mir::graphics::BufferID mtd::StubSession::create_buffer(mir::graphics::BufferProperties const&)
-{
-    return mir::graphics::BufferID(3);
-}
-
-mir::graphics::BufferID mtd::StubSession::create_buffer(mir::geometry::Size, uint32_t, uint32_t)
-{
-    return mir::graphics::BufferID(3);
-}
-
-mir::graphics::BufferID mtd::StubSession::create_buffer(mir::geometry::Size, MirPixelFormat)
-{
-    return mir::graphics::BufferID(3);
-}
-
-void mtd::StubSession::destroy_buffer(mir::graphics::BufferID)
-{
-}
-
-std::shared_ptr<mir::graphics::Buffer> mtd::StubSession::get_buffer(graphics::BufferID)
-{
-    return std::make_shared<mtd::StubBuffer>(
-        std::make_shared<mir_test_framework::NativeBuffer>(graphics::BufferProperties{}));
-}
-
 namespace
 {
 // Ensure we don't accidentally have an abstract class

=== modified file 'tests/unit-tests/compositor/CMakeLists.txt'
--- tests/unit-tests/compositor/CMakeLists.txt	2017-05-08 03:04:26 +0000
+++ tests/unit-tests/compositor/CMakeLists.txt	2017-07-07 07:27:48 +0000
@@ -1,13 +1,11 @@
 list(APPEND UNIT_TEST_SOURCES
   ${CMAKE_CURRENT_SOURCE_DIR}/test_default_display_buffer_compositor.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_stream.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_temporary_buffers.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_multi_threaded_compositor.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_occlusion.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_screencast_display_buffer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_compositing_screencast.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_multi_monitor_arbiter.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_client_buffers.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_dropping_schedule.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_queueing_schedule.cpp
 )

=== removed file 'tests/unit-tests/compositor/test_client_buffers.cpp'
--- tests/unit-tests/compositor/test_client_buffers.cpp	2017-05-08 03:04:26 +0000
+++ tests/unit-tests/compositor/test_client_buffers.cpp	1970-01-01 00:00:00 +0000
@@ -1,119 +0,0 @@
-/*
- * Copyright © 2015 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#include "mir/test/doubles/mock_event_sink.h"
-#include "mir/test/fake_shared.h"
-#include "mir/test/doubles/stub_buffer_allocator.h"
-#include "src/server/compositor/buffer_map.h"
-#include "mir/graphics/display_configuration.h"
-
-#include <gtest/gtest.h>
-using namespace testing;
-namespace mt = mir::test;
-namespace mtd = mir::test::doubles;
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-namespace mf = mir::frontend;
-namespace geom = mir::geometry;
-
-struct ClientBuffers : public Test
-{
-    std::shared_ptr<mtd::MockEventSink> mock_sink = std::make_shared<testing::NiceMock<mtd::MockEventSink>>();
-    mg::BufferProperties properties{geom::Size{42,43}, mir_pixel_format_abgr_8888, mg::BufferUsage::hardware};
-    mtd::StubBuffer stub_buffer{properties};
-    mc::BufferMap map{mock_sink};
-};
-
-TEST_F(ClientBuffers, sends_full_buffer_on_allocation)
-{
-    EXPECT_CALL(*mock_sink, add_buffer(Ref(stub_buffer)));
-    mc::BufferMap map{mock_sink};
-    EXPECT_THAT(map.add_buffer(mt::fake_shared(stub_buffer)), Eq(stub_buffer.id()));
-}
-
-TEST_F(ClientBuffers, access_of_nonexistent_buffer_throws)
-{
-    EXPECT_THROW({
-        auto buffer = map.get(stub_buffer.id());
-    }, std::logic_error);
-}
-
-TEST_F(ClientBuffers, removal_of_nonexistent_buffer_throws)
-{
-    EXPECT_THROW({
-        map.remove_buffer(stub_buffer.id());
-    }, std::logic_error);
-}
-
-TEST_F(ClientBuffers, can_access_once_added)
-{
-    auto id = map.add_buffer(mt::fake_shared(stub_buffer));
-    EXPECT_THAT(map.get(id).get(), Eq(&stub_buffer));
-}
-
-TEST_F(ClientBuffers, sends_update_msg_to_send_buffer)
-{
-    auto id = map.add_buffer(mt::fake_shared(stub_buffer));
-    auto buffer = map.get(id);
-    EXPECT_CALL(*mock_sink, update_buffer(Ref(*buffer)));
-    map.send_buffer(id);
-}
-
-TEST_F(ClientBuffers, sends_no_update_msg_if_buffer_is_not_around)
-{
-    auto id = map.add_buffer(mt::fake_shared(stub_buffer));
-    auto buffer = map.get(id);
-
-    EXPECT_CALL(*mock_sink, remove_buffer(Ref(*buffer)));
-    map.remove_buffer(id);
-    map.send_buffer(id);
-}
-
-TEST_F(ClientBuffers, can_remove_buffer_from_send_callback)
-{
-    auto id = map.add_buffer(mt::fake_shared(stub_buffer));
-    ON_CALL(*mock_sink, update_buffer(_))
-        .WillByDefault(Invoke(
-        [&] (mg::Buffer& buffer)
-        {
-            map.remove_buffer(buffer.id());
-        }));
-
-    map.send_buffer(id);
-}
-
-TEST_F(ClientBuffers, ignores_unknown_receive)
-{
-    EXPECT_CALL(*mock_sink, add_buffer(_))
-        .Times(1);
-    auto id = map.add_buffer(mt::fake_shared(stub_buffer));
-    map.remove_buffer(id);
-    map.send_buffer(id);
-}
-
-TEST_F(ClientBuffers, sends_error_buffer_when_alloc_fails)
-{
-    std::string error_msg = "a reason";
-    EXPECT_CALL(*mock_sink, add_buffer(_))
-        .WillOnce(Throw(std::runtime_error(error_msg)));
-    EXPECT_CALL(*mock_sink, error_buffer(stub_buffer.size(), stub_buffer.pixel_format(), StrEq(error_msg)));
-    mc::BufferMap map{mock_sink};
-    EXPECT_THROW({
-        map.add_buffer(mt::fake_shared(stub_buffer));
-    }, std::runtime_error);
-}

=== modified file 'tests/unit-tests/compositor/test_dropping_schedule.cpp'
--- tests/unit-tests/compositor/test_dropping_schedule.cpp	2017-05-08 03:04:26 +0000
+++ tests/unit-tests/compositor/test_dropping_schedule.cpp	2017-07-07 07:27:48 +0000
@@ -16,7 +16,6 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#include "mir/frontend/client_buffers.h"
 #include "src/server/compositor/dropping_schedule.h"
 #include "mir/test/doubles/stub_buffer.h"
 #include "mir/test/fake_shared.h"
@@ -28,20 +27,9 @@
 namespace mt = mir::test;
 namespace mg = mir::graphics;
 namespace mc = mir::compositor;
-namespace mf = mir::frontend;
 namespace
 {
 
-struct MockBufferMap : mf::ClientBuffers
-{
-    MOCK_METHOD1(add_buffer, mg::BufferID(std::shared_ptr<mg::Buffer> const&));
-    MOCK_METHOD1(remove_buffer, void(mg::BufferID id));
-    MOCK_METHOD1(send_buffer, void(mg::BufferID id));
-    MOCK_METHOD1(receive_buffer, void(mg::BufferID id));
-    MOCK_CONST_METHOD0(client_owned_buffer_count, size_t());
-    MOCK_CONST_METHOD1(get, std::shared_ptr<mg::Buffer>(mg::BufferID));
-};
-
 struct DroppingSchedule : Test
 {
     DroppingSchedule()
@@ -52,8 +40,7 @@
     unsigned int const num_buffers{5};
     std::vector<std::shared_ptr<mg::Buffer>> buffers;
 
-    MockBufferMap mock_client_buffers;
-    mc::DroppingSchedule schedule{mt::fake_shared(mock_client_buffers)};
+    mc::DroppingSchedule schedule;
     std::vector<std::shared_ptr<mg::Buffer>> drain_queue()
     {
         std::vector<std::shared_ptr<mg::Buffer>> scheduled_buffers;
@@ -74,49 +61,23 @@
 
 TEST_F(DroppingSchedule, drops_excess_buffers)
 {
-    InSequence seq;
-    EXPECT_CALL(mock_client_buffers, send_buffer(buffers[0]->id()));
-    EXPECT_CALL(mock_client_buffers, send_buffer(buffers[1]->id()));
-    EXPECT_CALL(mock_client_buffers, send_buffer(buffers[2]->id()));
-    EXPECT_CALL(mock_client_buffers, send_buffer(buffers[3]->id()));
- 
     for(auto i = 0u; i < num_buffers; i++)
         schedule.schedule(buffers[i]);
 
     auto queue = drain_queue();
     ASSERT_THAT(queue, SizeIs(1));
+
+    // The 5th buffer should be scheduled...
     EXPECT_THAT(queue[0]->id(), Eq(buffers[4]->id()));
-}
-
-TEST_F(DroppingSchedule, nonblocking_schedule_avoids_socket_io)
-{
-    for (auto i = 0u; i < num_buffers; i++)
+    for (int i = 0; i < 4 ; ++i)
     {
-        EXPECT_CALL(mock_client_buffers, send_buffer(_))
-            .Times(0);
-
-        auto deferred_io = schedule.schedule_nonblocking(buffers[i]);
-
-        testing::Mock::VerifyAndClearExpectations(&mock_client_buffers);
-        if (i > 0)
-        {
-            EXPECT_CALL(mock_client_buffers, send_buffer(buffers[i-1]->id()))
-                .Times(1);
-            ASSERT_TRUE(deferred_io.valid());
-            deferred_io.wait();
-            testing::Mock::VerifyAndClearExpectations(&mock_client_buffers);
-        }
+        // ...and all the others should have no external references
+        EXPECT_TRUE(buffers[i].unique());
     }
-
-    auto queue = drain_queue();
-    ASSERT_THAT(queue, SizeIs(1));
-    EXPECT_THAT(queue[0]->id(), Eq(buffers[4]->id()));
 }
 
 TEST_F(DroppingSchedule, queueing_same_buffer_many_times_doesnt_drop)
 {
-    EXPECT_CALL(mock_client_buffers, send_buffer(_)).Times(0);
- 
     schedule.schedule(buffers[2]);
     schedule.schedule(buffers[2]);
     schedule.schedule(buffers[2]);

=== modified file 'tests/unit-tests/compositor/test_multi_monitor_arbiter.cpp'
--- tests/unit-tests/compositor/test_multi_monitor_arbiter.cpp	2017-05-26 12:45:45 +0000
+++ tests/unit-tests/compositor/test_multi_monitor_arbiter.cpp	2017-07-07 07:27:48 +0000
@@ -21,7 +21,6 @@
 #include "mir/test/doubles/stub_buffer_allocator.h"
 #include "src/server/compositor/multi_monitor_arbiter.h"
 #include "src/server/compositor/schedule.h"
-#include "mir/frontend/client_buffers.h"
 
 #include <gtest/gtest.h>
 using namespace testing;
@@ -33,28 +32,12 @@
 
 namespace
 {
-struct MockBufferMap : mf::ClientBuffers
-{
-    MOCK_METHOD1(add_buffer, mg::BufferID(std::shared_ptr<mg::Buffer> const&));
-    MOCK_METHOD1(remove_buffer, void(mg::BufferID id));
-    MOCK_METHOD1(receive_buffer, void(mg::BufferID id));
-    MOCK_METHOD1(send_buffer, void(mg::BufferID id));
-    MOCK_CONST_METHOD0(client_owned_buffer_count, size_t());
-    MOCK_CONST_METHOD1(get, std::shared_ptr<mg::Buffer>(mg::BufferID));
-};
-
 struct FixedSchedule : mc::Schedule
 {
     void schedule(std::shared_ptr<mg::Buffer> const&) override
     {
         throw std::runtime_error("this stub doesnt support this");
     }
-    std::future<void> schedule_nonblocking(
-        std::shared_ptr<mg::Buffer> const&) override
-    {
-        throw std::runtime_error("this stub doesnt support this");
-        return {};
-    }
     unsigned int num_scheduled() override
     {
         return sched.size() - current;
@@ -63,7 +46,9 @@
     {
         if (sched.empty() || current == sched.size())
             throw std::runtime_error("no buffer scheduled");
-        return sched[current++];
+        auto buf = sched.front();
+        sched.erase(sched.begin());
+        return buf;
     }
     void set_schedule(std::vector<std::shared_ptr<mg::Buffer>> s)
     {
@@ -84,10 +69,67 @@
     }
     unsigned int const num_buffers{6u};
     std::vector<std::shared_ptr<mg::Buffer>> buffers;
-    NiceMock<MockBufferMap> mock_map;
     FixedSchedule schedule;
-    mc::MultiMonitorArbiter arbiter{mt::fake_shared(mock_map), mt::fake_shared(schedule)};
+    mc::MultiMonitorArbiter arbiter{mt::fake_shared(schedule)};
 };
+
+MATCHER_P(IsSameBufferAs, buffer, "")
+{
+    return buffer->id() == arg->id();
+}
+
+std::shared_ptr<mg::Buffer> wrap_with_destruction_notifier(
+    std::shared_ptr<mg::Buffer> const& buffer,
+    std::shared_ptr<bool> const& destroyed)
+{
+    class DestructionNotifyingBuffer : public mg::Buffer
+    {
+    public:
+        DestructionNotifyingBuffer(
+            std::shared_ptr<mg::Buffer> const& buffer,
+            std::shared_ptr<bool> const& destroyed)
+            : wrapped{buffer},
+              destroyed{destroyed}
+        {
+        }
+
+        ~DestructionNotifyingBuffer()
+        {
+            *destroyed = true;
+        }
+
+        std::shared_ptr<mg::NativeBuffer> native_buffer_handle() const override
+        {
+            return wrapped->native_buffer_handle();
+        }
+
+        mg::BufferID id() const override
+        {
+            return wrapped->id();
+        }
+
+        mir::geometry::Size size() const override
+        {
+            return wrapped->size();
+        }
+
+        MirPixelFormat pixel_format() const override
+        {
+            return wrapped->pixel_format();
+        }
+
+        mg::NativeBufferBase *native_buffer_base() override
+        {
+            return wrapped->native_buffer_base();
+        }
+
+    private:
+        std::shared_ptr<mg::Buffer> const wrapped;
+        std::shared_ptr<bool> const destroyed;
+    };
+
+    return std::make_shared<DestructionNotifyingBuffer>(buffer, destroyed);
+}
 }
 
 TEST_F(MultiMonitorArbiter, compositor_access_before_any_submission_throws)
@@ -107,32 +149,29 @@
 {
     schedule.set_schedule({buffers[0]});
     auto cbuffer = arbiter.compositor_acquire(this);
-    EXPECT_THAT(cbuffer, Eq(buffers[0]));
+    EXPECT_THAT(cbuffer, IsSameBufferAs(buffers[0]));
 }
 
 TEST_F(MultiMonitorArbiter, compositor_release_sends_buffer_back)
 {
-    EXPECT_CALL(mock_map, send_buffer(buffers[0]->id()));
-
-    schedule.set_schedule({buffers[0]});
+    auto buffer_released = std::make_shared<bool>(false);
+    schedule.set_schedule({ wrap_with_destruction_notifier(buffers[0], buffer_released) });
 
     auto cbuffer = arbiter.compositor_acquire(this);
     schedule.set_schedule({buffers[1]});
-    arbiter.compositor_release(cbuffer);
+    cbuffer.reset();
+    // We need to acquire a new buffer - the current one is on-screen, so can't be sent back.
+    arbiter.compositor_acquire(this);
+    EXPECT_TRUE(*buffer_released);
 }
 
 TEST_F(MultiMonitorArbiter, compositor_can_acquire_different_buffers)
 {
-    EXPECT_CALL(mock_map, send_buffer(buffers[0]->id()));
-
     schedule.set_schedule({buffers[0]});
     auto cbuffer1 = arbiter.compositor_acquire(this);
     schedule.set_schedule({buffers[1]});
     auto cbuffer2 = arbiter.compositor_acquire(this);
-    EXPECT_THAT(cbuffer1, Ne(cbuffer2));
-    arbiter.compositor_release(cbuffer2);
-    arbiter.compositor_release(cbuffer1);
-    Mock::VerifyAndClearExpectations(&mock_map);
+    EXPECT_THAT(cbuffer1, Not(IsSameBufferAs(cbuffer2)));
 }
 
 TEST_F(MultiMonitorArbiter, compositor_buffer_syncs_to_fastest_compositor)
@@ -155,35 +194,30 @@
     auto cbuffer6 = arbiter.compositor_acquire(&comp_id2);
     auto cbuffer7 = arbiter.compositor_acquire(&comp_id2);
 
-    EXPECT_THAT(cbuffer1, Eq(buffers[0]));
-    EXPECT_THAT(cbuffer2, Eq(buffers[0]));
-    EXPECT_THAT(cbuffer3, Eq(buffers[1]));
-    EXPECT_THAT(cbuffer4, Eq(buffers[0]));
-    EXPECT_THAT(cbuffer5, Eq(buffers[0]));
-    EXPECT_THAT(cbuffer6, Eq(buffers[1]));
-    EXPECT_THAT(cbuffer7, Eq(buffers[1]));
+    EXPECT_THAT(cbuffer1, IsSameBufferAs(buffers[0]));
+    EXPECT_THAT(cbuffer2, IsSameBufferAs(buffers[0]));
+    EXPECT_THAT(cbuffer3, IsSameBufferAs(buffers[1]));
+    EXPECT_THAT(cbuffer4, IsSameBufferAs(buffers[0]));
+    EXPECT_THAT(cbuffer5, IsSameBufferAs(buffers[0]));
+    EXPECT_THAT(cbuffer6, IsSameBufferAs(buffers[1]));
+    EXPECT_THAT(cbuffer7, IsSameBufferAs(buffers[1]));
 }
 
 TEST_F(MultiMonitorArbiter, compositor_consumes_all_buffers_when_operating_as_a_composited_scene_would)
 {
     schedule.set_schedule({buffers[0],buffers[1],buffers[2],buffers[3],buffers[4]});
 
-    auto cbuffer1 = arbiter.compositor_acquire(this);
-    arbiter.compositor_release(cbuffer1);
-    auto cbuffer2 = arbiter.compositor_acquire(this);
-    arbiter.compositor_release(cbuffer2);
-    auto cbuffer3 = arbiter.compositor_acquire(this);
-    arbiter.compositor_release(cbuffer3);
-    auto cbuffer4 = arbiter.compositor_acquire(this);
-    arbiter.compositor_release(cbuffer4);
-    auto cbuffer5 = arbiter.compositor_acquire(this);
-    arbiter.compositor_release(cbuffer5);
+    auto id1 = arbiter.compositor_acquire(this)->id();
+    auto id2 = arbiter.compositor_acquire(this)->id();
+    auto id3 = arbiter.compositor_acquire(this)->id();
+    auto id4 = arbiter.compositor_acquire(this)->id();
+    auto iddqd = arbiter.compositor_acquire(this)->id();
 
-    EXPECT_THAT(cbuffer1, Eq(buffers[0]));
-    EXPECT_THAT(cbuffer2, Eq(buffers[1]));
-    EXPECT_THAT(cbuffer3, Eq(buffers[2]));
-    EXPECT_THAT(cbuffer4, Eq(buffers[3]));
-    EXPECT_THAT(cbuffer5, Eq(buffers[4]));
+    EXPECT_THAT(id1, Eq(buffers[0]->id()));
+    EXPECT_THAT(id2, Eq(buffers[1]->id()));
+    EXPECT_THAT(id3, Eq(buffers[2]->id()));
+    EXPECT_THAT(id4, Eq(buffers[3]->id()));
+    EXPECT_THAT(iddqd, Eq(buffers[4]->id()));
 }
 
 TEST_F(MultiMonitorArbiter, compositor_consumes_all_buffers_when_operating_as_a_bypassed_buffer_would)
@@ -192,20 +226,28 @@
 
     auto cbuffer1 = arbiter.compositor_acquire(this);
     auto cbuffer2 = arbiter.compositor_acquire(this);
-    arbiter.compositor_release(cbuffer1);
+    auto id1 = cbuffer1->id();
+    cbuffer1.reset();
+
     auto cbuffer3 = arbiter.compositor_acquire(this);
-    arbiter.compositor_release(cbuffer2);
+    auto id2 = cbuffer2->id();
+    cbuffer2.reset();
+
     auto cbuffer4 = arbiter.compositor_acquire(this);
-    arbiter.compositor_release(cbuffer3);
+    auto id3 = cbuffer3->id();
+    cbuffer3.reset();
+
     auto cbuffer5 = arbiter.compositor_acquire(this);
-    arbiter.compositor_release(cbuffer4);
-    arbiter.compositor_release(cbuffer5);
+    auto id4 = cbuffer4->id();
+    cbuffer4.reset();
+    auto id5 = cbuffer5->id();
+    cbuffer5.reset();
 
-    EXPECT_THAT(cbuffer1, Eq(buffers[0]));
-    EXPECT_THAT(cbuffer2, Eq(buffers[1]));
-    EXPECT_THAT(cbuffer3, Eq(buffers[2]));
-    EXPECT_THAT(cbuffer4, Eq(buffers[3]));
-    EXPECT_THAT(cbuffer5, Eq(buffers[4]));
+    EXPECT_THAT(id1, Eq(buffers[0]->id()));
+    EXPECT_THAT(id2, Eq(buffers[1]->id()));
+    EXPECT_THAT(id3, Eq(buffers[2]->id()));
+    EXPECT_THAT(id4, Eq(buffers[3]->id()));
+    EXPECT_THAT(id5, Eq(buffers[4]->id()));
 }
 
 TEST_F(MultiMonitorArbiter, multimonitor_compositor_buffer_syncs_to_fastest_with_more_queueing)
@@ -228,18 +270,18 @@
     auto cbuffer7 = arbiter.compositor_acquire(&comp_id2); //buffer[4]
     auto cbuffer8 = arbiter.compositor_acquire(&comp_id1); //buffer[4]
 
-    EXPECT_THAT(cbuffer1, Eq(buffers[0]));
-    EXPECT_THAT(cbuffer2, Eq(buffers[0]));
-
-    EXPECT_THAT(cbuffer3, Eq(buffers[1]));
-
-    EXPECT_THAT(cbuffer4, Eq(buffers[2]));
-    EXPECT_THAT(cbuffer5, Eq(buffers[2]));
-
-    EXPECT_THAT(cbuffer6, Eq(buffers[3]));
-
-    EXPECT_THAT(cbuffer7, Eq(buffers[4]));
-    EXPECT_THAT(cbuffer8, Eq(buffers[4]));
+    EXPECT_THAT(cbuffer1, IsSameBufferAs(buffers[0]));
+    EXPECT_THAT(cbuffer2, IsSameBufferAs(buffers[0]));
+
+    EXPECT_THAT(cbuffer3, IsSameBufferAs(buffers[1]));
+
+    EXPECT_THAT(cbuffer4, IsSameBufferAs(buffers[2]));
+    EXPECT_THAT(cbuffer5, IsSameBufferAs(buffers[2]));
+
+    EXPECT_THAT(cbuffer6, IsSameBufferAs(buffers[3]));
+
+    EXPECT_THAT(cbuffer7, IsSameBufferAs(buffers[4]));
+    EXPECT_THAT(cbuffer8, IsSameBufferAs(buffers[4]));
 }
 
 TEST_F(MultiMonitorArbiter, can_set_a_new_schedule)
@@ -252,8 +294,8 @@
     arbiter.set_schedule(mt::fake_shared(another_schedule));
     auto cbuffer2 = arbiter.compositor_acquire(this);
 
-    EXPECT_THAT(cbuffer1, Eq(buffers[3]));
-    EXPECT_THAT(cbuffer2, Eq(buffers[0])); 
+    EXPECT_THAT(cbuffer1, IsSameBufferAs(buffers[3]));
+    EXPECT_THAT(cbuffer2, IsSameBufferAs(buffers[0]));
 }
 
 TEST_F(MultiMonitorArbiter, basic_snapshot_equals_compositor_buffer)
@@ -262,7 +304,7 @@
 
     auto cbuffer1 = arbiter.compositor_acquire(this);
     auto sbuffer1 = arbiter.snapshot_acquire();
-    EXPECT_EQ(cbuffer1, sbuffer1);
+    EXPECT_THAT(cbuffer1, IsSameBufferAs(sbuffer1));
 }
 
 TEST_F(MultiMonitorArbiter, basic_snapshot_equals_latest_compositor_buffer)
@@ -273,13 +315,12 @@
     auto cbuffer1 = arbiter.compositor_acquire(this);
     auto cbuffer2 = arbiter.compositor_acquire(&that);
     auto sbuffer1 = arbiter.snapshot_acquire();
-    arbiter.snapshot_release(sbuffer1);
-    arbiter.compositor_release(cbuffer2);
+    cbuffer2.reset();
     cbuffer2 = arbiter.compositor_acquire(&that);
 
     auto sbuffer2 = arbiter.snapshot_acquire();
-    EXPECT_EQ(cbuffer1, sbuffer1);
-    EXPECT_EQ(cbuffer2, sbuffer2);
+    EXPECT_THAT(cbuffer1, IsSameBufferAs(sbuffer1));
+    EXPECT_THAT(cbuffer2, IsSameBufferAs(sbuffer2));
 }
 
 TEST_F(MultiMonitorArbiter, snapshot_cycling_doesnt_advance_buffer_for_compositors)
@@ -288,17 +329,15 @@
     auto that = 4;
     auto a_few_times = 5u;
     auto cbuffer1 = arbiter.compositor_acquire(this);
-    std::vector<std::shared_ptr<mg::Buffer>> snapshot_buffers(a_few_times);
+    std::vector<mg::BufferID> snapshot_buffers(a_few_times);
     for(auto i = 0u; i < a_few_times; i++)
     {
-        auto b = arbiter.snapshot_acquire();
-        arbiter.snapshot_release(b);
-        snapshot_buffers[i] = b;
+        snapshot_buffers[i] = arbiter.snapshot_acquire()->id();
     }
     auto cbuffer2 = arbiter.compositor_acquire(&that);
 
-    EXPECT_THAT(cbuffer1, Eq(cbuffer2));
-    EXPECT_THAT(snapshot_buffers, Each(cbuffer1));
+    EXPECT_THAT(cbuffer1, IsSameBufferAs(cbuffer2));
+    EXPECT_THAT(snapshot_buffers, Each(Eq(cbuffer1->id())));
 }
 
 TEST_F(MultiMonitorArbiter, no_buffers_available_throws_on_snapshot)
@@ -311,29 +350,44 @@
 
 TEST_F(MultiMonitorArbiter, snapshotting_will_release_buffer_if_it_was_the_last_owner)
 {
-    EXPECT_CALL(mock_map, send_buffer(_)).Times(0);
-    schedule.set_schedule({buffers[3],buffers[4]});
+    auto buffer_released = std::make_shared<bool>(false);
+    schedule.set_schedule(
+        {
+            wrap_with_destruction_notifier(buffers[3], buffer_released),
+            buffers[4]
+        });
     auto cbuffer1 = arbiter.compositor_acquire(this);
     auto sbuffer1 = arbiter.snapshot_acquire();
-    arbiter.compositor_release(cbuffer1);
-
-    Mock::VerifyAndClearExpectations(&mock_map);
-    EXPECT_CALL(mock_map, send_buffer(sbuffer1->id()));
-    arbiter.snapshot_release(sbuffer1);
+    cbuffer1.reset();
+
+    // Acquire a new buffer so first one is no longer onscreen.
+    arbiter.compositor_acquire(this);
+
+    EXPECT_FALSE(*buffer_released);
+    sbuffer1.reset();
+    EXPECT_TRUE(*buffer_released);
 }
 
 TEST_F(MultiMonitorArbiter, compositor_can_acquire_a_few_times_and_only_sends_on_the_last_release)
 {
     int comp_id1{0};
     int comp_id2{0};
-    schedule.set_schedule({buffers[0], buffers[1]});
+
+    auto buffer_released = std::make_shared<bool>(false);
+    schedule.set_schedule(
+        {
+            wrap_with_destruction_notifier(buffers[0], buffer_released),
+            buffers[1]
+        });
     auto cbuffer1 = arbiter.compositor_acquire(&comp_id1);
     auto cbuffer2 = arbiter.compositor_acquire(&comp_id2);
-    EXPECT_THAT(cbuffer1, Eq(cbuffer2));
-    EXPECT_CALL(mock_map, send_buffer(buffers[0]->id())).Times(Exactly(1));
+    EXPECT_THAT(cbuffer1, IsSameBufferAs(cbuffer2));
+
     auto cbuffer3 = arbiter.compositor_acquire(&comp_id1);
-    arbiter.compositor_release(cbuffer2);
-    arbiter.compositor_release(cbuffer1);
+    EXPECT_FALSE(*buffer_released);
+    cbuffer1.reset();
+    cbuffer2.reset();
+    EXPECT_TRUE(*buffer_released);
 }
 
 TEST_F(MultiMonitorArbiter, advance_on_fastest_has_same_buffer)
@@ -342,51 +396,49 @@
     int comp_id2{0};
     schedule.set_schedule({buffers[0],buffers[1]});
 
-    auto cbuffer1 = arbiter.compositor_acquire(&comp_id1); //buffer[0]
-    arbiter.compositor_release(cbuffer1);
-    auto cbuffer2 = arbiter.compositor_acquire(&comp_id2); //buffer[0]
-    arbiter.compositor_release(cbuffer2);
+    auto id1 = arbiter.compositor_acquire(&comp_id1)->id(); //buffer[0]
+    auto id2 = arbiter.compositor_acquire(&comp_id2)->id(); //buffer[0]
 
     auto cbuffer3 = arbiter.compositor_acquire(&comp_id1); //buffer[1]
  
-    EXPECT_THAT(cbuffer1, Eq(cbuffer2));
-    EXPECT_THAT(cbuffer1, Eq(buffers[0]));
-    EXPECT_THAT(cbuffer3, Eq(buffers[1]));
-}
-
-TEST_F(MultiMonitorArbiter, compositor_acquire_sends_buffer_back_with_fastest_guarantee)
-{
-    EXPECT_CALL(mock_map, send_buffer(buffers[0]->id()));
-
-    schedule.set_schedule({buffers[0], buffers[1]});
-
-    auto cbuffer = arbiter.compositor_acquire(this);
-    schedule.set_schedule({buffers[1]});
-    arbiter.compositor_release(cbuffer);
-    cbuffer = arbiter.compositor_acquire(this);
+    EXPECT_THAT(id1, Eq(id2));
+    EXPECT_THAT(id1, Eq(buffers[0]->id()));
+    EXPECT_THAT(cbuffer3, IsSameBufferAs(buffers[1]));
 }
 
 TEST_F(MultiMonitorArbiter, buffers_are_sent_back)
 {
-    EXPECT_CALL(mock_map, send_buffer(_)).Times(3);
+    std::array<std::shared_ptr<bool>, 3> buffer_released = {
+        {
+            std::make_shared<bool>(false),
+            std::make_shared<bool>(false),
+            std::make_shared<bool>(false)
+        }};
     int comp_id1{0};
     int comp_id2{0};
-    schedule.set_schedule({buffers[0], buffers[1], buffers[2], buffers[3]});
+
+    schedule.set_schedule(
+        {
+            wrap_with_destruction_notifier(buffers[0], buffer_released[0]),
+            wrap_with_destruction_notifier(buffers[1], buffer_released[1]),
+            wrap_with_destruction_notifier(buffers[2], buffer_released[2]),
+            buffers[3]
+        });
 
     auto b1 = arbiter.compositor_acquire(&comp_id1);
-    arbiter.compositor_release(b1);
+    b1.reset();
     auto b2 = arbiter.compositor_acquire(&comp_id1);
-    arbiter.compositor_release(b2);
+    b2.reset();
     auto b3 = arbiter.compositor_acquire(&comp_id1);
     auto b5 = arbiter.compositor_acquire(&comp_id2);
-    arbiter.compositor_release(b3);
+    b3.reset();
     auto b4 = arbiter.compositor_acquire(&comp_id1);
-    arbiter.compositor_release(b5);
-    arbiter.compositor_release(b4);
+    b5.reset();
+    b4.reset();
     auto b6 = arbiter.compositor_acquire(&comp_id1);
-    arbiter.compositor_release(b6);
+    b6.reset();
 
-    Mock::VerifyAndClearExpectations(&mock_map);
+    EXPECT_THAT(buffer_released, Each(Pointee(true)));
 }
 
 TEST_F(MultiMonitorArbiter, can_check_if_buffers_are_ready)
@@ -401,13 +453,12 @@
     auto b1 = arbiter.compositor_acquire(&comp_id1);
     EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
     EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
-    arbiter.compositor_release(b1);
+    b1.reset();
 
     auto b2 = arbiter.compositor_acquire(&comp_id2);
     EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
     EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id2));
-    arbiter.compositor_release(b2);
-} 
+}
 
 TEST_F(MultiMonitorArbiter, other_compositor_ready_status_advances_with_fastest_compositor)
 {
@@ -418,23 +469,19 @@
     EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id1));
     EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
 
-    auto b1 = arbiter.compositor_acquire(&comp_id1);
-    arbiter.compositor_release(b1);
-    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id1));
-    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
-
-    b1 = arbiter.compositor_acquire(&comp_id1);
-    arbiter.compositor_release(b1);
-    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id1));
-    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
-
-    b1 = arbiter.compositor_acquire(&comp_id1);
-    arbiter.compositor_release(b1);
+    arbiter.compositor_acquire(&comp_id1);
+    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id1));
+    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
+
+    arbiter.compositor_acquire(&comp_id1);
+    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id1));
+    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
+
+    arbiter.compositor_acquire(&comp_id1);
     EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
     EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
 
-    b1 = arbiter.compositor_acquire(&comp_id2);
-    arbiter.compositor_release(b1);
+    arbiter.compositor_acquire(&comp_id2);
     EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
     EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id2));
 }
@@ -442,17 +489,26 @@
 TEST_F(MultiMonitorArbiter, will_release_buffer_in_nbuffers_2_overlay_scenario)
 {
     int comp_id1{0};
-    schedule.set_schedule({buffers[0], buffers[1], buffers[0], buffers[1]});
+    auto buffer_released = std::make_shared<bool>(false);
+    auto notifying_buffer = wrap_with_destruction_notifier(buffers[0], buffer_released);
+    schedule.set_schedule(
+        {
+            notifying_buffer,
+            buffers[1],
+            buffers[0],    // We only want to be notified when the first submission is released
+            buffers[1]
+        });
+    notifying_buffer.reset();
 
-    EXPECT_CALL(mock_map, send_buffer(buffers[0]->id()));
     auto b1 = arbiter.compositor_acquire(&comp_id1);
     auto b2 = arbiter.compositor_acquire(&comp_id1);
-    EXPECT_THAT(b1, Eq(buffers[0]));
-    EXPECT_THAT(b2, Eq(buffers[1]));
-    arbiter.compositor_release(b1);
-    arbiter.compositor_release(b2);
-    Mock::VerifyAndClearExpectations(&mock_map);
-} 
+    EXPECT_THAT(b1, IsSameBufferAs(buffers[0]));
+    EXPECT_THAT(b2, IsSameBufferAs(buffers[1]));
+    b1.reset();
+    b2.reset();
+
+    EXPECT_TRUE(*buffer_released);
+}
 
 TEST_F(MultiMonitorArbiter, will_release_buffer_in_nbuffers_2_starvation_scenario)
 {
@@ -461,20 +517,26 @@
     schedule.set_schedule({buffers[0], buffers[1], buffers[0], buffers[1]});
 
     auto b1 = arbiter.compositor_acquire(&comp_id1);
+    auto id1 = b1->id();
     auto b2 = arbiter.compositor_acquire(&comp_id1);
-    arbiter.compositor_release(b1);
+    auto id2 = b2->id();
+
+    b1.reset();
 
     auto b3 = arbiter.compositor_acquire(&comp_id2);
+    auto id3 = b3->id();
     auto b4 = arbiter.compositor_acquire(&comp_id2);
-    arbiter.compositor_release(b3);
-
-    arbiter.compositor_release(b2);
-    arbiter.compositor_release(b4);
-
-    EXPECT_THAT(b1, Eq(buffers[0]));
-    EXPECT_THAT(b2, Eq(buffers[1]));
-    EXPECT_THAT(b3, Eq(buffers[1]));
-    EXPECT_THAT(b4, Eq(buffers[0]));
+    auto id4 = b4->id();
+
+    b3.reset();
+
+    b2.reset();
+    b4.reset();
+
+    EXPECT_THAT(id1, Eq(buffers[0]->id()));
+    EXPECT_THAT(id2, Eq(buffers[1]->id()));
+    EXPECT_THAT(id3, Eq(buffers[1]->id()));
+    EXPECT_THAT(id4, Eq(buffers[0]->id()));
 
 } 
 
@@ -482,33 +544,34 @@
 {
     int comp_id1{0};
     int comp_id2{0};
+
     schedule.set_schedule({
         buffers[0], buffers[1], buffers[2],
         buffers[0], buffers[1], buffers[2],
         buffers[0], buffers[1], buffers[2]});
 
-    EXPECT_CALL(mock_map, send_buffer(buffers[0]->id()));
-
     auto b1 = arbiter.compositor_acquire(&comp_id1);
+    auto id1 = b1->id();
     auto b2 = arbiter.compositor_acquire(&comp_id2);
-    arbiter.compositor_release(b1); //send nothing
+    auto id2 = b2->id();
+    b1.reset();     // Send nothing
 
     auto b3 = arbiter.compositor_acquire(&comp_id1);
-    arbiter.compositor_release(b3); //send nothing
+    auto id3 = b3->id();
+    b3.reset();     // Send nothing
 
     auto b4 = arbiter.compositor_acquire(&comp_id2);
-    arbiter.compositor_release(b2); //send 0
+    auto id4 = b4->id();
+    b2.reset();     // Send 0
 
     auto b5 = arbiter.compositor_acquire(&comp_id1);
-    arbiter.compositor_release(b5); //send nothing
 
-    EXPECT_THAT(b1, Eq(buffers[0]));
-    EXPECT_THAT(b2, Eq(buffers[0]));
-    EXPECT_THAT(b3, Eq(buffers[1]));
-    EXPECT_THAT(b4, Eq(buffers[1]));
-    EXPECT_THAT(b5, Eq(buffers[2]));
-    Mock::VerifyAndClearExpectations(&mock_map);
-} 
+    EXPECT_THAT(id1, Eq(buffers[0]->id()));
+    EXPECT_THAT(id2, Eq(buffers[0]->id()));
+    EXPECT_THAT(id3, Eq(buffers[1]->id()));
+    EXPECT_THAT(id4, Eq(buffers[1]->id()));
+    EXPECT_THAT(b5, IsSameBufferAs(buffers[2]));
+}
 
 TEST_F(MultiMonitorArbiter, can_advance_buffer_manually)
 {
@@ -521,11 +584,11 @@
 
     auto b1 = arbiter.compositor_acquire(&comp_id1);
     auto b2 = arbiter.compositor_acquire(&comp_id2);
-    EXPECT_THAT(b1->id(), Eq(buffers[1]->id()));
-    EXPECT_THAT(b2->id(), Eq(buffers[1]->id()));
+    EXPECT_THAT(b1, IsSameBufferAs(buffers[1]));
+    EXPECT_THAT(b2, IsSameBufferAs(buffers[1]));
 
     auto b3 = arbiter.compositor_acquire(&comp_id1);
-    EXPECT_THAT(b3->id(), Eq(buffers[2]->id()));
+    EXPECT_THAT(b3, IsSameBufferAs(buffers[2]));
 }
 
 TEST_F(MultiMonitorArbiter, checks_if_buffer_is_valid_after_clean_onscreen_buffer)
@@ -547,8 +610,12 @@
 
 TEST_F(MultiMonitorArbiter, releases_buffer_on_destruction)
 {
-    mc::MultiMonitorArbiter arbiter{mt::fake_shared(mock_map), mt::fake_shared(schedule)};
-    EXPECT_CALL(mock_map, send_buffer(buffers[0]->id()));
-    schedule.set_schedule({buffers[0]});
-    arbiter.advance_schedule();
+    auto buffer_released = std::make_shared<bool>(false);
+    schedule.set_schedule({wrap_with_destruction_notifier(buffers[0], buffer_released)});
+
+    {
+        mc::MultiMonitorArbiter arbiter{mt::fake_shared(schedule)};
+        arbiter.advance_schedule();
+    }
+    EXPECT_TRUE(*buffer_released);
 }

=== modified file 'tests/unit-tests/compositor/test_queueing_schedule.cpp'
--- tests/unit-tests/compositor/test_queueing_schedule.cpp	2017-05-08 03:04:26 +0000
+++ tests/unit-tests/compositor/test_queueing_schedule.cpp	2017-07-07 07:27:48 +0000
@@ -75,25 +75,6 @@
     EXPECT_FALSE(schedule.num_scheduled());
 }
 
-TEST_F(QueueingSchedule, nonblocking_schedule_queues_buffers_up)
-{
-    EXPECT_EQ(0u, schedule.num_scheduled());
-
-    std::vector<std::shared_ptr<mg::Buffer>> scheduled_buffers {
-        buffers[1], buffers[3], buffers[0], buffers[2], buffers[4]
-    };
-
-    for (auto& buffer : scheduled_buffers)
-    {
-        auto deferred_io = schedule.schedule_nonblocking(buffer);
-        EXPECT_FALSE(deferred_io.valid());
-    }
-
-    EXPECT_EQ(scheduled_buffers.size(), schedule.num_scheduled());
-    EXPECT_THAT(drain_queue(), ContainerEq(scheduled_buffers));
-    EXPECT_EQ(0u, schedule.num_scheduled());
-}
-
 TEST_F(QueueingSchedule, queuing_the_same_buffer_moves_it_to_front_of_queue)
 {
     for(auto i = 0u; i < num_buffers; i++)

=== modified file 'tests/unit-tests/compositor/test_stream.cpp'
--- tests/unit-tests/compositor/test_stream.cpp	2017-05-08 03:04:26 +0000
+++ tests/unit-tests/compositor/test_stream.cpp	2017-07-07 07:27:48 +0000
@@ -22,7 +22,6 @@
 #include "mir/test/fake_shared.h"
 #include "src/server/compositor/stream.h"
 #include "mir/scene/null_surface_observer.h"
-#include "mir/frontend/client_buffers.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -41,45 +40,6 @@
     MOCK_METHOD2(frame_posted, void(int, geom::Size const&));
 };
 
-struct StubBufferMap : mf::ClientBuffers
-{
-    StubBufferMap(mf::EventSink& sink, std::vector<std::shared_ptr<mg::Buffer>>& buffers) :
-        buffers{buffers},
-        sink{sink}
-    {
-    }
-    mg::BufferID add_buffer(std::shared_ptr<mg::Buffer> const&)
-    {
-        return mg::BufferID{};
-    }
-    void remove_buffer(mg::BufferID)
-    {
-    }
-    void with_buffer(mg::BufferID, std::function<void(mg::Buffer&)> const&)
-    {
-    }
-    void receive_buffer(mg::BufferID)
-    {
-    }
-    void send_buffer(mg::BufferID id)
-    {
-        sink.send_buffer(mf::BufferStreamId{33}, *get(id), mg::BufferIpcMsgType::update_msg);
-    }
-    std::shared_ptr<mg::Buffer> get(mg::BufferID id) const
-    {
-        auto it = std::find_if(buffers.begin(), buffers.end(),
-            [id](std::shared_ptr<mg::Buffer> const& b)
-            {
-                return b->id() == id;
-            });
-        if (it == buffers.end())
-            throw std::logic_error("cannot find buffer in map");
-        return *it;
-    }
-    std::vector<std::shared_ptr<mg::Buffer>>& buffers;
-    mf::EventSink& sink;
-};
-
 struct Stream : Test
 {
     Stream() :
@@ -94,16 +54,14 @@
 
     geom::Size initial_size{44,2};
     std::vector<std::shared_ptr<mg::Buffer>> buffers;
-    NiceMock<mtd::MockEventSink> mock_sink;
     MirPixelFormat construction_format{mir_pixel_format_rgb_565};
     mc::Stream stream{
-        std::make_unique<StubBufferMap>(mock_sink, buffers), initial_size, construction_format};
+        initial_size, construction_format};
 };
 }
 
 TEST_F(Stream, transitions_from_queuing_to_framedropping)
 {
-    EXPECT_CALL(mock_sink, send_buffer(_,_,_)).Times(buffers.size() - 1);
     for(auto& buffer : buffers)
         stream.submit_buffer(buffer);
     stream.allow_framedropping(true);
@@ -111,25 +69,37 @@
     std::vector<std::shared_ptr<mg::Buffer>> cbuffers;
     while(stream.buffers_ready_for_compositor(this))
         cbuffers.push_back(stream.lock_compositor_buffer(this));
+    // Transition to framedropping should have dropped all queued buffers but the last...
     ASSERT_THAT(cbuffers, SizeIs(1));
     EXPECT_THAT(cbuffers[0]->id(), Eq(buffers.back()->id()));
-    Mock::VerifyAndClearExpectations(&mock_sink);
+
+    for (unsigned long i = 0; i < buffers.size() - 1; ++i)
+    {
+        // ...and so all the previous buffers should no longer have external references
+        EXPECT_TRUE(buffers[i].unique());
+    }
 }
 
 TEST_F(Stream, transitions_from_framedropping_to_queuing)
 {
     stream.allow_framedropping(true);
-    Mock::VerifyAndClearExpectations(&mock_sink);
 
-    EXPECT_CALL(mock_sink, send_buffer(_,_,_)).Times(buffers.size() - 1);
     for(auto& buffer : buffers)
         stream.submit_buffer(buffer);
 
+    // Only the last buffer should be owned by the stream...
+    EXPECT_THAT(
+        std::make_tuple(buffers.data(), buffers.size() - 1),
+        Each(Property(&std::shared_ptr<mg::Buffer>::unique, Eq(true))));
+
     stream.allow_framedropping(false);
     for(auto& buffer : buffers)
         stream.submit_buffer(buffer);
 
-    Mock::VerifyAndClearExpectations(&mock_sink);
+    // All buffers should be now owned by the the stream
+    EXPECT_THAT(
+        buffers,
+        Each(Property(&std::shared_ptr<mg::Buffer>::unique, Eq(false))));
 
     std::vector<std::shared_ptr<mg::Buffer>> cbuffers;
     while(stream.buffers_ready_for_compositor(this))
@@ -180,23 +150,6 @@
     stream.submit_buffer(buffers[0]);
 }
 
-TEST_F(Stream, wakes_compositor_before_starting_socket_io)
-{
-    auto observer = std::make_shared<MockSurfaceObserver>();
-
-    InSequence seq;
-    EXPECT_CALL(*observer, frame_posted(_,_)).Times(2);
-    EXPECT_CALL(mock_sink, send_buffer(_,_,_)).Times(1);
-
-    stream.add_observer(observer);
-    stream.allow_framedropping(true);
-    stream.submit_buffer(buffers[0]);
-    stream.submit_buffer(buffers[1]);
-    stream.remove_observer(observer);
-
-    Mock::VerifyAndClearExpectations(&mock_sink);
-}
-
 TEST_F(Stream, calls_observers_call_doesnt_hold_lock)
 {
     auto observer = std::make_shared<MockSurfaceObserver>();
@@ -269,9 +222,15 @@
     stream.submit_buffer(buffers[1]);
     stream.submit_buffer(buffers[2]);
 
-    Mock::VerifyAndClearExpectations(&mock_sink);
-    EXPECT_CALL(mock_sink, send_buffer(_,Ref(*buffers[0]),_));
-    EXPECT_CALL(mock_sink, send_buffer(_,Ref(*buffers[1]),_));
+    // Buffers should be owned by the stream, and our test
+    ASSERT_THAT(buffers[0].use_count(), Eq(2));
+    ASSERT_THAT(buffers[1].use_count(), Eq(2));
+    ASSERT_THAT(buffers[2].use_count(), Eq(2));
+
     stream.drop_old_buffers();
-    Mock::VerifyAndClearExpectations(&mock_sink);
+
+    // Stream should have released ownership of all but the most recent buffer
+    EXPECT_THAT(buffers[0].use_count(), Eq(1));
+    EXPECT_THAT(buffers[1].use_count(), Eq(1));
+    EXPECT_THAT(buffers[2].use_count(), Eq(2));
 }

=== removed file 'tests/unit-tests/compositor/test_temporary_buffers.cpp'
--- tests/unit-tests/compositor/test_temporary_buffers.cpp	2017-05-25 05:49:36 +0000
+++ tests/unit-tests/compositor/test_temporary_buffers.cpp	1970-01-01 00:00:00 +0000
@@ -1,143 +0,0 @@
-/*
- * Copyright © 2012 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#include "src/server/compositor/temporary_buffers.h"
-#include "src/server/compositor/buffer_acquisition.h"
-#include "mir/test/doubles/mock_buffer.h"
-#include "mir/test/doubles/stub_buffer.h"
-#include <gtest/gtest.h>
-#include <stdexcept>
-
-namespace mtd=mir::test::doubles;
-namespace mg = mir::graphics;
-namespace mc=mir::compositor;
-namespace geom=mir::geometry;
-
-namespace
-{
-class TemporaryTestBuffer : public mc::TemporaryBuffer
-{
-public:
-    TemporaryTestBuffer(const std::shared_ptr<mg::Buffer>& buf)
-        : TemporaryBuffer(buf)
-    {
-    }
-};
-
-struct MockBufferAcquisition : mc::BufferAcquisition
-{
-    MOCK_METHOD1(compositor_acquire, std::shared_ptr<mg::Buffer>(void const*));
-    MOCK_METHOD1(compositor_release, void(std::shared_ptr<mg::Buffer> const&));
-    MOCK_METHOD0(snapshot_acquire, std::shared_ptr<mg::Buffer>());
-    MOCK_METHOD1(snapshot_release, void(std::shared_ptr<mg::Buffer> const&));
-};
-
-class TemporaryBuffersTest : public ::testing::Test
-{
-public:
-    TemporaryBuffersTest()
-        : buffer_size{1024, 768},
-          buffer_stride{1024},
-          buffer_pixel_format{mir_pixel_format_abgr_8888},
-          mock_buffer{std::make_shared<testing::NiceMock<mtd::MockBuffer>>(
-                          buffer_size, buffer_stride, buffer_pixel_format)},
-          mock_acquisition{std::make_shared<testing::NiceMock<MockBufferAcquisition>>()}
-    {
-        using namespace testing;
-        ON_CALL(*mock_acquisition, compositor_acquire(_))
-            .WillByDefault(Return(mock_buffer));
-    }
-
-    geom::Size const buffer_size;
-    geom::Stride const buffer_stride;
-    MirPixelFormat const buffer_pixel_format;
-    std::shared_ptr<mtd::MockBuffer> const mock_buffer;
-    std::shared_ptr<MockBufferAcquisition> mock_acquisition;
-};
-}
-
-TEST_F(TemporaryBuffersTest, compositor_buffer_acquires_and_releases)
-{
-    using namespace testing;
-    EXPECT_CALL(*mock_acquisition, compositor_acquire(_))
-        .WillOnce(Return(mock_buffer));
-    EXPECT_CALL(*mock_acquisition, compositor_release(_))
-        .Times(1);
-
-    mc::TemporaryCompositorBuffer proxy_buffer(mock_acquisition, 0);
-}
-
-TEST_F(TemporaryBuffersTest, snapshot_buffer_acquires_and_releases)
-{
-    using namespace testing;
-    EXPECT_CALL(*mock_acquisition, snapshot_acquire())
-        .WillOnce(Return(mock_buffer));
-    EXPECT_CALL(*mock_acquisition, snapshot_release(_))
-        .Times(1);
-
-    mc::TemporarySnapshotBuffer proxy_buffer(mock_acquisition);
-}
-
-TEST_F(TemporaryBuffersTest, base_test_size)
-{
-    TemporaryTestBuffer proxy_buffer(mock_buffer);
-    EXPECT_CALL(*mock_buffer, size())
-        .Times(1);
-
-    geom::Size size;
-    size = proxy_buffer.size();
-    EXPECT_EQ(buffer_size, size);
-}
-
-TEST_F(TemporaryBuffersTest, base_test_pixel_format)
-{
-    TemporaryTestBuffer proxy_buffer(mock_buffer);
-    EXPECT_CALL(*mock_buffer, pixel_format())
-        .Times(1);
-
-    MirPixelFormat pixel_format;
-    pixel_format = proxy_buffer.pixel_format();
-    EXPECT_EQ(buffer_pixel_format, pixel_format);
-}
-
-TEST_F(TemporaryBuffersTest, base_test_id)
-{
-    TemporaryTestBuffer proxy_buffer(mock_buffer);
-    EXPECT_CALL(*mock_buffer, id())
-        .Times(1);
-
-    proxy_buffer.id();
-}
-
-TEST_F(TemporaryBuffersTest, base_test_native_buffer_handle)
-{
-    TemporaryTestBuffer proxy_buffer(mock_buffer);
-    EXPECT_CALL(*mock_buffer, native_buffer_handle())
-        .Times(1);
-
-    proxy_buffer.native_buffer_handle();
-}
-
-TEST_F(TemporaryBuffersTest, forwards_native_buffer_base_to_wrapped_buffer)
-{
-    TemporaryTestBuffer proxy_buffer(mock_buffer);
-    EXPECT_CALL(*mock_buffer, native_buffer_base())
-        .Times(1);
-
-    proxy_buffer.native_buffer_base();
-}

=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2017-05-25 08:58:03 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2017-07-07 07:27:48 +0000
@@ -32,6 +32,7 @@
 #include "mir/graphics/buffer_ipc_message.h"
 #include "mir/graphics/platform_operation_message.h"
 #include "mir/graphics/buffer_id.h"
+#include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/input/cursor_images.h"
 #include "mir/graphics/platform_ipc_operations.h"
 #include "mir/scene/coordinate_translator.h"
@@ -61,6 +62,7 @@
 #include "mir/test/doubles/mock_message_sender.h"
 #include "mir/test/doubles/mock_input_config_changer.h"
 #include "mir/test/doubles/stub_input_device.h"
+#include "mir/test/doubles/stub_buffer.h"
 #include "mir/test/display_config_matchers.h"
 #include "mir/test/input_devices_matcher.h"
 #include "mir/test/fake_shared.h"
@@ -119,11 +121,6 @@
 class StubbedSession : public mtd::StubSession
 {
 public:
-    StubbedSession()
-    {
-        ON_CALL(*this, destroy_buffer(_))
-            .WillByDefault(Invoke([this](mg::BufferID){ ++destroy_buffers;}));
-    }
     std::shared_ptr<mf::Surface> get_surface(mf::SurfaceId surface) const override
     {
         if (mock_surfaces.find(surface) == mock_surfaces.end())
@@ -195,27 +192,8 @@
         mock_surfaces.erase(surface);
     }
 
-    
-    mg::BufferID create_buffer(mg::BufferProperties const&) override
-    {
-        buffer_count++;
-        return mg::BufferID{3};
-    }
-
-    mg::BufferID create_buffer(geom::Size, MirPixelFormat) override
-    {
-        buffer_count++;
-        return mg::BufferID{3};
-    }
-
-    mg::BufferID create_buffer(geom::Size, uint32_t, uint32_t) override
-    {
-        native_buffer_count++;
-        return mg::BufferID{3};
-    }
 
     MOCK_METHOD1(destroy_buffer_stream, void(mf::BufferStreamId));
-    MOCK_METHOD1(destroy_buffer, void(mg::BufferID));
 
     int num_alloc_requests()
     {
@@ -258,6 +236,55 @@
     }
 };
 
+struct RecordingBufferAllocator : public mg::GraphicBufferAllocator
+{
+    std::shared_ptr<mg::Buffer> alloc_buffer(mg::BufferProperties const& buffer_properties) override
+    {
+        auto const buf = std::make_shared<mtd::StubBuffer>(buffer_properties);
+        allocated_buffers.push_back(buf);
+        return buf;
+    }
+
+    std::vector<MirPixelFormat> supported_pixel_formats() override
+    {
+        return {};
+    }
+
+    std::shared_ptr<mg::Buffer> alloc_buffer(
+        geom::Size size, uint32_t /*native_format*/, uint32_t /*native_flags*/) override
+    {
+        auto const buf = std::make_shared<mtd::StubBuffer>(size);
+        allocated_buffers.push_back(buf);
+        return buf;
+    }
+
+    std::shared_ptr<mg::Buffer> alloc_software_buffer(
+        geom::Size size, MirPixelFormat /*format*/) override
+    {
+        auto const buf = std::make_shared<mtd::StubBuffer>(size);
+        allocated_buffers.push_back(buf);
+        return buf;
+    }
+
+    std::vector<std::weak_ptr<mg::Buffer>> allocated_buffers;
+};
+
+class MockExecutor : public mir::Executor
+{
+public:
+    MockExecutor()
+    {
+        ON_CALL(*this, spawn_thunk(_))
+            .WillByDefault(InvokeArgument<0>());
+    }
+
+    void spawn(std::function<void()>&& task) override
+    {
+        spawn_thunk(task);
+    }
+    MOCK_METHOD1(spawn_thunk, void(std::function<void()>));
+};
+
 struct SessionMediator : public ::testing::Test
 {
     SessionMediator()
@@ -269,6 +296,8 @@
           stub_screencast{std::make_shared<StubScreencast>()},
           stubbed_session{std::make_shared<NiceMock<StubbedSession>>()},
           null_callback{google::protobuf::NewPermanentCallback(google::protobuf::DoNothing)},
+          allocator{std::make_shared<RecordingBufferAllocator>()},
+          executor{std::make_shared<MockExecutor>()},
           mediator{
             shell, mt::fake_shared(mock_ipc_operations), graphics_changer,
             surface_pixel_formats, report,
@@ -280,7 +309,9 @@
             std::make_shared<mtd::NullANRDetector>(),
             mir::cookie::Authority::create(),
             mt::fake_shared(mock_input_config_changer),
-            {}}
+            {},
+            allocator,
+            executor}
     {
         using namespace ::testing;
 
@@ -310,7 +341,9 @@
             std::make_shared<NullCoordinateTranslator>(),
             std::make_shared<mtd::NullANRDetector>(),
             mir::cookie::Authority::create(),
-            mt::fake_shared(mock_input_config_changer), std::vector<mir::ExtensionDescription>{});
+            mt::fake_shared(mock_input_config_changer), std::vector<mir::ExtensionDescription>{},
+            allocator,
+            executor);
     }
 
     std::shared_ptr<mf::SessionMediator> create_session_mediator_with_screencast(
@@ -325,7 +358,9 @@
             std::make_shared<NullCoordinateTranslator>(),
             std::make_shared<mtd::NullANRDetector>(),
             mir::cookie::Authority::create(),
-            mt::fake_shared(mock_input_config_changer), std::vector<mir::ExtensionDescription>{});
+            mt::fake_shared(mock_input_config_changer), std::vector<mir::ExtensionDescription>{},
+            allocator,
+            executor);
     }
 
     MockConnector connector;
@@ -339,6 +374,8 @@
     std::shared_ptr<StubScreencast> const stub_screencast;
     std::shared_ptr<NiceMock<StubbedSession>> const stubbed_session;
     std::unique_ptr<google::protobuf::Closure> null_callback;
+    std::shared_ptr<RecordingBufferAllocator> const allocator;
+    std::shared_ptr<MockExecutor> const executor;
     mf::SessionMediator mediator;
 
     mp::ConnectParameters connect_parameters;
@@ -383,7 +420,9 @@
         std::make_shared<NullCoordinateTranslator>(),
         std::make_shared<mtd::NullANRDetector>(),
         mir::cookie::Authority::create(),
-        mt::fake_shared(mock_input_config_changer), {}};
+        mt::fake_shared(mock_input_config_changer), {},
+        allocator,
+        executor};
 
     EXPECT_THAT(connects_handled_count, Eq(0));
 
@@ -413,21 +452,6 @@
     }, std::logic_error);
 }
 
-TEST_F(SessionMediator, calling_methods_after_connect_works)
-{
-    mediator.connect(&connect_parameters, &connection, null_callback.get());
-
-    EXPECT_NO_THROW({
-        mediator.create_surface(&surface_parameters, &surface_response, null_callback.get());
-        *buffer_request.mutable_buffer() = surface_response.buffer_stream().buffer();
-        buffer_request.mutable_id()->set_value(surface_response.id().value());
-        mediator.submit_buffer(&buffer_request, nullptr, null_callback.get());
-        mediator.release_surface(&surface_id_request, nullptr, null_callback.get());
-    });
-
-    mediator.disconnect(nullptr, nullptr, null_callback.get());
-}
-
 TEST_F(SessionMediator, calling_methods_after_disconnect_throws)
 {
     mediator.connect(&connect_parameters, &connection, null_callback.get());
@@ -701,7 +725,7 @@
     mediator.modify_surface(&mods, &null, null_callback.get());
 }
 
-TEST_F(SessionMediator, allocates_software_buffers_from_the_session)
+TEST_F(SessionMediator, allocates_software_buffers)
 {
     using namespace testing;
     auto num_requests = 3;
@@ -724,10 +748,10 @@
     mediator.create_surface(&surface_parameters, &surface_response, null_callback.get());
 
     mediator.allocate_buffers(&request, &null, null_callback.get());
-    EXPECT_THAT(stubbed_session->num_alloc_requests(), Eq(num_requests));
+    EXPECT_THAT(allocator->allocated_buffers.size(), Eq(num_requests));
 }
 
-TEST_F(SessionMediator, allocates_native_buffers_from_the_session)
+TEST_F(SessionMediator, allocates_native_buffers)
 {
     using namespace testing;
     geom::Size const size { 1029, 10302 };
@@ -748,30 +772,47 @@
     mediator.create_surface(&surface_parameters, &surface_response, null_callback.get());
 
     mediator.allocate_buffers(&request, &null, null_callback.get());
-    EXPECT_THAT(stubbed_session->native_buffer_count, Eq(1));
+    EXPECT_THAT(allocator->allocated_buffers.size(), Eq(1));
 }
 
-TEST_F(SessionMediator, removes_buffer_from_the_session)
+TEST_F(SessionMediator, removes_buffer)
 {
     using namespace testing;
     auto num_requests = 3;
     mp::Void null;
-    mp::BufferStreamId id;
-    id.set_value(0);
     mp::BufferRelease request;
-    *request.mutable_id() = id;
-    auto buffer_id = 442u;
+
+    // Allocate some buffers so we can release them later...
+    mp::BufferAllocation allocate_request;
     for(auto i = 0; i < num_requests; i++)
     {
-        auto buffer_request = request.add_buffers();
-        buffer_request->set_buffer_id(buffer_id);
+        auto allocate = allocate_request.add_buffer_requests();
+        allocate->set_buffer_usage(static_cast<int32_t>(mg::BufferUsage::software));
+        allocate->set_pixel_format(mir_pixel_format_abgr_8888);
+        allocate->set_width(640);
+        allocate->set_height(480);
     }
 
     mediator.connect(&connect_parameters, &connection, null_callback.get());
-    mediator.create_surface(&surface_parameters, &surface_response, null_callback.get());
-
+    mediator.allocate_buffers(&allocate_request, &null, null_callback.get());
+
+    ASSERT_THAT(allocator->allocated_buffers.size(), Eq(num_requests));
+
+    // ...Pull out the BufferIDs of the buffers we've allocated...
+    for (auto weak_buffer : allocator->allocated_buffers)
+    {
+        auto buffer = weak_buffer.lock();
+        ASSERT_THAT(buffer, NotNull());
+
+        auto release_buffer = request.add_buffers();
+        release_buffer->set_buffer_id(buffer->id().as_value());
+    }
+
+    // ...and now release all those buffers.
     mediator.release_buffers(&request, &null, null_callback.get());
-    EXPECT_THAT(stubbed_session->num_destroy_requests(), Eq(num_requests));
+    EXPECT_THAT(
+        allocator->allocated_buffers,
+        Each(Property(&std::weak_ptr<mg::Buffer>::expired, Eq(true))));
 }
 
 TEST_F(SessionMediator, configures_swap_intervals_on_streams)
@@ -861,7 +902,9 @@
         std::make_shared<NullCoordinateTranslator>(),
         std::make_shared<mtd::NullANRDetector>(),
         mir::cookie::Authority::create(),
-        mt::fake_shared(mock_input_config_changer), {}};
+        mt::fake_shared(mock_input_config_changer), {},
+        allocator,
+        executor};
 
     ON_CALL(*shell, create_surface( _, _, _))
         .WillByDefault(
@@ -1022,22 +1065,49 @@
 TEST_F(SessionMediator, disassociates_buffers_from_stream_before_destroying)
 {
     mp::BufferRelease release_buffer;
+    mp::BufferAllocation allocate_buffer;
     mp::Void null;
 
+    // Add a fake BufferStream...
     auto stream_id = mf::BufferStreamId{42};
-    auto buffer_id = mir::graphics::BufferID{42};
     auto stream = stubbed_session->create_mock_stream(stream_id);
-    auto buffer1 = std::make_shared<mtd::StubBuffer>();
+
+    // ...and allocate a buffer to it
+    allocate_buffer.mutable_id()->set_value(42);
+    auto buffer_props = allocate_buffer.add_buffer_requests();
+    buffer_props->set_buffer_usage(0);
+    buffer_props->set_pixel_format(0);
+    buffer_props->set_width(230);
+    buffer_props->set_height(230);
+
+    mediator.connect(&connect_parameters, &connection, null_callback.get());
+    mediator.allocate_buffers(&allocate_buffer, &null, null_callback.get());
+
+    ASSERT_THAT(allocator->allocated_buffers.size(), Eq(1));
+    auto allocated_buffer = allocator->allocated_buffers.front().lock();
+    ASSERT_THAT(allocated_buffer, NotNull());
+
+    auto const buffer_id = allocated_buffer->id();
+
+    // Release our share of the buffer ownership.
+    allocated_buffer.reset();
 
     auto buffer_item = release_buffer.add_buffers();
     buffer_item->set_buffer_id(buffer_id.as_value());
     release_buffer.mutable_id()->set_value(stream_id.as_value());
 
-    EXPECT_CALL(*stream, disassociate_buffer(buffer_id));
-    EXPECT_CALL(*stubbed_session, destroy_buffer(buffer_id));
+    EXPECT_CALL(*stream, disassociate_buffer(buffer_id))
+        .WillOnce(InvokeWithoutArgs(
+            [weak_buffer = allocator->allocated_buffers.front()]()
+            {
+                // The buffer should be live here!
+                EXPECT_THAT(weak_buffer.lock(), NotNull());
+            }));
 
-    mediator.connect(&connect_parameters, &connection, null_callback.get());
     mediator.release_buffers(&release_buffer, &null, null_callback.get());
+
+    // And now we expect the buffer to have been destroyed.
+    EXPECT_THAT(allocator->allocated_buffers.front().lock(), IsNull());
 }
 
 TEST_F(SessionMediator, releases_buffers_of_unknown_buffer_stream_does_not_throw)
@@ -1046,10 +1116,30 @@
     mp::BufferRelease release_buffer;
     mp::Void null;
 
+    // Add a fake BufferStream...
     auto stream_id = mf::BufferStreamId{42};
-    auto buffer_id = mir::graphics::BufferID{42};
     auto stream = stubbed_session->create_mock_stream(stream_id);
-    auto buffer1 = std::make_shared<mtd::StubBuffer>();
+
+    // ...and allocate a buffer to it
+    mp::BufferAllocation allocate_buffer;
+    allocate_buffer.mutable_id()->set_value(42);
+    auto buffer_props = allocate_buffer.add_buffer_requests();
+    buffer_props->set_buffer_usage(0);
+    buffer_props->set_pixel_format(0);
+    buffer_props->set_width(230);
+    buffer_props->set_height(230);
+
+    mediator.connect(&connect_parameters, &connection, null_callback.get());
+    mediator.allocate_buffers(&allocate_buffer, &null, null_callback.get());
+
+    ASSERT_THAT(allocator->allocated_buffers.size(), Eq(1));
+    auto allocated_buffer = allocator->allocated_buffers.front().lock();
+    ASSERT_THAT(allocated_buffer, NotNull());
+
+    auto const buffer_id = allocated_buffer->id();
+
+    // Release our share of the buffer ownership.
+    allocated_buffer.reset();
 
     auto buffer_item = release_buffer.add_buffers();
     buffer_item->set_buffer_id(buffer_id.as_value());
@@ -1058,15 +1148,15 @@
     stream_to_release.set_value(stream_id.as_value());
 
     EXPECT_CALL(*stubbed_session, destroy_buffer_stream(stream_id));
-    EXPECT_CALL(*stubbed_session, destroy_buffer(buffer_id));
 
-    mediator.connect(&connect_parameters, &connection, null_callback.get());
     mediator.release_buffer_stream(&stream_to_release, &null, null_callback.get());
     stream.reset();
 
     EXPECT_NO_THROW(
         mediator.release_buffers(&release_buffer, &null, null_callback.get());
         );
+
+    EXPECT_TRUE(allocator->allocated_buffers.front().expired());
 }
 
 MATCHER_P3(CursorIs, id_value, x_value, y_value, "cursor configuration match")
@@ -1165,7 +1255,6 @@
     buffer_request->set_height(129);
     buffer_request->set_pixel_format(mir_pixel_format_abgr_8888);
     buffer_request->set_buffer_usage(mir_buffer_usage_hardware);
-    int buffer_id = 3;
     mf::ScreencastSessionId screencast_id{7};
     auto mock_screencast = std::make_shared<NiceMock<mtd::MockScreencast>>();
 
@@ -1181,7 +1270,49 @@
     mp::ScreencastRequest screencast_request;
 
     screencast_request.mutable_id()->set_value(screencast_id.as_value());
-    screencast_request.set_buffer_id(buffer_id);
+    screencast_request.set_buffer_id(allocator->allocated_buffers.front().lock()->id().as_value());
 
     mediator->screencast_to_buffer(&screencast_request, &null, null_callback.get());
 }
+
+TEST_F(SessionMediator, buffer_releases_are_sent_from_specified_executor)
+{
+    mp::BufferRelease release_buffer;
+    mp::BufferAllocation allocate_buffer;
+    mp::Void null;
+
+    // Add a fake BufferStream...
+    auto stream_id = mf::BufferStreamId{42};
+    auto stream = stubbed_session->create_mock_stream(stream_id);
+
+    // ...and allocate a buffer to it
+    allocate_buffer.mutable_id()->set_value(42);
+    auto buffer_props = allocate_buffer.add_buffer_requests();
+    buffer_props->set_buffer_usage(0);
+    buffer_props->set_pixel_format(0);
+    buffer_props->set_width(230);
+    buffer_props->set_height(230);
+
+    mediator.connect(&connect_parameters, &connection, null_callback.get());
+    mediator.allocate_buffers(&allocate_buffer, &null, null_callback.get());
+
+    ASSERT_THAT(allocator->allocated_buffers.size(), Eq(1));
+    auto allocated_buffer = allocator->allocated_buffers.front().lock();
+    ASSERT_THAT(allocated_buffer, NotNull());
+
+    auto const buffer_id = allocated_buffer->id();
+
+    // Submit this buffer
+    mp::BufferRequest submit_request;
+    submit_request.mutable_id()->set_value(stream_id.as_value());
+    submit_request.mutable_buffer()->set_buffer_id(buffer_id.as_value());
+
+    // Ensure the submitted buffer's lifetime ends immediately, and so should
+    // get released to the client.
+    ON_CALL(*stream, submit_buffer(_))
+        .WillByDefault(Invoke([](auto const&) {}));
+    // And our buffer should be released by the executor.
+    EXPECT_CALL(*executor, spawn_thunk(_)).Times(1);
+
+    mediator.submit_buffer(&submit_request, &null, null_callback.get());
+}

=== modified file 'tests/unit-tests/scene/test_application_session.cpp'
--- tests/unit-tests/scene/test_application_session.cpp	2017-05-25 04:43:29 +0000
+++ tests/unit-tests/scene/test_application_session.cpp	2017-07-07 07:27:48 +0000
@@ -63,17 +63,10 @@
 
 struct MockBufferStreamFactory : public ms::BufferStreamFactory
 {
-    MockBufferStreamFactory()
-    {
-        ON_CALL(*this, create_buffer_map(testing::_))
-            .WillByDefault(testing::Return(std::make_shared<mtd::StubClientBuffers>()));
-    }
+    MOCK_METHOD2(create_buffer_stream, std::shared_ptr<mc::BufferStream>(
+        mf::BufferStreamId, mg::BufferProperties const&));
     MOCK_METHOD3(create_buffer_stream, std::shared_ptr<mc::BufferStream>(
-        mf::BufferStreamId, std::shared_ptr<mf::ClientBuffers> const&, mg::BufferProperties const&));
-    MOCK_METHOD4(create_buffer_stream, std::shared_ptr<mc::BufferStream>(
-        mf::BufferStreamId, std::shared_ptr<mf::ClientBuffers> const&, int, mg::BufferProperties const&));
-    MOCK_METHOD1(create_buffer_map, std::shared_ptr<mf::ClientBuffers>(
-        std::shared_ptr<mf::BufferSink> const&));
+        mf::BufferStreamId, int, mg::BufferProperties const&));
 };
 
 
@@ -488,7 +481,7 @@
     NiceMock<MockSurfaceFactory> surface_factory;
     MockBufferStreamFactory mock_buffer_stream_factory;
     std::shared_ptr<mc::BufferStream> const mock_stream = std::make_shared<mtd::MockBufferStream>();
-    ON_CALL(mock_buffer_stream_factory, create_buffer_stream(_,_,_)).WillByDefault(Return(mock_stream));
+    ON_CALL(mock_buffer_stream_factory, create_buffer_stream(_,_)).WillByDefault(Return(mock_stream));
     ON_CALL(surface_factory, create_surface(_,_)).WillByDefault(Return(mock_surface));
     NiceMock<mtd::MockSurfaceStack> surface_stack;
 
@@ -588,7 +581,7 @@
         std::make_shared<mtd::StubBufferStream>(),
         std::make_shared<mtd::StubBufferStream>()
     }};
-    EXPECT_CALL(mock_bufferstream_factory, create_buffer_stream(_,_,_))
+    EXPECT_CALL(mock_bufferstream_factory, create_buffer_stream(_,_))
         .WillOnce(Return(streams[0]))
         .WillOnce(Return(streams[1]))
         .WillOnce(Return(streams[2]));
@@ -630,7 +623,7 @@
 
     mg::BufferProperties properties(buffer_size, mir_pixel_format_argb_8888, mg::BufferUsage::software);
     
-    EXPECT_CALL(factory, create_buffer_stream(_,_,properties)).Times(1)
+    EXPECT_CALL(factory, create_buffer_stream(_,properties)).Times(1)
         .WillOnce(Return(mt::fake_shared(stream)));
 
     auto session = make_application_session_with_buffer_stream_factory(mt::fake_shared(factory));
@@ -658,7 +651,7 @@
 
     EXPECT_CALL(stream, allow_framedropping(true))
         .Times(0); 
-    EXPECT_CALL(factory, create_buffer_stream(_,_,properties)).Times(1)
+    EXPECT_CALL(factory, create_buffer_stream(_,properties)).Times(1)
         .WillOnce(Return(mt::fake_shared(stream)));
 
     auto session = make_application_session_with_buffer_stream_factory(mt::fake_shared(factory));

=== modified file 'tests/unit-tests/scene/test_surface_stack.cpp'
--- tests/unit-tests/scene/test_surface_stack.cpp	2017-05-08 03:04:26 +0000
+++ tests/unit-tests/scene/test_surface_stack.cpp	2017-07-07 07:27:48 +0000
@@ -289,17 +289,7 @@
     ms::SurfaceStack stack{report};
     stack.register_compositor(this);
 
-    struct StubBuffers : mtd::StubClientBuffers
-    {
-        std::shared_ptr<mg::Buffer> get(mg::BufferID) const override
-        {
-            return buffer;
-        }
-        std::shared_ptr<mg::Buffer> buffer {std::make_shared<mtd::StubBuffer>()};
-    };
-
-    auto buffers = std::make_shared<StubBuffers>();
-    auto stream = std::make_shared<mc::Stream>(buffers, geom::Size{ 1, 1 }, mir_pixel_format_abgr_8888);
+    auto stream = std::make_shared<mc::Stream>(geom::Size{ 1, 1 }, mir_pixel_format_abgr_8888);
 
     auto surface = std::make_shared<ms::BasicSurface>(
         std::string("stub"),