Mir

Merge lp:~cemil-azizoglu/mir/egl-native-window-for-PCs into lp:mir

egl-native-window-for-PCs
Merge into development-branch

Proposed by Cemil Azizoglu on 2016-06-02

Status:	Work in progress
Proposed branch:	lp:~cemil-azizoglu/mir/egl-native-window-for-PCs
Merge into:	lp:mir
Prerequisite:	lp:~kdub/mir/fix-1584784
Diff against target:	2285 lines (+1513/-425) 24 files modified playground/CMakeLists.txt (+10/-0) playground/eglflash_nbs.c (+155/-0) src/client/CMakeLists.txt (+2/-0) src/client/buffer_semantics.h (+410/-0) src/client/buffer_stream.cpp (+3/-363) src/client/buffer_stream.h (+1/-2) src/client/error_chain.cpp (+5/-0) src/client/error_chain.h (+1/-0) src/client/exchange_semantics.cpp (+173/-0) src/client/exchange_semantics.h (+70/-0) src/client/mir_connection.cpp (+1/-1) src/client/mir_presentation_chain.h (+13/-0) src/client/mir_presentation_chain_api.cpp (+13/-0) src/client/new_buffer_semantics.cpp (+181/-0) src/client/new_buffer_semantics.h (+79/-0) src/client/presentation_chain.cpp (+99/-6) src/client/presentation_chain.h (+31/-4) src/client/server_buffer_semantics.h (+59/-0) src/client/symbols.map (+1/-0) src/include/client/mir_toolkit/mir_presentation_chain.h (+17/-0) tests/unit-tests/client/stub_client_platform.h (+79/-0) tests/unit-tests/client/test_client_buffer_stream.cpp (+2/-43) tests/unit-tests/client/test_connection_resource_map.cpp (+1/-1) tests/unit-tests/client/test_presentation_chain.cpp (+107/-5)
To merge this branch:	bzr merge lp:~cemil-azizoglu/mir/egl-native-window-for-PCs
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration	2016-06-02	Needs Fixing on 2016-06-03
Chris Halse Rogers			Disapprove on 2016-06-03
Kevin DuBois (community)		2016-06-02	Needs Fixing on 2016-06-02
Review via email: mp+296344@code.launchpad.net

This proposal supersedes a proposal from 2016-06-02.

Commit message

Support for egl native window from presentation chains.

Description of the change

Support for egl native window from presentation chains.

Revision history for this message

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

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-06-02: Posted in a previous version of this proposal

Planning note:
src/client/buffer_semantics.h
is an abstraction that was meant to help with the transition. Hopefully it goes away soon, an "NewBufferSemantics" implementation gets condensed into mcl::BufferVault (this would greatly simplify the code).

Needs fixing:
The code needs some of the fixes in lp:~kdub/mir/fix-1584784 in order to avoid reintroducing that bug.

review: Needs Fixing

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-06-02: Posted in a previous version of this proposal

mir_presentation_chain_get_egl_native_window

is misleading about what MirPresentationChains are. They are generic buffer queues, and tying them to a specific technology (egl) can be avoided. We should have

MirEGLNativeWindowType mir_create_egl_native_window(MirPresentationChain*, int width, int height, MirPixelFormat pixel_format);

so that its a bit clearer that this more of a helper function to extend the use of MirPresentationChain, as opposed to something that's core to the mir_presentation_chain* generic functions.

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-06-02: Posted in a previous version of this proposal

+ virtual EGLNativeWindowType egl_native_window(mir::geometry::Size size, MirPixelFormat pixel_format) = 0;

In the same line of thought, a MirPresentationChain is not a EGLNativeWindowType, rather, an EGLNativeWindowType can be created using a MirPresentationChain.

This is internal, so can be changed easily so that the EGLNativeWindowType can take the PresentationChain in its constructor. (so its probably non blocking, but is something that needs a cleanup once the buffer_semantics.h header gets cleaned up, as mentioned above)

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-06-02: Posted in a previous version of this proposal

Also, I think that MirBufferStream shouldn't go away. It fits a need that the clients have (as well as being used extensively in the wild).

Made some design drawings:
A) How things are in current design:
https://docs.google.com/drawings/d/1U03QrxQwPFYVfryC_-xOb64D3GRYIkJCAyw8LEWbbIk

B) how things would be with mir_presentation_chain_get_egl_native_window_type(...):
https://docs.google.com/drawings/d/1cX54j6Wv7TRuWLCXRuUyni9RgyuljWGEAlalDirwAys

C) How things would be with mir_create_egl_native_window_type(...):
https://docs.google.com/drawings/d/1yze9GbDb4pbGyQM7pXPDWXqrToW9Ko3gaAtWt9DeV_Q

A) and C) keep the MirPresentationChain just a thin wrapper around the RPC (which is useful for building future technologies). IMO, A) is a bit better because we only have one way of supporting EGL.

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-06-02: Posted in a previous version of this proposal

Fixed permissions, hopefully:
A) https://docs.google.com/drawings/d/1U03QrxQwPFYVfryC_-xOb64D3GRYIkJCAyw8LEWbbIk/edit?usp=sharing
B) https://docs.google.com/drawings/d/1cX54j6Wv7TRuWLCXRuUyni9RgyuljWGEAlalDirwAys/edit?usp=sharing
C) https://docs.google.com/drawings/d/1yze9GbDb4pbGyQM7pXPDWXqrToW9Ko3gaAtWt9DeV_Q/edit?usp=sharing

Revision history for this message

Cemil Azizoglu (cemil-azizoglu) wrote on 2016-06-02:

@kdub, I've changed the name to mir_create_egl_native_window_type and rebased it with lp:~kdub/mir/fix-1584784 as prereq.

I'd rather not invest more time into the internal refactoring for now. I have a feeling we'll go back and clean this up with the MirRenderable idea that we discussed over email.

Revision history for this message

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

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-06-02:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

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

re, refactorings:
If we're pressed for time, I suppose that we can do the refactorings, later, but IMO, delaying a bit to avoid establishing this relationship :
+class PresentationChain : public MirPresentationChain, public EGLNativeSurface
internally is worth it.

The external bit (which is the hard part to change), is resolved IMO with the client API name change, thanks.

considerations:
eglflash_nbs could be renamed eglflash_presentation_chain (nbs won't have much permanent context, especially for mir 'outsiders'). We could also have a switch in eglapp that would switch between the two modes (and give a lot more ways to use the new code)

needs fixings:
src/client/buffer_semantics.h
+namespace
+{
anonymous namespace in header. The code should also be moved to a .cpp file.

The header also seems like we're overexposing some classes when they're not needed elsewhere... ExchangeSemantics doesn't seem like its needed anywhere in the new code. <optional> We could also hide the interface by just exposing the SubmitSemantics class, and then wrapping in buffer_stream.cpp

tests/unit-tests/client/stub_client_platform.h
should be in tests/include/mir/test/doubles (or tests/include/mir_test_framework). The namespace should match where it lives instead of being anonymous.
Also, we already have mtf::StubClientPlatform, maybe making that more accessible to the test is the way to go.

* Extract an MirEGLNativeWindowType object from a given presentation chain.
needs an update to
"Create a MirEGLNativeWindowType object from a given MirPresentationChain"

review: Needs Fixing

Revision history for this message

Chris Halse Rogers (raof) wrote on 2016-06-03:

So, as I've mentioned before, I think that both of these approaches are incorrect; EGL clients shouldn't know that the EGL implementation is using a MirPresentationChain or a MirBufferQueue.

We've got this on the agenda for the sprint next week, so I think we should not introduce extra client API that we'll probably immediately deprecate.

review: Disapprove

lp:~cemil-azizoglu/mir/egl-native-window-for-PCs updated on 2016-06-03

3531. By Cemil Azizoglu on 2016-06-03: Separate ServerBufferSemantics interfaces

Revision history for this message

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

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

review: Needs Fixing (continuous-integration)

Unmerged revisions

3531. By Cemil Azizoglu on 2016-06-03: Separate ServerBufferSemantics interfaces
3530. By Cemil Azizoglu on 2016-06-02: s/mir_presentation_chain_get_egl_native_window/mir_create_egl_native_window
3529. By Cemil Azizoglu on 2016-06-02: merge with lp:~kdub/mir/fix-1584784
3528. By Cemil Azizoglu on 2016-06-02: Do away with extraneous printfs
3527. By Cemil Azizoglu on 2016-06-02: Revert x-compile script
3526. By Cemil Azizoglu on 2016-06-02: EGLNativeWindowType support for presentation chains

Preview Diff

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

Subscribers

People subscribed via source and target branches

to all changes:

Cemil Azizoglu

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'playground/CMakeLists.txt'
 --- playground/CMakeLists.txt	2016-05-03 06:55:25 +0000
 +++ playground/CMakeLists.txt	2016-06-03 01:46:54 +0000
@@ -28,3 +28,13 @@
      mirclient
+     m
+ )
++
++mir_add_wrapped_executable(mir_demo_client_eglflash_nbs
++    eglflash_nbs.c
++)
++
++target_link_libraries(mir_demo_client_eglflash_nbs
++    mirclient
++    ${EGL_LIBRARIES}
++    ${GLESv2_LIBRARIES}
++)
 === added file 'playground/eglflash_nbs.c'
 --- playground/eglflash_nbs.c	1970-01-01 00:00:00 +0000
 +++ playground/eglflash_nbs.c	2016-06-03 01:46:54 +0000
@@ -0,0 +1,155 @@
++/*
++ * Trivial GL demo; flashes the screen with nbs.
++ *
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 3 as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Author: Cemil Azizoglu <cemil.azizoglu@canonical.com>
++ */
++
++#include <mir_toolkit/mir_client_library.h>
++#include <mir_toolkit/mir_presentation_chain.h>
++#include <mir_toolkit/mir_buffer.h>
++
++#include <stdio.h>
++#include <string.h>
++#include <unistd.h>
++#include <EGL/egl.h>
++#include <GLES2/gl2.h>
++#include <pthread.h>
++
++typedef struct Color
++{
++    GLfloat r, g, b, a;
++} Color;
++
++#define CHECK(_cond, _err) \
++    if (!(_cond)) \
++    { \
++       printf("%s\n", (_err)); \
++       return -1; \
++    }
++
++int main(int argc, char *argv[])
++{
++    (void) argc;
++    (void) argv;
++    unsigned int num_frames = 0;
++    const char* appname = "eglnbsdemo";
++    int width = 100;
++    int height = 100;
++    EGLDisplay egldisplay;
++    EGLSurface eglsurface;
++    EGLint ctxattribs[] =
++    {
++        EGL_CONTEXT_CLIENT_VERSION, 2,
++        EGL_NONE
++    };
++    EGLConfig eglconfig;
++    EGLint neglconfigs;
++    EGLContext eglctx;
++    EGLBoolean ok;
++    MirConnection* connection = NULL;
++    MirSurface* surface = NULL;
++    MirPresentationChain* chain = NULL;
++
++    connection = mir_connect_sync(NULL, appname);
++    CHECK(mir_connection_is_valid(connection), "Can't get connection");
++
++    egldisplay = eglGetDisplay(
++                    mir_connection_get_egl_native_display(connection));
++    CHECK(egldisplay != EGL_NO_DISPLAY, "Can't eglGetDisplay");
++
++    ok = eglInitialize(egldisplay, NULL, NULL);
++    CHECK(ok, "Can't eglInitialize");
++
++    const EGLint attribs[] =
++    {
++        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
++        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
++        EGL_RED_SIZE, 8,
++        EGL_GREEN_SIZE, 8,
++        EGL_BLUE_SIZE, 8,
++        EGL_ALPHA_SIZE, 8,
++        EGL_NONE
++    };
++
++    ok = eglChooseConfig(egldisplay, attribs, &eglconfig, 1, &neglconfigs);
++    CHECK(ok, "Could not eglChooseConfig");
++    CHECK(neglconfigs > 0, "No EGL config available");
++
++    MirPixelFormat pixel_format =
++        mir_connection_get_egl_pixel_format(connection, egldisplay, eglconfig);
++
++    printf("Mir chose pixel format %d.\n", pixel_format);
++
++    MirSurfaceSpec *spec =
++        mir_connection_create_spec_for_normal_surface(connection, width, height, pixel_format);
++
++    CHECK(spec, "Can't create a surface spec");
++
++    mir_surface_spec_set_name(spec, appname);
++
++    chain = mir_connection_create_presentation_chain_sync(connection);
++    CHECK(mir_presentation_chain_is_valid(chain), "Can't create presentation chain");
++
++    mir_surface_spec_add_presentation_chain(
++        spec, width, height, 0, 0, chain);
++
++    surface = mir_surface_create_sync(spec);
++
++    mir_surface_spec_release(spec);
++
++    eglsurface = eglCreateWindowSurface(egldisplay, eglconfig,
++        (EGLNativeWindowType)mir_create_egl_native_window(chain, width, height, pixel_format), NULL);
++
++    CHECK(eglsurface != EGL_NO_SURFACE, "eglCreateWindowSurface failed");
++
++    eglctx = eglCreateContext(egldisplay, eglconfig, EGL_NO_CONTEXT,
++                              ctxattribs);
++    CHECK(eglctx != EGL_NO_CONTEXT, "eglCreateContext failed");
++
++    ok = eglMakeCurrent(egldisplay, eglsurface, eglsurface, eglctx);
++    CHECK(ok, "Can't eglMakeCurrent");
++
++    Color red = {1.0f, 0.0f, 0.0f, 1.0f};
++    Color green = {0.0f, 1.0f, 0.0f, 1.0f};
++    Color blue = {0.0f, 0.0f, 1.0f, 1.0f};
++
++    do
++    {
++        glClearColor(red.r, red.g, red.b, red.a);
++        glClear(GL_COLOR_BUFFER_BIT);
++        eglSwapBuffers(egldisplay, eglsurface);
++        sleep(1);
++
++        glClearColor(green.r, green.g, green.b, green.a);
++        glClear(GL_COLOR_BUFFER_BIT);
++        eglSwapBuffers(egldisplay, eglsurface);
++        sleep(1);
++
++        glClearColor(blue.r, blue.g, blue.b, blue.a);
++        glClear(GL_COLOR_BUFFER_BIT);
++        eglSwapBuffers(egldisplay, eglsurface);
++        sleep(1);
++    } while (num_frames++ < 3);
++
++    eglMakeCurrent(egldisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
++    eglTerminate(egldisplay);
++    mir_presentation_chain_release(chain);
++    mir_surface_release_sync(surface);
++    mir_connection_release(connection);
++
++    return 0;
++}
 === modified file 'src/client/CMakeLists.txt'
 --- src/client/CMakeLists.txt	2016-06-02 05:33:50 +0000
 +++ src/client/CMakeLists.txt	2016-06-03 01:46:54 +0000
@@ -88,6 +88,8 @@
    mir_error.cpp
    mir_error.h
    mir_error_api.cpp
++  exchange_semantics.cpp
++  new_buffer_semantics.cpp
    ${MIR_CLIENT_SOURCES}
    ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/events/surface_output_event.h
    ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/mir_display_configuration.h
 === added file 'src/client/buffer_semantics.h'
 --- src/client/buffer_semantics.h	1970-01-01 00:00:00 +0000
 +++ src/client/buffer_semantics.h	2016-06-03 01:46:54 +0000
@@ -0,0 +1,410 @@
++/*
++ * 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 <kevin.dubois@canonical.com>
++ */
++
++#include "buffer_stream.h"
++#include "buffer.h"
++#include "buffer_factory.h"
++#include "make_protobuf_object.h"
++#include "mir_connection.h"
++#include "perf_report.h"
++#include "logging/perf_report.h"
++#include "rpc/mir_display_server.h"
++#include "mir_protobuf.pb.h"
++#include "buffer_vault.h"
++#include "protobuf_to_native_buffer.h"
++#include "buffer.h"
++#include "connection_surface_map.h"
++
++#include "mir/log.h"
++#include "mir/client_platform.h"
++#include "mir/frontend/client_constants.h"
++#include "mir_toolkit/mir_native_buffer.h"
++
++#include <boost/throw_exception.hpp>
++#include <boost/exception/diagnostic_information.hpp>
++
++#include <stdexcept>
++
++namespace mcl = mir::client;
++namespace mclr = mir::client::rpc;
++namespace mf = mir::frontend;
++namespace mp = mir::protobuf;
++namespace geom = mir::geometry;
++
++namespace mir
++{
++namespace client
++{
++//An internal interface useful in transitioning buffer exchange semantics based on
++//the BufferStream response provided by the server
++struct ServerBufferSemantics
++{
++    virtual void deposit(protobuf::Buffer const&, mir::optional_value<geometry::Size>, MirPixelFormat) = 0;
++    virtual void set_buffer_cache_size(unsigned int) = 0;
++    virtual std::shared_ptr<mir::client::ClientBuffer> current_buffer() = 0;
++    virtual uint32_t current_buffer_id() = 0;
++    virtual MirWaitHandle* submit(std::function<void()> const&, MirPixelFormat, int stream_id) = 0;
++    virtual void lost_connection() = 0;
++    virtual void set_size(geom::Size) = 0;
++    virtual MirWaitHandle* set_scale(float, mf::BufferStreamId) = 0;
++    virtual void set_interval(int interval) = 0;
++    virtual geom::Size size() const = 0;
++    virtual ~ServerBufferSemantics() = default;
++    ServerBufferSemantics() = default;
++    ServerBufferSemantics(ServerBufferSemantics const&) = delete;
++    ServerBufferSemantics& operator=(ServerBufferSemantics const&) = delete;
++};
++}
++}
++
++namespace
++{
++
++struct ExchangeSemantics : mcl::ServerBufferSemantics
++{
++    ExchangeSemantics(
++        mir::protobuf::DisplayServer& server,
++        std::shared_ptr<mcl::ClientBufferFactory> const& factory, int max_buffers,
++        mp::Buffer const& first_buffer, geom::Size first_size, MirPixelFormat first_pf) :
++        wrapped{factory, max_buffers},
++        display_server(server),
++        size_(first_size)
++    {
++        wrapped.deposit_package(
++            mcl::protobuf_to_native_buffer(first_buffer),
++            first_buffer.buffer_id(), first_size, first_pf);
++    }
++
++    void deposit(mp::Buffer const& buffer, mir::optional_value<geom::Size> size, MirPixelFormat pf) override
++    {
++        std::unique_lock<std::mutex> lock(mutex);
++        if (size.is_set())
++            size_ = size.value();
++
++        if (on_incoming_buffer)
++        {
++            wrapped.deposit_package(
++                mcl::protobuf_to_native_buffer(buffer),
++                buffer.buffer_id(), size_, pf);
++            if (on_incoming_buffer)
++            {
++                on_incoming_buffer();
++                next_buffer_wait_handle.result_received();
++                on_incoming_buffer = std::function<void()>{};
++            }
++        }
++        else
++        {
++            incoming_buffers.push(buffer);
++        }
++    }
++
++    void set_buffer_cache_size(unsigned int sz) override
++    {
++        std::unique_lock<std::mutex> lock(mutex);
++        wrapped.set_max_buffers(sz);
++    }
++    std::shared_ptr<mir::client::ClientBuffer> current_buffer() override
++    {
++        std::unique_lock<std::mutex> lock(mutex);
++        return wrapped.current_buffer();
++    }
++    uint32_t current_buffer_id() override
++    {
++        std::unique_lock<std::mutex> lock(mutex);
++        if (incoming_buffers.size())
++            return incoming_buffers.front().buffer_id();
++        return wrapped.current_buffer_id();
++    }
++
++    MirWaitHandle* submit(std::function<void()> const& done, MirPixelFormat pf, int stream_id) override
++    {
++        std::unique_lock<std::mutex> lock(mutex);
++        if (server_connection_lost)
++            BOOST_THROW_EXCEPTION(std::runtime_error("disconnected: no new buffers"));
++        //always submit what we have, whether we have a buffer, or will have to wait for an async reply
++        auto request = mcl::make_protobuf_object<mp::BufferRequest>();
++        request->mutable_id()->set_value(stream_id);
++        request->mutable_buffer()->set_buffer_id(wrapped.current_buffer_id());
++        lock.unlock();
++
++        display_server.submit_buffer(request.get(), protobuf_void.get(),
++            google::protobuf::NewCallback(google::protobuf::DoNothing));
++
++        lock.lock();
++        if (server_connection_lost)
++            BOOST_THROW_EXCEPTION(std::runtime_error("disconnected: no new buffers"));
++        if (incoming_buffers.empty())
++        {
++            next_buffer_wait_handle.expect_result();
++            on_incoming_buffer = done;
++        }
++        else
++        {
++            wrapped.deposit_package(
++                mcl::protobuf_to_native_buffer(incoming_buffers.front()),
++                incoming_buffers.front().buffer_id(), size_, pf);
++            incoming_buffers.pop();
++            done();
++        }
++        return &next_buffer_wait_handle;
++    }
++
++    void lost_connection() override
++    {
++        std::unique_lock<std::mutex> lock(mutex);
++        server_connection_lost = true;
++        if (on_incoming_buffer)
++        {
++            on_incoming_buffer();
++            on_incoming_buffer = std::function<void()>{};
++        }
++        if (next_buffer_wait_handle.is_pending())
++            next_buffer_wait_handle.result_received();
++
++        while (!incoming_buffers.empty())
++        {
++            auto b = incoming_buffers.front();
++            for (auto i = 0; i < b.fd_size(); i++)
++                close(b.fd(i));
++            incoming_buffers.pop();
++        }
++    }
++
++    void set_size(geom::Size) override
++    {
++    }
++
++    geom::Size size() const override
++    {
++        std::unique_lock<std::mutex> lk(mutex);
++        return size_;
++    }
++
++    void on_scale_set(float scale)
++    {
++        std::unique_lock<decltype(mutex)> lock(mutex);
++        scale_ = scale;
++        scale_wait_handle.result_received();
++    }
++
++    MirWaitHandle* set_scale(float scale, mf::BufferStreamId stream_id) override
++    {
++        mp::StreamConfiguration configuration;
++        configuration.mutable_id()->set_value(stream_id.as_value());
++        configuration.set_scale(scale);
++        scale_wait_handle.expect_result();
++
++        display_server.configure_buffer_stream(&configuration, protobuf_void.get(),
++            google::protobuf::NewCallback(this, &ExchangeSemantics::on_scale_set, scale));
++        return &scale_wait_handle;
++    }
++
++    void set_interval(int) override
++    {
++    }
++
++    std::mutex mutable mutex;
++    mcl::ClientBufferDepository wrapped;
++    mir::protobuf::DisplayServer& display_server;
++    std::function<void()> on_incoming_buffer;
++    std::queue<mir::protobuf::Buffer> incoming_buffers;
++    std::unique_ptr<mir::protobuf::Void> protobuf_void{std::make_unique<mp::Void>()};
++    MirWaitHandle next_buffer_wait_handle;
++    bool server_connection_lost {false};
++    MirWaitHandle scale_wait_handle;
++    float scale_;
++    geom::Size size_;
++};
++
++class Requests : public mcl::ServerBufferRequests
++{
++public:
++    Requests(mclr::DisplayServer& server, int stream_id) :
++        server(server),
++        stream_id(stream_id)
++    {
++    }
++
++    void allocate_buffer(geom::Size size, MirPixelFormat format, int usage) override
++    {
++        mp::BufferAllocation request;
++        request.mutable_id()->set_value(stream_id);
++        auto buf_params = request.add_buffer_requests();
++        buf_params->set_width(size.width.as_int());
++        buf_params->set_height(size.height.as_int());
++        buf_params->set_pixel_format(format);
++        buf_params->set_buffer_usage(usage);
++
++        //note, NewCallback will trigger on exception, deleting this object there
++        auto protobuf_void = new mp::Void;
++        server.allocate_buffers(&request,  protobuf_void,
++            google::protobuf::NewCallback(Requests::ignore_response, protobuf_void));
++    }
++
++    void free_buffer(int buffer_id) override
++    {
++        mp::BufferRelease request;
++        request.mutable_id()->set_value(stream_id);
++        request.add_buffers()->set_buffer_id(buffer_id);
++
++        //note, NewCallback will trigger on exception, deleting this object there
++        auto protobuf_void = new mp::Void;
++        server.release_buffers(&request, protobuf_void,
++            google::protobuf::NewCallback(Requests::ignore_response, protobuf_void));
++    }
++
++    void submit_buffer(mcl::Buffer& buffer) override
++    {
++        mp::BufferRequest request;
++        request.mutable_id()->set_value(stream_id);
++        request.mutable_buffer()->set_buffer_id(buffer.rpc_id());
++
++        //note, NewCallback will trigger on exception, deleting this object there
++        auto protobuf_void = new mp::Void;
++        server.submit_buffer(&request, protobuf_void,
++            google::protobuf::NewCallback(Requests::ignore_response, protobuf_void));
++    }
++
++    static void ignore_response(mp::Void* void_response)
++    {
++        delete void_response;
++    }
++
++private:
++    mclr::DisplayServer& server;
++    mp::Void protobuf_void;
++    int stream_id;
++};
++
++struct NewBufferSemantics : mcl::ServerBufferSemantics
++{
++    NewBufferSemantics(
++        std::shared_ptr<mcl::ClientBufferFactory> const& factory,
++        std::shared_ptr<mcl::AsyncBufferFactory> const& mirbuffer_factory,
++        std::shared_ptr<mcl::ServerBufferRequests> const& requests,
++        std::weak_ptr<mcl::SurfaceMap> const& surface_map,
++        geom::Size size, MirPixelFormat format, int usage,
++        unsigned int initial_nbuffers) :
++        vault(factory, mirbuffer_factory, requests, surface_map, size, format, usage, initial_nbuffers),
++        current(nullptr),
++        future(vault.withdraw()),
++        size_(size)
++    {
++    }
++
++    void deposit(mp::Buffer const&, mir::optional_value<geom::Size>, MirPixelFormat) override
++    {
++    }
++
++    void advance_current_buffer(std::unique_lock<std::mutex>& lk)
++    {
++        lk.unlock();
++        auto c = future.get();
++        lk.lock();
++        current = c;
++    }
++
++    std::shared_ptr<mir::client::ClientBuffer> current_buffer() override
++    {
++        std::unique_lock<std::mutex> lk(mutex);
++        if (!current)
++            advance_current_buffer(lk);
++        return current->client_buffer();
++    }
++
++    uint32_t current_buffer_id() override
++    {
++        std::unique_lock<std::mutex> lk(mutex);
++        if (!current)
++            advance_current_buffer(lk);
++        return current->rpc_id();
++    }
++
++    MirWaitHandle* submit(std::function<void()> const& done, MirPixelFormat, int) override
++    {
++        std::unique_lock<std::mutex> lk(mutex);
++        if (!current)
++            advance_current_buffer(lk);
++        auto c = current;
++        current = nullptr;
++        lk.unlock();
++
++        vault.deposit(c);
++        auto wh = vault.wire_transfer_outbound(c, done);
++        auto f = vault.withdraw();
++        lk.lock();
++        future = std::move(f);
++        return wh;
++    }
++
++    void set_size(geom::Size size) override
++    {
++        {
++            std::unique_lock<std::mutex> lk(mutex);
++            size_ = size;
++        }
++        vault.set_size(size);
++    }
++
++    geom::Size size() const override
++    {
++        std::unique_lock<std::mutex> lk(mutex);
++        return size_;
++    }
++
++    void lost_connection() override
++    {
++        vault.disconnected();
++    }
++
++    void set_buffer_cache_size(unsigned int) override
++    {
++    }
++
++    MirWaitHandle* set_scale(float scale, mf::BufferStreamId) override
++    {
++        scale_wait_handle.expect_result();
++        scale_wait_handle.result_received();
++        vault.set_scale(scale);
++        return &scale_wait_handle;
++    }
++
++    void set_interval(int interval) override
++    {
++        std::unique_lock<decltype(mutex)> lk(mutex);
++        interval = std::max(0, std::min(1, interval));
++        if (current_swap_interval == interval)
++            return;
++        if (interval == 0)
++            vault.increase_buffer_count();
++        else
++            vault.decrease_buffer_count();
++        current_swap_interval = interval;
++    }
++
++    mcl::BufferVault vault;
++    std::mutex mutable mutex;
++    std::shared_ptr<mcl::Buffer> current{nullptr};
++    mir::client::NoTLSFuture<std::shared_ptr<mcl::Buffer>> future;
++    MirWaitHandle scale_wait_handle;
++    int current_swap_interval = 1;
++    geom::Size size_;
++};
++
++}
 === modified file 'src/client/buffer_stream.cpp'
 --- src/client/buffer_stream.cpp	2016-06-03 01:46:54 +0000
 +++ src/client/buffer_stream.cpp	2016-06-03 01:46:54 +0000
@@ -37,6 +37,9 @@
  #include "mir/frontend/client_constants.h"
  #include "mir_toolkit/mir_native_buffer.h"
++#include "exchange_semantics.h"
++#include "new_buffer_semantics.h"
++
  #include <boost/throw_exception.hpp>
  #include <boost/exception/diagnostic_information.hpp>
@@ -51,369 +54,6 @@
  namespace gp = google::protobuf;
--namespace mir
--{
--namespace client
--{
--//An internal interface useful in transitioning buffer exchange semantics based on
--//the BufferStream response provided by the server
--struct ServerBufferSemantics
--{
--    virtual void deposit(protobuf::Buffer const&, mir::optional_value<geometry::Size>, MirPixelFormat) = 0;
--    virtual void set_buffer_cache_size(unsigned int) = 0;
--    virtual std::shared_ptr<mir::client::ClientBuffer> current_buffer() = 0;
--    virtual uint32_t current_buffer_id() = 0;
--    virtual MirWaitHandle* submit(std::function<void()> const&, MirPixelFormat, int stream_id) = 0;
--    virtual void lost_connection() = 0;
--    virtual void set_size(geom::Size) = 0;
--    virtual MirWaitHandle* set_scale(float, mf::BufferStreamId) = 0;
--    virtual void set_interval(int interval) = 0;
--    virtual geom::Size size() const = 0;
--    virtual ~ServerBufferSemantics() = default;
--    ServerBufferSemantics() = default;
--    ServerBufferSemantics(ServerBufferSemantics const&) = delete;
--    ServerBufferSemantics& operator=(ServerBufferSemantics const&) = delete;
--};
--}
--}
--
--namespace
--{
--
--struct ExchangeSemantics : mcl::ServerBufferSemantics
--{
--    ExchangeSemantics(
--        mir::protobuf::DisplayServer& server,
--        std::shared_ptr<mcl::ClientBufferFactory> const& factory, int max_buffers,
--        mp::Buffer const& first_buffer, geom::Size first_size, MirPixelFormat first_pf) :
--        wrapped{factory, max_buffers},
--        display_server(server),
--        size_(first_size)
--    {
--        wrapped.deposit_package(
--            mcl::protobuf_to_native_buffer(first_buffer),
--            first_buffer.buffer_id(), first_size, first_pf);
--    }
--
--    void deposit(mp::Buffer const& buffer, mir::optional_value<geom::Size> size, MirPixelFormat pf) override
--    {
--        std::unique_lock<std::mutex> lock(mutex);
--        if (size.is_set())
--            size_ = size.value();
--
--        if (on_incoming_buffer)
--        {
--            wrapped.deposit_package(
--                mcl::protobuf_to_native_buffer(buffer),
--                buffer.buffer_id(), size_, pf);
--            if (on_incoming_buffer)
--            {
--                on_incoming_buffer();
--                next_buffer_wait_handle.result_received();
--                on_incoming_buffer = std::function<void()>{};
--            }
--        }
--        else
--        {
--            incoming_buffers.push(buffer);
--        }
--    }
--
--    void set_buffer_cache_size(unsigned int sz) override
--    {
--        std::unique_lock<std::mutex> lock(mutex);
--        wrapped.set_max_buffers(sz);
--    }
--    std::shared_ptr<mir::client::ClientBuffer> current_buffer() override
--    {
--        std::unique_lock<std::mutex> lock(mutex);
--        return wrapped.current_buffer();
--    }
--    uint32_t current_buffer_id() override
--    {
--        std::unique_lock<std::mutex> lock(mutex);
--        if (incoming_buffers.size())
--            return incoming_buffers.front().buffer_id();
--        return wrapped.current_buffer_id();
--    }
--
--    MirWaitHandle* submit(std::function<void()> const& done, MirPixelFormat pf, int stream_id) override
--    {
--        std::unique_lock<std::mutex> lock(mutex);
--        if (server_connection_lost)
--            BOOST_THROW_EXCEPTION(std::runtime_error("disconnected: no new buffers"));
--        //always submit what we have, whether we have a buffer, or will have to wait for an async reply
--        auto request = mcl::make_protobuf_object<mp::BufferRequest>();
--        request->mutable_id()->set_value(stream_id);
--        request->mutable_buffer()->set_buffer_id(wrapped.current_buffer_id());
--        lock.unlock();
--
--        display_server.submit_buffer(request.get(), protobuf_void.get(),
--            google::protobuf::NewCallback(google::protobuf::DoNothing));
--
--        lock.lock();
--        if (server_connection_lost)
--            BOOST_THROW_EXCEPTION(std::runtime_error("disconnected: no new buffers"));
--        if (incoming_buffers.empty())
--        {
--            next_buffer_wait_handle.expect_result();
--            on_incoming_buffer = done;
--        }
--        else
--        {
--            wrapped.deposit_package(
--                mcl::protobuf_to_native_buffer(incoming_buffers.front()),
--                incoming_buffers.front().buffer_id(), size_, pf);
--            incoming_buffers.pop();
--            done();
--        }
--        return &next_buffer_wait_handle;
--    }
--
--    void lost_connection() override
--    {
--        std::unique_lock<std::mutex> lock(mutex);
--        server_connection_lost = true;
--        if (on_incoming_buffer)
--        {
--            on_incoming_buffer();
--            on_incoming_buffer = std::function<void()>{};
--        }
--        if (next_buffer_wait_handle.is_pending())
--            next_buffer_wait_handle.result_received();
--
--        while (!incoming_buffers.empty())
--        {
--            auto b = incoming_buffers.front();
--            for (auto i = 0; i < b.fd_size(); i++)
--                close(b.fd(i));
--            incoming_buffers.pop();
--        }
--    }
--
--    void set_size(geom::Size) override
--    {
--    }
--
--    geom::Size size() const override
--    {
--        std::unique_lock<std::mutex> lk(mutex);
--        return size_;
--    }
--
--    void on_scale_set(float scale)
--    {
--        std::unique_lock<decltype(mutex)> lock(mutex);
--        scale_ = scale;
--        scale_wait_handle.result_received();
--    }
--
--    MirWaitHandle* set_scale(float scale, mf::BufferStreamId stream_id) override
--    {
--        mp::StreamConfiguration configuration;
--        configuration.mutable_id()->set_value(stream_id.as_value());
--        configuration.set_scale(scale);
--        scale_wait_handle.expect_result();
--
--        display_server.configure_buffer_stream(&configuration, protobuf_void.get(),
--            google::protobuf::NewCallback(this, &ExchangeSemantics::on_scale_set, scale));
--        return &scale_wait_handle;
--    }
--
--    void set_interval(int) override
--    {
--    }
--
--    std::mutex mutable mutex;
--    mcl::ClientBufferDepository wrapped;
--    mir::protobuf::DisplayServer& display_server;
--    std::function<void()> on_incoming_buffer;
--    std::queue<mir::protobuf::Buffer> incoming_buffers;
--    std::unique_ptr<mir::protobuf::Void> protobuf_void{std::make_unique<mp::Void>()};
--    MirWaitHandle next_buffer_wait_handle;
--    bool server_connection_lost {false};
--    MirWaitHandle scale_wait_handle;
--    float scale_;
--    geom::Size size_;
--};
--
--class Requests : public mcl::ServerBufferRequests
--{
--public:
--    Requests(mclr::DisplayServer& server, int stream_id) :
--        server(server),
--        stream_id(stream_id)
--    {
--    }
--
--    void allocate_buffer(geom::Size size, MirPixelFormat format, int usage) override
--    {
--        mp::BufferAllocation request;
--        request.mutable_id()->set_value(stream_id);
--        auto buf_params = request.add_buffer_requests();
--        buf_params->set_width(size.width.as_int());
--        buf_params->set_height(size.height.as_int());
--        buf_params->set_pixel_format(format);
--        buf_params->set_buffer_usage(usage);
--
--        //note, NewCallback will trigger on exception, deleting this object there
--        auto protobuf_void = new mp::Void;
--        server.allocate_buffers(&request,  protobuf_void,
--            google::protobuf::NewCallback(Requests::ignore_response, protobuf_void));
--    }
--
--    void free_buffer(int buffer_id) override
--    {
--        mp::BufferRelease request;
--        request.mutable_id()->set_value(stream_id);
--        request.add_buffers()->set_buffer_id(buffer_id);
--
--        //note, NewCallback will trigger on exception, deleting this object there
--        auto protobuf_void = new mp::Void;
--        server.release_buffers(&request, protobuf_void,
--            google::protobuf::NewCallback(Requests::ignore_response, protobuf_void));
--    }
--
--    void submit_buffer(mcl::Buffer& buffer) override
--    {
--        mp::BufferRequest request;
--        request.mutable_id()->set_value(stream_id);
--        request.mutable_buffer()->set_buffer_id(buffer.rpc_id());
--
--        //note, NewCallback will trigger on exception, deleting this object there
--        auto protobuf_void = new mp::Void;
--        server.submit_buffer(&request, protobuf_void,
--            google::protobuf::NewCallback(Requests::ignore_response, protobuf_void));
--    }
--
--    static void ignore_response(mp::Void* void_response)
--    {
--        delete void_response;
--    }
--
--private:
--    mclr::DisplayServer& server;
--    mp::Void protobuf_void;
--    int stream_id;
--};
--
--struct NewBufferSemantics : mcl::ServerBufferSemantics
--{
--    NewBufferSemantics(
--        std::shared_ptr<mcl::ClientBufferFactory> const& factory,
--        std::shared_ptr<mcl::AsyncBufferFactory> const& mirbuffer_factory,
--        std::shared_ptr<mcl::ServerBufferRequests> const& requests,
--        std::weak_ptr<mcl::SurfaceMap> const& surface_map,
--        geom::Size size, MirPixelFormat format, int usage,
--        unsigned int initial_nbuffers) :
--        vault(factory, mirbuffer_factory, requests, surface_map, size, format, usage, initial_nbuffers),
--        current(nullptr),
--        future(vault.withdraw()),
--        size_(size)
--    {
--    }
--
--    void deposit(mp::Buffer const&, mir::optional_value<geom::Size>, MirPixelFormat) override
--    {
--    }
--
--    void advance_current_buffer(std::unique_lock<std::mutex>& lk)
--    {
--        lk.unlock();
--        auto c = future.get();
--        lk.lock();
--        current = c;
--    }
--
--    std::shared_ptr<mir::client::ClientBuffer> current_buffer() override
--    {
--        std::unique_lock<std::mutex> lk(mutex);
--        if (!current)
--            advance_current_buffer(lk);
--        return current->client_buffer();
--    }
--
--    uint32_t current_buffer_id() override
--    {
--        std::unique_lock<std::mutex> lk(mutex);
--        if (!current)
--            advance_current_buffer(lk);
--        return current->rpc_id();
--    }
--
--    MirWaitHandle* submit(std::function<void()> const& done, MirPixelFormat, int) override
--    {
--        std::unique_lock<std::mutex> lk(mutex);
--        if (!current)
--            advance_current_buffer(lk);
--        auto c = current;
--        current = nullptr;
--        lk.unlock();
--
--        vault.deposit(c);
--        auto wh = vault.wire_transfer_outbound(c, done);
--        auto f = vault.withdraw();
--        lk.lock();
--        future = std::move(f);
--        return wh;
--    }
--
--    void set_size(geom::Size size) override
--    {
--        {
--            std::unique_lock<std::mutex> lk(mutex);
--            size_ = size;
--        }
--        vault.set_size(size);
--    }
--
--    geom::Size size() const override
--    {
--        std::unique_lock<std::mutex> lk(mutex);
--        return size_;
--    }
--
--    void lost_connection() override
--    {
--        vault.disconnected();
--    }
--
--    void set_buffer_cache_size(unsigned int) override
--    {
--    }
--
--    MirWaitHandle* set_scale(float scale, mf::BufferStreamId) override
--    {
--        scale_wait_handle.expect_result();
--        scale_wait_handle.result_received();
--        vault.set_scale(scale);
--        return &scale_wait_handle;
--    }
--
--    void set_interval(int interval) override
--    {
--        std::unique_lock<decltype(mutex)> lk(mutex);
--        interval = std::max(0, std::min(1, interval));
--        if (current_swap_interval == interval)
--            return;
--        if (interval == 0)
--            vault.increase_buffer_count();
--        else
--            vault.decrease_buffer_count();
--        current_swap_interval = interval;
--    }
--
--    mcl::BufferVault vault;
--    std::mutex mutable mutex;
--    std::shared_ptr<mcl::Buffer> current{nullptr};
--    mir::client::NoTLSFuture<std::shared_ptr<mcl::Buffer>> future;
--    MirWaitHandle scale_wait_handle;
--    int current_swap_interval = 1;
--    geom::Size size_;
--};
--
--}
--
  mcl::BufferStream::BufferStream(
      MirConnection* connection,
      std::shared_ptr<MirWaitHandle> creation_wait_handle,
 === modified file 'src/client/buffer_stream.h'
 --- src/client/buffer_stream.h	2016-06-02 05:33:50 +0000
 +++ src/client/buffer_stream.h	2016-06-03 01:46:54 +0000
@@ -24,6 +24,7 @@
  #include "mir/client_buffer.h"
  #include "client_buffer_stream.h"
  #include "client_buffer_depository.h"
++#include "server_buffer_semantics.h"
  #include "mir/geometry/size.h"
  #include "mir_toolkit/client_types.h"
@@ -66,8 +67,6 @@
  class ClientPlatform;
  class PerfReport;
  struct MemoryRegion;
--class SurfaceMap;
--class ServerBufferSemantics;
  class BufferStream : public EGLNativeSurface, public ClientBufferStream
+ {
  public:
 === modified file 'src/client/error_chain.cpp'
 --- src/client/error_chain.cpp	2016-06-02 05:33:50 +0000
 +++ src/client/error_chain.cpp	2016-06-03 01:46:54 +0000
@@ -51,3 +51,8 @@
+ {
      BOOST_THROW_EXCEPTION(std::logic_error("Cannot submit: invalid MirPresentationChain"));
+ }
++
++EGLNativeWindowType mcl::ErrorChain::egl_native_window(geom::Size, MirPixelFormat)
++{
++    BOOST_THROW_EXCEPTION(std::logic_error("Cannot get native window: invalid MirPresentationChain"));
++}
 === modified file 'src/client/error_chain.h'
 --- src/client/error_chain.h	2016-06-02 05:33:50 +0000
 +++ src/client/error_chain.h	2016-06-03 01:46:54 +0000
@@ -38,6 +38,7 @@
      MirConnection* connection() const override;
      int rpc_id() const override;
      char const* error_msg() const override;
++    EGLNativeWindowType egl_native_window(mir::geometry::Size size, MirPixelFormat pixel_format) override;
  private:
      MirConnection* const connection_;
      int const stream_id;
 === added file 'src/client/exchange_semantics.cpp'
 --- src/client/exchange_semantics.cpp	1970-01-01 00:00:00 +0000
 +++ src/client/exchange_semantics.cpp	2016-06-03 01:46:54 +0000
@@ -0,0 +1,173 @@
++/*
++ * 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: Cemil Azizoglu <cemil.azizoglu@canonical.com>
++ */
++
++#include "exchange_semantics.h"
++#include "buffer.h"
++#include "protobuf_to_native_buffer.h"
++#include "make_protobuf_object.h"
++
++#include <boost/throw_exception.hpp>
++
++namespace mcl = mir::client;
++namespace mf = mir::frontend;
++namespace mp = mir::protobuf;
++namespace geom = mir::geometry;
++
++mcl::ExchangeSemantics::ExchangeSemantics(
++    mp::DisplayServer& server,
++    std::shared_ptr<ClientBufferFactory> const& factory, int max_buffers,
++    mp::Buffer const& first_buffer, geom::Size first_size, MirPixelFormat first_pf) :
++    wrapped{factory, max_buffers},
++    display_server(server),
++    size_(first_size)
++{
++    wrapped.deposit_package(
++        mcl::protobuf_to_native_buffer(first_buffer),
++        first_buffer.buffer_id(), first_size, first_pf);
++}
++
++void mcl::ExchangeSemantics::deposit(mp::Buffer const& buffer, mir::optional_value<geom::Size> size, MirPixelFormat pf)
++{
++    std::unique_lock<std::mutex> lock(mutex);
++    if (size.is_set())
++        size_ = size.value();
++
++    if (on_incoming_buffer)
++    {
++        wrapped.deposit_package(
++            mcl::protobuf_to_native_buffer(buffer),
++            buffer.buffer_id(), size_, pf);
++        if (on_incoming_buffer)
++        {
++            on_incoming_buffer();
++            next_buffer_wait_handle.result_received();
++            on_incoming_buffer = std::function<void()>{};
++        }
++    }
++    else
++    {
++        incoming_buffers.push(buffer);
++    }
++}
++
++void mcl::ExchangeSemantics::set_buffer_cache_size(unsigned int sz)
++{
++    std::unique_lock<std::mutex> lock(mutex);
++    wrapped.set_max_buffers(sz);
++}
++
++std::shared_ptr<mir::client::ClientBuffer> mcl::ExchangeSemantics::current_buffer()
++{
++    std::unique_lock<std::mutex> lock(mutex);
++    return wrapped.current_buffer();
++}
++
++uint32_t mcl::ExchangeSemantics::current_buffer_id()
++{
++    std::unique_lock<std::mutex> lock(mutex);
++    if (incoming_buffers.size())
++        return incoming_buffers.front().buffer_id();
++    return wrapped.current_buffer_id();
++}
++
++MirWaitHandle* mcl::ExchangeSemantics::submit(std::function<void()> const& done, MirPixelFormat pf, int stream_id)
++{
++    std::unique_lock<std::mutex> lock(mutex);
++    if (server_connection_lost)
++        BOOST_THROW_EXCEPTION(std::runtime_error("disconnected: no new buffers"));
++    //always submit what we have, whether we have a buffer, or will have to wait for an async reply
++    auto request = mcl::make_protobuf_object<mp::BufferRequest>();
++    request->mutable_id()->set_value(stream_id);
++    request->mutable_buffer()->set_buffer_id(wrapped.current_buffer_id());
++    lock.unlock();
++
++    display_server.submit_buffer(request.get(), protobuf_void.get(),
++        google::protobuf::NewCallback(google::protobuf::DoNothing));
++
++    lock.lock();
++    if (server_connection_lost)
++        BOOST_THROW_EXCEPTION(std::runtime_error("disconnected: no new buffers"));
++    if (incoming_buffers.empty())
++    {
++        next_buffer_wait_handle.expect_result();
++        on_incoming_buffer = done;
++    }
++    else
++    {
++        wrapped.deposit_package(
++            mcl::protobuf_to_native_buffer(incoming_buffers.front()),
++            incoming_buffers.front().buffer_id(), size_, pf);
++        incoming_buffers.pop();
++        done();
++    }
++    return &next_buffer_wait_handle;
++}
++
++void mcl::ExchangeSemantics::lost_connection()
++{
++    std::unique_lock<std::mutex> lock(mutex);
++    server_connection_lost = true;
++    if (on_incoming_buffer)
++    {
++        on_incoming_buffer();
++        on_incoming_buffer = std::function<void()>{};
++    }
++    if (next_buffer_wait_handle.is_pending())
++        next_buffer_wait_handle.result_received();
++
++    while (!incoming_buffers.empty())
++    {
++        auto b = incoming_buffers.front();
++        for (auto i = 0; i < b.fd_size(); i++)
++            close(b.fd(i));
++        incoming_buffers.pop();
++    }
++}
++
++void mcl::ExchangeSemantics::set_size(geom::Size)
++{
++}
++
++geom::Size mcl::ExchangeSemantics::size() const
++{
++    std::unique_lock<std::mutex> lk(mutex);
++    return size_;
++}
++
++void mcl::ExchangeSemantics::on_scale_set(float scale)
++{
++    std::unique_lock<decltype(mutex)> lock(mutex);
++    scale_ = scale;
++    scale_wait_handle.result_received();
++}
++
++MirWaitHandle* mcl::ExchangeSemantics::set_scale(float scale, mf::BufferStreamId stream_id)
++{
++    mp::StreamConfiguration configuration;
++    configuration.mutable_id()->set_value(stream_id.as_value());
++    configuration.set_scale(scale);
++    scale_wait_handle.expect_result();
++
++    display_server.configure_buffer_stream(&configuration, protobuf_void.get(),
++        google::protobuf::NewCallback(this, &ExchangeSemantics::on_scale_set, scale));
++    return &scale_wait_handle;
++}
++
++void mcl::ExchangeSemantics::set_interval(int)
++{
++}
 === added file 'src/client/exchange_semantics.h'
 --- src/client/exchange_semantics.h	1970-01-01 00:00:00 +0000
 +++ src/client/exchange_semantics.h	2016-06-03 01:46:54 +0000
@@ -0,0 +1,70 @@
++/*
++ * 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 <kevin.dubois@canonical.com>
++ */
++
++#ifndef MIR_CLIENT_EXCHANGE_SEMANTICS_H
++#define MIR_CLIENT_EXCHANGE_SEMANTICS_H
++
++#include "server_buffer_semantics.h"
++#include <mir/protobuf/display_server.h>
++#include "mir/client_buffer_factory.h"
++#include "client_buffer_depository.h"
++#include "mir_wait_handle.h"
++
++#include <mutex>
++#include <queue>
++
++namespace mir
++{
++namespace client
++{
++
++struct ExchangeSemantics : ServerBufferSemantics
++{
++    ExchangeSemantics(
++        protobuf::DisplayServer& server,
++        std::shared_ptr<ClientBufferFactory> const& factory, int max_buffers,
++        protobuf::Buffer const& first_buffer, geometry::Size first_size, MirPixelFormat first_pf);
++    void deposit(protobuf::Buffer const& buffer, optional_value<geometry::Size> size, MirPixelFormat pf) override;
++    void set_buffer_cache_size(unsigned int sz) override;
++    std::shared_ptr<ClientBuffer> current_buffer() override;
++    uint32_t current_buffer_id() override;
++    MirWaitHandle* submit(std::function<void()> const& done, MirPixelFormat pf, int stream_id) override;
++    void lost_connection() override;
++    void set_size(geometry::Size) override;
++    geometry::Size size() const override;
++    void set_interval(int) override;
++    void on_scale_set(float scale);
++    MirWaitHandle* set_scale(float scale, frontend::BufferStreamId stream_id) override;
++
++    std::mutex mutable mutex;
++    ClientBufferDepository wrapped;
++    protobuf::DisplayServer& display_server;
++    std::function<void()> on_incoming_buffer;
++    std::queue<protobuf::Buffer> incoming_buffers;
++    std::unique_ptr<protobuf::Void> protobuf_void{std::make_unique<protobuf::Void>()};
++    MirWaitHandle next_buffer_wait_handle;
++    bool server_connection_lost {false};
++    MirWaitHandle scale_wait_handle;
++    float scale_;
++    geometry::Size size_;
++};
++
++}
++}
++
++#endif /* MIR_CLIENT_EXCHANGE_SEMANTICS_H */
 === modified file 'src/client/mir_connection.cpp'
 --- src/client/mir_connection.cpp	2016-06-02 05:33:50 +0000
 +++ src/client/mir_connection.cpp	2016-06-03 01:46:54 +0000
@@ -1180,7 +1180,7 @@
          if (!client_buffer_factory)
              client_buffer_factory = platform->create_buffer_factory();
          auto chain = std::make_shared<mcl::PresentationChain>(
--            this, protobuf_bs->id().value(), server, client_buffer_factory, buffer_factory);
++            this, protobuf_bs->id().value(), server, platform, client_buffer_factory, buffer_factory, surface_map, nbuffers);
          surface_map->insert(mf::BufferStreamId(protobuf_bs->id().value()), chain);
 === modified file 'src/client/mir_presentation_chain.h'
 --- src/client/mir_presentation_chain.h	2016-03-10 14:30:48 +0000
 +++ src/client/mir_presentation_chain.h	2016-06-03 01:46:54 +0000
@@ -22,6 +22,18 @@
  #include "mir/geometry/size.h"
  #include "mir_toolkit/mir_presentation_chain.h"
++#include <EGL/eglplatform.h>
++
++//See comment in client_buffer_stream.h
++#include <type_traits>
++static_assert(
++    sizeof(EGLNativeWindowType) == sizeof(void*) &&
++    std::is_pod<EGLNativeWindowType>::value,
++    "MirPresentationChain requires that EGLNativeWindowType be no-op convertible to void*");
++
++#undef EGLNativeWindowType
++#define EGLNativeWindowType void*
++
  class MirPresentationChain
+ {
  public:
@@ -30,6 +42,7 @@
      virtual MirConnection* connection() const = 0;
      virtual int rpc_id() const = 0;
      virtual char const* error_msg() const = 0;
++    virtual EGLNativeWindowType egl_native_window(mir::geometry::Size size, MirPixelFormat pixel_format) = 0;
  protected:
      MirPresentationChain(MirPresentationChain const&) = delete;
 === modified file 'src/client/mir_presentation_chain_api.cpp'
 --- src/client/mir_presentation_chain_api.cpp	2016-05-03 06:55:25 +0000
 +++ src/client/mir_presentation_chain_api.cpp	2016-06-03 01:46:54 +0000
@@ -124,3 +124,16 @@
+ {
      MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+ }
++
++MirEGLNativeWindowType mir_create_egl_native_window(
++    MirPresentationChain* presentation_chain, int width, int height, MirPixelFormat pixel_format)
++try
++{
++    mir::require(presentation_chain && mir_presentation_chain_is_valid(presentation_chain));
++    return presentation_chain->egl_native_window(mir::geometry::Size{width, height}, pixel_format);
++}
++catch (std::exception const& ex)
++{
++    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
++    return nullptr;
++}
 === added file 'src/client/new_buffer_semantics.cpp'
 --- src/client/new_buffer_semantics.cpp	1970-01-01 00:00:00 +0000
 +++ src/client/new_buffer_semantics.cpp	2016-06-03 01:46:54 +0000
@@ -0,0 +1,181 @@
++/*
++ * 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 <kevin.dubois@canonical.com>
++ */
++
++#include "new_buffer_semantics.h"
++#include "buffer.h"
++
++namespace mcl = mir::client;
++namespace mclr = mir::client::rpc;
++namespace mf = mir::frontend;
++namespace mp = mir::protobuf;
++namespace geom = mir::geometry;
++
++mcl::Requests::Requests(mclr::DisplayServer& server, int stream_id) :
++    server(server),
++    stream_id(stream_id)
++{
++}
++
++void mcl::Requests::allocate_buffer(geom::Size size, MirPixelFormat format, int usage)
++{
++    mp::BufferAllocation request;
++    request.mutable_id()->set_value(stream_id);
++    auto buf_params = request.add_buffer_requests();
++    buf_params->set_width(size.width.as_int());
++    buf_params->set_height(size.height.as_int());
++    buf_params->set_pixel_format(format);
++    buf_params->set_buffer_usage(usage);
++
++    //note, NewCallback will trigger on exception, deleting this object there
++    auto protobuf_void = new mp::Void;
++    server.allocate_buffers(&request,  protobuf_void,
++        google::protobuf::NewCallback(Requests::ignore_response, protobuf_void));
++}
++
++void mcl::Requests::free_buffer(int buffer_id)
++{
++    mp::BufferRelease request;
++    request.mutable_id()->set_value(stream_id);
++    request.add_buffers()->set_buffer_id(buffer_id);
++
++    //note, NewCallback will trigger on exception, deleting this object there
++    auto protobuf_void = new mp::Void;
++    server.release_buffers(&request, protobuf_void,
++        google::protobuf::NewCallback(Requests::ignore_response, protobuf_void));
++}
++
++void mcl::Requests::submit_buffer(mcl::Buffer& buffer)
++{
++    mp::BufferRequest request;
++    request.mutable_id()->set_value(stream_id);
++    request.mutable_buffer()->set_buffer_id(buffer.rpc_id());
++
++    //note, NewCallback will trigger on exception, deleting this object there
++    auto protobuf_void = new mp::Void;
++    server.submit_buffer(&request, protobuf_void,
++        google::protobuf::NewCallback(Requests::ignore_response, protobuf_void));
++}
++
++void mcl::Requests::ignore_response(mp::Void* void_response)
++{
++    delete void_response;
++}
++
++mcl::NewBufferSemantics::NewBufferSemantics(
++    std::shared_ptr<mcl::ClientBufferFactory> const& factory,
++    std::shared_ptr<mcl::AsyncBufferFactory> const& mirbuffer_factory,
++    std::shared_ptr<mcl::ServerBufferRequests> const& requests,
++    std::weak_ptr<mcl::SurfaceMap> const& surface_map,
++    geom::Size size, MirPixelFormat format, int usage,
++    unsigned int initial_nbuffers) :
++    vault(factory, mirbuffer_factory, requests, surface_map, size, format, usage, initial_nbuffers),
++    current(nullptr),
++    future(vault.withdraw()),
++    size_(size)
++{
++}
++
++void mcl::NewBufferSemantics::deposit(mp::Buffer const&, mir::optional_value<geom::Size>, MirPixelFormat)
++{
++}
++
++void mcl::NewBufferSemantics::advance_current_buffer(std::unique_lock<std::mutex>& lk)
++{
++    lk.unlock();
++    auto c = future.get();
++    lk.lock();
++    current = c;
++}
++
++std::shared_ptr<mir::client::ClientBuffer> mcl::NewBufferSemantics::current_buffer()
++{
++    std::unique_lock<std::mutex> lk(mutex);
++    if (!current)
++        advance_current_buffer(lk);
++    return current->client_buffer();
++}
++
++uint32_t mcl::NewBufferSemantics::current_buffer_id()
++{
++    std::unique_lock<std::mutex> lk(mutex);
++    if (!current)
++        advance_current_buffer(lk);
++    return current->rpc_id();
++}
++
++MirWaitHandle* mcl::NewBufferSemantics::submit(std::function<void()> const& done, MirPixelFormat, int)
++{
++    std::unique_lock<std::mutex> lk(mutex);
++    if (!current)
++        advance_current_buffer(lk);
++    auto c = current;
++    current = nullptr;
++    lk.unlock();
++
++    vault.deposit(c);
++    auto wh = vault.wire_transfer_outbound(c, done);
++    auto f = vault.withdraw();
++    lk.lock();
++    future = std::move(f);
++    return wh;
++}
++
++void mcl::NewBufferSemantics::set_size(geom::Size size)
++{
++    {
++        std::unique_lock<std::mutex> lk(mutex);
++        size_ = size;
++    }
++    vault.set_size(size);
++}
++
++geom::Size mcl::NewBufferSemantics::size() const
++{
++    std::unique_lock<std::mutex> lk(mutex);
++    return size_;
++}
++
++void mcl::NewBufferSemantics::lost_connection()
++{
++    vault.disconnected();
++}
++
++void mcl::NewBufferSemantics::set_buffer_cache_size(unsigned int)
++{
++}
++
++MirWaitHandle* mcl::NewBufferSemantics::set_scale(float scale, mf::BufferStreamId)
++{
++    scale_wait_handle.expect_result();
++    scale_wait_handle.result_received();
++    vault.set_scale(scale);
++    return &scale_wait_handle;
++}
++
++void mcl::NewBufferSemantics::set_interval(int interval)
++{
++    std::unique_lock<decltype(mutex)> lk(mutex);
++    interval = std::max(0, std::min(1, interval));
++    if (current_swap_interval == interval)
++        return;
++    if (interval == 0)
++        vault.increase_buffer_count();
++    else
++        vault.decrease_buffer_count();
++    current_swap_interval = interval;
++}
 === added file 'src/client/new_buffer_semantics.h'
 --- src/client/new_buffer_semantics.h	1970-01-01 00:00:00 +0000
 +++ src/client/new_buffer_semantics.h	2016-06-03 01:46:54 +0000
@@ -0,0 +1,79 @@
++/*
++ * 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 <kevin.dubois@canonical.com>
++ */
++
++#ifndef MIR_CLIENT_NEW_BUFFER_SEMANTICS_H
++#define MIR_CLIENT_NEW_BUFFER_SEMANTICS_H
++
++#include "server_buffer_semantics.h"
++#include "buffer_vault.h"
++#include "rpc/mir_display_server.h"
++
++namespace mir
++{
++namespace client
++{
++
++class Requests : public ServerBufferRequests
++{
++public:
++    Requests(client::rpc::DisplayServer& server, int stream_id);
++    void allocate_buffer(geometry::Size size, MirPixelFormat format, int usage) override;
++    void free_buffer(int buffer_id) override;
++    void submit_buffer(Buffer& buffer) override;
++    static void ignore_response(protobuf::Void* void_response);
++
++private:
++    client::rpc::DisplayServer& server;
++    protobuf::Void protobuf_void;
++    int stream_id;
++};
++
++struct NewBufferSemantics : ServerBufferSemantics
++{
++    NewBufferSemantics(
++        std::shared_ptr<ClientBufferFactory> const& factory,
++        std::shared_ptr<AsyncBufferFactory> const& mirbuffer_factory,
++        std::shared_ptr<ServerBufferRequests> const& requests,
++        std::weak_ptr<SurfaceMap> const& surface_map,
++        geometry::Size size, MirPixelFormat format, int usage,
++        unsigned int initial_nbuffers);
++    void deposit(protobuf::Buffer const&, optional_value<geometry::Size>, MirPixelFormat) override;
++    void advance_current_buffer(std::unique_lock<std::mutex>& lk);
++    std::shared_ptr<ClientBuffer> current_buffer() override;
++    uint32_t current_buffer_id() override;
++    MirWaitHandle* submit(std::function<void()> const& done, MirPixelFormat, int) override;
++    void set_size(geometry::Size size) override;
++    geometry::Size size() const override;
++    void lost_connection() override;
++    void set_buffer_cache_size(unsigned int) override;
++    MirWaitHandle* set_scale(float scale, frontend::BufferStreamId) override;
++    void set_interval(int interval) override;
++
++    BufferVault vault;
++    std::mutex mutable mutex;
++    std::shared_ptr<Buffer> current{nullptr};
++    NoTLSFuture<std::shared_ptr<Buffer>> future;
++    MirWaitHandle scale_wait_handle;
++    int current_swap_interval = 1;
++    geometry::Size size_;
++};
++
++}
++}
++
++#endif /* MIR_CLIENT_NEW_BUFFER_SEMANTICS_H */
 === modified file 'src/client/presentation_chain.cpp'
 --- src/client/presentation_chain.cpp	2016-06-02 05:33:50 +0000
 +++ src/client/presentation_chain.cpp	2016-06-03 01:46:54 +0000
@@ -22,6 +22,8 @@
  #include "presentation_chain.h"
  #include "protobuf_to_native_buffer.h"
  #include "buffer_factory.h"
++#include "new_buffer_semantics.h"
++#include "mir/client_platform.h"
  #include <boost/throw_exception.hpp>
  #include <algorithm>
@@ -34,13 +36,22 @@
      MirConnection* connection,
      int stream_id,
      mir::client::rpc::DisplayServer& server,
++    std::shared_ptr<ClientPlatform> const& client_platform,
      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)
++    std::shared_ptr<mcl::AsyncBufferFactory> const& mir_buffer_factory,
++    std::weak_ptr<SurfaceMap> const& map,
++    size_t nbuffers) :
++        connection_(connection),
++        stream_id(stream_id),
++        server(server),
++        client_platform(client_platform),
++        native_buffer_factory(native_buffer_factory),
++        mir_buffer_factory(mir_buffer_factory),
++        egl_native_window_(nullptr),
++        map(map),
++        nbuffers(nbuffers),
++        buffer_depository(nullptr),
++        egl_native_window_pixel_format(mir_pixel_format_invalid)
+ {
+ }
@@ -58,6 +69,9 @@
  void mcl::PresentationChain::submit_buffer(MirBuffer* mirbuffer)
+ {
++    if (egl_native_window_)
++        BOOST_THROW_EXCEPTION(std::runtime_error("Buffers cannot be submitted when chain is in EGL mode"));
++
      mp::BufferRequest request;
+     {
          auto buffer = reinterpret_cast<mcl::Buffer*>(mirbuffer);
@@ -84,3 +98,82 @@
+ {
      return "";
+ }
++
++EGLNativeWindowType mcl::PresentationChain::egl_native_window(mir::geometry::Size size, MirPixelFormat pixel_format)
++{
++    std::unique_lock<decltype(mutex)> lock(mutex);
++    if (!egl_native_window_)
++    {
++        egl_native_window_pixel_format = pixel_format;
++        buffer_depository = std::make_unique<NewBufferSemantics>(
++            native_buffer_factory,
++            mir_buffer_factory,
++            std::make_shared<Requests>(server, stream_id),
++            map,
++            size,
++            pixel_format,
++            mir_buffer_usage_hardware,
++            nbuffers);
++
++        egl_native_window_ = client_platform->create_egl_native_window(this);
++    }
++
++    return static_cast<EGLNativeWindowType>(egl_native_window_.get());
++}
++
++//////////////////////////////
++// EGLNativeSurface interface
++//////////////////////////////
++
++namespace
++{
++    const char * const egl_mode_error = "Chain cannot be used in EGL mode";
++}
++
++MirSurfaceParameters mcl::PresentationChain::get_parameters() const
++{
++    std::unique_lock<decltype(mutex)> lock(mutex);
++
++    if (!buffer_depository)
++        BOOST_THROW_EXCEPTION(std::runtime_error(egl_mode_error));
++
++    auto size = buffer_depository->size();
++
++    return MirSurfaceParameters{
++        "",
++        size.width.as_int(),
++        size.height.as_int(),
++        egl_native_window_pixel_format,
++        mir_buffer_usage_hardware,
++        mir_display_output_id_invalid};
++}
++
++std::shared_ptr<mcl::ClientBuffer> mcl::PresentationChain::get_current_buffer()
++{
++    {
++        std::unique_lock<decltype(mutex)> lock(mutex);
++        if (!buffer_depository)
++            BOOST_THROW_EXCEPTION(std::runtime_error(egl_mode_error));
++    }
++    return buffer_depository->current_buffer();
++}
++
++void mcl::PresentationChain::request_and_wait_for_next_buffer()
++{
++    {
++        std::unique_lock<decltype(mutex)> lock(mutex);
++        if (!buffer_depository)
++            BOOST_THROW_EXCEPTION(std::runtime_error(egl_mode_error));
++    }
++    buffer_depository->submit([](){}, egl_native_window_pixel_format, 0)->wait_for_all();
++}
++
++void mcl::PresentationChain::request_and_wait_for_configure(MirSurfaceAttrib /*a*/, int /*value*/)
++{
++    //TODO: implement this function
++}
++
++void mcl::PresentationChain::set_buffer_cache_size(unsigned int)
++{
++    //TODO: implement this function
++}
 === modified file 'src/client/presentation_chain.h'
 --- src/client/presentation_chain.h	2016-06-02 05:33:50 +0000
 +++ src/client/presentation_chain.h	2016-06-03 01:46:54 +0000
@@ -22,8 +22,10 @@
  #include "mir_presentation_chain.h"
  #include "mir/geometry/size.h"
  #include "mir_toolkit/mir_presentation_chain.h"
++#include "mir/egl_native_surface.h"
  #include "mir_protobuf.pb.h"
  #include "buffer.h"
++#include "server_buffer_semantics.h"
  #include <mutex>
  #include <memory>
@@ -34,34 +36,59 @@
  class ClientBufferFactory;
  class ClientBuffer;
  class AsyncBufferFactory;
++class ClientPlatform;
++class SurfaceMap;
++
  namespace rpc
+ {
  class DisplayServer;
+ }
--class PresentationChain : public MirPresentationChain
++class PresentationChain : public MirPresentationChain, public EGLNativeSurface
+ {
  public:
      PresentationChain(
          MirConnection* connection,
          int rpc_id,
          rpc::DisplayServer& server,
++        std::shared_ptr<ClientPlatform> const& client_platform,
          std::shared_ptr<ClientBufferFactory> const& native_buffer_factory,
--        std::shared_ptr<AsyncBufferFactory> const& mir_buffer_factory);
++        std::shared_ptr<AsyncBufferFactory> const& mir_buffer_factory,
++        std::weak_ptr<SurfaceMap> const& map,
++        size_t nbuffers);
++
      void submit_buffer(MirBuffer* buffer) override;
      MirConnection* connection() const override;
      int rpc_id() const override;
      char const* error_msg() const override;
++    EGLNativeWindowType egl_native_window(mir::geometry::Size size, MirPixelFormat pixel_format) override;
++
++    // EGLNativeSurface interface
++    std::shared_ptr<ClientBuffer> get_current_buffer() override;
++    MirSurfaceParameters get_parameters() const override;
++    void request_and_wait_for_next_buffer() override;
++    void request_and_wait_for_configure(MirSurfaceAttrib a, int value) override;
++    void set_buffer_cache_size(unsigned int) override;
++
++protected:
++    PresentationChain(PresentationChain const&) = delete;
++    PresentationChain& operator=(PresentationChain const&) = delete;
++
  private:
--
      MirConnection* const connection_;
      int const stream_id;
      rpc::DisplayServer& server;
++    std::shared_ptr<ClientPlatform> const client_platform;
      std::shared_ptr<ClientBufferFactory> const native_buffer_factory;
      std::shared_ptr<AsyncBufferFactory> const mir_buffer_factory;
++    std::shared_ptr<void> egl_native_window_;
++    std::weak_ptr<SurfaceMap> const map;
++    size_t nbuffers;
--    std::mutex mutex;
++    mutable std::mutex mutex;
      std::vector<std::unique_ptr<Buffer>> buffers;
++    std::unique_ptr<ServerBufferSemantics> buffer_depository;
++    MirPixelFormat egl_native_window_pixel_format;
  };
+ }
+ }
 === added file 'src/client/server_buffer_semantics.h'
 --- src/client/server_buffer_semantics.h	1970-01-01 00:00:00 +0000
 +++ src/client/server_buffer_semantics.h	2016-06-03 01:46:54 +0000
@@ -0,0 +1,59 @@
++/*
++ * 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 <kevin.dubois@canonical.com>
++ */
++
++#ifndef MIR_CLIENT_SERVER_BUFFER_SEMANTICS_H
++#define MIR_CLIENT_SERVER_BUFFER_SEMANTICS_H
++
++#include "mir/optional_value.h"
++#include "mir/frontend/buffer_stream_id.h"
++#include "mir/geometry/size.h"
++#include "mir_toolkit/common.h"
++#include "mir/client_buffer.h"
++#include "mir_protobuf.pb.h"
++
++#include <memory>
++
++namespace mir
++{
++namespace client
++{
++
++//An internal interface useful in transitioning buffer exchange semantics based on
++//the BufferStream response provided by the server
++struct ServerBufferSemantics
++{
++    virtual void deposit(protobuf::Buffer const&, optional_value<geometry::Size>, MirPixelFormat) = 0;
++    virtual void set_buffer_cache_size(unsigned int) = 0;
++    virtual std::shared_ptr<ClientBuffer> current_buffer() = 0;
++    virtual uint32_t current_buffer_id() = 0;
++    virtual MirWaitHandle* submit(std::function<void()> const&, MirPixelFormat, int stream_id) = 0;
++    virtual void lost_connection() = 0;
++    virtual void set_size(geometry::Size) = 0;
++    virtual MirWaitHandle* set_scale(float, frontend::BufferStreamId) = 0;
++    virtual void set_interval(int interval) = 0;
++    virtual geometry::Size size() const = 0;
++    virtual ~ServerBufferSemantics() = default;
++    ServerBufferSemantics() = default;
++    ServerBufferSemantics(ServerBufferSemantics const&) = delete;
++    ServerBufferSemantics& operator=(ServerBufferSemantics const&) = delete;
++};
++
++}
++}
++
++#endif /* MIR_CLIENT_SERVER_BUFFER_SEMANTICS_H */
 === modified file 'src/client/symbols.map'
 --- src/client/symbols.map	2016-06-02 05:33:50 +0000
 +++ src/client/symbols.map	2016-06-03 01:46:54 +0000
@@ -370,6 +370,7 @@
      mir_connection_create_presentation_chain_sync;
      mir_presentation_chain_is_valid;
      mir_presentation_chain_get_error_message;
++    mir_create_egl_native_window;
      mir_connection_create_presentation_chain;
      mir_connection_allocate_buffer;
      mir_presentation_chain_submit_buffer;
 === modified file 'src/include/client/mir_toolkit/mir_presentation_chain.h'
 --- src/include/client/mir_toolkit/mir_presentation_chain.h	2016-06-02 05:33:50 +0000
 +++ src/include/client/mir_toolkit/mir_presentation_chain.h	2016-06-03 01:46:54 +0000
@@ -29,6 +29,23 @@
  #endif
  /**
++ * Extract an MirEGLNativeWindowType object from a given presentation chain.
++ * MirEGLNativeWindowType object that can be used in eglCreateWindowSurface()
++ * as native window. After this function is called, buffer management
++ * (allocation/deallocation/submission) of this presentation chain is done
++ * internally - clients should refrain from managing their buffers.
++ *
++ * \param [in] presentation_chain  The presentation chain
++ * \param [in] width               Native window width
++ * \param [in] height              Native window height
++ * \param [in] pixel format        Pixel format of native window
++ * \return                     MirEGLNativeWindowType object that can be used
++ *                             in eglCreateWindowSurface() as native window.
++ */
++MirEGLNativeWindowType mir_create_egl_native_window(
++    MirPresentationChain* presentation_chain, int width, int height, MirPixelFormat pixel_format);
++
++/**
   * Test for a valid presentation chain
+  *
   * \param [in] presentation_chain  The presentation chain
 === added file 'tests/unit-tests/client/stub_client_platform.h'
 --- tests/unit-tests/client/stub_client_platform.h	1970-01-01 00:00:00 +0000
 +++ tests/unit-tests/client/stub_client_platform.h	2016-06-03 01:46:54 +0000
@@ -0,0 +1,79 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Kevin DuBois <kevin.dubois@canonical.com>
++ */
++
++#ifndef STUB_CLIENT_PLATFORM_H_
++#define STUB_CLIENT_PLATFORM_H_
++
++#include "mir/client_platform.h"
++
++namespace
++{
++
++struct StubClientPlatform : public mir::client::ClientPlatform
++{
++    StubClientPlatform(
++        std::shared_ptr<mir::client::ClientBufferFactory> const& bf)
++        : buffer_factory(bf)
++    {
++    }
++
++    MirPlatformType platform_type() const override
++    {
++        return MirPlatformType();
++    }
++
++    void populate(MirPlatformPackage& /* package */) const override
++    {
++    }
++
++    std::shared_ptr<void> create_egl_native_window(mir::client::EGLNativeSurface * /* surface */) override
++    {
++        return mir::test::fake_shared(egl_native_window);
++    }
++
++    std::shared_ptr<EGLNativeDisplayType> create_egl_native_display() override
++    {
++        return nullptr;
++    }
++
++    MirNativeBuffer* convert_native_buffer(mir::graphics::NativeBuffer*) const override
++    {
++        return nullptr;
++    }
++
++    std::shared_ptr<mir::client::ClientBufferFactory> create_buffer_factory() override
++    {
++        return buffer_factory;
++    }
++
++    MirPlatformMessage* platform_operation(MirPlatformMessage const* /* request */)
++    {
++        return nullptr;
++    }
++
++    MirPixelFormat get_egl_pixel_format(EGLDisplay, EGLConfig) const override
++    {
++        return mir_pixel_format_invalid;
++    }
++
++    static EGLNativeWindowType egl_native_window;
++    std::shared_ptr<mir::client::ClientBufferFactory> const buffer_factory;
++};
++
++}
++#endif /* STUB_CLIENT_PLATFORM_H_ */
 === modified file 'tests/unit-tests/client/test_client_buffer_stream.cpp'
 --- tests/unit-tests/client/test_client_buffer_stream.cpp	2016-06-03 01:46:54 +0000
 +++ tests/unit-tests/client/test_client_buffer_stream.cpp	2016-06-03 01:46:54 +0000
@@ -35,6 +35,8 @@
  #include "mir_toolkit/mir_client_library.h"
++#include "stub_client_platform.h"
++
  #include <future>
  #include <atomic>
@@ -57,49 +59,6 @@
      arg1->set_error(message);
+ }
--struct StubClientPlatform : public mcl::ClientPlatform
--{
--    StubClientPlatform(
--        std::shared_ptr<mcl::ClientBufferFactory> const& bf)
--        : buffer_factory(bf)
--    {
--    }
--    MirPlatformType platform_type() const override
--    {
--        return MirPlatformType();
--    }
--    void populate(MirPlatformPackage& /* package */) const override
--    {
--    }
--    std::shared_ptr<void> create_egl_native_window(mcl::EGLNativeSurface * /* surface */) override
--    {
--        return mt::fake_shared(egl_native_window);
--    }
--    std::shared_ptr<EGLNativeDisplayType> create_egl_native_display() override
--    {
--        return nullptr;
--    }
--    MirNativeBuffer* convert_native_buffer(mg::NativeBuffer*) const override
--    {
--        return nullptr;
--    }
--
--    std::shared_ptr<mcl::ClientBufferFactory> create_buffer_factory() override
--    {
--        return buffer_factory;
--    }
--    MirPlatformMessage* platform_operation(MirPlatformMessage const* /* request */)
--    {
--        return nullptr;
--    }
--    MirPixelFormat get_egl_pixel_format(EGLDisplay, EGLConfig) const override
--    {
--        return mir_pixel_format_invalid;
--    }
--    static EGLNativeWindowType egl_native_window;
--    std::shared_ptr<mcl::ClientBufferFactory> const buffer_factory;
--};
--
  struct MockPerfReport : public mcl::PerfReport
+ {
      MOCK_METHOD1(name_surface, void(char const*));
 === modified file 'tests/unit-tests/client/test_connection_resource_map.cpp'
 --- tests/unit-tests/client/test_connection_resource_map.cpp	2016-06-02 05:33:50 +0000
 +++ tests/unit-tests/client/test_connection_resource_map.cpp	2016-06-03 01:46:54 +0000
@@ -42,7 +42,7 @@
          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) };
++        nullptr, 0, mock_server, nullptr, nullptr, nullptr, std::shared_ptr<mcl::SurfaceMap>(nullptr), 0) };
      mf::SurfaceId const surface_id{43};
      mf::BufferStreamId const stream_id{43};
 === modified file 'tests/unit-tests/client/test_presentation_chain.cpp'
 --- tests/unit-tests/client/test_presentation_chain.cpp	2016-06-02 05:33:50 +0000
 +++ tests/unit-tests/client/test_presentation_chain.cpp	2016-06-03 01:46:54 +0000
@@ -21,13 +21,18 @@
  #include "mir/test/doubles/mock_client_buffer.h"
  #include "mir/test/fake_shared.h"
  #include "src/client/presentation_chain.h"
++#include "src/client/connection_surface_map.h"
  #include "src/client/buffer_factory.h"
  #include "mir/client_buffer_factory.h"
++#include "stub_client_platform.h"
  #include <mutex>
  #include <condition_variable>
  #include <gtest/gtest.h>
++
  using namespace testing;
++
++namespace mt = mir::test;
  namespace mtd = mir::test::doubles;
  namespace geom = mir::geometry;
  namespace mcl = mir::client;
@@ -50,11 +55,15 @@
      geom::Size size {100, 200};
      MirPixelFormat format = mir_pixel_format_abgr_8888;
      MirBufferUsage usage = mir_buffer_usage_software;
--    mtd::MockProtobufServer mock_server;
++    NiceMock<mtd::MockProtobufServer> mock_server;
      int buffer_id {4312};
      mp::Buffer ipc_buf;
      std::shared_ptr<mtd::StubClientBuffer> client_buffer = std::make_shared<mtd::StubClientBuffer>(
          std::make_shared<MirBufferPackage>(), size, format);
++    std::shared_ptr<mcl::ConnectionSurfaceMap> map{std::make_shared<mcl::ConnectionSurfaceMap>()};
++    mtd::StubClientBufferFactory stub_factory;
++    std::shared_ptr<mcl::BufferFactory> factory{std::make_shared<mcl::BufferFactory>()};
++    size_t nbuffers{3};
  };
  MATCHER_P(BufferRequestMatches, val, "")
@@ -65,6 +74,9 @@
          arg->buffer().buffer_id() == val.buffer().buffer_id());
+ }
++EGLNativeWindowType StubClientPlatform::egl_native_window{
++    reinterpret_cast<EGLNativeWindowType>(&StubClientPlatform::egl_native_window)};
++
  void buffer_callback(MirBuffer*, void*)
+ {
+ }
@@ -75,8 +87,11 @@
+ {
      mcl::PresentationChain chain(
          connection, rpc_id, mock_server,
++        std::make_shared<StubClientPlatform>(mt::fake_shared(stub_factory)),
          std::make_shared<mtd::StubClientBufferFactory>(),
--        std::make_shared<mcl::BufferFactory>());
++        factory,
++        map,
++        nbuffers);
      EXPECT_THAT(chain.connection(), Eq(connection));
+ }
@@ -84,8 +99,11 @@
+ {
      mcl::PresentationChain chain(
          connection, rpc_id, mock_server,
++        std::make_shared<StubClientPlatform>(mt::fake_shared(stub_factory)),
          std::make_shared<mtd::StubClientBufferFactory>(),
--        std::make_shared<mcl::BufferFactory>());
++        factory,
++        map,
++        nbuffers);
      EXPECT_THAT(chain.rpc_id(), Eq(rpc_id));
+ }
@@ -101,8 +119,11 @@
      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<StubClientPlatform>(mt::fake_shared(stub_factory)),
          std::make_shared<mtd::StubClientBufferFactory>(),
--        std::make_shared<mcl::BufferFactory>());
++        factory,
++        map,
++        nbuffers);
      buffer.received();
      chain.submit_buffer(reinterpret_cast<MirBuffer*>(&buffer));
@@ -116,8 +137,11 @@
      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<StubClientPlatform>(mt::fake_shared(stub_factory)),
          std::make_shared<mtd::StubClientBufferFactory>(),
--        std::make_shared<mcl::BufferFactory>());
++        factory,
++        map,
++        nbuffers);
      buffer.received();
      chain.submit_buffer(reinterpret_cast<MirBuffer*>(&buffer));
@@ -126,3 +150,81 @@
          chain.submit_buffer(reinterpret_cast<MirBuffer*>(&buffer));
      }, std::logic_error);
+ }
++
++TEST_F(PresentationChain, gets_egl_native_window)
++{
++    int const width = 73;
++    int const height = 32;
++    MirPixelFormat const format = mir_pixel_format_argb_8888;
++
++    mcl::PresentationChain chain(
++        connection, rpc_id, mock_server,
++        std::make_shared<StubClientPlatform>(mt::fake_shared(stub_factory)),
++        std::make_shared<mtd::StubClientBufferFactory>(),
++        factory,
++        map,
++        nbuffers);
++
++    EXPECT_EQ(StubClientPlatform::egl_native_window, chain.egl_native_window(geom::Size{width, height}, format));
++}
++
++TEST_F(PresentationChain, returns_correct_parameters)
++{
++    int const width = 73;
++    int const height = 32;
++    MirPixelFormat const format = mir_pixel_format_argb_8888;
++    MirBufferUsage const usage = mir_buffer_usage_hardware;
++    MirSurfaceParameters params;
++
++    mcl::PresentationChain chain(
++        connection, rpc_id, mock_server,
++        std::make_shared<StubClientPlatform>(mt::fake_shared(stub_factory)),
++        std::make_shared<mtd::StubClientBufferFactory>(),
++        factory,
++        map,
++        nbuffers);
++    chain.egl_native_window(geom::Size{width, height}, format);
++
++    EXPECT_NO_THROW(params = chain.get_parameters());
++
++    EXPECT_STREQ("", params.name);
++    EXPECT_EQ(width, params.width);
++    EXPECT_EQ(height, params.height);
++    EXPECT_EQ(format, params.pixel_format);
++    EXPECT_EQ(usage, params.buffer_usage);
++}
++
++TEST_F(PresentationChain, EGLNativeSurface_functions_throw_when_egl_native_window_not_called)
++{
++    mcl::PresentationChain chain(
++        connection, rpc_id, mock_server,
++        std::make_shared<StubClientPlatform>(mt::fake_shared(stub_factory)),
++        std::make_shared<mtd::StubClientBufferFactory>(),
++        factory,
++        map,
++        nbuffers);
++
++    ASSERT_THROW(chain.get_parameters(), std::runtime_error);
++}
++
++TEST_F(PresentationChain, submission_throws_in_EGL_mode)
++{
++    int const width = 73;
++    int const height = 32;
++    MirPixelFormat const format = mir_pixel_format_argb_8888;
++
++    mcl::PresentationChain chain(
++        connection, rpc_id, mock_server,
++        std::make_shared<StubClientPlatform>(mt::fake_shared(stub_factory)),
++        std::make_shared<mtd::StubClientBufferFactory>(),
++        factory,
++        map,
++        nbuffers);
++
++    EXPECT_EQ(StubClientPlatform::egl_native_window, chain.egl_native_window(geom::Size{width, height}, format));
++
++    mcl::Buffer buffer(buffer_callback, nullptr, buffer_id, client_buffer, nullptr, mir_buffer_usage_software);
++    buffer.received();
++
++    ASSERT_THROW(chain.submit_buffer(reinterpret_cast<MirBuffer*>(&buffer)), std::runtime_error);
++}