Mir

Merge lp:~raof/mir/better-buffer-plumbing into lp:mir

better-buffer-plumbing
Merge into development-branch

Proposed by Chris Halse Rogers on 2017-07-18

Status:	Merged
Approved by:	Alan Griffiths on 2017-07-19
Approved revision:	no longer in the source branch.
Merged at revision:	4208
Proposed branch:	lp:~raof/mir/better-buffer-plumbing
Merge into:	lp:mir
Prerequisite:	lp:~raof/mir/dont-ack-release-buffer
Diff against target:	3607 lines (+1033/-1089) 44 files modified examples/server_example_canonical_window_manager.cpp (+5/-3) examples/server_example_canonical_window_manager.h (+7/-1) examples/server_example_window_management.cpp (+6/-1) include/server/mir/frontend/client_buffers.h (+0/-46) include/server/mir/frontend/session.h (+0/-6) include/server/mir/scene/buffer_stream_factory.h (+4/-6) include/server/mir/scene/session.h (+0/-6) include/server/mir/shell/window_management_info.h (+5/-1) include/test/mir/test/doubles/stub_session.h (+0/-6) src/client/mir_connection.cpp (+0/-1) src/server/compositor/CMakeLists.txt (+0/-1) src/server/compositor/buffer_map.cpp (+0/-114) src/server/compositor/buffer_map.h (+0/-65) src/server/compositor/buffer_stream_factory.cpp (+5/-12) src/server/compositor/buffer_stream_factory.h (+4/-5) src/server/compositor/dropping_schedule.cpp (+1/-12) src/server/compositor/dropping_schedule.h (+1/-3) src/server/compositor/multi_monitor_arbiter.cpp (+1/-5) src/server/compositor/multi_monitor_arbiter.h (+0/-2) src/server/compositor/stream.cpp (+7/-25) src/server/compositor/stream.h (+1/-2) src/server/frontend/default_ipc_factory.cpp (+3/-1) src/server/frontend/session_mediator.cpp (+127/-32) src/server/frontend/session_mediator.h (+6/-2) src/server/scene/application_session.cpp (+1/-53) src/server/scene/application_session.h (+0/-7) src/server/shell/window_management_info.cpp (+13/-26) tests/include/mir/test/doubles/stub_buffer_stream_factory.h (+9/-30) tests/integration-tests/compositor/test_swapping_swappers.cpp (+1/-2) tests/integration-tests/test_buffer_scheduling.cpp (+25/-14) tests/integration-tests/test_session.cpp (+1/-1) tests/integration-tests/test_submit_buffer.cpp (+146/-108) tests/integration-tests/test_surface_stack_with_compositor.cpp (+2/-5) tests/integration-tests/test_swapinterval.cpp (+3/-8) tests/mir_test_framework/stub_session.cpp (+0/-25) tests/unit-tests/client/test_mir_connection.cpp (+0/-1) tests/unit-tests/compositor/CMakeLists.txt (+0/-1) tests/unit-tests/compositor/test_client_buffers.cpp (+0/-118) tests/unit-tests/compositor/test_dropping_schedule.cpp (+6/-45) tests/unit-tests/compositor/test_multi_monitor_arbiter.cpp (+171/-112) tests/unit-tests/compositor/test_stream.cpp (+27/-68) tests/unit-tests/frontend/test_session_mediator.cpp (+437/-82) tests/unit-tests/scene/test_application_session.cpp (+7/-14) tests/unit-tests/scene/test_surface_stack.cpp (+1/-11)
To merge this branch:	bzr merge lp:~raof/mir/better-buffer-plumbing
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration	2017-07-18	Approve on 2017-07-19
Alan Griffiths		2017-07-18	Approve on 2017-07-18
Brandon Schaefer		2017-07-18	Pending
Review via email: mp+327576@code.launchpad.net

This proposal supersedes a proposal from 2017-07-04.

Commit message

Move full responsibility for buffer IPC into the frontend.

Currently buffer IPC is split between the frontend and various things which shared an mf::BufferMap.

This branch consolidates everything so that, outside the SessionMediator, everything is dealing with
a std::shared_ptr<mg::Buffer>.

In addition to consolidating IPC into the frontend where it belongs, this makes it easy
to submit client-allocated buffers.

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-07-04: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-07-05: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-07-06: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-07-06: Posted in a previous version of this proposal

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

review: Approve (continuous-integration)

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2017-07-11: Posted in a previous version of this proposal

Nice, lgtm. Now we can accept gbm buffers easier then the way it looked before :)

review: Approve

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-07-11: Posted in a previous version of this proposal

The name "mir::graphics::GraphicBufferAllocator" seems tautological why not "mir::graphics::BufferAllocator"?

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-07-11: Posted in a previous version of this proposal

> The name "mir::graphics::GraphicBufferAllocator" seems tautological why not
> "mir::graphics::BufferAllocator"?

/sigh I guess that's pre-existing.

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-07-11: Posted in a previous version of this proposal

nits

+ // We can't reasonably answer this question -
+ // Suitability for cursor use is a per-buffer property, not a per-stream property.
return true;

Instead of hard coding this to true wouldn't it be less misleading to remove the calls to this function?

~~~~

Looks like this changes the mirserver ABI - there ought to be removals from the symbols script (e.g. mir::frontend::ClientBuffers) and a bump to the SONAME.

But that can be done separately.

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-07-11: Posted in a previous version of this proposal

This breaks when starting a load of clients. (I built lp:miral against it and...)

$ cat `which mir_demo_client_all`
#!/bin/sh
mir_demo_client_animated_cursor&mir_demo_client_eglsquare&mir_demo_client_prerendered_frames&mir_demo_client_basic&mir_demo_client_eglstateswitcher&mir_demo_client_progressbar&mir_demo_client_camera&mir_demo_client_egltriangle&mir_demo_client_prompt_session&mir_demo_client_cursors&mir_demo_client_fingerpaint&mir_demo_client_release_at_exit&mir_demo_client_display_config&mir_demo_client_flicker&mir_demo_client_scroll&mir_demo_client_eglcounter&mir_demo_client_input_shapes&mir_demo_client_target&mir_demo_client_eglflash&mir_demo_client_multistream&mir_demo_client_tooltip&mir_demo_client_eglplasma&mir_demo_client_multiwin&mir_demo_client_touch_validator&

$miral-app

[in the miral terminal]
$ mir_demo_client_all

Expect: all the demos clients start
Actual: miral-shell crashes

I don't see this without this MP.

review: Needs Fixing

Revision history for this message

Chris Halse Rogers (raof) wrote on 2017-07-12: Posted in a previous version of this proposal

Interesting. I'll investigate!

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-07-12: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-07-12: Posted in a previous version of this proposal

Works much better but...

$ miral-app -launcher mir_demo_client_multistream

Wait about 30sec and it locks up

review: Needs Fixing

Revision history for this message

Chris Halse Rogers (raof) wrote on 2017-07-13: Posted in a previous version of this proposal

Huh. Artful build failures are due to Artful (specifically, dh_strip_nondeterminism) being broken.

Urgh. Let's try multistream!

Revision history for this message

Chris Halse Rogers (raof) wrote on 2017-07-13: Posted in a previous version of this proposal

Ah, good. This also happens with mir_demo_server, which is easier to deal with.

But only multistream? Not the EGL demos, as far as I can tell. Odd.

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-07-13: Posted in a previous version of this proposal

Thinking about it - a client setting a bad BufferStreamID shouldn't crash the server. It should simply kill the session.

Revision history for this message

Chris Halse Rogers (raof) wrote on 2017-07-14: Posted in a previous version of this proposal

Setting a bad BufferStreamID doesn't crash the server. At least, not that alone.

Hah! The hang in mir_demo_client_multistream is a client buffer leak, leading to fd starvation. Yay!

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-07-18:

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

review: Approve (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-07-18:

> SessionMediator: std::logic_error is not derived from std::runtime_error.
>
> So we need to catch std::exception in order to actually send error-buffers rather than crash
> the server!

Surely logic errors need to be found and avoided before release? Crashing the server seems a good way to motivate this.

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-07-18:

Looks mostly good, except that mir_demo_client_animated_cursor seems to be in slow motion.

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-07-18:

> Looks mostly good, except that mir_demo_client_animated_cursor seems to be in
> slow motion.

Hmm that appears to happen on trunk too. Seems recent (0.27 from archive is fine.)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-07-18:

I'm down to nits, approving on the basis that I trust you:

There's a trivial merge conflict with latest trunk.

~~~~

+ // We can't reasonably answer this question -
+ // Suitability for cursor use is a per-buffer property, not a per-stream property.
return true;

Instead of hard coding this to true wouldn't it be less misleading to remove the calls to this function?

~~~~

Looks like this changes the mirserver ABI - there ought to be removals from the symbols script (e.g. mir::frontend::ClientBuffers) and a bump to the SONAME.

But that can be done separately.

review: Approve

Revision history for this message

Chris Halse Rogers (raof) wrote on 2017-07-19:

Yeah. There's even more follow-up to be done. I thought this was probably getting big enough, and the follow up could be done in follow up :)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-07-19:

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

review: Approve (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-07-19:

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

review: Approve (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) on 2017-07-19:

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Chris Halse Rogers

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === 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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +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 <kevin.dubois@canonical.com>
-- */
--
--#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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +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/client/mir_connection.cpp'
 --- src/client/mir_connection.cpp	2017-07-19 05:46:21 +0000
 +++ src/client/mir_connection.cpp	2017-07-19 05:46:21 +0000
@@ -1305,7 +1305,6 @@
      MirBufferCallback callback, void* context)
+ {
      mp::BufferAllocation request;
--    request.mutable_id()->set_value(-1);
      auto buffer_request = request.add_buffer_requests();
      buffer_request->set_width(size.width.as_int());
      buffer_request->set_height(size.height.as_int());
 === 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-19 05:46:21 +0000
@@ -18,7 +18,6 @@
    compositing_screencast.cpp
    stream.cpp
    multi_monitor_arbiter.cpp
--  buffer_map.cpp
    dropping_schedule.cpp
    queueing_schedule.cpp
+ )
 === removed file 'src/server/compositor/buffer_map.cpp'
 --- src/server/compositor/buffer_map.cpp	2017-07-19 05:46:21 +0000
 +++ src/server/compositor/buffer_map.cpp	1970-01-01 00:00:00 +0000
@@ -1,114 +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 <kevin.dubois@canonical.com>
-- */
--
--#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);
--    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 <kevin.dubois@canonical.com>
-- */
--
--#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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +0000
@@ -17,16 +17,13 @@
   */
  #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()
+ {
+ }
@@ -42,14 +39,6 @@
+ {
      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;
+ }
 === 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-19 05:46:21 +0000
@@ -25,13 +25,12 @@
  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;
@@ -40,7 +39,6 @@
  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-19 05:46:21 +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,9 +29,7 @@
  namespace mf = mir::frontend;
  mc::MultiMonitorArbiter::MultiMonitorArbiter(
--    std::shared_ptr<frontend::ClientBuffers> const& map,
      std::shared_ptr<Schedule> const& schedule) :
--    map(map),
      schedule(schedule)
+ {
+ }
@@ -43,7 +40,7 @@
      for(auto it = onscreen_buffers.begin(); it != onscreen_buffers.end(); it++)
+     {
          if (it->use_count == 0)
--            map->send_buffer(it->buffer->id());
++            it->buffer.reset();
+     }
+ }
@@ -96,7 +93,6 @@
          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
 === 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-19 05:46:21 +0000
@@ -38,7 +38,6 @@
+ {
  public:
      MultiMonitorArbiter(
--        std::shared_ptr<frontend::ClientBuffers> const& map,
          std::shared_ptr<Schedule> const& schedule);
      ~MultiMonitorArbiter();
@@ -56,7 +55,6 @@
      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) :
 === 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-19 05:46:21 +0000
@@ -21,7 +21,6 @@
  #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 +36,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
+ {
@@ -72,9 +66,8 @@
+     {
          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();
++        deferred_io = schedule->schedule_nonblocking(buffer);
+     }
      observers.frame_posted(1, buffer->size());
@@ -134,7 +127,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 +175,6 @@
          transferred_buffers.pop_back();
+     }
--    for (auto &buffer : transferred_buffers)
--        buffers->send_buffer(buffer->id());
--
      arbiter->advance_schedule();
+ }
@@ -214,15 +204,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-19 05:46:21 +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;
 === 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-19 05:46:21 +0000
@@ -26,6 +26,7 @@
  #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"
@@ -150,5 +151,6 @@
          anr_detector,
          cookie_authority,
          input_changer,
--        extensions);
++        extensions,
++        buffer_allocator);
+ }
 === 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-19 05:46:21 +0000
@@ -59,6 +59,7 @@
  #include "mir/fd.h"
  #include "mir/cookie/authority.h"
  #include "mir/module_properties.h"
++#include "mir/graphics/graphic_buffer_allocator.h"
  #include "mir/geometry/rectangles.h"
  #include "protobuf_buffer_packer.h"
@@ -110,7 +111,8 @@
      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) :
      client_pid_(0),
      shell(shell),
      ipc_operations(ipc_operations),
@@ -128,7 +130,8 @@
      anr_detector{anr_detector},
      cookie_authority(cookie_authority),
      input_changer(input_changer),
--    extensions(extensions)
++    extensions(extensions),
++    allocator{allocator}
+ {
+ }
@@ -374,6 +377,58 @@
      buffering_sender->uncork();
+ }
++namespace
++{
++    class AutoSendBuffer : public mg::Buffer
++    {
++    public:
++        AutoSendBuffer(
++            std::shared_ptr<mg::Buffer> const& wrapped,
++            std::weak_ptr<mf::BufferSink> const& sink)
++            : buffer{wrapped},
++              sink{sink}
++        {
++        }
++        ~AutoSendBuffer()
++        {
++            if (auto live_sink = sink.lock())
++            {
++                live_sink->update_buffer(*buffer);
++            }
++        }
++
++        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::weak_ptr<mf::BufferSink> const sink;
++    };
++
++}
++
  void mf::SessionMediator::submit_buffer(
      mir::protobuf::BufferRequest const* request,
      mir::protobuf::Void*,
@@ -388,15 +443,37 @@
      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, event_sink));
      done->Run();
+ }
--void mf::SessionMediator::allocate_buffers(
++namespace
++{
++bool validate_buffer_request(mir::protobuf::BufferStreamParameters const& req)
++{
++    // A valid buffer request has either flags & native_format set
++    // or buffer_usage & pixel_format set, not both.
++    return
++        (
++            req.has_pixel_format() &&
++            req.has_buffer_usage() &&
++            !req.has_native_format() &&
++            !req.has_flags()
++        ) ||
++        (
++            !req.has_pixel_format() &&
++            !req.has_buffer_usage() &&
++            req.has_native_format() &&
++            req.has_flags()
++        );
++}
++}
++
++void mf::SessionMediator::allocate_buffers(
      mir::protobuf::BufferAllocation const* request,
      mir::protobuf::Void*,
      google::protobuf::Closure* done)
@@ -409,36 +486,54 @@
      for (auto i = 0; i < request->buffer_requests().size(); i++)
+     {
          auto const& req = request->buffer_requests(i);
++        std::shared_ptr<mg::Buffer> buffer;
++        try
++        {
++            if (!validate_buffer_request(req))
++            {
++                BOOST_THROW_EXCEPTION(std::logic_error("Invalid buffer request"));
++            }
--        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)
++            if (req.has_flags() && req.has_native_format())
+             {
--                id = session->create_buffer(size, pf);
++                buffer = allocator->alloc_buffer(
++                    {req.width(), req.height()},
++                    req.native_format(),
++                    req.flags());
+             }
              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);
++                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});
++                }
++            }
++
++            if (request->has_id())
++            {
++                auto stream = session->get_buffer_stream(mf::BufferStreamId(request->id().value()));
++                stream->associate_buffer(buffer->id());
++            }
++
++            // TODO: Throw if insert fails (duplicate ID)?
++            buffer_cache.insert(std::make_pair(buffer->id(), buffer));
++            event_sink->add_buffer(*buffer);
++        }
++        catch (std::exception const& err)
++        {
++            event_sink->error_buffer(
++                geom::Size{req.width(), req.height()},
++                static_cast<MirPixelFormat>(req.pixel_format()),
++                err.what());
+         }
+     }
      done->Run();
@@ -473,7 +568,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 +964,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-19 05:46:21 +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"
@@ -77,6 +78,7 @@
  class PromptSession;
  class BufferStream;
  class InputConfigurationChanger;
++class BufferMap;
  namespace detail
+ {
@@ -124,8 +126,8 @@
          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);
      ~SessionMediator() noexcept;
@@ -299,6 +301,8 @@
      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;
      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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +0000
@@ -16,17 +16,15 @@
   * Authored by: Kevin DuBois <kevin.dubois@canonical.com>
   */
--#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 "src/server/compositor/temporary_buffers.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 +46,6 @@
  namespace
+ {
--enum class TestType
--{
--    ExchangeSemantics,
--    SubmitSemantics
--};
--
  enum class Access
+ {
      blocked,
@@ -462,6 +454,24 @@
      return never_blocks;
+ }
++class AutoSendBuffer : public mc::TemporaryBuffer
++{
++public:
++    AutoSendBuffer(
++        std::shared_ptr<mg::Buffer> const& wrapped,
++        std::shared_ptr<mf::BufferSink> const& sink)
++        : TemporaryBuffer(wrapped),
++          sink{sink}
++    {
++    }
++
++    ~AutoSendBuffer()
++    {
++        sink->update_buffer(*buffer);
++    }
++private:
++    std::shared_ptr<mf::BufferSink> const sink;
++};
  //test infrastructure
  struct BufferScheduling : public Test, ::testing::WithParamInterface<int>
@@ -470,9 +480,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 +491,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 +540,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 {};
 === 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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +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-19 05:46:21 +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/client/test_mir_connection.cpp'
 --- tests/unit-tests/client/test_mir_connection.cpp	2017-05-25 06:28:52 +0000
 +++ tests/unit-tests/client/test_mir_connection.cpp	2017-07-19 05:46:21 +0000
@@ -873,7 +873,6 @@
      auto native_format = 342u;
      auto native_flags = 0x44;
      mp::BufferAllocation mp_alloc;
--    mp_alloc.mutable_id()->set_value(-1);
      auto params = mp_alloc.add_buffer_requests();
      params->set_width(size.width.as_int());
      params->set_height(size.height.as_int());
 === 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-19 05:46:21 +0000
@@ -7,7 +7,6 @@
    ${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-07-19 05:46:21 +0000
 +++ tests/unit-tests/compositor/test_client_buffers.cpp	1970-01-01 00:00:00 +0000
@@ -1,118 +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 <kevin.dubois@canonical.com>
-- */
--
--#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);
--
--    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-19 05:46:21 +0000
@@ -16,7 +16,6 @@
   * Authored by: Kevin DuBois <kevin.dubois@canonical.com>
   */
--#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-19 05:46:21 +0000
@@ -21,7 +21,7 @@
  #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 "src/server/compositor/temporary_buffers.h"
  #include <gtest/gtest.h>
  using namespace testing;
@@ -33,16 +33,6 @@
  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
@@ -63,7 +53,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 +76,40 @@
+     }
      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 mc::TemporaryBuffer
++    {
++    public:
++        DestructionNotifyingBuffer(
++            std::shared_ptr<mg::Buffer> const& buffer,
++            std::shared_ptr<bool> const& destroyed)
++            : TemporaryBuffer(buffer),
++              destroyed{destroyed}
++        {
++        }
++
++        ~DestructionNotifyingBuffer()
++        {
++            *destroyed = true;
++        }
++    private:
++        std::shared_ptr<bool> const destroyed;
++    };
++
++    return std::make_shared<DestructionNotifyingBuffer>(buffer, destroyed);
++}
+ }
  TEST_F(MultiMonitorArbiter, compositor_access_before_any_submission_throws)
@@ -107,32 +129,30 @@
+ {
      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,13 +175,13 @@
      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)
@@ -179,11 +199,11 @@
      auto cbuffer5 = arbiter.compositor_acquire(this);
      arbiter.compositor_release(cbuffer5);
--    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(cbuffer1, IsSameBufferAs(buffers[0]));
++    EXPECT_THAT(cbuffer2, IsSameBufferAs(buffers[1]));
++    EXPECT_THAT(cbuffer3, IsSameBufferAs(buffers[2]));
++    EXPECT_THAT(cbuffer4, IsSameBufferAs(buffers[3]));
++    EXPECT_THAT(cbuffer5, IsSameBufferAs(buffers[4]));
+ }
  TEST_F(MultiMonitorArbiter, compositor_consumes_all_buffers_when_operating_as_a_bypassed_buffer_would)
@@ -201,11 +221,11 @@
      arbiter.compositor_release(cbuffer4);
      arbiter.compositor_release(cbuffer5);
--    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(cbuffer1, IsSameBufferAs(buffers[0]));
++    EXPECT_THAT(cbuffer2, IsSameBufferAs(buffers[1]));
++    EXPECT_THAT(cbuffer3, IsSameBufferAs(buffers[2]));
++    EXPECT_THAT(cbuffer4, IsSameBufferAs(buffers[3]));
++    EXPECT_THAT(cbuffer5, IsSameBufferAs(buffers[4]));
+ }
  TEST_F(MultiMonitorArbiter, multimonitor_compositor_buffer_syncs_to_fastest_with_more_queueing)
@@ -228,18 +248,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 +272,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 +282,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)
@@ -278,8 +298,8 @@
      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)
@@ -297,8 +317,8 @@
+     }
      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(IsSameBufferAs(cbuffer1)));
+ }
  TEST_F(MultiMonitorArbiter, no_buffers_available_throws_on_snapshot)
@@ -311,29 +331,48 @@
  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()));
++    cbuffer1.reset();
++
++    // Acquire a new buffer so first one is no longer onscreen.
++    arbiter.compositor_acquire(this);
++
++    EXPECT_FALSE(*buffer_released);
      arbiter.snapshot_release(sbuffer1);
++    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);
++    EXPECT_FALSE(*buffer_released);
      arbiter.compositor_release(cbuffer1);
++    cbuffer1.reset();
++    cbuffer2.reset();
++    EXPECT_TRUE(*buffer_released);
+ }
  TEST_F(MultiMonitorArbiter, advance_on_fastest_has_same_buffer)
@@ -349,29 +388,29 @@
      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(cbuffer1, IsSameBufferAs(cbuffer2));
++    EXPECT_THAT(cbuffer1, IsSameBufferAs(buffers[0]));
++    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);
@@ -386,7 +425,14 @@
      auto b6 = arbiter.compositor_acquire(&comp_id1);
      arbiter.compositor_release(b6);
--    Mock::VerifyAndClearExpectations(&mock_map);
++    b1.reset();
++    b2.reset();
++    b3.reset();
++    b4.reset();
++    b5.reset();
++    b6.reset();
++
++    EXPECT_THAT(buffer_released, Each(Pointee(true)));
+ }
  TEST_F(MultiMonitorArbiter, can_check_if_buffers_are_ready)
@@ -442,17 +488,28 @@
  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]));
++    EXPECT_THAT(b1, IsSameBufferAs(buffers[0]));
++    EXPECT_THAT(b2, IsSameBufferAs(buffers[1]));
      arbiter.compositor_release(b1);
      arbiter.compositor_release(b2);
--    Mock::VerifyAndClearExpectations(&mock_map);
--}
++    b1.reset();
++    b2.reset();
++
++    EXPECT_TRUE(*buffer_released);
++}
  TEST_F(MultiMonitorArbiter, will_release_buffer_in_nbuffers_2_starvation_scenario)
+ {
@@ -471,10 +528,10 @@
      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]));
++    EXPECT_THAT(b1, IsSameBufferAs(buffers[0]));
++    EXPECT_THAT(b2, IsSameBufferAs(buffers[1]));
++    EXPECT_THAT(b3, IsSameBufferAs(buffers[1]));
++    EXPECT_THAT(b4, IsSameBufferAs(buffers[0]));
+ }
@@ -482,13 +539,12 @@
+ {
      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 b2 = arbiter.compositor_acquire(&comp_id2);
      arbiter.compositor_release(b1); //send nothing
@@ -502,13 +558,12 @@
      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(b1, IsSameBufferAs(buffers[0]));
++    EXPECT_THAT(b2, IsSameBufferAs(buffers[0]));
++    EXPECT_THAT(b3, IsSameBufferAs(buffers[1]));
++    EXPECT_THAT(b4, IsSameBufferAs(buffers[1]));
++    EXPECT_THAT(b5, IsSameBufferAs(buffers[2]));
++}
  TEST_F(MultiMonitorArbiter, can_advance_buffer_manually)
+ {
@@ -521,11 +576,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 +602,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_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-19 05:46:21 +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));
+ }
 === 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-19 05:46:21 +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,42 @@
+     }
  };
++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
++    {
++        if ((format >= mir_pixel_formats) || format == mir_pixel_format_invalid)
++            BOOST_THROW_EXCEPTION((std::runtime_error{"Invalid pixel format"}));
++
++        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;
++};
++
  struct SessionMediator : public ::testing::Test
+ {
      SessionMediator()
@@ -269,6 +283,7 @@
            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>()},
            mediator{
              shell, mt::fake_shared(mock_ipc_operations), graphics_changer,
              surface_pixel_formats, report,
@@ -280,7 +295,8 @@
              std::make_shared<mtd::NullANRDetector>(),
              mir::cookie::Authority::create(),
              mt::fake_shared(mock_input_config_changer),
--            {}}
++            {},
++            allocator}
+     {
          using namespace ::testing;
@@ -310,7 +326,8 @@
              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);
+     }
      std::shared_ptr<mf::SessionMediator> create_session_mediator_with_screencast(
@@ -325,7 +342,112 @@
              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);
++    }
++
++    std::shared_ptr<mf::SessionMediator> create_session_mediator_with_event_sink(
++        std::shared_ptr<mf::EventSink> const& sink)
++    {
++        class WrappingEventSink : public mf::EventSink
++        {
++        public:
++            WrappingEventSink(std::shared_ptr<mf::EventSink> const& wrapped)
++                : wrapped{wrapped}
++            {
++            }
++
++            void handle_event(MirEvent const &e) override
++            {
++                wrapped->handle_event(e);
++            }
++
++            void handle_lifecycle_event(MirLifecycleState state) override
++            {
++                wrapped->handle_lifecycle_event(state);
++            }
++
++            void handle_display_config_change(
++                mg::DisplayConfiguration const& config) override
++            {
++                wrapped->handle_display_config_change(config);
++            }
++
++            void send_ping(int32_t serial) override
++            {
++                wrapped->send_ping(serial);
++            }
++
++            void handle_input_config_change(MirInputConfig const& config) override
++            {
++                wrapped->handle_input_config_change(config);
++            }
++
++            void handle_error(mir::ClientVisibleError const& error) override
++            {
++                wrapped->handle_error(error);
++            }
++
++            void send_buffer(
++                mf::BufferStreamId id,
++                mg::Buffer& buffer,
++                mg::BufferIpcMsgType type) override
++            {
++                wrapped->send_buffer(id, buffer, type);
++            }
++
++            void add_buffer(mg::Buffer& buffer) override
++            {
++                wrapped->add_buffer(buffer);
++            }
++
++            void error_buffer(
++                geom::Size req_size,
++                MirPixelFormat req_format,
++                std::string const &error_msg) override
++            {
++                wrapped->error_buffer(req_size, req_format, error_msg);
++            }
++
++            void update_buffer(mg::Buffer &buffer) override
++            {
++                wrapped->update_buffer(buffer);
++            }
++
++        private:
++            std::shared_ptr<mf::EventSink> const wrapped;
++        };
++
++        class EventSinkFactory : public mf::EventSinkFactory
++        {
++        public:
++            EventSinkFactory(std::shared_ptr<mf::EventSink> const& sink)
++                : the_sink{sink}
++            {
++            }
++
++            std::unique_ptr<mf::EventSink> create_sink(
++                std::shared_ptr<mf::MessageSender> const&) override
++            {
++                return std::make_unique<WrappingEventSink>(the_sink);
++            }
++
++        private:
++            std::shared_ptr<mf::EventSink> const the_sink;
++        };
++
++        return std::make_shared<mf::SessionMediator>(
++            shell, mt::fake_shared(mock_ipc_operations), graphics_changer,
++            surface_pixel_formats, report,
++            std::make_shared<EventSinkFactory>(sink),
++            std::make_shared<mtd::NullMessageSender>(),
++            resource_cache, stub_screencast, &connector, nullptr,
++            std::make_shared<NullCoordinateTranslator>(),
++            std::make_shared<mtd::NullANRDetector>(),
++            mir::cookie::Authority::create(),
++            mt::fake_shared(mock_input_config_changer),
++            std::vector<mir::ExtensionDescription>{},
++            allocator);
+     }
      MockConnector connector;
@@ -339,6 +461,7 @@
      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;
      mf::SessionMediator mediator;
      mp::ConnectParameters connect_parameters;
@@ -383,7 +506,8 @@
          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};
      EXPECT_THAT(connects_handled_count, Eq(0));
@@ -413,21 +537,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,15 +810,20 @@
      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 sink = std::make_shared<NiceMock<mtd::MockEventSink>>();
++    auto mediator = create_session_mediator_with_event_sink(sink);
++
++    mediator->connect(&connect_parameters, &connection, null_callback.get());
++    mediator->create_surface(&surface_parameters, &surface_response, null_callback.get());
++
      auto num_requests = 3;
      mp::Void null;
--    mp::BufferStreamId id;
--    id.set_value(0);
      mp::BufferAllocation request;
--    *request.mutable_id() = id;
++    *request.mutable_id() = surface_response.buffer_stream().id();
      mg::BufferProperties properties(geom::Size{34, 84}, mir_pixel_format_abgr_8888, mg::BufferUsage::hardware);
      for(auto i = 0; i < num_requests; i++)
+     {
@@ -720,58 +834,79 @@
          buffer_request->set_buffer_usage((int)properties.usage);
+     }
--    mediator.connect(&connect_parameters, &connection, null_callback.get());
--    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_CALL(*sink, add_buffer(_)).Times(num_requests);
++    EXPECT_CALL(*sink, error_buffer(_,_,_)).Times(0);
++    mediator->allocate_buffers(&request, &null, null_callback.get());
++    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;
++
++    auto sink = std::make_shared<NiceMock<mtd::MockEventSink>>();
++    auto mediator = create_session_mediator_with_event_sink(sink);
++
++    mediator->connect(&connect_parameters, &connection, null_callback.get());
++    mediator->create_surface(&surface_parameters, &surface_response, null_callback.get());
++
      geom::Size const size { 1029, 10302 };
      auto native_flags = 24u;
      auto native_format = 124u;
      mp::Void null;
--    mp::BufferStreamId id;
--    id.set_value(0);
      mp::BufferAllocation request;
--    *request.mutable_id() = id;
++    *request.mutable_id() = surface_response.buffer_stream().id();
      auto buffer_request = request.add_buffer_requests();
      buffer_request->set_width(size.width.as_int());
      buffer_request->set_height(size.height.as_int());
      buffer_request->set_native_format(native_format);
      buffer_request->set_flags(native_flags);
--    mediator.connect(&connect_parameters, &connection, null_callback.get());
--    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_CALL(*sink, add_buffer(_)).Times(1);
++    EXPECT_CALL(*sink, error_buffer(_,_,_)).Times(0);
++    mediator->allocate_buffers(&request, &null, null_callback.get());
++    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 +996,8 @@
          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};
      ON_CALL(*shell, create_surface( _, _, _))
          .WillByDefault(
@@ -1022,22 +1158,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 +1209,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 +1241,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 +1348,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 +1363,180 @@
      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());
+ }
++
++namespace
++{
++void add_software_buffer_request(
++    mp::BufferAllocation& request,
++    int width,
++    int height,
++    MirPixelFormat format)
++{
++    auto buffer_request = request.add_buffer_requests();
++    buffer_request->set_width(width);
++    buffer_request->set_height(height);
++    buffer_request->set_pixel_format(format);
++    buffer_request->set_buffer_usage(static_cast<int>(mg::BufferUsage::software));
++}
++
++void add_hardware_request(
++    mp::BufferAllocation& request,
++    int width,
++    int height,
++    int native_format,
++    int flags)
++{
++    auto buffer_request = request.add_buffer_requests();
++
++    buffer_request->set_width(width);
++    buffer_request->set_height(height);
++    buffer_request->set_native_format(native_format);
++    buffer_request->set_flags(flags);
++}
++}
++
++TEST_F(SessionMediator, invalid_buffer_stream_in_software_buffer_allocation_sends_only_error_buffer)
++{
++    using namespace testing;
++
++    auto sink = std::make_shared<NiceMock<mtd::MockEventSink>>();
++    auto mediator = create_session_mediator_with_event_sink(sink);
++
++    mediator->connect(&connect_parameters, &connection, null_callback.get());
++
++    auto num_requests = 3;
++    mp::Void null;
++    mp::BufferAllocation request;
++    request.mutable_id()->set_value(-1);
++    mg::BufferProperties properties(geom::Size{34, 84}, mir_pixel_format_abgr_8888, mg::BufferUsage::software);
++    for(auto i = 0; i < num_requests; i++)
++    {
++        add_software_buffer_request(
++            request,
++            properties.size.width.as_int(),
++            properties.size.height.as_int(),
++            properties.format);
++    }
++
++    EXPECT_CALL(*sink, add_buffer(_)).Times(0);
++    EXPECT_CALL(*sink, error_buffer(_,_,_)).Times(num_requests);
++    mediator->allocate_buffers(&request, &null, null_callback.get());
++    EXPECT_THAT(allocator->allocated_buffers.size(), Eq(num_requests));
++}
++
++TEST_F(SessionMediator, invalid_request_sends_error_buffer)
++{
++    using namespace testing;
++
++    auto sink = std::make_shared<NiceMock<mtd::MockEventSink>>();
++    auto mediator = create_session_mediator_with_event_sink(sink);
++
++    mediator->connect(&connect_parameters, &connection, null_callback.get());
++    mediator->create_surface(&surface_parameters, &surface_response, null_callback.get());
++
++    mp::Void null;
++    mp::BufferAllocation request;
++    *request.mutable_id() = surface_response.buffer_stream().id();
++
++    decltype(request.add_buffer_requests()) buffer_request;
++
++    // Loop through all possibilities of has_flags, has_native_format,
++    // has_buffer_usage, has_pixel_format
++    for (int i = 0 ; i < 1<<4; ++i)
++    {
++        buffer_request = request.add_buffer_requests();
++        buffer_request->set_width(1024);
++        buffer_request->set_height(768);
++
++        if (i & 1<<0)
++            buffer_request->set_flags(0xfaac);
++        if (i & 1<<1)
++            buffer_request->set_native_format(0xdeeb);
++        if (i & 1<<2)
++            buffer_request->set_pixel_format(mir_pixel_format_abgr_8888);
++        if (i & 1<<3)
++            buffer_request->set_buffer_usage(static_cast<int>(mg::BufferUsage::software));
++    }
++
++    // There are two valid allocations here - one with flags and native_format set,
++    // one with pixel_format and buffer_usage set.
++    EXPECT_CALL(*sink, add_buffer(_)).Times(2);
++
++    EXPECT_CALL(*sink, error_buffer(_,_,_)).Times(16 - 2);
++    mediator->allocate_buffers(&request, &null, null_callback.get());
++    EXPECT_THAT(allocator->allocated_buffers.size(), Eq(2));
++}
++
++TEST_F(SessionMediator, sends_errors_only_for_invalid_buffer_parameters)
++{
++    using namespace testing;
++
++    auto sink = std::make_shared<NiceMock<mtd::MockEventSink>>();
++    auto mediator = create_session_mediator_with_event_sink(sink);
++
++    mediator->connect(&connect_parameters, &connection, null_callback.get());
++    mediator->create_surface(&surface_parameters, &surface_response, null_callback.get());
++
++    auto const num_requests = 3;
++    mp::Void null;
++    mp::BufferAllocation request;
++    *request.mutable_id() = surface_response.buffer_stream().id();
++    mg::BufferProperties properties(geom::Size{34, 84}, mir_pixel_format_abgr_8888, mg::BufferUsage::software);
++    for(auto i = 0; i < num_requests; i++)
++    {
++        add_software_buffer_request(
++            request,
++            properties.size.width.as_int(),
++            properties.size.height.as_int(),
++            properties.format);
++    }
++
++    // Make the 2nd buffer request invalid, leaving the 1st and 3rd valid
++    request.mutable_buffer_requests(1)->set_pixel_format(mir_pixel_format_invalid);
++
++    EXPECT_CALL(*sink, add_buffer(_)).Times(num_requests - 1);
++    EXPECT_CALL(*sink, error_buffer(_,_,_)).Times(1);
++    mediator->allocate_buffers(&request, &null, null_callback.get());
++    EXPECT_THAT(allocator->allocated_buffers.size(), Eq(num_requests - 1));
++}
++
++TEST_F(SessionMediator, invalid_buffer_stream_in_native_buffer_allocation_sends_only_error_buffer)
++{
++    using namespace testing;
++
++    auto const num_requests = 3;
++
++    auto sink = std::make_shared<NiceMock<mtd::MockEventSink>>();
++    auto mediator = create_session_mediator_with_event_sink(sink);
++
++    mediator->connect(&connect_parameters, &connection, null_callback.get());
++
++    geom::Size const size { 1029, 10302 };
++    auto native_flags = 24u;
++    auto native_format = 124u;
++    mp::Void null;
++    mp::BufferAllocation request;
++    request.mutable_id()->set_value(42);
++
++    for (auto i = 0; i < num_requests; ++i)
++    {
++        add_hardware_request(
++            request,
++            size.width.as_int(),
++            size.height.as_int(),
++            native_format,
++            native_flags);
++    }
++
++    EXPECT_CALL(*sink, add_buffer(_)).Times(0);
++    EXPECT_CALL(*sink, error_buffer(_,_,_)).Times(num_requests);
++    mediator->allocate_buffers(&request, &null, null_callback.get());
++    // We don't much care if the buffers were allocated and then freed or never allocated
++    EXPECT_THAT(
++        allocator->allocated_buffers,
++        Each(Property(&std::weak_ptr<mg::Buffer>::expired, Eq(true))));
++}
 === 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-19 05:46:21 +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-19 05:46:21 +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"),

Mir

Merge lp:~raof/mir/better-buffer-plumbing into lp:mir

Commit message

Description of the change

Preview Diff

Subscribers