Merge lp:~mir-team/mir/chain-simplification into lp:mir

[Kevin DuBois]

staged client api:
Eliminate MirPresentationChain, as there isn't enough of a distinction between MirRenderSurface and MirPresentationChain to have a difference.

This comment from Daniel got me thinking that the types are pretty much the same thing:
https://code.launchpad.net/~cemil-azizoglu/mir/create-chain-from-render-surface/+merge/312211/comments/810630
and unifying the types was pretty easy.

This makes use of the objects easier (see playground/ examples).
It has less types to think through
Less code
Reduces the wart of how you mir_render_surface_get_presentation_chain(), as they're the same thing

staged client api:
Eliminate MirPresentationChain, as there isn't enough of a distinction between MirRenderSurface and MirPresentationChain to have a difference.

This comment from Daniel got me thinking that the types are pretty much the same thing:
https://code.launchpad.net/~cemil-azizoglu/mir/create-chain-from-render-surface/+merge/312211/comments/810630
and unifying the types was pretty easy.

This makes use of the objects easier (see playground/ examples).
It has less types to think through
Less code
Reduces the wart of how you mir_render_surface_get_presentation_chain(), as they're the same thing

Reviewers notes:
A lot of the diff is removals of files or #includes of the removed files.

After the prereq branch (which gets rid of surely unneeded functions), there was a mere one-function difference between MirRenderSurface and MirPresentationChain, which was mir_presentation_chain_submit_buffer().

MirRenderSurface header now looks like:
https://bazaar.launchpad.net/~mir-team/mir/chain-simplification/view/head:/src/include/client/mir_toolkit/mir_render_surface.h

The last remaining wart in there (other than the name of course) is mir_render_surface_get_buffer_stream(), as it has 'hidden razorblades' about how to use it, as well as it uses MirBufferUsage (which is being deprecated). I have followup ideas on how to clean that up (including some of the other MP's)

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3893
https://mir-jenkins.ubuntu.com/job/mir-ci/2405/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/3133/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/3200
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/3192
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/3192
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/3192
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/3162/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/3162
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/3162/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/3162
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/3162/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/3162
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/3162/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/3162
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/3162/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/3162/console

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

review: Needs Fixing (continuous-integration)

[Chris Halse Rogers (raof)]

Weak disapprove.

So, I think this is less typing in the uncommon case in return for higher complexity everywhere.

I don't think having more types makes the code more complex. I think having more types, each of which is conceptually atomic, makes the code *less* complex because the type gives you more information.

This makes the MirRenderSurface type more complex - it's no longer a generic handle to some sort of rendered content, it's now *sometimes* a generic handle to some sort of rendered content and *sometimes* a specific thing you can submit buffers to. You can't tell how it's being used without reading the code.

If we really want to rearrange how MirRenderSurface works we could call it MirContentSinkId or something, re-introduce the mir_connection_create_{buffer_stream,presentation_chain,eglstream}, and add mir_{buffer_stream,presentation_chain,eglstream}_bind_id($OBJECT, MirContentSinkId id).

Finally, this is optimising for the uncommon case. The majority of code that interacts with MirRenderSurface will just pass it to an EGL implementation¹ and go to town. The code that *doesn't* just pass it to an EGL implementation is going to associate it with a software-backed MirBufferStream and render to that.

This reduces the length of (unrepresentative) example code and driver code, but does not change expected real-world code.

¹: Or other hardware abstraction layer, like GStreamer.

review: Disapprove

[Kevin DuBois (kdub)]

> Weak disapprove.
>
> So, I think this is less typing in the uncommon case in return for higher
> complexity everywhere.
>
> I don't think having more types makes the code more complex. I think having
> more types, each of which is conceptually atomic, makes the code *less*
> complex because the type gives you more information.
>
> This makes the MirRenderSurface type more complex - it's no longer a generic
> handle to some sort of rendered content, it's now *sometimes* a generic handle
> to some sort of rendered content and *sometimes* a specific thing you can
> submit buffers to. You can't tell how it's being used without reading the
> code.

I agree that having more types reduces complexity (in terms of how complicated it is for a user to grasp the concept behind the type). If the types are conceptually different, then they need different types.

I think though that MirPresentationChain and MirRenderSurface are the same thing. They're the generic content. Its the "Surface".

MirBufferStream is pretty useless, if you discount legacy usage. Its built on top of MirBuffer+MirPresentationChain internally, and I see it as a helper class that we provide.

If MirBufferStream is useless/legacy, and everything wants to rally around MirPresentationChain [1], then I don't know if there's any value in segregating the parts the driver wants to use (MirPresentationChain) from the parts that the user uses (MirRenderSurface).

The added benefit for the user is that we don't have to construct a MirPresentationChain from a MirRenderSurface, and we don't have to explain externally why the user has to call a function to switch a MirRenderSurface to a MirPresentationChain.

I can get used to the way it is (so obviously won't be offended if MP is rejected), but still think that reducing the number of types and treating MirBufferStream as legacy makes for cleaner code for the user and driver to use.

[1]
MirPresentationChain needs some functions added to it to support the other 3 Vulkan submission modes, and perhaps multimedia-specific submissions (timestamps), but those can be done post 1.0 without ABI breakage.

>
> If we really want to rearrange how MirRenderSurface works we could call it
> MirContentSinkId or something, re-introduce the
> mir_connection_create_{buffer_stream,presentation_chain,eglstream}, and add
> mir_{buffer_stream,presentation_chain,eglstream}_bind_id($OBJECT,
> MirContentSinkId id).
>
A system of binding would also work, but might be too late to change too much of the naming given release?

> Finally, this is optimising for the uncommon case. The majority of code that
> interacts with MirRenderSurface will just pass it to an EGL implementation¹
> and go to town. The code that *doesn't* just pass it to an EGL implementation
> is going to associate it with a software-backed MirBufferStream and render to
> that.
>
> This reduces the length of (unrepresentative) example code and driver code,
> but does not change expected real-world code.

It does save a type conversion and a concern about how to clean up MirPresentationChain in the driver code.

> ¹: Or other hardware abstraction layer, like GStreamer.

[Chris Halse Rogers (raof)]

> > Weak disapprove.
> >
> > So, I think this is less typing in the uncommon case in return for higher
> > complexity everywhere.
> >
> > I don't think having more types makes the code more complex. I think having
> > more types, each of which is conceptually atomic, makes the code *less*
> > complex because the type gives you more information.
> >
> > This makes the MirRenderSurface type more complex - it's no longer a generic
> > handle to some sort of rendered content, it's now *sometimes* a generic
> handle
> > to some sort of rendered content and *sometimes* a specific thing you can
> > submit buffers to. You can't tell how it's being used without reading the
> > code.
>
> I agree that having more types reduces complexity (in terms of how complicated
> it is for a user to grasp the concept behind the type). If the types are
> conceptually different, then they need different types.
>
> I think though that MirPresentationChain and MirRenderSurface are the same
> thing. They're the generic content. Its the "Surface".
>
> MirBufferStream is pretty useless, if you discount legacy usage. Its built on
> top of MirBuffer+MirPresentationChain internally, and I see it as a helper
> class that we provide.
>
> If MirBufferStream is useless/legacy, and everything wants to rally around
> MirPresentationChain [1], then I don't know if there's any value in
> segregating the parts the driver wants to use (MirPresentationChain) from the
> parts that the user uses (MirRenderSurface).

This might be our disconnect. Everything does not (and *cannot*) rally around MirPresentationChain. Specifically, the nvidia driver cannot support hardware-backed MirPresentationChain, and requires an EGLStream-backed MirRenderSurface.

I think MirBufferStream will be sufficiently useful to (software) clients for it to stick around, but even if we change the API to make its helper-code-on-top-of-MirPresentationChain nature explicit we still need to have PresentationChain-backed RenderSurfaces and EGLStream-backed RenderSurfaces.

Since MirPresentationChain cannot be the generic content abstraction, I think it makes sense to have a distinguished MirRenderSurface as the generic content abstraction.

> A system of binding would also work, but might be too late to change too much of the naming
> given release?

I don't think any of the current API has actually made it into a release yet, and *if* we think the bind-to-sink API is significantly better it'd be sensible to make the change before we do have a release with the API public.

I don't think that a binding API *is* significantly better, but others may have different opinions.

[Cemil Azizoglu (cemil-azizoglu)]

Going with the conviction that EGLStreams are the only way that we can support the NVidia driver, I agree with Chris.

Also, I believe there is value in having an external facing type such as MirRenderSurface that decouples clients from the underlying implementation.

I don't see what benefit a binding API would provide.

To move things along, I'll add my own 'Disapprove'.

review: Disapprove

Unmerged revisions

3893. By Kevin DuBois on 2016-12-15

fix unit tests

3892. By Kevin DuBois on 2016-12-15

remove more ifdefs

3891. By Kevin DuBois on 2016-12-15

all unit tests passing

3890. By Kevin DuBois on 2016-12-15

remove files

3889. By Kevin DuBois on 2016-12-15

remove get presentation chain

3888. By Kevin DuBois on 2016-12-15

unify the two types and get the tests to compile

3887. By Kevin DuBois on 2016-12-15

remove unneeded file

3886. By Kevin DuBois on 2016-12-15

chase the last pc function away

3885. By Kevin DuBois on 2016-12-15

whittle down to just one function on pc

3884. By Kevin DuBois on 2016-12-15

merge in other base

=== modified file 'playground/egldiamond_render_surface.c'
--- playground/egldiamond_render_surface.c	2016-12-14 06:27:05 +0000
+++ playground/egldiamond_render_surface.c	2016-12-15 15:17:18 +0000
@@ -21,7 +21,6 @@
 #include "mir_toolkit/mir_client_library.h"
 #include "mir_toolkit/mir_render_surface.h"
 #include "mir_toolkit/mir_buffer.h"
-#include "mir_toolkit/mir_presentation_chain.h"
 #include "mir_egl_platform_shim.h"
 #include "diamond.h"
 
 
=== modified file 'playground/mir_demo_client_chain_jumping_buffers.c'
--- playground/mir_demo_client_chain_jumping_buffers.c	2016-12-09 02:54:31 +0000
+++ playground/mir_demo_client_chain_jumping_buffers.c	2016-12-15 15:17:18 +0000
@@ -20,7 +20,6 @@
 #include <mir_toolkit/mir_connection.h>
 #include <mir_toolkit/mir_buffer_stream.h>
 #include <mir_toolkit/mir_surface.h>
-#include <mir_toolkit/mir_presentation_chain.h>
 #include <mir_toolkit/mir_render_surface.h>
 #include <mir_toolkit/mir_buffer.h>
 #include <mir_toolkit/version.h>
@@ -128,8 +127,8 @@
     }
 
 
-    int const chain_width = width / 2;
-    int const chain_height = height / 2;
+    int const rs_width = width / 2;
+    int const rs_height = height / 2;
 
     sigset_t signal_set;
     sigemptyset(&signal_set);
@@ -156,8 +155,8 @@
         return -1;
     }
 
-    unsigned int const num_chains = 4;
-    unsigned int const num_buffers = num_chains + 1;
+    unsigned int const num_render_surfs = 4;
+    unsigned int const num_buffers = num_render_surfs + 1;
     unsigned int const fg[PALETTE_SIZE] = {
         0xFF14BEA0,
         0xFF000000,
@@ -174,42 +173,27 @@
     };
     unsigned int spare_buffer = 0;
 
-    MirPresentationChain* chain[num_chains];
-    MirRenderSurface* render_surface[num_chains];
-    for(unsigned int i = 0u; i < num_chains; i++)
+    MirRenderSurface* render_surface[num_render_surfs];
+    for(unsigned int i = 0u; i < num_render_surfs; i++)
     {
-        render_surface[i] = mir_connection_create_render_surface_sync(connection, chain_width, chain_height);
+        render_surface[i] = mir_connection_create_render_surface_sync(connection, rs_width, rs_height);
         if (!mir_render_surface_is_valid(render_surface[i]))
         {
             printf("could not create render surface\n");
             return -1;
         }
-
-        chain[i] =  mir_render_surface_get_presentation_chain(render_surface[i]);
-        if (!mir_presentation_chain_is_valid(chain[i]))
-        {
-            printf("could not create MirPresentationChain\n");
-
-            // TODO this is a frig to pass smoke tests until we support NBS by default
-#if (MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 3, 0))
-            printf("This is currently an unreleased API - likely server support is switched off\n");
-            return 0;
-#else
-            return -1;
-#endif
-        }
     }
 
-    //Arrange a 2x2 grid of chains within surface
+    //Arrange a 2x2 grid of render_surfs within surface
     MirSurfaceSpec* spec = mir_connection_create_spec_for_normal_surface(connection, width, height, format);
     mir_surface_spec_add_render_surface(
-        spec, render_surface[0], chain_width, chain_height, displacement_x, displacement_y);
-    mir_surface_spec_add_render_surface(
-        spec, render_surface[1], chain_width, chain_height, chain_width, displacement_y);
-    mir_surface_spec_add_render_surface(
-        spec, render_surface[2], chain_width, chain_height, displacement_x, chain_height);
-    mir_surface_spec_add_render_surface(
-        spec, render_surface[3], chain_width, chain_height, chain_width, chain_height);
+        spec, render_surface[0], rs_width, rs_height, displacement_x, displacement_y);
+    mir_surface_spec_add_render_surface(
+        spec, render_surface[1], rs_width, rs_height, rs_width, displacement_y);
+    mir_surface_spec_add_render_surface(
+        spec, render_surface[2], rs_width, rs_height, displacement_x, rs_height);
+    mir_surface_spec_add_render_surface(
+        spec, render_surface[3], rs_width, rs_height, rs_width, rs_height);
     MirSurface* surface = mir_surface_create_sync(spec);
     mir_surface_spec_release(spec);
 
@@ -239,7 +223,7 @@
 
     while (rendering)
     {
-        for(unsigned int i = 0u; i < num_chains; i++)
+        for(unsigned int i = 0u; i < num_render_surfs; i++)
         {
             MirBuffer* b;
             pthread_mutex_lock(&buffer_available[spare_buffer].lock);
@@ -249,7 +233,7 @@
             b = buffer_available[spare_buffer].buffer;
             pthread_mutex_unlock(&buffer_available[spare_buffer].lock);
 
-            mir_presentation_chain_submit_buffer(chain[i], b);
+            mir_render_surface_submit_buffer(render_surface[i], b);
 
             //just looks like a blur if we don't slow things down
             ualarm(500000, 0);
@@ -257,14 +241,14 @@
             sigwait(&signal_set, &sig);
             if (!rendering) break;
 
-            if (++spare_buffer > num_chains)
+            if (++spare_buffer > num_render_surfs)
                 spare_buffer = 0;
         }
     }
 
     for (unsigned int i = 0u; i < num_buffers; i++)
         mir_buffer_release(buffer_available[i].buffer);
-    for (unsigned int i = 0u; i < num_chains; i++)
+    for (unsigned int i = 0u; i < num_render_surfs; i++)
         mir_render_surface_release(render_surface[i]);
     mir_surface_release_sync(surface);
     mir_connection_release(connection);
 
=== modified file 'playground/mir_demo_client_prerendered_frames.c'
--- playground/mir_demo_client_prerendered_frames.c	2016-12-09 02:54:31 +0000
+++ playground/mir_demo_client_prerendered_frames.c	2016-12-15 15:17:18 +0000
@@ -20,7 +20,6 @@
 #include <mir_toolkit/mir_connection.h>
 #include <mir_toolkit/mir_buffer_stream.h>
 #include <mir_toolkit/mir_surface.h>
-#include <mir_toolkit/mir_presentation_chain.h>
 #include <mir_toolkit/mir_render_surface.h>
 #include <mir_toolkit/mir_buffer.h>
 #include <mir_toolkit/version.h>
@@ -154,20 +153,6 @@
         return -1;
     }
 
-    MirPresentationChain* chain =  mir_render_surface_get_presentation_chain(render_surface);
-    if (!mir_presentation_chain_is_valid(chain))
-    {
-        printf("could not create MirPresentationChain\n");
-
-// TODO this is a frig to pass smoke tests until we support NBS by default
-#if (MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 3, 0))
-        printf("This is currently an unreleased API - likely server support is switched off\n");
-        return 0;
-#else
-        return -1;
-#endif
-    }
-
     MirSurfaceSpec* spec = mir_connection_create_spec_for_normal_surface(connection, width, height, format);
     mir_surface_spec_add_render_surface(
         spec, render_surface, width, height, displacement_x, displacement_y);
@@ -223,7 +208,7 @@
         b = buffer_available[i].buffer;
         pthread_mutex_unlock(&buffer_available[i].lock);
 
-        mir_presentation_chain_submit_buffer(chain, b);
+        mir_render_surface_submit_buffer(render_surface, b);
 
         if ((i == num_prerendered_frames - 1) || (i == 0))
             inc *= -1; 
 
=== modified file 'playground/mir_egl_platform_shim.c'
--- playground/mir_egl_platform_shim.c	2016-11-23 04:37:50 +0000
+++ playground/mir_egl_platform_shim.c	2016-12-15 15:17:18 +0000
@@ -31,7 +31,7 @@
     MirConnection* connection;      //EGLNativeDisplayType
     MirRenderSurface* surface;      //EGLNativeWindowType
     MirBufferStream* stream;        //the internal semantics a driver might want to use...
-                                    //could be MirPresentationChain as well
+                                    //could be MirRenderSurface as well
     int current_physical_width;     //The driver is in charge of the physical width
     int current_physical_height;    //The driver is in charge of the physical height
 
 
=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2016-12-13 06:00:32 +0000
+++ src/client/CMakeLists.txt	2016-12-15 15:17:18 +0000
@@ -77,13 +77,10 @@
   mir_buffer_stream_api.cpp
   error_stream.cpp
   error_render_surface.cpp
-  error_chain.cpp
   buffer.cpp
   error_buffer.cpp
   mir_render_surface_api.cpp
   render_surface.cpp
-  presentation_chain.cpp
-  mir_presentation_chain_api.cpp
   mir_buffer_api.cpp
   display_configuration_api.cpp
   protobuf_to_native_buffer.cpp
 
=== modified file 'src/client/connection_surface_map.cpp'
--- src/client/connection_surface_map.cpp	2016-12-13 06:00:32 +0000
+++ src/client/connection_surface_map.cpp	2016-12-15 15:17:18 +0000
@@ -18,7 +18,6 @@
 
 #include "connection_surface_map.h"
 #include "mir_surface.h"
-#include "presentation_chain.h"
 
 #include <boost/throw_exception.hpp>
 #include <sstream>
@@ -70,22 +69,12 @@
     streams[stream_id] = stream;
 }
 
-void mcl::ConnectionSurfaceMap::insert(
-    mf::BufferStreamId stream_id, std::shared_ptr<MirPresentationChain> const& chain)
-{
-    std::lock_guard<decltype(stream_guard)> lk(stream_guard);
-    chains[stream_id] = chain; 
-}
-
 void mcl::ConnectionSurfaceMap::erase(mf::BufferStreamId stream_id)
 {
     std::lock_guard<decltype(stream_guard)> lk(stream_guard);
     auto stream_it = streams.find(stream_id);
-    auto chain_it = chains.find(stream_id);
     if (stream_it != streams.end())
         streams.erase(stream_it);
-    if (chain_it != chains.end())
-        chains.erase(chain_it);
 }
 
 void mcl::ConnectionSurfaceMap::insert(int buffer_id, std::shared_ptr<mcl::MirBuffer> const& buffer)
 
=== modified file 'src/client/connection_surface_map.h'
--- src/client/connection_surface_map.h	2016-12-13 06:00:32 +0000
+++ src/client/connection_surface_map.h	2016-12-15 15:17:18 +0000
@@ -24,7 +24,6 @@
 #include <shared_mutex>
 #include <unordered_map>
 
-class MirPresentationChain;
 class MirRenderSurface;
 namespace mir
 {
@@ -42,7 +41,6 @@
     void with_all_streams_do(std::function<void(MirBufferStream*)> const&) const override;
 
     void insert(frontend::BufferStreamId stream_id, std::shared_ptr<MirBufferStream> const& chain);
-    void insert(frontend::BufferStreamId stream_id, std::shared_ptr<MirPresentationChain> const& chain);
     void erase(frontend::BufferStreamId surface_id);
 
     //TODO: should have a mf::BufferID
@@ -58,7 +56,6 @@
     std::unordered_map<frontend::SurfaceId, std::shared_ptr<MirSurface>> surfaces;
     std::shared_timed_mutex mutable stream_guard;
     std::unordered_map<frontend::BufferStreamId, std::shared_ptr<MirBufferStream>> streams;
-    std::unordered_map<frontend::BufferStreamId, std::shared_ptr<MirPresentationChain>> chains;
     std::shared_timed_mutex mutable buffer_guard;
     std::unordered_map<int, std::shared_ptr<MirBuffer>> buffers;
     std::unordered_map<void*, std::shared_ptr<MirRenderSurface>> render_surfaces;
 
=== removed file 'src/client/error_chain.cpp'
--- src/client/error_chain.cpp	2016-11-09 02:30:14 +0000
+++ src/client/error_chain.cpp	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-/*
- * Copyright © 2016 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#include "error_chain.h"
-#include <boost/throw_exception.hpp>
-
-namespace mcl = mir::client;
-namespace geom = mir::geometry;
-
-mcl::ErrorChain::ErrorChain(
-    MirConnection* connection,
-    int id,
-    std::string const& error_msg) :
-    connection_(connection),
-    stream_id(id),
-    error(error_msg)
-{
-}
-
-char const* mcl::ErrorChain::error_msg() const
-{
-    return error.c_str();
-}
-
-MirConnection* mcl::ErrorChain::connection() const
-{
-    return connection_;
-}
-
-int mcl::ErrorChain::rpc_id() const
-{
-    return stream_id;
-}
-
-void mcl::ErrorChain::submit_buffer(MirBuffer*)
-{
-    BOOST_THROW_EXCEPTION(std::logic_error("Cannot submit: invalid MirPresentationChain"));
-}
-
-void mcl::ErrorChain::set_queueing_mode()
-{
-    BOOST_THROW_EXCEPTION(std::logic_error("Cannot set mode: invalid MirPresentationChain"));
-}
-
-void mcl::ErrorChain::set_dropping_mode()
-{
-    BOOST_THROW_EXCEPTION(std::logic_error("Cannot set mode: invalid MirPresentationChain"));
-}
 
=== removed file 'src/client/error_chain.h'
--- src/client/error_chain.h	2016-11-09 02:30:14 +0000
+++ src/client/error_chain.h	1970-01-01 00:00:00 +0000
@@ -1,51 +0,0 @@
-/*
- * Copyright © 2016 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_CLIENT_ERROR_CHAIN_H
-#define MIR_CLIENT_ERROR_CHAIN_H
-
-#include "mir_presentation_chain.h"
-#include <memory>
-
-namespace mir
-{
-namespace client
-{
-
-class ErrorChain : public MirPresentationChain
-{
-public:
-    ErrorChain(
-        MirConnection* connection,
-        int id,
-        std::string const& error_msg);
-    void submit_buffer(MirBuffer* buffer) override;
-    MirConnection* connection() const override;
-    int rpc_id() const override;
-    char const* error_msg() const override;
-    void set_dropping_mode() override;
-    void set_queueing_mode() override;
-private:
-    MirConnection* const connection_;
-    int const stream_id;
-    std::string const error;
-};
-
-}
-}
-#endif /* MIR_CLIENT_ERROR_CHAIN_H */
 
=== modified file 'src/client/error_render_surface.cpp'
--- src/client/error_render_surface.cpp	2016-12-09 02:54:31 +0000
+++ src/client/error_render_surface.cpp	2016-12-15 15:17:18 +0000
@@ -62,12 +62,22 @@
     BOOST_THROW_EXCEPTION(std::runtime_error(error));
 }
 
-MirPresentationChain* mcl::ErrorRenderSurface::get_presentation_chain()
-{
-    BOOST_THROW_EXCEPTION(std::runtime_error(error));
-}
-
 char const* mcl::ErrorRenderSurface::get_error_message() const
 {
     return error.c_str();
 }
+    
+void mcl::ErrorRenderSurface::submit_buffer(MirBuffer*)
+{
+    BOOST_THROW_EXCEPTION(std::runtime_error(error));
+}
+
+void mcl::ErrorRenderSurface::set_dropping_mode()
+{
+    BOOST_THROW_EXCEPTION(std::runtime_error(error));
+}
+
+void mcl::ErrorRenderSurface::set_queueing_mode()
+{
+    BOOST_THROW_EXCEPTION(std::runtime_error(error));
+}
 
=== modified file 'src/client/error_render_surface.h'
--- src/client/error_render_surface.h	2016-12-09 02:54:31 +0000
+++ src/client/error_render_surface.h	2016-12-15 15:17:18 +0000
@@ -41,7 +41,9 @@
         int width, int height,
         MirPixelFormat format,
         MirBufferUsage buffer_usage) override;
-    MirPresentationChain* get_presentation_chain() override;
+    void submit_buffer(mir::client::MirBuffer* buffer) override;
+    void set_dropping_mode() override;
+    void set_queueing_mode() override;
 private:
     std::string const error;
     MirConnection* const connection_;
 
=== modified file 'src/client/mir_buffer_api.cpp'
--- src/client/mir_buffer_api.cpp	2016-12-14 06:27:05 +0000
+++ src/client/mir_buffer_api.cpp	2016-12-15 15:17:18 +0000
@@ -16,10 +16,8 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#include "mir_toolkit/mir_presentation_chain.h"
 #include "mir_toolkit/mir_buffer.h"
 #include "mir_toolkit/mir_buffer_private.h"
-#include "presentation_chain.h"
 #include "mir_connection.h"
 #include "buffer.h"
 #include "mir/client_buffer.h"
 
=== modified file 'src/client/mir_connection.cpp'
--- src/client/mir_connection.cpp	2016-12-15 15:17:18 +0000
+++ src/client/mir_connection.cpp	2016-12-15 15:17:18 +0000
@@ -38,8 +38,6 @@
 #include "perf_report.h"
 #include "render_surface.h"
 #include "error_render_surface.h"
-#include "presentation_chain.h"
-#include "error_chain.h"
 #include "logging/perf_report.h"
 #include "lttng/perf_report.h"
 #include "buffer_factory.h"
@@ -1172,19 +1170,6 @@
     return display_configuration->take_snapshot();
 }
 
-std::shared_ptr<mcl::PresentationChain> MirConnection::create_presentation_chain_with_id(
-    MirRenderSurface* render_surface,
-    mir::protobuf::BufferStream const& a_protobuf_bs)
-{
-    if (!client_buffer_factory)
-        client_buffer_factory = platform->create_buffer_factory();
-    auto chain = std::make_shared<mcl::PresentationChain>(
-        this, a_protobuf_bs.id().value(), server, client_buffer_factory, buffer_factory);
-
-    surface_map->insert(render_surface->stream_id(), chain);
-    return chain;
-}
-
 void MirConnection::allocate_buffer(
     geom::Size size, MirPixelFormat format, MirBufferUsage usage,
     mir_buffer_callback callback, void* context)
@@ -1280,9 +1265,10 @@
     {
         auto rs = std::make_shared<mcl::RenderSurface>(
             this,
+            display_server(),
             request->native_window,
             platform,
-            protobuf_bs,
+            mf::BufferStreamId{protobuf_bs->id().value()},
             request->logical_size);
         surface_map->insert(request->native_window.get(), rs);
 
 
=== modified file 'src/client/mir_connection.h'
--- src/client/mir_connection.h	2016-12-15 15:17:18 +0000
+++ src/client/mir_connection.h	2016-12-15 15:17:18 +0000
@@ -167,10 +167,6 @@
         mir_buffer_stream_callback callback,
         void *context);
 
-    std::shared_ptr<mir::client::PresentationChain> create_presentation_chain_with_id(
-        MirRenderSurface* render_surface,
-        mir::protobuf::BufferStream const& a_protobuf_bs);
-
     void release_consumer_stream(MirBufferStream*);
 
     static bool is_valid(MirConnection *connection);
 
=== removed file 'src/client/mir_presentation_chain.h'
--- src/client/mir_presentation_chain.h	2016-11-22 03:42:44 +0000
+++ src/client/mir_presentation_chain.h	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-/*
- * Copyright © 2016 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_CLIENT_MIR_PRESENTATION_CHAIN_H
-#define MIR_CLIENT_MIR_PRESENTATION_CHAIN_H
-
-#include "mir/geometry/size.h"
-#include "mir_toolkit/mir_presentation_chain.h"
-#include "mir/mir_buffer.h"
-
-class MirPresentationChain
-{
-public:
-    virtual ~MirPresentationChain() = default;
-    virtual void submit_buffer(mir::client::MirBuffer* buffer) = 0;
-    virtual MirConnection* connection() const = 0;
-    virtual int rpc_id() const = 0;
-    virtual char const* error_msg() const = 0;
-
-    //In the future, the only mode will be dropping
-    virtual void set_dropping_mode() = 0;
-    virtual void set_queueing_mode() = 0;
-
-protected:
-    MirPresentationChain(MirPresentationChain const&) = delete;
-    MirPresentationChain& operator=(MirPresentationChain const&) = delete;
-    MirPresentationChain() = default;
-};
-
-#endif /* MIR_CLIENT_MIR_PRESENTATION_CHAIN_H */
 
=== removed file 'src/client/mir_presentation_chain_api.cpp'
--- src/client/mir_presentation_chain_api.cpp	2016-12-15 15:17:18 +0000
+++ src/client/mir_presentation_chain_api.cpp	1970-01-01 00:00:00 +0000
@@ -1,88 +0,0 @@
-/*
- * Copyright © 2016 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#include "mir_toolkit/mir_presentation_chain.h"
-#include "mir_toolkit/mir_buffer.h"
-#include "mir_toolkit/mir_buffer_private.h"
-#include "mir_connection.h"
-#include "buffer.h"
-#include "mir_presentation_chain.h"
-#include "mir/uncaught.h"
-#include "mir/require.h"
-#include <stdexcept>
-#include <boost/throw_exception.hpp>
-namespace mcl = mir::client;
-
-//private NBS api under development
-void mir_presentation_chain_submit_buffer(MirPresentationChain* chain, MirBuffer* b)
-try
-{
-    auto buffer = reinterpret_cast<mcl::MirBuffer*>(b);
-    mir::require(chain && buffer && mir_presentation_chain_is_valid(chain));
-    chain->submit_buffer(buffer);
-}
-catch (std::exception const& ex)
-{
-    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
-}
-
-bool mir_presentation_chain_is_valid(MirPresentationChain* chain)
-try
-{
-    mir::require(chain);
-    return mir_presentation_chain_get_error_message(chain) == std::string("");
-}
-catch (std::exception const& ex)
-{
-    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
-    return false;
-}
-
-char const *mir_presentation_chain_get_error_message(MirPresentationChain* chain)
-try
-{
-    mir::require(chain);
-    return chain->error_msg();
-}
-catch (std::exception const& ex)
-{
-    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
-    return "error accessing error message";
-}
-
-void mir_presentation_chain_set_queueing_mode(MirPresentationChain* chain)
-try
-{
-    mir::require(chain);
-    chain->set_queueing_mode();
-}
-catch (std::exception const& ex)
-{
-    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
-}
-
-void mir_presentation_chain_set_dropping_mode(MirPresentationChain* chain)
-try
-{
-    mir::require(chain);
-    chain->set_dropping_mode();
-}
-catch (std::exception const& ex)
-{
-    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
-}
 
=== modified file 'src/client/mir_render_surface.h'
--- src/client/mir_render_surface.h	2016-12-09 02:54:31 +0000
+++ src/client/mir_render_surface.h	2016-12-15 15:17:18 +0000
@@ -24,6 +24,13 @@
 #include "mir/frontend/buffer_stream_id.h"
 #include "mir/geometry/size.h"
 
+namespace mir
+{
+namespace client
+{
+class MirBuffer;
+}
+}
 class MirRenderSurface
 {
 public:
@@ -36,8 +43,10 @@
         int width, int height,
         MirPixelFormat format,
         MirBufferUsage buffer_usage) = 0;
-    virtual MirPresentationChain* get_presentation_chain() = 0;
     virtual char const* get_error_message() const = 0;
+    virtual void submit_buffer(mir::client::MirBuffer* buffer) = 0;
+    virtual void set_dropping_mode() = 0;
+    virtual void set_queueing_mode() = 0;
     virtual ~MirRenderSurface() = default;
 protected:
     MirRenderSurface(MirRenderSurface const&) = delete;
 
=== modified file 'src/client/mir_render_surface_api.cpp'
--- src/client/mir_render_surface_api.cpp	2016-12-15 15:17:18 +0000
+++ src/client/mir_render_surface_api.cpp	2016-12-15 15:17:18 +0000
@@ -14,10 +14,12 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Cemil Azizoglu <[e-mail]>
+ *              Kevin DuBois <[e-mail]>
  */
 
 #include "mir_connection.h"
 #include "render_surface.h"
+#include "mir_toolkit/mir_buffer_private.h"
 #include "mir/uncaught.h"
 #include "mir/require.h"
 #include "connection_surface_map.h"
@@ -191,21 +193,6 @@
     return nullptr;
 }
 
-MirPresentationChain* mir_render_surface_get_presentation_chain(
-    MirRenderSurface* render_surface)
-try
-{
-    mir::require(render_surface);
-    auto connection = connection_map.connection(render_surface);
-    auto rs = connection->connection_surface_map()->render_surface(render_surface);
-    return rs->get_presentation_chain();
-}
-catch (std::exception const& ex)
-{
-    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
-    return nullptr;
-}
-
 void mir_render_surface_get_size(MirRenderSurface* render_surface, int* width, int* height)
 {
     mir::require(render_surface && width && height);
@@ -233,3 +220,43 @@
     auto rs = connection->connection_surface_map()->render_surface(surface);
     spec->rendersurface_cursor = MirSurfaceSpec::RenderSurfaceCursor{rs->stream_id(), {hotspot_x, hotspot_y}};
 }
+
+void mir_render_surface_set_queueing_mode(MirRenderSurface* render_surface)
+try
+{
+    mir::require(render_surface);
+    auto connection = connection_map.connection(render_surface);
+    auto rs = connection->connection_surface_map()->render_surface(render_surface);
+    rs->set_queueing_mode();
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+}
+
+void mir_render_surface_set_dropping_mode(MirRenderSurface* render_surface)
+try
+{
+    mir::require(render_surface);
+    auto connection = connection_map.connection(render_surface);
+    auto rs = connection->connection_surface_map()->render_surface(render_surface);
+    rs->set_dropping_mode();
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+}
+
+void mir_render_surface_submit_buffer(MirRenderSurface* render_surface, MirBuffer* b)
+try
+{
+    mir::require(render_surface && b && mir_render_surface_is_valid(render_surface));
+    auto connection = connection_map.connection(render_surface);
+    auto rs = connection->connection_surface_map()->render_surface(render_surface);
+    auto buffer = reinterpret_cast<mir::client::MirBuffer*>(b);
+    rs->submit_buffer(buffer);
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+}
 
=== modified file 'src/client/mir_surface_api.cpp'
--- src/client/mir_surface_api.cpp	2016-12-15 15:17:18 +0000
+++ src/client/mir_surface_api.cpp	2016-12-15 15:17:18 +0000
@@ -20,12 +20,10 @@
 
 #include "mir_toolkit/mir_surface.h"
 #include "mir_toolkit/mir_wait.h"
-#include "mir_toolkit/mir_presentation_chain.h"
 #include "mir/require.h"
 
 #include "mir_connection.h"
 #include "mir_surface.h"
-#include "presentation_chain.h"
 #include "render_surface.h"
 #include "error_connections.h"
 #include "connection_surface_map.h"
 
=== removed file 'src/client/presentation_chain.cpp'
--- src/client/presentation_chain.cpp	2016-12-09 02:54:31 +0000
+++ src/client/presentation_chain.cpp	1970-01-01 00:00:00 +0000
@@ -1,96 +0,0 @@
-/*
- * Copyright © 2016 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#include "mir/client_buffer_factory.h"
-#include "mir/client_buffer.h"
-#include "rpc/mir_display_server.h"
-#include "presentation_chain.h"
-#include "protobuf_to_native_buffer.h"
-#include "buffer_factory.h"
-#include <boost/throw_exception.hpp>
-#include <algorithm>
-
-namespace mcl = mir::client;
-namespace geom = mir::geometry;
-namespace mp = mir::protobuf;
-namespace gp = google::protobuf;
-
-mcl::PresentationChain::PresentationChain(
-    MirConnection* connection,
-    int stream_id,
-    mir::client::rpc::DisplayServer& server,
-    std::shared_ptr<mcl::ClientBufferFactory> const& native_buffer_factory,
-    std::shared_ptr<mcl::AsyncBufferFactory> const& mir_buffer_factory) :
-    connection_(connection),
-    stream_id(stream_id),
-    server(server),
-    native_buffer_factory(native_buffer_factory),
-    mir_buffer_factory(mir_buffer_factory),
-    interval_config{server, frontend::BufferStreamId{stream_id}}
-{
-}
-
-//note: the caller of the mir::client::rpc::DisplayServer interface
-//      has to provide the object for the server to fill when we get a
-//      response, but we can't pass ownership of the response object to
-//      the server given the current interface, nor do we know when the
-//      server has been destroyed, so we have to allow for responses
-//      to complete after the PresentationChain object has been deleted.
-//      (mcl::BufferStream has a similar situation)
-static void ignore_response(mp::Void* response)
-{
-    delete response;
-}
-
-void mcl::PresentationChain::submit_buffer(MirBuffer* buffer)
-{
-    mp::BufferRequest request;
-    {
-        request.mutable_id()->set_value(stream_id);
-        request.mutable_buffer()->set_buffer_id(buffer->rpc_id());
-        buffer->submitted();
-    }
-
-    auto ignored = new mp::Void;
-    server.submit_buffer(&request, ignored, gp::NewCallback(ignore_response, ignored));
-}
-
-int mcl::PresentationChain::rpc_id() const
-{
-    return stream_id;
-}
-
-MirConnection* mcl::PresentationChain::connection() const
-{
-    return connection_;
-}
-
-char const* mcl::PresentationChain::error_msg() const
-{
-    return "";
-}
-
-void mcl::PresentationChain::set_dropping_mode()
-{
-    mir_wait_for(interval_config.set_swap_interval(0));
-}
-
-void mcl::PresentationChain::set_queueing_mode()
-{
-    mir_wait_for(interval_config.set_swap_interval(1));
-}
 
=== removed file 'src/client/presentation_chain.h'
--- src/client/presentation_chain.h	2016-11-09 02:30:14 +0000
+++ src/client/presentation_chain.h	1970-01-01 00:00:00 +0000
@@ -1,74 +0,0 @@
-/*
- * Copyright © 2016 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_CLIENT_PRESENTATION_CHAIN_H
-#define MIR_CLIENT_PRESENTATION_CHAIN_H
-
-#include "mir_presentation_chain.h"
-#include "buffer_stream.h"
-#include "mir/geometry/size.h"
-#include "mir_toolkit/mir_presentation_chain.h"
-#include "mir_protobuf.pb.h"
-#include "buffer.h"
-#include <mutex>
-#include <memory>
-
-namespace mir
-{
-namespace client
-{
-class ClientBufferFactory;
-class ClientBuffer;
-class AsyncBufferFactory;
-namespace rpc
-{
-class DisplayServer;
-}
-
-class PresentationChain : public MirPresentationChain
-{
-public:
-    PresentationChain(
-        MirConnection* connection,
-        int rpc_id,
-        rpc::DisplayServer& server,
-        std::shared_ptr<ClientBufferFactory> const& native_buffer_factory,
-        std::shared_ptr<AsyncBufferFactory> const& mir_buffer_factory);
-    void submit_buffer(MirBuffer* buffer) override;
-    MirConnection* connection() const override;
-    int rpc_id() const override;
-    char const* error_msg() const override;
-    void set_dropping_mode() override;
-    void set_queueing_mode() override;
-
-private:
-
-    MirConnection* const connection_;
-    int const stream_id;
-    rpc::DisplayServer& server;
-    std::shared_ptr<ClientBufferFactory> const native_buffer_factory;
-    std::shared_ptr<AsyncBufferFactory> const mir_buffer_factory;
-
-    BufferStreamConfiguration interval_config;
-
-    std::mutex mutex;
-    std::vector<std::unique_ptr<Buffer>> buffers;
-};
-}
-}
-#endif /* MIR_CLIENT_PRESENTATION_CHAIN_H */
 
=== modified file 'src/client/render_surface.cpp'
--- src/client/render_surface.cpp	2016-12-09 02:54:31 +0000
+++ src/client/render_surface.cpp	2016-12-15 15:17:18 +0000
@@ -15,11 +15,13 @@
  *
  * Authored by:
  *   Cemil Azizoglu <[e-mail]>
+ *   Kevin DuBois <[e-mail]>
  */
 
 #include "render_surface.h"
 #include "buffer_stream.h"
 #include "mir_wait_handle.h"
+#include "mir/mir_buffer.h"
 #include "rpc/mir_display_server.h"
 
 #include "mir/client_platform.h"
@@ -33,15 +35,18 @@
 
 mcl::RenderSurface::RenderSurface(
     MirConnection* const connection,
+    mcl::rpc::DisplayServer& server,
     std::shared_ptr<void> native_window,
     std::shared_ptr<ClientPlatform> client_platform,
-    std::shared_ptr<mp::BufferStream> protobuf_bs,
+    mf::BufferStreamId id,
     geom::Size size) :
     connection_(connection),
+    server(server),
     wrapped_native_window(native_window),
     platform(client_platform),
-    protobuf_bs(protobuf_bs),
-    desired_size{size}
+    id(id),
+    desired_size{size},
+    interval_config(server, id)
 {
 }
 
@@ -52,7 +57,7 @@
 
 mf::BufferStreamId mcl::RenderSurface::stream_id() const
 {
-    return mf::BufferStreamId(protobuf_bs->id().value());
+    return id;
 }
 
 MirBufferStream* mcl::RenderSurface::get_buffer_stream(
@@ -60,15 +65,17 @@
     MirPixelFormat format,
     MirBufferUsage buffer_usage)
 {
-    if (chain_from_id || stream_from_id)
+    if (submitting || stream_from_id)
         BOOST_THROW_EXCEPTION(std::logic_error("Content already handed out"));
 
-    protobuf_bs->set_pixel_format(format);
-    protobuf_bs->set_buffer_usage(buffer_usage);
+    mir::protobuf::BufferStream protobuf_bs;
+    protobuf_bs.mutable_id()->set_value(id.as_value());
+    protobuf_bs.set_pixel_format(format);
+    protobuf_bs.set_buffer_usage(buffer_usage);
     stream_from_id = connection_->create_client_buffer_stream_with_id(width,
                                                                       height,
                                                                       this,
-                                                                      *protobuf_bs);
+                                                                      protobuf_bs);
     if (buffer_usage == mir_buffer_usage_hardware)
     {
         platform->use_egl_native_window(
@@ -78,19 +85,6 @@
     return stream_from_id.get();
 }
 
-MirPresentationChain* mcl::RenderSurface::get_presentation_chain()
-{
-    if (chain_from_id || stream_from_id)
-        BOOST_THROW_EXCEPTION(std::logic_error("Content already handed out"));
-
-    chain_from_id = connection_->create_presentation_chain_with_id(this,
-                                                                   *protobuf_bs);
-    //TODO: Figure out how to handle mir_buffer_usage_hardware once
-    //      EGL is made to support RSs.
-
-    return reinterpret_cast<MirPresentationChain*>(chain_from_id.get());
-}
-
 geom::Size mcl::RenderSurface::size() const
 {
     std::lock_guard<decltype(size_mutex)> lk(size_mutex);
@@ -105,14 +99,49 @@
 
 bool mcl::RenderSurface::valid() const
 {
-    return protobuf_bs->has_id() && !protobuf_bs->has_error();
+    return true;
 }
 
 char const* mcl::RenderSurface::get_error_message() const
 {
-    if (protobuf_bs->has_error())
-    {
-        return protobuf_bs->error().c_str();
-    }
     return "";
 }
+
+//note: the caller of the mir::client::rpc::DisplayServer interface
+//      has to provide the object for the server to fill when we get a
+//      response, but we can't pass ownership of the response object to
+//      the server given the current interface, nor do we know when the
+//      server has been destroyed, so we have to allow for responses
+//      to complete after the PresentationChain object has been deleted.
+//      (mcl::BufferStream has a similar situation)
+static void ignore_response(mp::Void* response)
+{
+    delete response;
+}
+
+void mcl::RenderSurface::submit_buffer(MirBuffer* buffer)
+{
+    if (stream_from_id)
+        BOOST_THROW_EXCEPTION(std::logic_error("Content already handed out"));
+
+    submitting = true;
+    mp::BufferRequest request;
+    {
+        request.mutable_id()->set_value(stream_id().as_value());
+        request.mutable_buffer()->set_buffer_id(buffer->rpc_id());
+        buffer->submitted();
+    }
+
+    auto ignored = new mp::Void;
+    server.submit_buffer(&request, ignored, google::protobuf::NewCallback(ignore_response, ignored));
+}
+
+void mcl::RenderSurface::set_dropping_mode()
+{
+    mir_wait_for(interval_config.set_swap_interval(0));
+}
+
+void mcl::RenderSurface::set_queueing_mode()
+{
+    mir_wait_for(interval_config.set_swap_interval(1));
+}
 
=== modified file 'src/client/render_surface.h'
--- src/client/render_surface.h	2016-12-13 06:00:32 +0000
+++ src/client/render_surface.h	2016-12-15 15:17:18 +0000
@@ -22,6 +22,7 @@
 
 #include "mir_connection.h"
 #include "mir_render_surface.h"
+#include "buffer_stream_configuration.h"
 #include "mir_toolkit/mir_render_surface.h"
 #include "mir_toolkit/client_types.h"
 #include "mir/frontend/surface_id.h"
@@ -43,11 +44,13 @@
 class RenderSurface : public MirRenderSurface
 {
 public:
-    RenderSurface(MirConnection* const connection,
-                  std::shared_ptr<void> native_window,
-                  std::shared_ptr<ClientPlatform> client_platform,
-                  std::shared_ptr<mir::protobuf::BufferStream> protobuf_bs,
-                  geometry::Size size);
+    RenderSurface(
+        MirConnection* const connection,
+        rpc::DisplayServer& server,
+        std::shared_ptr<void> native_window,
+        std::shared_ptr<ClientPlatform> client_platform,
+        frontend::BufferStreamId id,
+        geometry::Size size);
     MirConnection* connection() const override;
     mir::geometry::Size size() const override;
     void set_size(mir::geometry::Size) override;
@@ -58,18 +61,22 @@
         int width, int height,
         MirPixelFormat format,
         MirBufferUsage buffer_usage) override;
-    MirPresentationChain* get_presentation_chain() override;
+    void submit_buffer(MirBuffer* buffer) override;
+    void set_dropping_mode() override;
+    void set_queueing_mode() override;
 
 private:
     MirConnection* const connection_;
+    rpc::DisplayServer& server;
     std::shared_ptr<void> wrapped_native_window;
     std::shared_ptr<ClientPlatform> platform;
-    std::shared_ptr<mir::protobuf::BufferStream> protobuf_bs;
+    frontend::BufferStreamId id;
     std::shared_ptr<mir::client::BufferStream> stream_from_id;
-    std::shared_ptr<mir::client::PresentationChain> chain_from_id;
 
+    bool submitting = false;
     std::mutex mutable size_mutex;
     geometry::Size desired_size;
+    BufferStreamConfiguration interval_config;
 };
 }
 }
 
=== modified file 'src/client/rpc/mir_protobuf_rpc_channel.cpp'
--- src/client/rpc/mir_protobuf_rpc_channel.cpp	2016-12-13 06:00:32 +0000
+++ src/client/rpc/mir_protobuf_rpc_channel.cpp	2016-12-15 15:17:18 +0000
@@ -21,7 +21,6 @@
 
 #include "../surface_map.h"
 #include "../buffer.h"
-#include "../presentation_chain.h"
 #include "../buffer_factory.h"
 #include "../mir_surface.h"
 #include "../display_configuration.h"
 
=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2016-12-15 15:17:18 +0000
+++ src/client/symbols.map	2016-12-15 15:17:18 +0000
@@ -368,10 +368,8 @@
     mir_buffer_unmap;
     mir_buffer_set_callback;
     mir_buffer_release;
-    mir_presentation_chain_is_valid;
-    mir_presentation_chain_get_error_message;
     mir_connection_allocate_buffer;
-    mir_presentation_chain_submit_buffer;
+    mir_render_surface_submit_buffer;
     mir_buffer_get_width;
     mir_buffer_get_height;
     mir_buffer_get_pixel_format;
@@ -382,7 +380,6 @@
     mir_connection_create_render_surface;
     mir_connection_create_render_surface_sync;
     mir_render_surface_get_buffer_stream;
-    mir_render_surface_get_presentation_chain;
     mir_render_surface_is_valid;
     mir_render_surface_get_error_message;
     mir_render_surface_get_size;
@@ -393,8 +390,8 @@
     #private functions needed temporarily by nested passthrough
     #should not be published along with the rest of the NBS symbols
     mir_buffer_get_egl_image_parameters;
-    mir_presentation_chain_set_queueing_mode;
-    mir_presentation_chain_set_dropping_mode;
+    mir_render_surface_set_queueing_mode;
+    mir_render_surface_set_dropping_mode;
   local:
     *;
 } MIR_CLIENT_DETAIL_9v19;
 
=== modified file 'src/include/client/mir_toolkit/client_types_nbs.h'
--- src/include/client/mir_toolkit/client_types_nbs.h	2016-12-15 15:17:18 +0000
+++ src/include/client/mir_toolkit/client_types_nbs.h	2016-12-15 15:17:18 +0000
@@ -29,7 +29,6 @@
 #endif
 
 /* NOTE: this file will be rolled into mir_toolkit/client_types.h when made public. */
-typedef struct MirPresentationChain MirPresentationChain;
 typedef struct MirBuffer MirBuffer;
 typedef struct MirRenderSurface MirRenderSurface;
 
 
=== modified file 'src/include/client/mir_toolkit/extensions/android_buffer.h'
--- src/include/client/mir_toolkit/extensions/android_buffer.h	2016-11-30 18:00:03 +0000
+++ src/include/client/mir_toolkit/extensions/android_buffer.h	2016-12-15 15:17:18 +0000
@@ -34,7 +34,7 @@
  *
  *  The callback will be called when the buffer is available for use.
  *  It will be called once when created, and once per every
- *  mir_presentation_chain_submit_buffer.
+ *  mir_render_surface_submit_buffer.
  *
  *  The buffer can be destroyed via mir_buffer_release().
  *
 
=== modified file 'src/include/client/mir_toolkit/mir_buffer.h'
--- src/include/client/mir_toolkit/mir_buffer.h	2016-12-14 06:27:05 +0000
+++ src/include/client/mir_toolkit/mir_buffer.h	2016-12-15 15:17:18 +0000
@@ -34,7 +34,7 @@
  *
  *  The callback will be called when the buffer is available for use.
  *  It will be called once when created, and once per every
- *  mir_presentation_chain_submit_buffer.
+ *  mir_render_surface_submit_buffer.
  *
  *   \param [in] connection            The connection
  *   \param [in] width                 Requested buffer width
 
=== modified file 'src/include/client/mir_toolkit/mir_buffer_private.h'
--- src/include/client/mir_toolkit/mir_buffer_private.h	2016-11-11 07:56:09 +0000
+++ src/include/client/mir_toolkit/mir_buffer_private.h	2016-12-15 15:17:18 +0000
@@ -30,28 +30,28 @@
 extern "C" {
 #endif
 
-/** Note: mir_presentation_chain{set_queueing,set_dropping}_mode are temporary
+/** Note: mir_render_surface{set_queueing,set_dropping}_mode are temporary
  * modes needed by the nested server to support swapinterval on passthrough
  * clients. Once frame notification signals are given to the client, we can
  * just have dropping mode.
  **/
 
 /**
- * Set the MirPresentationChain to display all buffers for at least 1 frame
- * once submitted via mir_presentation_chain_submit_buffer.
+ * Set the MirRenderSurface to display all buffers for at least 1 frame
+ * once submitted via mir_render_surface_submit_buffer.
  *
  *   \param [in] chain         The chain
  **/
-void mir_presentation_chain_set_queueing_mode(MirPresentationChain* chain);
+void mir_render_surface_set_queueing_mode(MirRenderSurface* chain);
 
 /**
- * Set the MirPresentationChain to return buffers held by the server
+ * Set the MirRenderSurface to return buffers held by the server
  * to the client at the earliest possible time when a new buffer is submitted
- * to mir_presentation_chain_submit_buffer.
+ * to mir_render_surface_submit_buffer.
  *
  *   \param [in] chain         The chain
  **/
-void mir_presentation_chain_set_dropping_mode(MirPresentationChain* chain);
+void mir_render_surface_set_dropping_mode(MirRenderSurface* chain);
 
 /** Suggest parameters to use with EGLCreateImage for a given MirBuffer
  *
 
=== removed file 'src/include/client/mir_toolkit/mir_presentation_chain.h'
--- src/include/client/mir_toolkit/mir_presentation_chain.h	2016-12-15 15:17:18 +0000
+++ src/include/client/mir_toolkit/mir_presentation_chain.h	1970-01-01 00:00:00 +0000
@@ -1,72 +0,0 @@
-/*
- * Copyright © 2016 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef MIR_TOOLKIT_MIR_PRESENTATION_CHAIN_H_
-#define MIR_TOOLKIT_MIR_PRESENTATION_CHAIN_H_
-
-#include <mir_toolkit/client_types_nbs.h>
-
-#ifdef __cplusplus
-/**
- * \addtogroup mir_toolkit
- * @{
- */
-extern "C" {
-#endif
-
-/**
- * Test for a valid presentation chain
- *
- * \param [in] presentation_chain  The presentation chain
- * \return                     True if the supplied presentation_chain is valid,
- *                             or false otherwise.
- */
-bool mir_presentation_chain_is_valid(MirPresentationChain* presentation_chain);
-
-/**
- * Retrieve a text description of the error. The returned string is owned by
- * the library and remains valid until the chain or the associated
- * connection has been released.
- *   \param [in] presentation_chain    The presentation chain
- *   \return                           A text description of any error
- *                                     resulting in an invalid chain, or the
- *                                     empty string "" if the chain is valid.
- */
-char const *mir_presentation_chain_get_error_message(
-    MirPresentationChain* presentation_chain);
-
-/** Submit a buffer to the server so the server can display it.
- *
- *  The server will notify the client when the buffer is available again via
- *  the callback registered during buffer creation.
- *
- *   \warning: Once submitted, the buffer cannot be modified until the server 
- *             has returned it. There's no guarantee about how long a server
- *             may hold the submitted buffer.
- *
- *   \param [in] presentation_chain  The presentation chain
- *   \param [in] buffer              The buffer to be submitted
- **/
-void mir_presentation_chain_submit_buffer(
-    MirPresentationChain* presentation_chain, MirBuffer* buffer);
-
-#ifdef __cplusplus
-}
-/**@}*/
-#endif
-
-#endif // MIR_TOOLKIT_MIR_PRESENTATION_CHAIN_H_
 
=== modified file 'src/include/client/mir_toolkit/mir_render_surface.h'
--- src/include/client/mir_toolkit/mir_render_surface.h	2016-12-13 06:00:32 +0000
+++ src/include/client/mir_toolkit/mir_render_surface.h	2016-12-15 15:17:18 +0000
@@ -125,9 +125,8 @@
  * \param [in] usage             Requested buffer usage
  *
  * \return                       The buffer stream contained in the given render surface
- *                               or 'nullptr' if it, or
- *                               mir_render_surface_get_presentation_chain(), has already
- *                               been called once
+ *                               or 'nullptr' if mir_render_surface_submit_buffer()
+ *                               has already been called once.
  */
 MirBufferStream* mir_render_surface_get_buffer_stream(
     MirRenderSurface* render_surface,
@@ -136,17 +135,6 @@
     MirBufferUsage usage);
 
 /**
- * Obtain the presentation chain backing a given render surface
- *
- * \return                       The chain contained in the given render surface
- *                               or 'nullptr' if it, or
- *                               mir_render_surface_get_buffer_stream(), has already
- *                               been called once
- */
-MirPresentationChain* mir_render_surface_get_presentation_chain(
-    MirRenderSurface* render_surface);
-
-/**
  * Set the MirSurfaceSpec to display content contained in a render surface
  *
  * \warning: The initial call to mir_surface_spec_add_render_surface will set
@@ -181,6 +169,22 @@
     MirRenderSurface* render_surface,
     int hotspot_x, int hotspot_y);
 
+/** Submit a buffer to the server so the server can display it.
+ *
+ *  The server will notify the client when the buffer is available again via
+ *  the callback registered during buffer creation.
+ *
+ *   \note: this queues in the same way as VK_PRESENT_MODE_FIFO_KHR
+ *   \warning: Once submitted, the buffer cannot be modified until the server 
+ *             has returned it. There's no guarantee about how long a server
+ *             may hold the submitted buffer.
+ *
+ *   \param [in] render_surface  The presentation chain
+ *   \param [in] buffer              The buffer to be submitted
+ **/
+void mir_render_surface_submit_buffer(
+    MirRenderSurface* render_surface, MirBuffer* buffer);
+
 #ifdef __cplusplus
 }
 /**@}*/
 
=== modified file 'src/server/graphics/nested/display_buffer.cpp'
--- src/server/graphics/nested/display_buffer.cpp	2016-11-16 13:24:41 +0000
+++ src/server/graphics/nested/display_buffer.cpp	2016-12-15 15:17:18 +0000
@@ -137,7 +137,7 @@
 
     {
         std::unique_lock<std::mutex> lk(mutex);
-        SubmissionInfo submission_info{native->client_handle(), host_chain->handle()};
+        SubmissionInfo submission_info{native->client_handle(), host_chain->rs()};
         auto submitted = submitted_buffers.find(submission_info);
         if ((submission_info != last_submitted) && (submitted != submitted_buffers.end()))
             BOOST_THROW_EXCEPTION(std::logic_error("cannot resubmit buffer that has not been returned by host server"));
@@ -155,7 +155,7 @@
 
     native->on_ownership_notification(
         std::bind(&mgn::detail::DisplayBuffer::release_buffer, this,
-        native->client_handle(), host_chain->handle()));
+        native->client_handle(), host_chain->rs()));
     host_chain->submit_buffer(*native);
 
     if (content != BackingContent::chain)
@@ -168,7 +168,7 @@
     return true;
 }
 
-void mgn::detail::DisplayBuffer::release_buffer(MirBuffer* b, MirPresentationChain *c)
+void mgn::detail::DisplayBuffer::release_buffer(MirBuffer* b, MirRenderSurface *c)
 {
     std::unique_lock<std::mutex> lk(mutex);
     auto buf = submitted_buffers.find(SubmissionInfo{b, c});
 
=== modified file 'src/server/graphics/nested/display_buffer.h'
--- src/server/graphics/nested/display_buffer.h	2016-10-31 02:37:31 +0000
+++ src/server/graphics/nested/display_buffer.h	2016-12-15 15:17:18 +0000
@@ -93,11 +93,11 @@
     glm::mat4 const identity;
 
     std::mutex mutex;
-    typedef std::tuple<MirBuffer*, MirPresentationChain*> SubmissionInfo;
+    typedef std::tuple<MirBuffer*, MirRenderSurface*> SubmissionInfo;
     std::map<SubmissionInfo, std::shared_ptr<graphics::Buffer>> submitted_buffers;
     SubmissionInfo last_submitted { nullptr, nullptr };
 
-    void release_buffer(MirBuffer* b, MirPresentationChain* c);
+    void release_buffer(MirBuffer* b, MirRenderSurface* c);
 };
 }
 }
 
=== modified file 'src/server/graphics/nested/host_chain.h'
--- src/server/graphics/nested/host_chain.h	2016-12-15 15:17:18 +0000
+++ src/server/graphics/nested/host_chain.h	2016-12-15 15:17:18 +0000
@@ -40,7 +40,6 @@
     virtual ~HostChain() = default;
     virtual void submit_buffer(NativeBuffer&) = 0;
     virtual void set_submission_mode(SubmissionMode mode) = 0;
-    virtual MirPresentationChain* handle() = 0;
     virtual MirRenderSurface* rs() const = 0;
 protected:
     HostChain() = default;
 
=== modified file 'src/server/graphics/nested/mir_client_host_connection.cpp'
--- src/server/graphics/nested/mir_client_host_connection.cpp	2016-12-15 15:17:18 +0000
+++ src/server/graphics/nested/mir_client_host_connection.cpp	2016-12-15 15:17:18 +0000
@@ -29,7 +29,6 @@
 #include "mir_toolkit/mir_buffer.h"
 #include "mir_toolkit/mir_extension_core.h"
 #include "mir_toolkit/mir_buffer_private.h"
-#include "mir_toolkit/mir_presentation_chain.h"
 #include "mir_toolkit/mir_render_surface.h"
 #include "mir_toolkit/extensions/fenced_buffers.h"
 #include "mir/raii.h"
@@ -505,8 +504,7 @@
 {
 
     Chain(MirConnection* connection) :
-        render_surface(mir_connection_create_render_surface_sync(connection, 0, 0)),
-        chain(mir_render_surface_get_presentation_chain(render_surface))
+        render_surface(mir_connection_create_render_surface_sync(connection, 0, 0))
     {
     }
     ~Chain()
@@ -516,20 +514,15 @@
 
     void submit_buffer(mgn::NativeBuffer& buffer) override
     {
-        mir_presentation_chain_submit_buffer(chain, buffer.client_handle());
+        mir_render_surface_submit_buffer(render_surface, buffer.client_handle());
     }
 
     void set_submission_mode(mgn::SubmissionMode mode) override
     {
         if (mode == mgn::SubmissionMode::queueing)
-            mir_presentation_chain_set_queueing_mode(chain);
+            mir_render_surface_set_queueing_mode(render_surface);
         else
-            mir_presentation_chain_set_dropping_mode(chain);
-    }
-
-    MirPresentationChain* handle() override
-    {
-        return chain;
+            mir_render_surface_set_dropping_mode(render_surface);
     }
 
     MirRenderSurface* rs() const override
@@ -539,7 +532,6 @@
 
 private:
     MirRenderSurface* const render_surface;
-    MirPresentationChain* chain;
 };
 
 std::unique_ptr<mgn::HostChain> mgn::MirClientHostConnection::create_chain() const
 
=== modified file 'tests/acceptance-tests/staging/test_buffer_stream_arrangement.cpp'
--- tests/acceptance-tests/staging/test_buffer_stream_arrangement.cpp	2016-12-15 15:17:18 +0000
+++ tests/acceptance-tests/staging/test_buffer_stream_arrangement.cpp	2016-12-15 15:17:18 +0000
@@ -17,7 +17,6 @@
  */
 
 #include "../buffer_stream_arrangement.h"
-#include "mir_toolkit/mir_presentation_chain.h"
 #include "mir_toolkit/mir_render_surface.h"
 #include <gmock/gmock.h>
 
 
=== modified file 'tests/acceptance-tests/staging/test_presentation_chain.cpp'
--- tests/acceptance-tests/staging/test_presentation_chain.cpp	2016-12-15 15:17:18 +0000
+++ tests/acceptance-tests/staging/test_presentation_chain.cpp	2016-12-15 15:17:18 +0000
@@ -17,7 +17,6 @@
  */
 
 #include "mir_toolkit/mir_render_surface.h"
-#include "mir_toolkit/mir_presentation_chain.h"
 #include "mir_toolkit/mir_buffer.h"
 
 #include "mir_toolkit/mir_client_library.h"
@@ -46,28 +45,21 @@
     Chain& operator=(Chain const&) = delete;
 
     Chain(MirConnection* connection) :
-        rs(mir_connection_create_render_surface_sync(connection, 0, 0)),
-        chain(mir_render_surface_get_presentation_chain(rs))
+        rs(mir_connection_create_render_surface_sync(connection, 0, 0))
     {
     }
 
-    MirRenderSurface* content()
+    operator MirRenderSurface*()
     {
         return rs;
     }
 
-    operator MirPresentationChain*()
-    {
-        return chain;
-    }
-
     ~Chain()
     {
         mir_render_surface_release(rs);
     }
 private:
     MirRenderSurface* rs;
-    MirPresentationChain* chain;
 };
 
 class SurfaceWithChain
@@ -118,7 +110,7 @@
         auto spec = mir_connection_create_spec_for_normal_surface(
             connection, size.width.as_int(), size.height.as_int(), pf);
         mir_surface_spec_add_render_surface(
-            spec, chain.content(), size.width.as_int(), size.height.as_int(), 0, 0);
+            spec, chain, size.width.as_int(), size.height.as_int(), 0, 0);
         auto surface = mir_surface_create_sync(spec);
         mir_surface_spec_release(spec);
         return surface;
@@ -144,7 +136,7 @@
         mir_surface_spec_release(spec);
         spec = mir_create_surface_spec(connection);
         mir_surface_spec_add_render_surface(
-            spec, chain.content(), size.width.as_int(), size.height.as_int(), 0, 0);
+            spec, chain, size.width.as_int(), size.height.as_int(), 0, 0);
         mir_surface_apply_spec(surface, spec);
         mir_surface_spec_release(spec);
         return surface;
@@ -310,7 +302,7 @@
 
     for(auto i = 0u; i < num_iterations; i++)
     {
-        mir_presentation_chain_submit_buffer(surface.chain(), contexts[i % num_buffers].buffer());
+        mir_render_surface_submit_buffer(surface.chain(), contexts[i % num_buffers].buffer());
         contexts[i % num_buffers].unavailable();
         if (i != 0)
             ASSERT_TRUE(contexts[(i-1) % num_buffers].wait_for_buffer(10s)) << "iteration " << i;
@@ -339,7 +331,7 @@
 
     for(auto i = 0u; i < num_iterations; i++)
     {
-        mir_presentation_chain_submit_buffer(surface.chain(), contexts[i % num_buffers].buffer());
+        mir_render_surface_submit_buffer(surface.chain(), contexts[i % num_buffers].buffer());
         contexts[i % num_buffers].unavailable();
         if (i != 0)
             ASSERT_TRUE(contexts[(i-1) % num_buffers].wait_for_buffer(10s)) << "iteration " << i;
@@ -360,7 +352,7 @@
 
     ASSERT_TRUE(context.wait_for_buffer(10s));
     ASSERT_THAT(context.buffer(), Ne(nullptr));
-    mir_presentation_chain_submit_buffer(surface.chain(), context.buffer());
+    mir_render_surface_submit_buffer(surface.chain(), context.buffer());
     mir_buffer_release(context.buffer());
 }
 
@@ -383,10 +375,8 @@
 TEST_F(PresentationChain, destroying_a_chain_will_return_buffers_associated_with_chain)
 {
     auto rs_chain = mir_connection_create_render_surface_sync(connection, 1, 1);
-    auto chain = mir_render_surface_get_presentation_chain(rs_chain);
     auto rs_stream = mir_connection_create_render_surface_sync(connection, 1, 1);
     auto stream = mir_render_surface_get_buffer_stream(rs_stream, 25, 12, mir_pixel_format_abgr_8888, mir_buffer_usage_hardware);
-    ASSERT_TRUE(mir_presentation_chain_is_valid(chain));
     ASSERT_TRUE(mir_render_surface_is_valid(rs_chain));
     ASSERT_TRUE(mir_render_surface_is_valid(rs_stream));
 
@@ -408,7 +398,7 @@
         buffer_callback, &context);
     ASSERT_TRUE(context.wait_for_buffer(10s));
     context.unavailable();
-    mir_presentation_chain_submit_buffer(chain, context.buffer());
+    mir_render_surface_submit_buffer(rs_chain, context.buffer());
 
     spec = mir_connection_create_spec_for_changes(connection);
     mir_surface_spec_add_render_surface(spec, rs_stream, size.width.as_int(), size.height.as_int(), 0, 0);
@@ -498,9 +488,9 @@
 
     mir_buffer_set_callback(context.buffer(), another_buffer_callback, &another_context);
 
-    mir_presentation_chain_submit_buffer(surface.chain(), context.buffer());
+    mir_render_surface_submit_buffer(surface.chain(), context.buffer());
     //flush the 1st buffer out
-    mir_presentation_chain_submit_buffer(surface.chain(), second_buffer_context.buffer());
+    mir_render_surface_submit_buffer(surface.chain(), second_buffer_context.buffer());
 
     ASSERT_TRUE(another_context.wait_for_buffer(10s));
     ASSERT_THAT(another_context.buffer(), Ne(nullptr));
 
=== modified file 'tests/acceptance-tests/staging/test_render_surface.cpp'
--- tests/acceptance-tests/staging/test_render_surface.cpp	2016-12-13 06:00:32 +0000
+++ tests/acceptance-tests/staging/test_render_surface.cpp	2016-12-15 15:17:18 +0000
@@ -18,7 +18,7 @@
 
 #include "mir_toolkit/mir_client_library.h"
 #include "mir_toolkit/mir_render_surface.h"
-#include "mir_toolkit/mir_presentation_chain.h"
+#include "mir_toolkit/mir_buffer.h"
 
 #include "mir/geometry/size.h"
 #include "mir_test_framework/headless_in_process_server.h"
@@ -30,6 +30,7 @@
 
 namespace mtf = mir_test_framework;
 namespace geom = mir::geometry;
+using namespace std::chrono_literals;
 
 namespace
 {
@@ -192,127 +193,47 @@
     mir_connection_release(connection);
 }
 
-TEST_F(RenderSurfaceTest, can_hand_out_presentation_chain)
-{
-    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-
-    auto rs = mir_connection_create_render_surface_sync(
-        connection, logical_size.width.as_int(), logical_size.height.as_int());
-
-    auto pc = mir_render_surface_get_presentation_chain(rs);
-
-    ASSERT_THAT(pc, NotNull());
-    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
-
-    mir_render_surface_release(rs);
-    mir_connection_release(connection);
-}
-
-TEST_F(RenderSurfaceTest, hands_out_presentation_chain_only_once)
-{
-    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-
-    auto rs = mir_connection_create_render_surface_sync(
-        connection, logical_size.width.as_int(), logical_size.height.as_int());
-
-    auto pc = mir_render_surface_get_presentation_chain(rs);
-
-    ASSERT_THAT(pc, NotNull());
-    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
-
-    auto pc2 = mir_render_surface_get_presentation_chain(rs);
-
-    EXPECT_THAT(pc2, Eq(nullptr));
-
-    mir_render_surface_release(rs);
-    mir_connection_release(connection);
-}
-
-TEST_F(RenderSurfaceTest, chain_can_be_constructed_after_surface_creation)
-{
-    int const width{800}, height{600};
-    MirPixelFormat const format{mir_pixel_format_abgr_8888};
-
-    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-
-    auto rs = mir_connection_create_render_surface_sync(
-        connection, logical_size.width.as_int(), logical_size.height.as_int());
-    auto spec = mir_connection_create_spec_for_normal_surface(connection,
-                                                              width, height,
-                                                              format);
-    mir_surface_spec_add_render_surface(spec, rs, width, height, 0, 0);
-    auto surface = mir_surface_create_sync(spec);
-    mir_surface_spec_release(spec);
-    auto pc = mir_render_surface_get_presentation_chain(rs);
-
-    EXPECT_THAT(surface, IsValid());
-    EXPECT_THAT(mir_surface_get_buffer_stream(surface), Eq(nullptr));
-    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
-
-    mir_render_surface_release(rs);
-    mir_surface_release_sync(surface);
-    mir_connection_release(connection);
-}
-
-TEST_F(RenderSurfaceTest, dont_have_to_release_presentation_chain)
-{
-    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-
-    auto rs = mir_connection_create_render_surface_sync(
-        connection, logical_size.width.as_int(), logical_size.height.as_int());
-    auto pc = mir_render_surface_get_presentation_chain(rs);
-
-    ASSERT_THAT(pc, NotNull());
-    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
-
-    mir_render_surface_release(rs);
-    mir_connection_release(connection);
-}
-
-TEST_F(RenderSurfaceTest, excepts_on_stream_request_if_chain_handed_out)
+//FIXME?: create/release for MirBufferStream would eliminate any sort of gotchas
+//       with using that API.
+TEST_F(RenderSurfaceTest, excepts_on_stream_request_if_content_is_in_use)
 {
     auto physical_size = logical_size;
     auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
 
+    struct Buffer
+    {
+        std::mutex mutex;
+        std::condition_variable cv;
+        MirBuffer* buffer = nullptr;
+    } buffer;
+
+    mir_connection_allocate_buffer(
+        connection,
+        10, 10, mir_pixel_format_abgr_8888, mir_buffer_usage_software,
+        [](auto buffer, auto cxt) {
+            auto c = reinterpret_cast<Buffer*>(cxt);
+            std::unique_lock<decltype(c->mutex)> lk(c->mutex);
+            c->buffer = buffer;
+            c->cv.notify_all();
+        }, &buffer);
+
+    std::unique_lock<decltype(buffer.mutex)> lk(buffer.mutex);
+    EXPECT_TRUE(buffer.cv.wait_for(lk, 10s, [&] { return buffer.buffer; }));
+ 
     auto rs = mir_connection_create_render_surface_sync(
         connection, logical_size.width.as_int(), logical_size.height.as_int());
-    auto pc = mir_render_surface_get_presentation_chain(rs);
+    EXPECT_TRUE(mir_render_surface_is_valid(rs));
 
-    ASSERT_THAT(pc, NotNull());
-    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
+    mir_render_surface_submit_buffer(rs, buffer.buffer);
 
     auto bs = mir_render_surface_get_buffer_stream(
         rs,
         physical_size.width.as_int(), physical_size.height.as_int(),
         mir_pixel_format_abgr_8888,
         mir_buffer_usage_hardware);
-
     EXPECT_THAT(bs, Eq(nullptr));
 
-    mir_render_surface_release(rs);
-    mir_connection_release(connection);
-}
-
-TEST_F(RenderSurfaceTest, excepts_on_chain_request_if_stream_handed_out)
-{
-    auto physical_size = logical_size;
-    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-
-    auto rs = mir_connection_create_render_surface_sync(
-        connection, logical_size.width.as_int(), logical_size.height.as_int());
-    auto bs = mir_render_surface_get_buffer_stream(
-        rs,
-        physical_size.width.as_int(), physical_size.height.as_int(),
-        mir_pixel_format_abgr_8888,
-        mir_buffer_usage_hardware);
-
-    ASSERT_THAT(bs, NotNull());
-    EXPECT_TRUE(mir_buffer_stream_is_valid(bs));
-
-    auto pc = mir_render_surface_get_presentation_chain(rs);
-
-    EXPECT_THAT(pc, Eq(nullptr));
-
+    mir_buffer_release(buffer.buffer);
     mir_render_surface_release(rs);
     mir_connection_release(connection);
 }
 
=== modified file 'tests/include/mir/test/doubles/stub_host_connection.h'
--- tests/include/mir/test/doubles/stub_host_connection.h	2016-12-15 15:17:18 +0000
+++ tests/include/mir/test/doubles/stub_host_connection.h	2016-12-15 15:17:18 +0000
@@ -123,7 +123,6 @@
         {
             MirRenderSurface* rs() const override { return nullptr; }
             void submit_buffer(graphics::nested::NativeBuffer&) override {}
-            MirPresentationChain* handle() override { return nullptr; }
             void set_submission_mode(graphics::nested::SubmissionMode) override {}
         };
         return std::make_unique<NullHostChain>();
 
=== modified file 'tests/unit-tests/client/test_connection_resource_map.cpp'
--- tests/unit-tests/client/test_connection_resource_map.cpp	2016-12-13 06:00:32 +0000
+++ tests/unit-tests/client/test_connection_resource_map.cpp	2016-12-15 15:17:18 +0000
@@ -18,7 +18,8 @@
 
 #include "src/client/connection_surface_map.h"
 #include "src/client/mir_surface.h"
-#include "src/client/presentation_chain.h"
+#include "src/client/buffer.h"
+#include "mir/mir_buffer.h"
 #include "src/client/render_surface.h"
 #include "mir/test/doubles/mock_mir_buffer_stream.h"
 #include "mir/test/doubles/mock_protobuf_server.h"
@@ -42,10 +43,8 @@
     std::shared_ptr<mcl::Buffer> buffer {
         std::make_shared<mcl::Buffer>(buffer_cb, nullptr, 0, nullptr, nullptr, mir_buffer_usage_software) };
     mtd::MockProtobufServer mock_server;
-    std::shared_ptr<mcl::PresentationChain> chain{ std::make_shared<mcl::PresentationChain>(
-        nullptr, 0, mock_server, nullptr, nullptr) };
     std::shared_ptr<MirRenderSurface> render_surface { std::make_shared<mcl::RenderSurface>(
-        nullptr, nullptr, nullptr, nullptr, mir::geometry::Size{0, 0}) };
+        nullptr, mock_server, nullptr, nullptr, mf::BufferStreamId{11}, mir::geometry::Size{0, 0}) };
 
     mf::SurfaceId const surface_id{43};
     mf::BufferStreamId const stream_id{43};
@@ -79,17 +78,6 @@
     map.erase(stream_id);
 }
 
-TEST_F(ConnectionResourceMap, holds_chain_reference)
-{
-    using namespace testing;
-    mcl::ConnectionSurfaceMap map;
-    auto use_count = chain.use_count();
-    map.insert(stream_id, chain);
-    EXPECT_THAT(chain.use_count(), Gt(use_count));
-    map.erase(stream_id);
-    EXPECT_THAT(chain.use_count(), Eq(use_count));
-}
-
 TEST_F(ConnectionResourceMap, maps_buffers)
 {
     using namespace testing;
 
=== modified file 'tests/unit-tests/client/test_mir_connection.cpp'
--- tests/unit-tests/client/test_mir_connection.cpp	2016-12-15 15:17:18 +0000
+++ tests/unit-tests/client/test_mir_connection.cpp	2016-12-15 15:17:18 +0000
@@ -24,7 +24,6 @@
 #include "src/client/mir_render_surface.h"
 #include "src/client/buffer_factory.h"
 #include "src/client/connection_surface_map.h"
-#include "src/client/presentation_chain.h"
 
 #include "mir/client_platform.h"
 #include "mir/client_platform_factory.h"
@@ -33,7 +32,6 @@
 #include "mir/dispatch/dispatchable.h"
 #include "mir/events/event_builders.h"
 #include "mir/geometry/rectangle.h"
-#include "mir_toolkit/mir_presentation_chain.h"
 #include "mir_toolkit/mir_render_surface.h"
 
 #include "src/server/frontend/resource_cache.h" /* needed by test_server.h */
 
=== modified file 'tests/unit-tests/client/test_mir_render_surface.cpp'
--- tests/unit-tests/client/test_mir_render_surface.cpp	2016-12-13 06:00:32 +0000
+++ tests/unit-tests/client/test_mir_render_surface.cpp	2016-12-15 15:17:18 +0000
@@ -28,6 +28,8 @@
 
 #include "mir/test/fake_shared.h"
 #include "mir/test/doubles/stub_client_buffer_factory.h"
+#include "mir/test/doubles/mock_protobuf_server.h"
+#include "mir/test/doubles/mock_mir_buffer.h"
 #include "mir_protobuf.pb.h"
 
 #include <sys/eventfd.h>
@@ -51,7 +53,6 @@
     if (context)
         *context = result;
 }
-
 struct RenderSurfaceCallback
 {
     static void created(MirRenderSurface* render_surface, void *client_context)
@@ -193,7 +194,11 @@
     std::shared_ptr<testing::NiceMock<MockClientPlatform>> const mock_platform;
     std::shared_ptr<testing::NiceMock<MockRpcChannel>> const mock_channel;
     TestConnectionConfiguration conf;
+    mtd::MockProtobufServer mock_server;
     std::shared_ptr<MirConnection> const connection;
+    mir::frontend::BufferStreamId rpc_id { 33 };
+    int id = 4;
+    MirConnection* conn{ reinterpret_cast<MirConnection*>(&id) };
 };
 
 TEST_F(MirRenderSurfaceTest, render_surface_can_be_created_and_released)
@@ -249,29 +254,15 @@
 
 TEST_F(MirRenderSurfaceTest, render_surface_returns_connection)
 {
-    MirConnection* conn{ reinterpret_cast<MirConnection*>(0x12345678) };
-
-    mcl::RenderSurface rs(
-        conn, nullptr, nullptr, nullptr, {});
+    mcl::RenderSurface rs(conn, mock_server, nullptr, nullptr, rpc_id, {}); 
 
     EXPECT_THAT(rs.connection(), Eq(conn));
 }
 
 TEST_F(MirRenderSurfaceTest, render_surface_has_correct_id_before_content_creation)
 {
-    MirConnection* conn{ reinterpret_cast<MirConnection*>(0x12345678) };
-    auto id = 123;
-
-    mp::BufferStream protobuf_bs;
-    mp::BufferStreamId bs_id;
-
-    bs_id.set_value(id);
-    *protobuf_bs.mutable_id() = bs_id;
-
-    mcl::RenderSurface rs(
-        conn, nullptr, nullptr, mt::fake_shared(protobuf_bs), {});
-
-    EXPECT_THAT(rs.stream_id().as_value(), Eq(id));
+    mcl::RenderSurface rs(conn, mock_server, nullptr, nullptr, rpc_id, {}); 
+    EXPECT_THAT(rs.stream_id(), Eq(rpc_id));
 }
 
 TEST_F(MirRenderSurfaceTest, render_surface_can_create_buffer_stream)
@@ -287,8 +278,7 @@
 
     auto native_window = mock_platform->create_egl_native_window(nullptr);
 
-    mcl::RenderSurface rs(
-        connection.get(), native_window, nullptr, mt::fake_shared(protobuf_bs), {});
+    mcl::RenderSurface rs(connection.get(), mock_server, native_window, mock_platform, rpc_id, {}); 
 
     auto bs = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
         mir_buffer_usage_software);
@@ -296,34 +286,6 @@
     EXPECT_THAT(bs, NotNull());
 }
 
-TEST_F(MirRenderSurfaceTest, excepts_on_creation_of_buffer_stream_more_than_once)
-{
-    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
-    auto id = 123;
-
-    mp::BufferStream protobuf_bs;
-    mp::BufferStreamId bs_id;
-
-    bs_id.set_value(id);
-    *protobuf_bs.mutable_id() = bs_id;
-
-    auto native_window = mock_platform->create_egl_native_window(nullptr);
-
-    mcl::RenderSurface rs(
-        connection.get(), native_window, mock_platform, mt::fake_shared(protobuf_bs), {});
-
-    EXPECT_CALL(*mock_platform, use_egl_native_window(native_window,_));
-
-    auto bs = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
-        mir_buffer_usage_hardware);
-
-    EXPECT_THROW(
-        { rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
-              mir_buffer_usage_hardware); },
-        std::logic_error);
-    EXPECT_THAT(bs, NotNull());
-}
-
 TEST_F(MirRenderSurfaceTest, render_surface_creation_of_buffer_stream_with_hardware_usage_installs_new_native_window)
 {
     connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
@@ -337,8 +299,7 @@
 
     auto native_window = mock_platform->create_egl_native_window(nullptr);
 
-    mcl::RenderSurface rs(
-        connection.get(), native_window, mock_platform, mt::fake_shared(protobuf_bs), {});
+    mcl::RenderSurface rs(connection.get(), mock_server, native_window, mock_platform, rpc_id, {}); 
 
     EXPECT_CALL(*mock_platform, use_egl_native_window(native_window,_));
 
@@ -361,8 +322,7 @@
 
     auto native_window = mock_platform->create_egl_native_window(nullptr);
 
-    mcl::RenderSurface rs(
-        connection.get(), native_window, mock_platform, mt::fake_shared(protobuf_bs), {});
+    mcl::RenderSurface rs(connection.get(), mock_server, native_window, mock_platform, rpc_id, {}); 
 
     EXPECT_CALL(*mock_platform, use_egl_native_window(_,_)).Times(0);
 
@@ -391,111 +351,30 @@
     EXPECT_THAT(callback.resulting_render_surface, Eq(render_surface));
 
     auto rs = connection->connection_surface_map()->render_surface(callback.resulting_render_surface);
-
-    EXPECT_THAT(rs->get_error_message(),
-        StrEq("Error processing buffer stream response during render "
-              "surface creation: no ID in response (disconnected?)"));
+    EXPECT_THAT(rs->get_error_message(), StrEq("Error creating MirRenderSurface: no ID in response"));
     EXPECT_FALSE(reinterpret_cast<mcl::RenderSurface*>(rs->valid()));
 }
 
-TEST_F(MirRenderSurfaceTest, render_surface_can_create_presentation_chain)
-{
-    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
-    auto id = 123;
-
-    mp::BufferStream protobuf_bs;
-    mp::BufferStreamId bs_id;
-
-    bs_id.set_value(id);
-    *protobuf_bs.mutable_id() = bs_id;
-
-    auto native_window = mock_platform->create_egl_native_window(nullptr);
-
-    mcl::RenderSurface rs(
-        connection.get(), native_window, nullptr, mt::fake_shared(protobuf_bs), {});
-
-    auto pc = rs.get_presentation_chain();
-
-    EXPECT_THAT(pc, NotNull());
-}
-
-TEST_F(MirRenderSurfaceTest, excepts_on_creation_of_presentation_chain_more_than_once)
-{
-    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
-    auto id = 123;
-
-    mp::BufferStream protobuf_bs;
-    mp::BufferStreamId bs_id;
-
-    bs_id.set_value(id);
-    *protobuf_bs.mutable_id() = bs_id;
-
-    auto native_window = mock_platform->create_egl_native_window(nullptr);
-
-    mcl::RenderSurface rs(
-        connection.get(), native_window, mock_platform, mt::fake_shared(protobuf_bs), {});
-
-    auto pc = rs.get_presentation_chain();
-    EXPECT_THAT(pc, NotNull());
-
-    EXPECT_THROW(
-        { rs.get_presentation_chain(); },
-        std::logic_error);
-}
-
-TEST_F(MirRenderSurfaceTest, excepts_on_creation_of_chain_after_stream)
-{
-    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
-    auto id = 123;
-
-    mp::BufferStream protobuf_bs;
-    mp::BufferStreamId bs_id;
-
-    bs_id.set_value(id);
-    *protobuf_bs.mutable_id() = bs_id;
-
-    auto native_window = mock_platform->create_egl_native_window(nullptr);
-
-    mcl::RenderSurface rs(connection.get(),
-                          native_window,
-                          mock_platform,
-                          mt::fake_shared(protobuf_bs),
-                          {});
-
-    auto bs = rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888,
-        mir_buffer_usage_hardware);
-
-    EXPECT_THAT(bs, NotNull());
-    EXPECT_THROW(
-        { rs.get_presentation_chain(); },
-        std::logic_error);
-}
-
-TEST_F(MirRenderSurfaceTest, excepts_on_creation_of_stream_after_chain)
-{
-    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
-    auto id = 123;
-
-    mp::BufferStream protobuf_bs;
-    mp::BufferStreamId bs_id;
-
-    bs_id.set_value(id);
-    *protobuf_bs.mutable_id() = bs_id;
-
-    auto native_window = mock_platform->create_egl_native_window(nullptr);
-
-    mcl::RenderSurface rs(connection.get(),
-                          native_window,
-                          mock_platform,
-                          mt::fake_shared(protobuf_bs),
-                          {});
-
-    auto pc = rs.get_presentation_chain();
-
-    EXPECT_THAT(pc, NotNull());
-    EXPECT_THROW(
-        { rs.get_buffer_stream(2, 2,
-                               mir_pixel_format_abgr_8888,
-                               mir_buffer_usage_hardware); },
-        std::logic_error);
+TEST_F(MirRenderSurfaceTest, excepts_on_creation_of_stream_after_submission)
+{
+    mtd::MockMirBuffer buffer;
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+    auto native_window = mock_platform->create_egl_native_window(nullptr);
+    mcl::RenderSurface rs(connection.get(), mock_server, native_window, mock_platform, rpc_id, {}); 
+    rs.submit_buffer(&buffer);
+    EXPECT_THROW({
+        rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888, mir_buffer_usage_hardware);
+    }, std::logic_error);
+}
+
+TEST_F(MirRenderSurfaceTest, excepts_on_submission_after_creation_of_stream)
+{
+    mtd::MockMirBuffer buffer;
+    connection->connect("MirRenderSurfaceTest", connected_callback, 0)->wait_for_all();
+    auto native_window = mock_platform->create_egl_native_window(nullptr);
+    mcl::RenderSurface rs(connection.get(), mock_server, native_window, mock_platform, rpc_id, {}); 
+    rs.get_buffer_stream(2, 2, mir_pixel_format_abgr_8888, mir_buffer_usage_hardware);
+    EXPECT_THROW({
+        rs.submit_buffer(&buffer);
+    }, std::logic_error);
 }
 
=== modified file 'tests/unit-tests/client/test_presentation_chain.cpp'
--- tests/unit-tests/client/test_presentation_chain.cpp	2016-07-18 07:38:38 +0000
+++ tests/unit-tests/client/test_presentation_chain.cpp	2016-12-15 15:17:18 +0000
@@ -20,7 +20,7 @@
 #include "mir/test/doubles/stub_client_buffer_factory.h"
 #include "mir/test/doubles/mock_client_buffer.h"
 #include "mir/test/fake_shared.h"
-#include "src/client/presentation_chain.h"
+#include "src/client/render_surface.h"
 #include "src/client/buffer_factory.h"
 #include "mir/client_buffer_factory.h"
 
@@ -36,16 +36,16 @@
 
 namespace
 {
-struct PresentationChain : Test
+struct RenderSurface : Test
 {
-    PresentationChain()
+    RenderSurface()
     {
         ipc_buf.set_width(size.width.as_int());
         ipc_buf.set_height(size.height.as_int());
         ipc_buf.set_buffer_id(buffer_id);
     }
 
-    int rpc_id { 33 };
+    mir::frontend::BufferStreamId rpc_id { 33 };
     MirConnection* connection {reinterpret_cast<MirConnection*>(this)};
     geom::Size size {100, 200};
     MirPixelFormat format = mir_pixel_format_abgr_8888;
@@ -71,53 +71,41 @@
 
 }
 
-TEST_F(PresentationChain, returns_associated_connection)
+TEST_F(RenderSurface, returns_associated_connection)
 {
-    mcl::PresentationChain chain(
-        connection, rpc_id, mock_server,
-        std::make_shared<mtd::StubClientBufferFactory>(),
-        std::make_shared<mcl::BufferFactory>());
+    mcl::RenderSurface chain(connection, mock_server, nullptr, nullptr, rpc_id, {0, 0}); 
     EXPECT_THAT(chain.connection(), Eq(connection));
 }
 
-TEST_F(PresentationChain, returns_associated_rpc_id)
+TEST_F(RenderSurface, returns_associated_stream_id)
 {
-    mcl::PresentationChain chain(
-        connection, rpc_id, mock_server,
-        std::make_shared<mtd::StubClientBufferFactory>(),
-        std::make_shared<mcl::BufferFactory>());
-    EXPECT_THAT(chain.rpc_id(), Eq(rpc_id));
+    mcl::RenderSurface chain(connection, mock_server, nullptr, nullptr, rpc_id, {0, 0}); 
+    EXPECT_THAT(chain.stream_id(), Eq(rpc_id));
 }
 
-TEST_F(PresentationChain, submits_buffer_when_asked)
+TEST_F(RenderSurface, submits_buffer_when_asked)
 {
     mp::BufferRequest request;
-    request.mutable_id()->set_value(rpc_id);
+    request.mutable_id()->set_value(rpc_id.as_value());
     request.mutable_buffer()->set_buffer_id(buffer_id);
 
     EXPECT_CALL(mock_server, submit_buffer(BufferRequestMatches(request),_,_))
         .WillOnce(mtd::RunProtobufClosure());
 
     mcl::Buffer buffer(buffer_callback, nullptr, buffer_id, client_buffer, nullptr, mir_buffer_usage_software);
-    mcl::PresentationChain chain(
-        connection, rpc_id, mock_server,
-        std::make_shared<mtd::StubClientBufferFactory>(),
-        std::make_shared<mcl::BufferFactory>());
+    mcl::RenderSurface chain(connection, mock_server, nullptr, nullptr, rpc_id, {0, 0}); 
 
     buffer.received();
     chain.submit_buffer(&buffer);
 } 
 
-TEST_F(PresentationChain, double_submission_throws)
+TEST_F(RenderSurface, double_submission_throws)
 {
     EXPECT_CALL(mock_server, submit_buffer(_,_,_))
         .WillOnce(mtd::RunProtobufClosure());
 
     mcl::Buffer buffer(buffer_callback, nullptr, buffer_id, client_buffer, nullptr, mir_buffer_usage_software);
-    mcl::PresentationChain chain(
-        connection, rpc_id, mock_server,
-        std::make_shared<mtd::StubClientBufferFactory>(),
-        std::make_shared<mcl::BufferFactory>());
+    mcl::RenderSurface chain(connection, mock_server, nullptr, nullptr, rpc_id, {0, 0}); 
 
     buffer.received();
     chain.submit_buffer(&buffer);
 
=== modified file 'tests/unit-tests/client/test_protobuf_rpc_channel.cpp'
--- tests/unit-tests/client/test_protobuf_rpc_channel.cpp	2016-12-13 06:00:32 +0000
+++ tests/unit-tests/client/test_protobuf_rpc_channel.cpp	2016-12-15 15:17:18 +0000
@@ -65,7 +65,6 @@
         void(std::function<void(MirBufferStream*)> const&));
     MOCK_CONST_METHOD1(buffer, std::shared_ptr<mcl::MirBuffer>(int));
     MOCK_METHOD2(insert, void(int, std::shared_ptr<mcl::MirBuffer> const&));
-    MOCK_METHOD2(insert, void(mir::frontend::BufferStreamId, std::shared_ptr<MirPresentationChain> const&));
     MOCK_METHOD1(erase, void(int));
 }; 
  
@@ -83,9 +82,6 @@
     void with_all_streams_do(std::function<void(MirBufferStream*)> const&) const override
     {
     }
-    void insert(mir::frontend::BufferStreamId, std::shared_ptr<MirPresentationChain> const&)
-    {
-    }
     std::shared_ptr<mcl::MirBuffer> buffer(int) const override
     {
         return nullptr;
 
=== modified file 'tests/unit-tests/platforms/nested/test_nested_display_buffer.cpp'
--- tests/unit-tests/platforms/nested/test_nested_display_buffer.cpp	2016-12-15 15:17:18 +0000
+++ tests/unit-tests/platforms/nested/test_nested_display_buffer.cpp	2016-12-15 15:17:18 +0000
@@ -93,7 +93,6 @@
 struct MockNestedChain : mgn::HostChain
 {
     MOCK_METHOD1(submit_buffer, void(mgn::NativeBuffer&));
-    MOCK_METHOD0(handle, MirPresentationChain*());
     MOCK_METHOD1(set_submission_mode, void(mgn::SubmissionMode));
     MOCK_CONST_METHOD0(rs, MirRenderSurface*());
 };
@@ -317,8 +316,8 @@
     EXPECT_CALL(nested_buffer, on_ownership_notification(_))
         .Times(2);
     EXPECT_CALL(*mock_chain, submit_buffer(Ref(nested_buffer)));
-    ON_CALL(*mock_chain, handle())
-        .WillByDefault(Return(reinterpret_cast<MirPresentationChain*>(&fake_chain_handle)));
+    ON_CALL(*mock_chain, rs())
+        .WillByDefault(Return(reinterpret_cast<MirRenderSurface*>(&fake_chain_handle)));
     EXPECT_CALL(*mock_chain2, submit_buffer(Ref(nested_buffer)));
 
     EXPECT_CALL(mock_host_connection, create_surface(_,_,_,_,_))