Mir

Merge lp:~kdub/mir/require-streams-when-creating-surface into lp:mir

require-streams-when-creating-surface
Merge into development-branch

Proposed by Kevin DuBois on 2016-03-30

Status:	Merged
Approved by:	Alan Griffiths on 2016-04-12
Approved revision:	no longer in the source branch.
Merged at revision:	3453
Proposed branch:	lp:~kdub/mir/require-streams-when-creating-surface
Merge into:	lp:mir
Prerequisite:	lp:~kdub/mir/deprecate-next-buffer
Diff against target:	1228 lines (+343/-184) 16 files modified examples/server_example_canonical_window_manager.cpp (+9/-3) examples/server_example_window_management_info.h (+1/-0) include/server/mir/scene/surface_creation_parameters.h (+1/-0) src/client/mir_connection.cpp (+17/-1) src/protobuf/mir_protobuf.proto (+1/-0) src/server/frontend/buffer_stream_tracker.cpp (+24/-0) src/server/frontend/buffer_stream_tracker.h (+7/-0) src/server/frontend/session_mediator.cpp (+66/-18) src/server/scene/application_session.cpp (+31/-27) src/server/scene/application_session.h (+2/-0) tests/integration-tests/session_management.cpp (+7/-2) tests/integration-tests/test_session.cpp (+5/-1) tests/unit-tests/frontend/test_session_mediator.cpp (+40/-56) tests/unit-tests/scene/test_abstract_shell.cpp (+47/-21) tests/unit-tests/scene/test_application_session.cpp (+80/-54) tests/unit-tests/scene/test_session_manager.cpp (+5/-1)
To merge this branch:	bzr merge lp:~kdub/mir/require-streams-when-creating-surface
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration		Approve on 2016-04-12
Andreas Pokorny (community)			Approve on 2016-04-12
Cemil Azizoglu (community)			Approve on 2016-04-12
Brandon Schaefer (community)		2016-03-30	Approve on 2016-04-06
Review via email: mp+290484@code.launchpad.net

Commit message

shell: no longer auto-create a 'default stream' on behalf of user creating a surface without specifying a stream. Session::create_surface() was creating two resources, and we were kludging around this by casting the mf::SurfaceId it returns to a mf::BufferStreamId, and assuming that the stream was created.

Now, BufferStreamId and SurfaceId are independent id sequences (whereas previously, every SurfaceId was a BufferStreamId, but not vice-versa)

We got into the situation where create_surface() creates a stream and a surface when we split the stream concept from the surface concept a long time ago. Now that we want to create more elaborate stream configurations at startup (see lp: #1563278), we should just have the user tell us what they want via SurfaceCreationParameters instead of guessing and trying to compensate with an automatically created stream.

Its currently necessary to have some content with a Surface (due to existing interfaces that need changing), but soon enough we could probably have content-less surfaces, if that's useful anywhere...

Downstreams (usc/qtmir) are not using Session to create their own surfaces apart from actual ipc clients, so although its an ABI break, they should be compatible.

Description of the change

Its currently necessary to have some content with a Surface (due to existing interfaces that need changing), but soon enough we could probably have content-less surfaces, if that's useful anywhere...

Downstreams (usc/qtmir) are not using Session to create their own surfaces apart from actual ipc clients, so although its an ABI break, they should be compatible.

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-31:

FAILED: Continuous integration, rev:3440
https://mir-jenkins.ubuntu.com/job/mir-ci/701/
Executed test runs:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-31:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-01:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-04-01:

conflict

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-01:

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

review: Approve (continuous-integration)

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-05:

Nit. Couldnt a_surface() take a mir::graphics::BufferProperties? Since we use all the same arguments in both. Such as of_buffer_properties(...) or something... though either way we have to use those values twice :)
+ auto params = ms::a_surface()

Dont see this namespace used in the header.
+class Session;

Shared ptr are defaulted to a nullptr, no need to set it.
+ std::shared_ptr<mf::BufferStream> legacy_stream = nullptr;

// /usr/include/c++/5/tr1/shared_ptr.h:546
      __shared_ptr()
      : _M_ptr(0), _M_refcount() // never throws
      { }

This could be a bit simpler, as you have right now:
!(A || (B && C))
This could turn into:
!A && (B || C)

(wanted to do a truth table just to check haha: http://paste.ubuntu.com/15635820/)

Not super sure if its *simpler* just reads a bit easier :)

+ if (!((the_params.content_id.is_set()) ||
+ (the_params.streams.is_set() && the_params.streams.value().size() > 0

Would turn into:

if (!the_params.content_id.is_set() && (the_params.streams.is_set() || the_params.streams.value().size() > 0))

Up to you :)

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-04-06:

> Nit. Couldnt a_surface() take a mir::graphics::BufferProperties? Since we use
> all the same arguments in both. Such as of_buffer_properties(...) or
> something... though either way we have to use those values twice :)
> + auto params = ms::a_surface()
>

Surfaces don't really have pixel_format and usage, these are really just properties of buffers. (although surfaces do have pf/usage fields still from un-cleaned-up cruft).

> Dont see this namespace used in the header.
> +class Session;
This is needed in the remove_content_for() function added to the header

> Shared ptr are defaulted to a nullptr, no need to set it.
> + std::shared_ptr<mf::BufferStream> legacy_stream = nullptr;
>
> // /usr/include/c++/5/tr1/shared_ptr.h:546
> __shared_ptr()
> : _M_ptr(0), _M_refcount() // never throws
> { }

fixed

> This could be a bit simpler, as you have right now:
> !(A || (B && C))
> This could turn into:
> !A && (B || C)
>
> (wanted to do a truth table just to check haha:
> http://paste.ubuntu.com/15635820/)
>
> Not super sure if its *simpler* just reads a bit easier :)
>

Line 6 in the pastebin isn't correct. (the original expression is not computed correctly, the new expression is)

The expression could be reduced I suppose:
!(A || (B && C))
to
!A && !(B && C)
to
!A && (!B || !C)

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-06:

Opps youre right! (Dang truth table :).

LGTM

review: Approve

Revision history for this message

Cemil Azizoglu (cemil-azizoglu) wrote on 2016-04-07:

The name added_streams is a bit confusing since streams may later be removed as well. How about just calling it 'streams'.
180 + std::unordered_map<SurfaceId, frontend::BufferStreamId> added_streams;
-------------------

We should just call them add_buffer_stream_for() and remove_buffer_stream_for() instead of
170 + void add_content_for(frontend::SurfaceId id, frontend::BufferStreamId);
171 + void remove_content_for(frontend::SurfaceId, frontend::Session&);

review: Needs Fixing

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-04-11:

Hm. Why does the BufferStream Tracker care about the frontend::Session in the remove_content_for method. It seems unbalanced in comparison to the add call. Correct me if I got the wrong picture..

Otherwise it looks fine

review: Needs Information

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-11:

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

review: Approve (continuous-integration)

Revision history for this message

Cemil Azizoglu (cemil-azizoglu) wrote on 2016-04-12:

review: Approve

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-04-12:

Ok my needs info is gone ..

review: Approve

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-04-12:

noticed that (for consistency's sake) we should throw when trying to delete a bufferstream that doesnt exist. will fix in this MP before TA.

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-12:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2016-04-12:

I've a feeling this has been seen before, but I can't find the bug...

14:41:46 11: /��BUILDDIR��/mir-0.22.0+xenial846bzr3447/tests/acceptance-tests/test_nested_mir.cpp:1076: Failure
14:41:46 11: Value of: client_config_changed.raised()
14:41:46 11: Actual: false
14:41:46 11: Expected: true
14:41:46 11: [2016-04-12 14:41:46.324381] mirserver: Stopping
14:41:46 11: [2016-04-12 14:41:46.602429] mirserver: Stopping
14:41:46 11: [ FAILED ] NestedServer.when_monitor_plugged_in_client_is_notified_of_new_display_configuration (4453 ms)

Revision history for this message

Mir CI Bot (mir-ci-bot) on 2016-04-12:

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:

Emanuele Antonio Faraone

Gerry Boland

Kevin DuBois

Mir development team

 === modified file 'examples/server_example_canonical_window_manager.cpp'
 --- examples/server_example_canonical_window_manager.cpp	2016-04-05 11:59:12 +0000
 +++ examples/server_example_canonical_window_manager.cpp	2016-04-12 14:23:09 +0000
@@ -251,13 +251,17 @@
          return;
      auto format = mir_pixel_format_xrgb_8888;
--    ms::SurfaceCreationParameters params;
--    params.of_size(titlebar_size_for_window(surface->size()))
++    mir::graphics::BufferProperties properties(titlebar_size_for_window(surface->size()),
++        format, mir::graphics::BufferUsage::software);
++    auto stream_id = session->create_buffer_stream(properties);
++    auto params = ms::a_surface()
++        .of_size(titlebar_size_for_window(surface->size()))
          .of_name("decoration")
          .of_pixel_format(format)
          .of_buffer_usage(mir::graphics::BufferUsage::software)
          .of_position(titlebar_position_for_window(surface->top_left()))
--        .of_type(mir_surface_type_gloss);
++        .of_type(mir_surface_type_gloss)
++        .with_buffer_stream(stream_id);
      auto id = build(session, params);
      auto titlebar = session->surface(id);
      titlebar->set_alpha(0.9);
@@ -265,6 +269,7 @@
      auto& surface_info = tools->info_for(surface);
      surface_info.titlebar = titlebar;
      surface_info.titlebar_id = id;
++    surface_info.titlebar_stream_id = stream_id;
      surface_info.children.push_back(titlebar);
      SurfaceInfo& titlebar_info =
@@ -437,6 +442,7 @@
      if (info.titlebar)
+     {
          session->destroy_surface(info.titlebar_id);
++        session->destroy_buffer_stream(info.titlebar_stream_id);
          tools->forget(info.titlebar);
+     }
 === modified file 'examples/server_example_window_management_info.h'
 --- examples/server_example_window_management_info.h	2016-01-29 08:18:22 +0000
 +++ examples/server_example_window_management_info.h	2016-04-12 14:23:09 +0000
@@ -65,6 +65,7 @@
      std::vector <std::weak_ptr<scene::Surface>> children;
      std::shared_ptr <scene::Surface> titlebar;
      frontend::SurfaceId titlebar_id;
++    frontend::BufferStreamId titlebar_stream_id;
      bool is_titlebar = false;
      geometry::Width min_width;
      geometry::Height min_height;
 === modified file 'include/server/mir/scene/surface_creation_parameters.h'
 --- include/server/mir/scene/surface_creation_parameters.h	2016-01-29 08:18:22 +0000
 +++ include/server/mir/scene/surface_creation_parameters.h	2016-04-12 14:23:09 +0000
@@ -101,6 +101,7 @@
      mir::optional_value<std::vector<geometry::Rectangle>> input_shape;
      mir::optional_value<MirShellChrome> shell_chrome;
++    mir::optional_value<std::vector<shell::StreamSpecification>> streams;
  };
  bool operator==(const SurfaceCreationParameters& lhs, const SurfaceCreationParameters& rhs);
 === modified file 'src/client/mir_connection.cpp'
 --- src/client/mir_connection.cpp	2016-03-23 06:39:56 +0000
 +++ src/client/mir_connection.cpp	2016-04-12 14:23:09 +0000
@@ -172,6 +172,22 @@
+         }
+     }
++    if (spec.streams.is_set())
++    {
++        for(auto const& stream : spec.streams.value())
++        {
++            auto const new_stream = message.add_stream();
++            new_stream->set_displacement_x(stream.displacement.dx.as_int());
++            new_stream->set_displacement_y(stream.displacement.dy.as_int());
++            new_stream->mutable_id()->set_value(stream.stream_id);
++            if (stream.size.is_set())
++            {
++                new_stream->set_width(stream.size.value().width.as_int());
++                new_stream->set_height(stream.size.value().height.as_int());
++            }
++        }
++    }
++
      return message;
+ }
@@ -400,7 +416,7 @@
              this, server, &debug, stream, input_platform, spec, *surface_proto, request->wh);
          surface_map->insert(mf::SurfaceId{surface_proto->id().value()}, surf);
--        surface_map->insert(mf::BufferStreamId{surface_proto->id().value()}, stream);
++        surface_map->insert(mf::BufferStreamId{surface_proto->buffer_stream().id().value()}, stream);
+     }
      callback(surf.get(), context);
 === modified file 'src/protobuf/mir_protobuf.proto'
 --- src/protobuf/mir_protobuf.proto	2016-03-23 06:39:56 +0000
 +++ src/protobuf/mir_protobuf.proto	2016-04-12 14:23:09 +0000
@@ -39,6 +39,7 @@
    optional PersistentSurfaceId parent_persistent_id = 21;
    repeated Rectangle input_shape = 22;
    optional int32 shell_chrome = 24;
++  repeated StreamConfiguration stream = 25;
+ }
  message SurfaceAspectRatio
 === modified file 'src/server/frontend/buffer_stream_tracker.cpp'
 --- src/server/frontend/buffer_stream_tracker.cpp	2015-06-17 05:20:42 +0000
 +++ src/server/frontend/buffer_stream_tracker.cpp	2016-04-12 14:23:09 +0000
@@ -21,6 +21,7 @@
  #include "mir/graphics/buffer.h"
  #include "mir/graphics/buffer_id.h"
++#include "mir/frontend/session.h"
  #include <boost/throw_exception.hpp>
  #include <stdexcept>
@@ -93,3 +94,26 @@
+     }
      BOOST_THROW_EXCEPTION(std::logic_error("Buffer is not tracked"));
+ }
++
++void mf::BufferStreamTracker::set_default_stream(mf::SurfaceId id, mf::BufferStreamId content)
++{
++    std::lock_guard<decltype(mutex)> lock{mutex};
++    default_streams[id] = content;
++}
++
++mir::optional_value<mf::BufferStreamId> mf::BufferStreamTracker::default_stream(mf::SurfaceId id)
++{
++    std::lock_guard<decltype(mutex)> lock{mutex};
++    auto it = default_streams.find(id);
++    if (it != default_streams.end())
++        return it->second;
++    return {};
++}
++
++void mf::BufferStreamTracker::remove_default_stream(mf::SurfaceId id)
++{
++    std::lock_guard<decltype(mutex)> lock{mutex};
++    auto it = default_streams.find(id);
++    if (it != default_streams.end())
++        default_streams.erase(it);
++}
 === modified file 'src/server/frontend/buffer_stream_tracker.h'
 --- src/server/frontend/buffer_stream_tracker.h	2015-06-17 05:20:42 +0000
 +++ src/server/frontend/buffer_stream_tracker.h	2016-04-12 14:23:09 +0000
@@ -19,8 +19,10 @@
  #ifndef MIR_FRONTEND_BUFFER_STREAM_TRACKER_H_
  #define MIR_FRONTEND_BUFFER_STREAM_TRACKER_H_
++#include "mir/frontend/surface_id.h"
  #include "mir/frontend/buffer_stream_id.h"
  #include "mir/graphics/buffer_id.h"
++#include "mir/optional_value.h"
  #include <unordered_map>
  #include <memory>
@@ -56,6 +58,10 @@
      /* Access the buffer resource that the id corresponds to. */
      graphics::Buffer* buffer_from(graphics::BufferID) const;
++    void set_default_stream(frontend::SurfaceId id, frontend::BufferStreamId);
++    optional_value<BufferStreamId> default_stream(SurfaceId id);
++    void remove_default_stream(frontend::SurfaceId);
++
  private:
      size_t const client_cache_size;
      std::unordered_map<BufferStreamId, std::shared_ptr<ClientBufferTracker>> client_buffer_tracker;
@@ -67,6 +73,7 @@
  private:
      mutable std::mutex mutex;
      std::unordered_map<BufferStreamId, graphics::Buffer*> client_buffer_resource;
++    std::unordered_map<SurfaceId, frontend::BufferStreamId> default_streams;
  };
+ }
 === modified file 'src/server/frontend/session_mediator.cpp'
 --- src/server/frontend/session_mediator.cpp	2016-04-05 03:47:49 +0000
 +++ src/server/frontend/session_mediator.cpp	2016-04-12 14:23:09 +0000
@@ -286,6 +286,40 @@
      #undef COPY_IF_SET
++    mf::BufferStreamId buffer_stream_id;
++    std::shared_ptr<mf::BufferStream> legacy_stream = nullptr;
++    if (request->stream_size() > 0)
++    {
++        std::vector<msh::StreamSpecification> stream_spec;
++        for (auto& stream : request->stream())
++        {
++            if (stream.has_width() && stream.has_height())
++            {
++                stream_spec.emplace_back(
++                    msh::StreamSpecification{
++                        mf::BufferStreamId{stream.id().value()},
++                        geom::Displacement{stream.displacement_x(), stream.displacement_y()},
++                        geom::Size{stream.width(), stream.height()}});
++            }
++            else
++            {
++                stream_spec.emplace_back(
++                    msh::StreamSpecification{
++                        mf::BufferStreamId{stream.id().value()},
++                        geom::Displacement{stream.displacement_x(), stream.displacement_y()},
++                        {}});
++            }
++        }
++        params.streams = std::move(stream_spec);
++    }
++    else
++    {
++        buffer_stream_id = session->create_buffer_stream(
++            {params.size, params.pixel_format, params.buffer_usage});
++        legacy_stream = session->get_buffer_stream(buffer_stream_id);
++        params.content_id = buffer_stream_id;
++    }
++
      if (request->has_min_aspect())
          params.min_aspect = { request->min_aspect().width(), request->min_aspect().height()};
@@ -298,10 +332,9 @@
      std::shared_ptr<mf::EventSink> sink = sink_factory->create_sink(buffering_sender);
      auto const surf_id = shell->create_surface(session, params, sink);
--    auto stream_id = mf::BufferStreamId(surf_id.as_value());
      auto surface = session->get_surface(surf_id);
--    auto stream = session->get_buffer_stream(stream_id);
++    auto stream = session->get_buffer_stream(buffer_stream_id);
      auto const& client_size = surface->client_size();
      response->mutable_id()->set_value(surf_id.as_value());
      response->set_width(client_size.width.as_uint32_t());
@@ -326,21 +359,29 @@
          setting->set_ivalue(shell->get_surface_attribute(session, surf_id, static_cast<MirSurfaceAttrib>(i)));
+     }
--    advance_buffer(stream_id, *stream, buffer_stream_tracker.last_buffer(stream_id),
--        [this, buffering_sender, surf_id, response, done, session]
--        (graphics::Buffer* client_buffer, graphics::BufferIpcMsgType msg_type)
--        {
--            response->mutable_buffer_stream()->mutable_id()->set_value(surf_id.as_value());
--            if (client_buffer)
--                pack_protobuf_buffer(*response->mutable_buffer_stream()->mutable_buffer(), client_buffer, msg_type);
--
--
--            // Send the create_surface reply first...
--            done->Run();
--
--            // ...then uncork the message sender, sending all buffered surface events.
--            buffering_sender->uncork();
--        });
++    if (legacy_stream)
++    {
++        buffer_stream_tracker.set_default_stream(surf_id, buffer_stream_id);
++        response->mutable_buffer_stream()->mutable_id()->set_value(buffer_stream_id.as_value());
++        advance_buffer(buffer_stream_id, *legacy_stream, buffer_stream_tracker.last_buffer(buffer_stream_id),
++            [this, buffering_sender, response, done, session]
++            (graphics::Buffer* client_buffer, graphics::BufferIpcMsgType msg_type)
++            {
++                if (client_buffer)
++                    pack_protobuf_buffer(*response->mutable_buffer_stream()->mutable_buffer(), client_buffer, msg_type);
++
++                // Send the create_surface reply first...
++                done->Run();
++
++                // ...then uncork the message sender, sending all buffered surface events.
++                buffering_sender->uncork();
++            });
++    }
++    else
++    {
++        done->Run();
++        buffering_sender->uncork();
++    }
+ }
  void mf::SessionMediator::exchange_buffer(
@@ -469,7 +510,14 @@
      auto const id = SurfaceId(request->value());
      shell->destroy_surface(session, id);
--    buffer_stream_tracker.remove_buffer_stream(BufferStreamId(request->value()));
++
++    auto default_stream = buffer_stream_tracker.default_stream(id);
++    if (default_stream.is_set())
++    {
++        session->destroy_buffer_stream(default_stream.value());
++        buffer_stream_tracker.remove_buffer_stream(default_stream.value());
++        buffer_stream_tracker.remove_default_stream(id);
++    }
      // TODO: We rely on this sending responses synchronously.
      done->Run();
 === modified file 'src/server/scene/application_session.cpp'
 --- src/server/scene/application_session.cpp	2016-04-06 08:44:01 +0000
 +++ src/server/scene/application_session.cpp	2016-04-12 14:23:09 +0000
@@ -90,27 +90,31 @@
      std::shared_ptr<mf::EventSink> const& surface_sink)
+ {
      auto const id = next_id();
--    mf::BufferStreamId const stream_id{the_params.content_id.is_set() ?
--        the_params.content_id.value().as_value() : id.as_value()};
++
++    //TODO: we take either the content_id or the first streams content for now.
++    //      Once the surface factory interface takes more than one stream,
++    //      we can take all the streams as content.
++    if (!((the_params.content_id.is_set()) ||
++          (the_params.streams.is_set() && the_params.streams.value().size() > 0)))
++    {
++        BOOST_THROW_EXCEPTION(std::logic_error("surface must have content"));
++    }
      auto params = the_params;
++    mf::BufferStreamId stream_id;
++    if (params.content_id.is_set())
++        stream_id = params.content_id.value();
++    else
++        stream_id = params.streams.value()[0].stream_id;
++
      if (params.parent_id.is_set())
          params.parent = checked_find(the_params.parent_id.value())->second;
--    std::shared_ptr<compositor::BufferStream> buffer_stream;
--    if (params.content_id.is_set())
--    {
--        buffer_stream = checked_find(params.content_id.value())->second;
--    }
--    else
--    {
--        mg::BufferProperties buffer_properties{params.size,
--                                               params.pixel_format,
--                                               params.buffer_usage};
--        buffer_stream = buffer_stream_factory->create_buffer_stream(
--            stream_id, surface_sink, buffer_properties);
--    }
++    auto buffer_stream = checked_find(params.content_id.value())->second;
++    if (params.size != buffer_stream->stream_size())
++        buffer_stream->resize(params.size);
++
      auto surface = surface_factory->create_surface(buffer_stream, params);
      surface_stack->add_surface(surface, params.input_mode);
@@ -133,7 +137,7 @@
+     {
          std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
          surfaces[id] = surface;
--        streams[stream_id] = buffer_stream;
++        default_content_map[id] = stream_id;
+     }
      observer->moved_to(surface->top_left());
@@ -154,7 +158,7 @@
+ {
      auto p = streams.find(id);
      if (p == streams.end())
--        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SurfaceId"));
++        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid BufferStreamId"));
      return p;
+ }
@@ -220,7 +224,7 @@
+     {
          if (default_surface() == surface_it.second)
+         {
--            auto id = mf::BufferStreamId(surface_it.first.as_value());
++            auto id = default_content_map[surface_it.first];
              snapshot_strategy->take_snapshot_of(checked_find(id)->second, snapshot_taken);
              return;
+         }
@@ -360,7 +364,12 @@
  void ms::ApplicationSession::destroy_buffer_stream(mf::BufferStreamId id)
+ {
      std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
--    streams.erase(checked_find(id));
++    auto stream_it = streams.find(mir::frontend::BufferStreamId(id.as_value()));
++    if (stream_it == streams.end())
++        BOOST_THROW_EXCEPTION(std::runtime_error("cannot destroy stream: Invalid BufferStreamId"));
++
++    stream_it->second->drop_outstanding_requests();
++    streams.erase(stream_it);
+ }
  void ms::ApplicationSession::configure_streams(
@@ -391,17 +400,12 @@
  void ms::ApplicationSession::destroy_surface(std::unique_lock<std::mutex>& lock, Surfaces::const_iterator in_surfaces)
+ {
      auto const surface = in_surfaces->second;
--    auto const id = in_surfaces->first;
--
++    auto it = default_content_map.find(in_surfaces->first);
      session_listener->destroying_surface(*this, surface);
      surfaces.erase(in_surfaces);
--    auto stream_it = streams.find(mir::frontend::BufferStreamId(id.as_value()));
--    if (stream_it != streams.end())
--    {
--        stream_it->second->drop_outstanding_requests();
--        streams.erase(stream_it);
--    }
++    if (it != default_content_map.end())
++        default_content_map.erase(it);
      lock.unlock();
 === modified file 'src/server/scene/application_session.h'
 --- src/server/scene/application_session.h	2016-04-06 08:44:01 +0000
 +++ src/server/scene/application_session.h	2016-04-12 14:23:09 +0000
@@ -126,6 +126,8 @@
      Surfaces surfaces;
      Streams streams;
++    std::map<frontend::SurfaceId, frontend::BufferStreamId> default_content_map;
++
      void destroy_surface(std::unique_lock<std::mutex>& lock, Surfaces::const_iterator in_surfaces);
  };
 === modified file 'tests/integration-tests/session_management.cpp'
 --- tests/integration-tests/session_management.cpp	2016-01-29 08:18:22 +0000
 +++ tests/integration-tests/session_management.cpp	2016-04-12 14:23:09 +0000
@@ -95,8 +95,6 @@
      std::shared_ptr<mf::EventSink> const event_sink = std::make_shared<mtd::NullEventSink>();
      std::shared_ptr<mf::Shell> const session_manager = builder.the_frontend_shell();
      std::shared_ptr<TestSurfaceStack> const& test_surface_stack = builder.test_surface_stack;
--    ms::SurfaceCreationParameters const params = ms::SurfaceCreationParameters().of_size(100,100).of_type(mir_surface_type_normal);
--
      void SetUp()
+     {
          ASSERT_THAT(test_surface_stack, Ne(nullptr));
@@ -117,6 +115,13 @@
+ {
      auto const session = session_manager->open_session(0, __PRETTY_FUNCTION__, event_sink);
++    mir::graphics::BufferProperties properties(
++        mir::geometry::Size{1,1}, mir_pixel_format_abgr_8888, mir::graphics::BufferUsage::software);
++    ms::SurfaceCreationParameters const params = ms::SurfaceCreationParameters()
++        .of_size(100,100)
++        .of_type(mir_surface_type_normal)
++        .with_buffer_stream(session->create_buffer_stream(properties));
++
      EXPECT_CALL(*test_surface_stack, add_surface(_,_)).Times(1);
      session_manager->create_surface(session, params, event_sink);
+ }
 === modified file 'tests/integration-tests/test_session.cpp'
 --- tests/integration-tests/test_session.cpp	2016-01-29 08:18:22 +0000
 +++ tests/integration-tests/test_session.cpp	2016-04-12 14:23:09 +0000
@@ -126,7 +126,11 @@
          mtd::StubDisplayConfig{},
          std::make_shared<mtd::NullEventSink>()
      };
--    session.create_surface(ms::a_surface(), std::make_shared<mtd::NullEventSink>());
++
++    mg::BufferProperties properties(geom::Size{1,1}, mir_pixel_format_abgr_8888, mg::BufferUsage::software);
++    session.create_surface(
++        ms::a_surface().with_buffer_stream(session.create_buffer_stream(properties)),
++        std::make_shared<mtd::NullEventSink>());
      auto compositor = conf.the_compositor();
 === modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
 --- tests/unit-tests/frontend/test_session_mediator.cpp	2016-04-05 03:47:49 +0000
 +++ tests/unit-tests/frontend/test_session_mediator.cpp	2016-04-12 14:23:09 +0000
@@ -111,11 +111,6 @@
  class StubbedSession : public mtd::StubSession
+ {
  public:
--    StubbedSession() :
--        last_surface_id{0}
--    {
--    }
--
      std::shared_ptr<mf::Surface> get_surface(mf::SurfaceId surface) const
+     {
          if (mock_surfaces.find(surface) == mock_surfaces.end())
@@ -126,7 +121,7 @@
      std::shared_ptr<mf::BufferStream> get_buffer_stream(mf::BufferStreamId stream) const override
+     {
          if (mock_streams.find(stream) == mock_streams.end())
--            BOOST_THROW_EXCEPTION(std::logic_error("Invalid SurfaceId"));
++            BOOST_THROW_EXCEPTION(std::logic_error("Invalid StreamId"));
          return mock_streams.at(stream);
+     }
@@ -137,43 +132,37 @@
          return mock_surfaces.at(id);
+     }
--    std::shared_ptr<mtd::MockBufferStream> mock_primary_stream_at(mf::SurfaceId id)
++    std::shared_ptr<mtd::MockBufferStream> mock_stream_at(mf::BufferStreamId id)
+     {
--        if (mock_surfaces.end() == mock_surfaces.find(id))
--            create_mock_surface(id);
--        return mock_streams.at(mf::BufferStreamId(id.as_value()));
++        if (mock_streams.end() == mock_streams.find(id))
++            return create_mock_stream(id);
++        return mock_streams.at(id);
+     }
      std::shared_ptr<mtd::MockFrontendSurface> create_mock_surface(mf::SurfaceId id)
+     {
          using namespace testing;
++        mg::BufferProperties properties;
++        create_buffer_stream(properties);
          auto surface = std::make_shared<testing::NiceMock<mtd::MockFrontendSurface>>(testing_client_input_fd);
--        auto stream = std::make_shared<testing::NiceMock<mtd::MockBufferStream>>();
++        mock_surfaces[id] = surface;
++        return surface;
++    }
++    std::shared_ptr<mtd::MockBufferStream> create_mock_stream(mf::BufferStreamId id)
++    {
++        mock_streams[id] = std::make_shared<testing::NiceMock<mtd::MockBufferStream>>();
          auto buffer1 = std::make_shared<mtd::StubBuffer>();
          auto buffer2 = std::make_shared<mtd::StubBuffer>();
--        ON_CALL(*stream, swap_buffers(testing::_,testing::_))
++        ON_CALL(*mock_streams[id], swap_buffers(testing::_,testing::_))
              .WillByDefault(testing::Invoke(
              [buffer1, buffer2](mg::Buffer* b, std::function<void(mg::Buffer* new_buffer)> complete)
+             {
                  if ((!b) || (b == buffer1.get()))
                      complete(buffer2.get());
                  if (b == buffer2.get())
--                    complete(buffer1.get());
++                    complete(buffer1.get());
              }));
--
--        ON_CALL(*surface, primary_buffer_stream())
--            .WillByDefault(Return(stream));
--
--
--        mock_surfaces[id] = surface;
--        mock_streams[mf::BufferStreamId(id.as_value())] = stream;
--        return surface;
--    }
--
--    std::shared_ptr<mtd::MockBufferStream> create_mock_stream(mf::BufferStreamId id)
--    {
--        mock_streams[id] = std::make_shared<testing::NiceMock<mtd::MockBufferStream>>();
          return mock_streams[id];
+     }
@@ -190,10 +179,10 @@
      mf::BufferStreamId create_buffer_stream(mg::BufferProperties const&)
+     {
--        mf::BufferStreamId id{last_surface_id};
++        mf::BufferStreamId id{last_stream_id};
          if (mock_streams.end() == mock_streams.find(id))
              create_mock_stream(id);
--        last_surface_id++;
++        last_stream_id++;
          return id;
+     }
@@ -205,7 +194,8 @@
      std::map<mf::BufferStreamId, std::shared_ptr<mtd::MockBufferStream>> mock_streams;
      std::map<mf::SurfaceId, std::shared_ptr<mtd::MockFrontendSurface>> mock_surfaces;
      static int const testing_client_input_fd;
--    int last_surface_id;
++    int last_surface_id = 0;
++    int last_stream_id = 0;
  };
  int const StubbedSession::testing_client_input_fd{11};
@@ -298,6 +288,7 @@
      mp::Buffer buffer_response;
      mp::BufferRequest buffer_request;
  };
++
+ }
  TEST_F(SessionMediator, disconnect_releases_session)
@@ -388,10 +379,6 @@
      }, std::logic_error);
      EXPECT_THROW({
--        mediator.exchange_buffer(&buffer_request, &buffer_response, null_callback.get());
--    }, std::logic_error);
--
--    EXPECT_THROW({
          mediator.release_surface(&surface_id_request, nullptr, null_callback.get());
      }, std::logic_error);
@@ -510,7 +497,7 @@
      mp::SurfaceParameters surface_request;
      mp::Surface surface_response;
--    auto stream1 = stubbed_session->mock_primary_stream_at(mf::SurfaceId{0});
++    auto stream1 = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      ON_CALL(*stream1, swap_buffers(_,_))
          .WillByDefault(InvokeArgument<1>(&buffer));
@@ -653,7 +640,7 @@
  TEST_F(SessionMediator, exchange_buffer)
+ {
      using namespace testing;
--    auto const& mock_stream = stubbed_session->mock_primary_stream_at(mf::SurfaceId{0});
++    auto mock_stream = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      mp::Buffer exchanged_buffer;
      mtd::StubBuffer stub_buffer1;
      mtd::StubBuffer stub_buffer2;
@@ -682,10 +669,10 @@
+ {
      using namespace testing;
      mp::Buffer exchanged_buffer;
--    mf::SurfaceId surf_id{0};
++    mf::BufferStreamId stream_id{0};
      mtd::StubBuffer buffer1;
      mtd::StubBuffer buffer2;
--    auto stream = stubbed_session->mock_primary_stream_at(surf_id);
++    auto stream = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      ON_CALL(*stream, swap_buffers(nullptr,_))
          .WillByDefault(InvokeArgument<1>(&buffer2));
      ON_CALL(*stream, swap_buffers(&buffer1,_))
@@ -732,7 +719,7 @@
  TEST_F(SessionMediator, exchange_buffer_throws_if_client_submits_bad_request)
+ {
      using namespace testing;
--    auto const& mock_stream = stubbed_session->mock_primary_stream_at(mf::SurfaceId{0});
++    auto mock_stream = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      mp::Buffer exchanged_buffer;
      mtd::StubBuffer stub_buffer1;
      mtd::StubBuffer stub_buffer2;
@@ -765,8 +752,8 @@
      mp::SurfaceParameters surface_request;
      mp::BufferRequest req1;
      mp::BufferRequest req2;
--    auto const& mock_stream1 = stubbed_session->mock_primary_stream_at(mf::SurfaceId{0});
--    auto const& mock_stream2 = stubbed_session->mock_primary_stream_at(mf::SurfaceId{1});
++    auto mock_stream1 = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
++    auto mock_stream2 = stubbed_session->mock_stream_at(mf::BufferStreamId{2});
      Sequence seq;
      EXPECT_CALL(*mock_stream1, swap_buffers(_,_))
          .InSequence(seq);
@@ -780,10 +767,10 @@
      mediator.connect(&connect_parameters, &connection, null_callback.get());
      mediator.create_surface(&surface_request, &surface_response, null_callback.get());
--    req1.mutable_id()->set_value(surface_response.id().value());
++    req1.mutable_id()->set_value(surface_response.buffer_stream().id().value());
      *req1.mutable_buffer() = surface_response.buffer_stream().buffer();
      mediator.create_surface(&surface_request, &surface_response, null_callback.get());
--    req2.mutable_id()->set_value(surface_response.id().value());
++    req2.mutable_id()->set_value(surface_response.buffer_stream().id().value());
      *req2.mutable_buffer() = surface_response.buffer_stream().buffer();
      mediator.exchange_buffer(&req2, &buffer_response, null_callback.get());
      mediator.exchange_buffer(&req1, &buffer_response, null_callback.get());
@@ -840,7 +827,7 @@
  TEST_F(SessionMediator, completes_exchange_buffer_when_completion_is_invoked_asynchronously_from_thread_that_initiated_exchange)
+ {
      using namespace testing;
--    auto const& mock_stream = stubbed_session->mock_primary_stream_at(mf::SurfaceId{0});
++    auto const& mock_stream = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      mtd::StubBuffer stub_buffer1;
      mtd::StubBuffer stub_buffer2;
      std::function<void(mg::Buffer*)> completion_func;
@@ -954,7 +941,7 @@
      mediator.connect(&connect_parameters, &connection, null_callback.get());
      mediator.create_surface(&surface_parameters, &surface_response, null_callback.get());
--    auto mock_stream = stubbed_session->mock_primary_stream_at(mf::SurfaceId{0});
++    auto mock_stream = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      request.mutable_id()->set_value(surface_response.id().value());
      request.mutable_buffer()->set_buffer_id(buffer1->id().as_value());
@@ -989,7 +976,7 @@
      mediator.connect(&connect_parameters, &connection, null_callback.get());
      mediator.create_surface(&surface_parameters, &surface_response, null_callback.get());
--    auto mock_stream = stubbed_session->mock_primary_stream_at(mf::SurfaceId{0});
++    auto mock_stream = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      EXPECT_CALL(*mock_stream, allocate_buffer(properties))
          .Times(num_requests)
          .WillRepeatedly(Return(mg::BufferID{}));
@@ -1016,7 +1003,7 @@
      mediator.connect(&connect_parameters, &connection, null_callback.get());
      mediator.create_surface(&surface_parameters, &surface_response, null_callback.get());
--    auto mock_stream = stubbed_session->mock_primary_stream_at(mf::SurfaceId{0});
++    auto mock_stream = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      EXPECT_CALL(*mock_stream, remove_buffer(mg::BufferID{buffer_id}))
          .Times(num_requests);
@@ -1026,7 +1013,7 @@
  TEST_F(SessionMediator, doesnt_mind_swap_buffers_returning_nullptr_in_submit)
+ {
      using namespace testing;
--    auto mock_stream = stubbed_session->mock_primary_stream_at(mf::SurfaceId{0});
++    auto mock_stream = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      ON_CALL(*mock_stream, swap_buffers(_,_))
          .WillByDefault(InvokeArgument<1>(nullptr));
      auto buffer1 = std::make_shared<mtd::StubBuffer>();
@@ -1062,10 +1049,9 @@
  TEST_F(SessionMediator, doesnt_mind_swap_buffers_returning_nullptr_in_create)
+ {
      using namespace testing;
--    mf::SurfaceId surf_id{0};
      mtd::StubBuffer buffer;
--    auto stream = stubbed_session->mock_primary_stream_at(surf_id);
++    auto stream = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      ON_CALL(*stream, swap_buffers(_,_))
          .WillByDefault(InvokeArgument<1>(nullptr));
@@ -1081,10 +1067,9 @@
  TEST_F(SessionMediator, doesnt_mind_swap_buffers_returning_nullptr_in_bstream_create)
+ {
      using namespace testing;
--    mf::SurfaceId surf_id{0};
      mtd::StubBuffer buffer;
--    auto stream = stubbed_session->mock_primary_stream_at(surf_id);
++    auto stream = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      ON_CALL(*stream, swap_buffers(_,_))
          .WillByDefault(InvokeArgument<1>(nullptr));
@@ -1100,20 +1085,20 @@
  TEST_F(SessionMediator, configures_swap_intervals_on_streams)
+ {
      using namespace testing;
--    mf::SurfaceId surf_id{0};
++    mf::BufferStreamId stream_id{0};
      mp::StreamConfiguration request;
      mp::Void response;
      auto interval = 0u;
      mtd::StubBuffer buffer;
--    auto stream = stubbed_session->mock_primary_stream_at(surf_id);
++    auto stream = stubbed_session->mock_stream_at(stream_id);
      EXPECT_CALL(*stream, allow_framedropping(true));
      mediator.connect(&connect_parameters, &connection, null_callback.get());
      mediator.create_surface(&surface_parameters, &surface_response, null_callback.get());
--    request.mutable_id()->set_value(surf_id.as_value());
++    request.mutable_id()->set_value(stream_id.as_value());
      request.set_swapinterval(interval);
      mediator.configure_buffer_stream(&request, &response, null_callback.get());
+ }
@@ -1209,10 +1194,9 @@
  TEST_F(SessionMediator, doesnt_inadventently_set_buffer_field_when_theres_no_buffer)
+ {
      mp::Void null;
--    mf::SurfaceId surf_id{0};
      mp::BufferStreamParameters stream_request;
      mp::BufferStream stream_response;
--    auto stream = stubbed_session->mock_primary_stream_at(surf_id);
++    auto stream = stubbed_session->mock_stream_at(mf::BufferStreamId{0});
      ON_CALL(*stream, swap_buffers(nullptr,testing::_))
          .WillByDefault(testing::InvokeArgument<1>(nullptr));
      mediator.connect(&connect_parameters, &connection, null_callback.get());
 === modified file 'tests/unit-tests/scene/test_abstract_shell.cpp'
 --- tests/unit-tests/scene/test_abstract_shell.cpp	2016-01-29 08:18:22 +0000
 +++ tests/unit-tests/scene/test_abstract_shell.cpp	2016-04-12 14:23:09 +0000
@@ -145,6 +145,7 @@
      std::chrono::nanoseconds const event_timestamp = std::chrono::nanoseconds(0);
      std::vector<uint8_t> const cookie;
++    mg::BufferProperties properties { geom::Size{1,1}, mir_pixel_format_abgr_8888, mg::BufferUsage::software};
  };
+ }
@@ -197,9 +198,12 @@
          WillOnce(Return(mt::fake_shared(surface3)));
      auto const session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
--    auto const surface_id1 = shell.create_surface(session, ms::a_surface(), nullptr);
--    auto const surface_id2 = shell.create_surface(session, ms::a_surface(), nullptr);
--    auto const surface_id3 = shell.create_surface(session, ms::a_surface(), nullptr);
++    auto const surface_id1 = shell.create_surface(session,
++        ms::a_surface().with_buffer_stream(session->create_buffer_stream(properties)), nullptr);
++    auto const surface_id2 = shell.create_surface(session,
++        ms::a_surface().with_buffer_stream(session->create_buffer_stream(properties)), nullptr);
++    auto const surface_id3 = shell.create_surface(session,
++        ms::a_surface().with_buffer_stream(session->create_buffer_stream(properties)), nullptr);
      session->destroy_surface(surface_id2);
@@ -217,8 +221,8 @@
      std::shared_ptr<ms::Session> session =
          shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
--    auto params = ms::a_surface();
--
++    auto params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
      EXPECT_CALL(*wm, add_surface(session, Ref(params), _));
      shell.create_surface(session, params, nullptr);
@@ -229,7 +233,8 @@
      std::shared_ptr<ms::Session> const session =
          shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
--    auto params = ms::a_surface();
++    auto params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
      auto placed_params = params;
      placed_params.size.width = geom::Width{100};
@@ -246,9 +251,10 @@
  TEST_F(AbstractShell, destroy_surface_removes_surface_from_window_manager)
+ {
--    auto const params = ms::a_surface();
      std::shared_ptr<ms::Session> const session =
          shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
++    auto const params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
      auto const surface_id = shell.create_surface(session, params, nullptr);
      auto const surface = session->surface(surface_id);
@@ -357,7 +363,9 @@
      std::shared_ptr<ms::Session> const session =
          shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
--    auto const surface_id = shell.create_surface(session, ms::a_surface(), nullptr);
++    auto const params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
++    auto const surface_id = shell.create_surface(session, params, nullptr);
      auto const surface = session->surface(surface_id);
      MirSurfaceState const state{mir_surface_state_fullscreen};
@@ -392,8 +400,12 @@
      msh::FocusController& focus_controller = shell;
      auto session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
      auto session1 = shell.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
--    shell.create_surface(session, ms::a_surface(), nullptr);
--    shell.create_surface(session1, ms::a_surface(), nullptr);
++    auto const params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
++    auto const params2 = ms::a_surface()
++        .with_buffer_stream(session1->create_buffer_stream(properties));
++    shell.create_surface(session, params, nullptr);
++    shell.create_surface(session1, params2, nullptr);
      focus_controller.set_focus_to(session, {});
@@ -409,8 +421,12 @@
+ {
      auto session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
      auto session1 = shell.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
--    shell.create_surface(session, ms::a_surface(), nullptr);
--    shell.create_surface(session1, ms::a_surface(), nullptr);
++    auto const params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
++    auto const params2 = ms::a_surface()
++        .with_buffer_stream(session1->create_buffer_stream(properties));
++    shell.create_surface(session, params, nullptr);
++    shell.create_surface(session1, params2, nullptr);
      EXPECT_CALL(session_container, successor_of(session1)).
          WillOnce(Return(session));
@@ -437,10 +453,13 @@
      EXPECT_CALL(session_container, successor_of(session1)).
          WillOnce(Return(session0));
--
--    auto const surface0_id = shell.create_surface(session0, ms::a_surface(), nullptr);
++    auto const params = ms::a_surface()
++        .with_buffer_stream(session0->create_buffer_stream(properties));
++    auto const params2 = ms::a_surface()
++        .with_buffer_stream(session1->create_buffer_stream(properties));
++    auto const surface0_id = shell.create_surface(session0, params, nullptr);
      auto const surface0 = session0->surface(surface0_id);
--    auto const surface1_id = shell.create_surface(session1, ms::a_surface(), nullptr);
++    auto const surface1_id = shell.create_surface(session1, params2, nullptr);
      auto const surface1 = session1->surface(surface1_id);
      msh::FocusController& focus_controller = shell;
@@ -477,8 +496,12 @@
      auto session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
      auto session1 = shell.open_session(__LINE__, "Surfaceless", std::shared_ptr<mf::EventSink>());
      auto session2 = shell.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
--    auto surface_id = shell.create_surface(session, ms::a_surface(), nullptr);
--    shell.create_surface(session2, ms::a_surface(), nullptr);
++    auto const params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
++    auto surface_id = shell.create_surface(session, params, nullptr);
++    auto const params2 = ms::a_surface()
++        .with_buffer_stream(session2->create_buffer_stream(properties));
++    shell.create_surface(session2, params2, nullptr);
      focus_controller.set_focus_to(session, session->surface(surface_id));
@@ -498,7 +521,9 @@
      msh::FocusController& focus_controller = shell;
      auto session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
      auto session1 = shell.open_session(__LINE__, "Surfaceless", std::shared_ptr<mf::EventSink>());
--    auto surface_id = shell.create_surface(session, ms::a_surface(), nullptr);
++    auto creation_params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
++    auto surface_id = shell.create_surface(session, creation_params, nullptr);
      focus_controller.set_focus_to(session, session->surface(surface_id));
@@ -519,8 +544,8 @@
      std::shared_ptr<ms::Session> session =
          shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
--    auto creation_params = ms::a_surface();
--
++    auto creation_params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
      auto surface_id = shell.create_surface(session, creation_params, nullptr);
      auto surface = session->surface(surface_id);
@@ -537,7 +562,8 @@
      std::shared_ptr<ms::Session> session =
          shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
--    auto creation_params = ms::a_surface();
++    auto creation_params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
      auto surface_id = shell.create_surface(session, creation_params, nullptr);
      auto surface = session->surface(surface_id);
 === modified file 'tests/unit-tests/scene/test_application_session.cpp'
 --- tests/unit-tests/scene/test_application_session.cpp	2016-04-04 03:30:04 +0000
 +++ tests/unit-tests/scene/test_application_session.cpp	2016-04-12 14:23:09 +0000
@@ -223,6 +223,7 @@
      std::shared_ptr<mtd::StubBufferStream> const stub_buffer_stream{std::make_shared<mtd::StubBufferStream>()};
      pid_t pid;
      std::string name;
++    mg::BufferProperties properties { geom::Size{1,1}, mir_pixel_format_abgr_8888, mg::BufferUsage::hardware };
  };
  struct MockSurfaceFactory : ms::SurfaceFactory
@@ -246,10 +247,48 @@
      auto session = make_application_session(
          mt::fake_shared(surface_stack), mt::fake_shared(mock_surface_factory));
--    ms::SurfaceCreationParameters params;
--    auto surf = session->create_surface(params, event_sink);
--
--    session->destroy_surface(surf);
++    ms::SurfaceCreationParameters params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
++    auto surf = session->create_surface(params, event_sink);
++
++    session->destroy_surface(surf);
++}
++
++TEST_F(ApplicationSession, attempt_to_destroy_non_existent_stream_throws)
++{
++    using namespace ::testing;
++    NiceMock<MockSurfaceFactory> mock_surface_factory;
++    NiceMock<mtd::MockSurfaceStack> surface_stack;
++    auto session = make_application_session(
++        mt::fake_shared(surface_stack), mt::fake_shared(mock_surface_factory));
++
++    mf::BufferStreamId made_up_id{332};
++    EXPECT_THROW({
++        session->destroy_buffer_stream(made_up_id);
++    }, std::runtime_error);
++}
++
++TEST_F(ApplicationSession, can_destroy_buffer_stream_after_destroying_surface)
++{
++    using namespace ::testing;
++
++    NiceMock<MockSurfaceFactory> mock_surface_factory;
++    NiceMock<mtd::MockSurfaceStack> surface_stack;
++    std::shared_ptr<ms::Surface> mock_surface = make_mock_surface();
++
++    EXPECT_CALL(mock_surface_factory, create_surface(_,_))
++        .WillOnce(Return(mock_surface));
++    EXPECT_CALL(surface_stack, add_surface(mock_surface,_));
++    auto session = make_application_session(
++        mt::fake_shared(surface_stack), mt::fake_shared(mock_surface_factory));
++
++    auto buffer_stream = session->create_buffer_stream(properties);
++    ms::SurfaceCreationParameters params = ms::a_surface()
++        .with_buffer_stream(buffer_stream);
++    auto surf = session->create_surface(params, event_sink);
++
++    session->destroy_surface(surf);
++    session->destroy_buffer_stream(buffer_stream);
+ }
  TEST_F(ApplicationSession, notifies_listener_of_create_and_destroy_surface)
@@ -264,7 +303,8 @@
      auto session = make_application_session_with_listener(mt::fake_shared(listener));
--    ms::SurfaceCreationParameters params;
++    ms::SurfaceCreationParameters params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
      auto surf = session->create_surface(params, event_sink);
      session->destroy_surface(surf);
@@ -283,7 +323,8 @@
+     {
          auto session = make_application_session_with_listener(mt::fake_shared(listener));
--        ms::SurfaceCreationParameters params;
++        ms::SurfaceCreationParameters params = ms::a_surface()
++            .with_buffer_stream(session->create_buffer_stream(properties));
          session->create_surface(params, event_sink);
+     }
+ }
@@ -320,7 +361,8 @@
      auto app_session = make_application_session_with_stubs();
--    ms::SurfaceCreationParameters params;
++    ms::SurfaceCreationParameters params = ms::a_surface()
++        .with_buffer_stream(app_session->create_buffer_stream(properties));
      auto id1 = app_session->create_surface(params, nullptr);
      auto id2 = app_session->create_surface(params, nullptr);
      auto id3 = app_session->create_surface(params, nullptr);
@@ -341,7 +383,8 @@
  TEST_F(ApplicationSession, foreign_surface_has_no_successor)
+ {
      auto session1 = make_application_session_with_stubs();
--    ms::SurfaceCreationParameters params;
++    ms::SurfaceCreationParameters params = ms::a_surface()
++        .with_buffer_stream(session1->create_buffer_stream(properties));
      auto id1 = session1->create_surface(params, nullptr);
      auto surf1 = session1->surface(id1);
      auto id2 = session1->create_surface(params, nullptr);
@@ -358,7 +401,8 @@
  TEST_F(ApplicationSession, surface_after_one_is_self)
+ {
      auto session = make_application_session_with_stubs();
--    ms::SurfaceCreationParameters params;
++    ms::SurfaceCreationParameters params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
      auto id = session->create_surface(params, nullptr);
      auto surf = session->surface(id);
@@ -371,7 +415,8 @@
+ {
      auto app_session = make_application_session_with_stubs();
--    ms::SurfaceCreationParameters params;
++    ms::SurfaceCreationParameters params = ms::a_surface()
++        .with_buffer_stream(app_session->create_buffer_stream(properties));
      int const N = 3;
      std::shared_ptr<ms::Surface> surf[N];
@@ -412,7 +457,8 @@
          EXPECT_CALL(*mock_surface, show()).Times(1);
+     }
--    ms::SurfaceCreationParameters params;
++    ms::SurfaceCreationParameters params = ms::a_surface()
++        .with_buffer_stream(app_session->create_buffer_stream(properties));
      auto surf = app_session->create_surface(params, event_sink);
      app_session->hide();
@@ -447,7 +493,9 @@
          mtd::StubDisplayConfig{},
          event_sink);
--    auto surface = app_session.create_surface(ms::SurfaceCreationParameters{}, event_sink);
++    ms::SurfaceCreationParameters params = ms::a_surface()
++        .with_buffer_stream(app_session.create_buffer_stream(properties));
++    auto surface = app_session.create_surface(params, event_sink);
      app_session.take_snapshot(ms::SnapshotCallback());
      app_session.destroy_surface(surface);
+ }
@@ -492,42 +540,13 @@
      EXPECT_THAT(app_session.process_id(), Eq(session_pid));
+ }
--TEST_F(ApplicationSession, surface_ids_are_bufferstream_ids)
--{
--    using namespace ::testing;
--
--    NiceMock<MockSurfaceFactory> mock_surface_factory;
--    NiceMock<MockBufferStreamFactory> mock_bufferstream_factory;
--    NiceMock<mtd::MockSurfaceStack> surface_stack;
--    std::shared_ptr<ms::Surface> mock_surface = make_mock_surface();
--    auto stub_bstream = std::make_shared<mtd::StubBufferStream>();
--    EXPECT_CALL(mock_bufferstream_factory, create_buffer_stream(_,_,_))
--        .WillOnce(Return(stub_bstream));
--    EXPECT_CALL(mock_surface_factory, create_surface(std::shared_ptr<mc::BufferStream>(stub_bstream),_))
--        .WillOnce(Return(mock_surface));
--    auto session = make_application_session(
--        mt::fake_shared(mock_bufferstream_factory),
--        mt::fake_shared(mock_surface_factory));
--
--    ms::SurfaceCreationParameters params;
--
--    auto id1 = session->create_surface(params, event_sink);
--    EXPECT_THAT(session->get_buffer_stream(mf::BufferStreamId(id1.as_value())), Eq(stub_bstream));
--    EXPECT_THAT(session->get_surface(id1), Eq(mock_surface));
--
--    session->destroy_surface(id1);
--
--    EXPECT_THROW({
--            session->get_buffer_stream(mf::BufferStreamId(id1.as_value()));
--    }, std::runtime_error);
--}
--
  TEST_F(ApplicationSession, can_destroy_surface_bstream)
+ {
      auto session = make_application_session_with_stubs();
--    ms::SurfaceCreationParameters params;
++    mf::BufferStreamId stream_id = session->create_buffer_stream(properties);
++    ms::SurfaceCreationParameters params = ms::a_surface()
++        .with_buffer_stream(stream_id);
      auto id = session->create_surface(params, event_sink);
--    mf::BufferStreamId stream_id(id.as_value());
      session->destroy_buffer_stream(stream_id);
      EXPECT_THROW({
          session->get_buffer_stream(stream_id);
@@ -565,11 +584,8 @@
      auto session = make_application_session(
          mt::fake_shared(mock_bufferstream_factory),
          mt::fake_shared(mock_surface_factory));
--    auto stream_id0 = mf::BufferStreamId(
--        session->create_surface(
--            ms::a_surface().of_position({1,1}),
--            event_sink).as_value());
++    auto stream_id0 = session->create_buffer_stream(stream_properties);
      auto stream_id1 = session->create_buffer_stream(stream_properties);
      auto stream_id2 = session->create_buffer_stream(stream_properties);
@@ -578,6 +594,10 @@
          {streams[0], geom::Displacement{-1,1}, {}},
          {streams[1], geom::Displacement{0,2}, {}}
      };
++
++    session->create_surface(
++        ms::a_surface().with_buffer_stream(stream_id0), event_sink);
++
      EXPECT_CALL(*mock_surface, set_streams(Pointwise(StreamEq(), info)));
      session->configure_streams(*mock_surface, {
          {stream_id2, geom::Displacement{0,3}, {}},
@@ -884,7 +904,8 @@
      app_session.send_display_config(config);
      ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
--        .of_size({100, 100});
++        .of_size({100, 100})
++        .with_buffer_stream(app_session.create_buffer_stream(properties));
      auto surf_id = app_session.create_surface(params, sender);
      auto surface = app_session.surface(surf_id);
@@ -909,7 +930,8 @@
                           }));
      ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
--        .of_size({100, 100});
++        .of_size({100, 100})
++        .with_buffer_stream(app_session.create_buffer_stream(properties));
      mf::SurfaceId ids[2];
      std::shared_ptr<ms::Surface> surfaces[2];
@@ -962,7 +984,8 @@
                                }));
      ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
--        .of_size({100, 100});
++        .of_size({100, 100})
++        .with_buffer_stream(app_session.create_buffer_stream(properties));
      auto id = app_session.create_surface(params, sender);
      auto surface = app_session.surface(id);
@@ -1019,7 +1042,8 @@
      app_session.send_display_config(config);
      ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
--        .of_size({640, 480});
++        .of_size({640, 480})
++        .with_buffer_stream(app_session.create_buffer_stream(properties));
      auto id = app_session.create_surface(params, sender);
      auto surface = app_session.surface(id);
@@ -1076,7 +1100,8 @@
      app_session.send_display_config(config);
      ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
--        .of_size({100, 100});
++        .of_size({100, 100})
++        .with_buffer_stream(app_session.create_buffer_stream(properties));
      auto id = app_session.create_surface(params, sender);
      auto surface = app_session.surface(id);
@@ -1138,7 +1163,8 @@
      app_session.send_display_config(config);
      ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
--        .of_size({100, 100});
++        .of_size({100, 100})
++        .with_buffer_stream(app_session.create_buffer_stream(properties));
      auto id = app_session.create_surface(params, sender);
      auto surface = app_session.surface(id);
 === modified file 'tests/unit-tests/scene/test_session_manager.cpp'
 --- tests/unit-tests/scene/test_session_manager.cpp	2016-01-29 08:18:22 +0000
 +++ tests/unit-tests/scene/test_session_manager.cpp	2016-04-12 14:23:09 +0000
@@ -129,9 +129,13 @@
      EXPECT_CALL(container, insert_session(_)).Times(1);
      EXPECT_CALL(container, remove_session(_)).Times(1);
++    mg::BufferProperties properties {
++        geom::Size{1,1}, mir_pixel_format_abgr_8888, mg::BufferUsage::software };
      auto session = session_manager.open_session(__LINE__, "Visual Basic Studio", mt::fake_shared(event_sink));
      session->create_surface(
--        ms::a_surface().of_size(geom::Size{geom::Width{1024}, geom::Height{768}}),
++        ms::a_surface()
++            .of_size(geom::Size{geom::Width{1024}, geom::Height{768}})
++            .with_buffer_stream(session->create_buffer_stream(properties)),
          mt::fake_shared(event_sink));
      session_manager.close_session(session);