Mir

Merge lp:~raof/mir/provide-event-fd into lp:mir

provide-event-fd
Merge into development-branch

Proposed by Chris Halse Rogers on 2015-01-28

Status:

Work in progress

Proposed branch:

lp:~raof/mir/provide-event-fd

Merge into:

lp:mir

Prerequisite:

lp:~raof/mir/make-input-dispatcher-a-dispatchable

Diff against target:

7460 lines (+4248/-373) (has conflicts)

87 files modified

benchmarks/benchmark_multiplexing_dispatchable.cpp (+1/-0)
debian/control (+1/-0)
examples/chain_jumping_buffers.c (+6/-0)
examples/prerendered_frames.c (+5/-0)
examples/render_surface.cpp (+20/-4)
include/client/mir_toolkit/mir_connection.h (+70/-0)
include/client/mir_toolkit/mir_wait.h (+1/-0)
include/client/mir_toolkit/rs/mir_render_surface.h (+69/-5)
include/common/mir/dispatch/threaded_dispatcher.h.moved (+75/-0)
include/test/mir/test/validity_matchers.h (+8/-0)
playground/egldiamond_render_surface.c (+5/-0)
playground/mir_egl_platform_shim.c (+9/-0)
src/client/CMakeLists.txt (+9/-0)
src/client/buffer_factory.cpp (+11/-1)
src/client/buffer_stream.cpp (+146/-38)
src/client/buffer_stream.h (+27/-3)
src/client/buffer_stream_configuration.cpp (+8/-0)
src/client/buffer_stream_configuration.h (+1/-0)
src/client/buffer_vault.cpp (+22/-5)
src/client/client_buffer_stream_factory.h.THIS (+66/-0)
src/client/connection_configuration.h (+11/-0)
src/client/connection_surface_map.cpp (+53/-1)
src/client/connection_surface_map.h (+32/-0)
src/client/default_client_buffer_stream_factory.cpp.THIS (+87/-0)
src/client/default_client_buffer_stream_factory.h.THIS (+70/-0)
src/client/default_connection_configuration.cpp (+15/-2)
src/client/default_connection_configuration.h (+2/-0)
src/client/error_render_surface.cpp (+1/-4)
src/client/error_render_surface.h (+6/-3)
src/client/mir_buffer_stream_api.cpp (+29/-14)
src/client/mir_connection.cpp (+194/-50)
src/client/mir_connection.h (+37/-11)
src/client/mir_connection_api.cpp (+159/-0)
src/client/mir_prompt_session_api.cpp (+13/-0)
src/client/mir_render_surface_api.cpp (+104/-4)
src/client/mir_screencast.cpp (+13/-2)
src/client/mir_screencast.h (+2/-1)
src/client/mir_screencast_api.cpp (+20/-3)
src/client/mir_surface.cpp (+30/-2)
src/client/mir_surface.h (+5/-2)
src/client/mir_surface_api.cpp (+25/-0)
src/client/mir_wait_api.cpp (+9/-0)
src/client/no_tls_future-inl.h (+1/-0)
src/client/render_surface.cpp (+34/-14)
src/client/render_surface.h (+6/-3)
src/client/rpc/make_rpc_channel.h (+1/-0)
src/client/rpc/mir_basic_rpc_channel.h (+8/-0)
src/client/rpc/mir_protobuf_rpc_channel.cpp (+10/-1)
src/client/rpc/mir_protobuf_rpc_channel.h (+3/-3)
src/client/symbols.map (+21/-0)
src/client/synchronous_helper.cpp (+33/-0)
src/client/synchronous_helper.h (+160/-0)
src/common/dispatch/threaded_dispatcher.cpp.moved (+294/-0)
src/include/client/mir/mir_render_surface.h (+6/-3)
src/server/scene/mediating_display_changer.cpp (+1/-1)
tests/acceptance-tests/CMakeLists.txt (+8/-0)
tests/acceptance-tests/test_client_library.cpp (+494/-0)
tests/acceptance-tests/test_client_surfaces.cpp (+40/-0)
tests/acceptance-tests/test_render_surface.cpp (+235/-20)
tests/acceptance-tests/test_server_shutdown.cpp (+1/-1)
tests/include/mir/test/doubles/mock_client_buffer_stream_factory.h.THIS (+59/-0)
tests/include/mir/test/doubles/mock_mir_buffer_stream.h (+1/-0)
tests/include/mir/test/doubles/stub_buffer_stream_factory.h (+18/-2)
tests/include/mir/test/doubles/stub_client_buffer_stream_factory.h.THIS (+66/-0)
tests/integration-tests/test_buffer_scheduling.cpp (+3/-1)
tests/integration-tests/test_surfaceloop.cpp (+60/-35)
tests/integration-tests/test_swapinterval.cpp (+2/-2)
tests/mir_test/CMakeLists.txt (+5/-1)
tests/mir_test/validity_matchers.cpp (+31/-0)
tests/mir_test_doubles/stub_buffer.cpp.THIS (+39/-0)
tests/mir_test_doubles/test_protobuf_client.cpp (+2/-1)
tests/mir_test_framework/CMakeLists.txt (+1/-0)
tests/mir_test_framework/udev_environment.cpp (+12/-4)
tests/unit-tests/client/test_buffer_vault.cpp (+2/-1)
tests/unit-tests/client/test_client_buffer_stream.cpp (+158/-82)
tests/unit-tests/client/test_client_mir_surface.cpp (+22/-0)
tests/unit-tests/client/test_connection_resource_map.cpp (+71/-5)
tests/unit-tests/client/test_mir_connection.cpp (+206/-7)
tests/unit-tests/client/test_mir_render_surface.cpp (+182/-20)
tests/unit-tests/compositor/test_stream.cpp (+1/-1)
tests/unit-tests/dispatch/CMakeLists.txt (+1/-0)
tests/unit-tests/dispatch/test_multiplexing_dispatchable.cpp (+7/-8)
tests/unit-tests/dispatch/test_threaded_dispatcher.cpp.moved (+403/-0)
tests/unit-tests/frontend/stress_protobuf_communicator.cpp (+4/-1)
tests/unit-tests/scene/test_application_session.cpp (+3/-1)
tests/unit-tests/scene/test_surface_stack.cpp (+11/-0)
tools/valgrind_suppressions_generic (+45/-0)

Text conflict in examples/chain_jumping_buffers.c
Text conflict in examples/prerendered_frames.c
Text conflict in examples/render_surface.cpp
Text conflict in include/client/mir_toolkit/rs/mir_render_surface.h
Text conflict in playground/egldiamond_render_surface.c
Text conflict in playground/mir_egl_platform_shim.c
Text conflict in src/client/CMakeLists.txt
Text conflict in src/client/buffer_stream.cpp
Text conflict in src/client/buffer_stream.h
Text conflict in src/client/connection_surface_map.cpp
Text conflict in src/client/connection_surface_map.h
Text conflict in src/client/mir_buffer_stream_api.cpp
Text conflict in src/client/mir_connection.cpp
Text conflict in src/client/mir_connection_api.cpp
Text conflict in src/client/mir_prompt_session_api.cpp
Text conflict in src/client/mir_render_surface_api.cpp
Text conflict in src/client/mir_screencast.cpp
Text conflict in src/client/mir_surface.cpp
Text conflict in src/client/mir_surface.h
Text conflict in src/client/mir_surface_api.cpp
Text conflict in src/client/rpc/mir_basic_rpc_channel.h
Text conflict in src/client/rpc/mir_protobuf_rpc_channel.cpp
Text conflict in src/client/symbols.map
Text conflict in tests/acceptance-tests/CMakeLists.txt
Text conflict in tests/acceptance-tests/test_client_library.cpp
Text conflict in tests/acceptance-tests/test_client_surfaces.cpp
Text conflict in tests/acceptance-tests/test_render_surface.cpp
Text conflict in tests/include/mir/test/doubles/stub_buffer_stream_factory.h
Text conflict in tests/integration-tests/test_surfaceloop.cpp
Text conflict in tests/unit-tests/client/test_client_buffer_stream.cpp
Text conflict in tests/unit-tests/client/test_client_mir_surface.cpp
Text conflict in tests/unit-tests/client/test_connection_resource_map.cpp
Text conflict in tests/unit-tests/client/test_mir_connection.cpp
Text conflict in tests/unit-tests/client/test_mir_render_surface.cpp
Text conflict in tests/unit-tests/scene/test_surface_stack.cpp

To merge this branch:

bzr merge lp:~raof/mir/provide-event-fd

Wishlist

Won't Fix

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration		Needs Fixing on 2015-04-15
Alexandros Frantzis (community)			Needs Fixing on 2015-04-14
Andreas Pokorny (community)			Approve on 2015-03-10
Robert Carr (community)			Approve on 2015-02-17
Kevin DuBois (community)		2015-01-28	Approve on 2015-01-29
Review via email: mp+247794@code.launchpad.net

Commit Message

Provide a mechanism for manual dispatch of client events.

A client can create a manually dispatched MirConnection by mir_connect_with_manual_dispatch. The client can then dispatch events by calling mir_connection_dispatch() on the MirConnection, and can know when to dispatch events by checking when the file descriptor returned from mir_connection_get_fd becomes readable.

Fixes: https://bugs.launchpad.net/mir/+bug/1397375

Description of the Change

The last, client-visible component of eventloop-integration.

The relevant client API bits are mir_connect_with_manual_dispatch/mir_connection_get_fd/mir_connection_dispatch

This mostly preserves the current behaviour for automatic, threaded dispatch. The one difference is that there are now no longer dedicated threads for surfaces' input loops; instead there is now one thread per surface with input plus one for RPC that together dispatch whatever events may happen.

PS Jenkins bot (ps-jenkins) wrote on 2015-01-28:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/2841/rebuild

review: Needs Fixing (continuous-integration)

Kevin DuBois (kdub) wrote on 2015-01-28:

int mir_connection_get_fd(MirConnection* connection);
It seems more important what the fd is for, so I'd rather the fn say something about what the fd does... maybe:
int mir_connection_event_dispatch_fd(MirConnection* connection)

201 + thread_local static bool running;
Nothing wrong here, but we still haven't properly sorted out TLS with hybris. We'd probably be a bit more robust if we still avoid using TLS.

704 + if (pipe2(pipefds, O_NONBLOCK) < 0)
O_CLOEXEC?

review: Needs Fixing

Chris Halse Rogers (raof) wrote on 2015-01-28:

On Thu, Jan 29, 2015 at 1:18 AM, Kevin DuBois
<email address hidden> wrote:
> Review: Needs Fixing
>
> int mir_connection_get_fd(MirConnection* connection);
> It seems more important what the fd is for, so I'd rather the fn say
> something about what the fd does... maybe:
> int mir_connection_event_dispatch_fd(MirConnection* connection)

Seems reasonable, I'll use that naming.
>
>
> 201 + thread_local static bool running;
> Nothing wrong here, but we still haven't properly sorted out TLS with
> hybris. We'd probably be a bit more robust if we still avoid using
> TLS.

Boo. And it was sooooo elegant.

I'll rework this to not need TLS.

>
> 704 + if (pipe2(pipefds, O_NONBLOCK) < 0)
> O_CLOEXEC?

While we're at it, yes.

Chris Halse Rogers (raof) wrote on 2015-01-29:

Harumph.

So, this adds tests to TestClientLibrary that require umockdev's evemu replay functionality. I guess I'll need to (a) modify the test runner to call through umockdev-run, (b) ensure that the recordings get installed in the packages, and (c) ensure that the tests can *find* them.

PS Jenkins bot (ps-jenkins) wrote on 2015-01-29:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/2852/rebuild

review: Needs Fixing (continuous-integration)

Kevin DuBois (kdub) wrote on 2015-01-29:

looks good to me, although perhaps some clients might disagree with:
757 + // If the client is entirely unresponsive for a whole minute, it deserves to die.

review: Approve

PS Jenkins bot (ps-jenkins) wrote on 2015-02-03:

FAILED: Continuous integration, rev:2337
http://jenkins.qa.ubuntu.com/job/mir-ci/2882/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1165/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1164/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1124/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/879/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1124/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/2882/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-03:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/2891/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-04:

FAILED: Continuous integration, rev:2339
http://jenkins.qa.ubuntu.com/job/mir-ci/2901/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1195/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1194/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1152/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/898/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1152/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/2901/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-04:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/2907/rebuild

review: Approve (continuous-integration)

Robert Carr (robertcarr) wrote on 2015-02-06:

I really like the way this turned out :)

A few nits:

+TEST_F(ClientLibrary, manual_dispatch_handles_callbacks_in_parent_thread)

I think its worth refactoring this and the following test. If you merged the TestData and test up to SurfaceCreation in to a fixture it would be possible to then split the sections of the test without duplicating code. Then the next test could not have to deal with surface states and umockdev recordings in the same test.

1888 and elsewhere + auto connection = std::make_shared<MirConnection>(conf);

You can keep connection in the fixture and then inherit from the fixture with
MirConnectionAutomaticDispatchTest and MirConnectionManualDispatchTest

Robert Carr (robertcarr) wrote on 2015-02-06:

2 small needs fixing:

The 1 second timeouts are going to fail in ARMHF valgrind.

1499 + GError* err = nullptr;

Here and at 1511 please use g_error_free (I know a leak is unlikely to matter here but its worth using the API correctly I think)

review: Needs Fixing

Robert Carr (robertcarr) wrote on 2015-02-11:

PINGGGGGGGGGGGGGGGGGGGGGGGGG

PS Jenkins bot (ps-jenkins) wrote on 2015-02-12:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/2957/rebuild

review: Approve (continuous-integration)

Chris Halse Rogers (raof) wrote on 2015-02-16:

PIIIIING responded to :)

Robert Carr (robertcarr) wrote on 2015-02-17:

Yay. Thanks.

review: Approve

Andreas Pokorny (andreas-pokorny) wrote on 2015-03-04:

A call to mir::set_thread_name is missing.

What about exceptions that reach the dispatch_loop? Do we need something like mir_terminate_with_current_exception?

Looks good otherwise

review: Needs Fixing

Andreas Pokorny (andreas-pokorny) wrote on 2015-03-04:

> A call to mir::set_thread_name is missing.

Could be a constructor parameter to ThreadedDispatcher.. and a trivial numbering scheme.

PS Jenkins bot (ps-jenkins) wrote on 2015-03-10:

FAILED: Continuous integration, rev:2349
http://jenkins.qa.ubuntu.com/job/mir-ci/3175/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1577
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1576
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1531/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1172/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1531/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3175/rebuild

review: Needs Fixing (continuous-integration)

Andreas Pokorny (andreas-pokorny) wrote on 2015-03-10:

lgtm as soon as jenkins agrees.

review: Approve

PS Jenkins bot (ps-jenkins) wrote on 2015-03-11:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3188/rebuild

review: Approve (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-03-11:

review: Needs Fixing (continuous-integration)

Chris Halse Rogers (raof) wrote on 2015-03-12:

Retrigger CI now that we've got shiny new log output for the failed test.

PS Jenkins bot (ps-jenkins) wrote on 2015-03-12:

review: Needs Fixing (continuous-integration)

lp:~raof/mir/provide-event-fd updated on 2015-03-18

2351. By Chris Halse Rogers on 2015-03-18

Switch manual dispatch tests over to an eventloop thread.

This still tests that the callbacks are dispatched on the thread that called dispatch(),
but doesn't rely on implementation details like how many times you'll need to call
dispatch() after each request in order to get it processed, and is less prone to possible
races where fd readability races the while(fd_is_readable()) loop.

PS Jenkins bot (ps-jenkins) wrote on 2015-03-18:

FAILED: Continuous integration, rev:2351
http://jenkins.qa.ubuntu.com/job/mir-ci/3258/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1687/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1686/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1641/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1255/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1641/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3258/rebuild

review: Needs Fixing (continuous-integration)

lp:~raof/mir/provide-event-fd updated on 2015-03-18

2352. By Chris Halse Rogers on 2015-03-18: Merge trunk

PS Jenkins bot (ps-jenkins) wrote on 2015-03-18:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3260/rebuild

review: Needs Fixing (continuous-integration)

Alexandros Frantzis (afrantzis) wrote on 2015-03-24:

267 + dispatcher{std::shared_ptr<md::MultiplexingDispatchable>(new md::MultiplexingDispatchable{std::dynamic_pointer_cast<md::Dispatchable>(channel)})},

Why not std::make_shared?

286 + if (eventloop) abort();

It would be helpful to the poor users if we printed an informative error message before we abort.

755 + std::thread::id terminate_one_thread()

I think there is a potential race here:

T1: calls terminate_one_thread(), T2: calls terminate_one_thread()
A thread terminates, sets terminating_thread_id
Another thread terminates, sets terminating_thread_id, overwriting previous value
T1 wakes up, finds a valid terminating_thread_id, continues and clears terminating_thread_id
T2 wakes up, finds a cleared terminating_thread_id and blocks for the remainder of 60s timeout

review: Needs Fixing

lp:~raof/mir/provide-event-fd updated on 2015-03-26

2353. By Chris Halse Rogers on 2015-03-25

Add timeout to EventDispatchThread

2354. By Chris Halse Rogers on 2015-03-25

Resolve race in terminate_one_thread.

If two threads called terminate_one_thread simultaneously it was possible for
both threadpool threads to unregister before either terminate_one_thread picked the
terminating_thread_mutex lock up again.

In this case the second threadpool thread would overwrite terminating_thread_id, and the
second terminate_one_thread call would timeout.

This is fundamentally a typical producer/consumer situation; resolve it by having terminating
threads write to a queue of ids, and terminate_one_thread pull from that queue.

2355. By Chris Halse Rogers on 2015-03-26

Switch ThreadExiter over to an eventfd.

We don't actually need a pipe; an eventfd is lighter for just handling notifications.

2356. By Chris Halse Rogers on 2015-03-26

Fix handles_events_in_parent_thread test.

We need to post a buffer to the surface in order for it to be a vaild focus target!

PS Jenkins bot (ps-jenkins) wrote on 2015-03-26:

FAILED: Continuous integration, rev:2356
http://jenkins.qa.ubuntu.com/job/mir-ci/3374/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1834/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1833/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1784/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1371/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1784/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3374/rebuild

review: Needs Fixing (continuous-integration)

lp:~raof/mir/provide-event-fd updated on 2015-03-26

2357. By Chris Halse Rogers on 2015-03-26: Merge trunk

PS Jenkins bot (ps-jenkins) wrote on 2015-03-26:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3377/rebuild

review: Needs Fixing (continuous-integration)

lp:~raof/mir/provide-event-fd updated on 2015-03-27

2358. By Chris Halse Rogers on 2015-03-27: Merge trunk. MOAR CONFLICTS!

PS Jenkins bot (ps-jenkins) wrote on 2015-03-27:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3391/rebuild

review: Needs Fixing (continuous-integration)

lp:~raof/mir/provide-event-fd updated on 2015-03-31

2359. By Chris Halse Rogers on 2015-03-31: Merge trunk
2360. By Chris Halse Rogers on 2015-03-31: Fix race in dispatches_multiple_dispatchees_simultaneously

PS Jenkins bot (ps-jenkins) wrote on 2015-03-31:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3408/rebuild

review: Needs Fixing (continuous-integration)

lp:~raof/mir/provide-event-fd updated on 2015-04-01

2361. By Chris Halse Rogers on 2015-04-01: Merge trunk

PS Jenkins bot (ps-jenkins) wrote on 2015-04-01:

FAILED: Continuous integration, rev:2360
http://jenkins.qa.ubuntu.com/job/mir-ci/3417/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1903/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1902/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1853/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1414/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1853/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3417/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-04-01:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3418/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-04-01:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3420/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-04-07:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3456/rebuild

review: Needs Fixing (continuous-integration)

Alan Griffiths (alan-griffiths) wrote on 2015-04-13:

2850+ auto dispatchable = std::make_shared<mt::TestDispatchable>([dispatched]()
2851+ {
2852+ static std::atomic<int> dispatch_count{0};
2853+ char buffer[80] = {0};
2854+ pthread_getname_np(pthread_self(), buffer, sizeof(buffer));
2855+ EXPECT_THAT(buffer, StartsWith(threadname_base));
2856+
2857+ if (++dispatch_count == threadcount)
2858+ {
2859+ dispatched->raise();
2860+ }
2861+ else
2862+ {
2863+ dispatched->wait_for(10s);
2864+ }
2865+ });

I'm not convinced by the massive indents that this style causes. (Nor the multi-line diffs a simple change like "auto dispatchable" => "auto const dispatchable" would imply.)

Alexandros Frantzis (afrantzis) wrote on 2015-04-14:

286 + if (eventloop) abort();

We should print out an error message before we abort so that the users have some clue of what they did wrong.

review: Needs Fixing

PS Jenkins bot (ps-jenkins) wrote on 2015-04-15:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3524/rebuild

review: Needs Fixing (continuous-integration)

Chris Halse Rogers (raof) wrote on 2015-04-16:

Oh ho ho!

While cleaning up the dispatch tests I've noticed that mir_connection_release() is an implicit synchronous RPC call, which obviously doesn't work if you're manually dispatching from the same thread that calls mir_connection_release().

Ryan *will* be pleased that I have to fix that case first!

lp:~raof/mir/provide-event-fd updated on 2017-03-28

2362. By Chris Halse Rogers on 2015-04-16

Merge trunk

2363. By Chris Halse Rogers on 2015-04-16

ClientLibrary dispatch tests: release the MirConnection from the dispatch thread.

This prevents us from accessing a freed MirConnection.

2364. By Chris Halse Rogers on 2015-04-16

Add acceptance test for async/sync call interaction with manual dispatch.

2365. By Chris Halse Rogers on 2015-05-05

Use mir::require for MirConnection::dispatch() precondition

2366. By Chris Halse Rogers on 2015-05-05

make_client_protobuf_tests_match_naming_scheme

2367. By Chris Halse Rogers on 2015-05-05

Merge trunk

2368. By Chris Halse Rogers on 2015-05-07

Improve MirProtobufRpcChanneltests.

Rather than having the mock StreamTransport manually notifying until all
data is read (somewhat defeating the purpose of the “does it read all the
data” test), have the mock StreamTransport properly implement Dispatchable
and use MirProtobufRpcChannel's Dispatchable interface to drive things.

2369. By Chris Halse Rogers on 2015-05-07

Merge prereq: ActionQueue

2370. By Chris Halse Rogers on 2015-05-07

Add an out-of-order processing mode to MirProtobufRpcChannel.

This lets a consumer wait on the result of a particular call, delaying other message
processing until it has completed.

This is required for proper *_sync handling in eventloop-driven dispatch mode.

2371. By Chris Halse Rogers on 2015-05-08

Fix mir_connection_release with manual dispatch

2372. By Chris Halse Rogers on 2015-05-12

Hook up process_next_request_first to MirConnection

2373. By Chris Halse Rogers on 2015-05-12

Add mir_wait_handle_ready to client API

2374. By Chris Halse Rogers on 2015-05-12

Pump the eventloop from the main test body.

This makes it possible to mix synchronous and asynchronous calls in the test;
otherwise the synchonous calls get done on the main thread, and the asynchonous
calls on the eventloop thread.

2375. By Chris Halse Rogers on 2015-05-13

Move reply parsing out of PendingCallCache and into ProtobufRpc.

This lets us do all the reply processing in one place, leaving the
PendingCallCache to just handle ID lookup, storage, and final completion
dispatch.

2376. By Chris Halse Rogers on 2015-05-13

Make MirBasicRpcChannel the lowest-common-denominator type.

Rather than dynamic_cast<>ing in multiple places, just return a MirBasicRpcChannel
from ConnectionConfiguration and ensure that MirBasicRpcChannel provides all the
interfaces the code needs.

2377. By Chris Halse Rogers on 2015-05-13

Add a way to get the MirConnection associated with a BufferStream.

This is necessary for synchonous calls on manually-dispatched MirConnections

2378. By Chris Halse Rogers on 2015-05-13

Add a way to get the MirConnection associated with a MirSurface

2379. By Chris Halse Rogers on 2015-05-14

We treat MirBufferStream as a ClientBufferStream internally - make sure the pointers we return *are* ClientBufferStreams

2380. By Chris Halse Rogers on 2015-05-14

Enable getting a MirConnection out of a MirScreencast

2381. By Chris Halse Rogers on 2015-05-14

Add helper infrastructure for making synchronous RPC calls

2382. By Chris Halse Rogers on 2015-05-14

Use make_synchronous_call helper for all synchronous RPC calls

2383. By Chris Halse Rogers on 2015-05-14

Minor improvements to synchronous helper

2384. By Chris Halse Rogers on 2015-05-14

Initialise ProtobufRpcChannel::prioritise_next_request.

Thanks, valgrind.

2385. By Chris Halse Rogers on 2015-05-14

Don't call a synchronous method from a manually-dispatched async callback.

This fails for... some reason. Don't know at the moment.

2386. By Chris Halse Rogers on 2015-05-14

Free the surface_spec in ClientLibrary test.

Now doesn't leak!

2387. By Chris Halse Rogers on 2015-05-14

Add valgrind suppressions for GDBus bollocks.

2388. By Chris Halse Rogers on 2016-06-17

Merge trunk.

Lots and lots of changes, and the test-suite now fails due to NBS, but
commit this so that there's a stable base to fix the test-suite on.

2389. By Chris Halse Rogers on 2016-06-27

Merge prerequisite

2390. By Chris Halse Rogers on 2016-06-28

Set connection field of MirScreencast error-objects.

The synchonous dispatch helper requires the MirConnection to be valid.

2391. By Chris Halse Rogers on 2016-06-28

Update tests; everything now passes.

Mostly. Still have crashes where *_release_sync race with event delivery on the released object.

2392. By Chris Halse Rogers on 2016-06-28

Remove superfluous threads in tests.

These mt::AutoJoinThread()s were immediately being destroyed - and so, thread.join()ed - so
they only served to obfuscate the callstack.

2393. By Chris Halse Rogers on 2016-06-28

Add mir_connect_with_manual_dispatch_sync.

It's easy, it's plausibly useful, and it makes the tests easier

2394. By Chris Halse Rogers on 2016-06-28

Merge trunk

2395. By Chris Halse Rogers on 2016-07-04

Revert no-hidden-RPC-in-bufferstream.

This turns out to be surprisingly hard, and I can work around it.

2396. By Chris Halse Rogers on 2016-07-04

Merge trunk

2397. By Chris Halse Rogers on 2016-07-05

Revert the no-hidden-BufferStream-RPC reversion.

Turns out I *can* make this work.

2398. By Chris Halse Rogers on 2016-07-06

Merge in new bufferstream-no-hidden-RPC

2399. By Chris Halse Rogers on 2016-11-21

Merge trunk, resolving conflicts but not testsuite failures

2400. By Chris Halse Rogers on 2016-11-21

Merge BufferStream simplification branch

2401. By Chris Halse Rogers on 2016-11-21

Merge NoTLSFuture<T>::detach()

2402. By Chris Halse Rogers on 2016-12-08

Merge prerequisite, resolving conflicts

Unmerged revisions

2402. By Chris Halse Rogers on 2016-12-08

Merge prerequisite, resolving conflicts

2401. By Chris Halse Rogers on 2016-11-21

Merge NoTLSFuture<T>::detach()

2400. By Chris Halse Rogers on 2016-11-21

Merge BufferStream simplification branch

2399. By Chris Halse Rogers on 2016-11-21

Merge trunk, resolving conflicts but not testsuite failures

2398. By Chris Halse Rogers on 2016-07-06

Merge in new bufferstream-no-hidden-RPC

2397. By Chris Halse Rogers on 2016-07-05

Revert the no-hidden-BufferStream-RPC reversion.

Turns out I *can* make this work.

2396. By Chris Halse Rogers on 2016-07-04

Merge trunk

2395. By Chris Halse Rogers on 2016-07-04

Revert no-hidden-RPC-in-bufferstream.

This turns out to be surprisingly hard, and I can work around it.

2394. By Chris Halse Rogers on 2016-06-28

Merge trunk

2393. By Chris Halse Rogers on 2016-06-28

Add mir_connect_with_manual_dispatch_sync.

It's easy, it's plausibly useful, and it makes the tests easier

Preview Diff

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

The diff has been truncated for viewing.

Subscribers

People subscribed via source and target branches

to all changes:

Chris Halse Rogers

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'benchmarks/benchmark_multiplexing_dispatchable.cpp'
 --- benchmarks/benchmark_multiplexing_dispatchable.cpp	2015-06-17 05:20:42 +0000
 +++ benchmarks/benchmark_multiplexing_dispatchable.cpp	2017-03-28 00:17:49 +0000
@@ -19,6 +19,7 @@
  #include "mir/dispatch/multiplexing_dispatchable.h"
  #include <iostream>
++#include <thread>
  #include <vector>
  #include <memory>
  #include <chrono>
 === modified file 'debian/control'
 --- debian/control	2017-03-22 23:38:59 +0000
 +++ debian/control	2017-03-28 00:17:49 +0000
@@ -288,6 +288,7 @@
  Pre-Depends: ${misc:Pre-Depends}
  Depends: ${misc:Depends},
           ${shlibs:Depends},
++         umockdev,
  Recommends: mir-demos,
  Description: Display Server for Ubuntu - stress tests and other test tools
   Mir is a display server running on linux systems, with a focus on efficiency,
 === modified file 'examples/chain_jumping_buffers.c'
 --- examples/chain_jumping_buffers.c	2017-03-10 19:47:57 +0000
 +++ examples/chain_jumping_buffers.c	2017-03-28 00:17:49 +0000
@@ -268,8 +268,14 @@
      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++)
++<<<<<<< TREE
          mir_render_surface_release(render_surface[i]);
      mir_window_release_sync(window);
++=======
++        mir_render_surface_release_sync(render_surface[i]);
++
++    mir_surface_release_sync(surface);
++>>>>>>> MERGE-SOURCE
      mir_connection_release(connection);
      return 0;
+ }
 === modified file 'examples/prerendered_frames.c'
 --- examples/prerendered_frames.c	2017-03-10 19:47:57 +0000
 +++ examples/prerendered_frames.c	2017-03-28 00:17:49 +0000
@@ -234,8 +234,13 @@
      for (i = 0u; i < num_prerendered_frames; i++)
          mir_buffer_release(buffer_available[i].buffer);
++<<<<<<< TREE
      mir_render_surface_release(render_surface);
      mir_window_release_sync(window);
++=======
++    mir_render_surface_release_sync(render_surface);
++    mir_surface_release_sync(surface);
++>>>>>>> MERGE-SOURCE
      mir_connection_release(connection);
      return 0;
+ }
 === modified file 'examples/render_surface.cpp'
 --- examples/render_surface.cpp	2017-03-10 19:47:57 +0000
 +++ examples/render_surface.cpp	2017-03-28 00:17:49 +0000
@@ -23,6 +23,8 @@
  #include <signal.h>
  #include <sys/signalfd.h>
  #include <poll.h>
++#include <mutex>
++#include <condition_variable>
  #include "mir_toolkit/mir_client_library.h"
  #include "mir_toolkit/rs/mir_render_surface.h"
@@ -207,14 +209,23 @@
      if (nformats == 0)
          throw std::runtime_error("no pixel formats for buffer stream");
      printf("Software Driver selected pixel format %d\n", pixel_format);
++<<<<<<< TREE
      auto buffer_stream = mir_render_surface_get_buffer_stream(
          render_surface, width, height, pixel_format);
++=======
++
++    auto stream = mir_render_surface_get_buffer_stream_sync(
++        render_surface,
++        width, height,
++        pixel_format,
++        mir_buffer_usage_software);
++>>>>>>> MERGE-SOURCE
      auto window = mir_create_window_sync(spec);
      mir_window_spec_release(spec);
--    fill_stream_with(buffer_stream, 255, 0, 0, 128);
--    mir_buffer_stream_swap_buffers_sync(buffer_stream);
++    fill_stream_with(stream, 255, 0, 0, 128);
++    mir_buffer_stream_swap_buffers_sync(stream);
      sigset_t halt_signals;
      sigemptyset(&halt_signals);
@@ -235,13 +246,18 @@
+     {
          bounce_position(baseColour, dbase, 128, 255);
--        fill_stream_with(buffer_stream, baseColour, 0, 0, 128);
++        fill_stream_with(stream, baseColour, 0, 0, 128);
--        mir_buffer_stream_swap_buffers_sync(buffer_stream);
++        mir_buffer_stream_swap_buffers_sync(stream);
+     }
++<<<<<<< TREE
      mir_render_surface_release(render_surface);
      mir_window_release_sync(window);
++=======
++    mir_render_surface_release_sync(render_surface);
++    mir_surface_release_sync(surface);
++>>>>>>> MERGE-SOURCE
      close(signal_watch);
      return 0;
 === modified file 'include/client/mir_toolkit/mir_connection.h'
 --- include/client/mir_toolkit/mir_connection.h	2017-03-13 08:12:52 +0000
 +++ include/client/mir_toolkit/mir_connection.h	2017-03-28 00:17:49 +0000
@@ -63,6 +63,54 @@
  MirConnection *mir_connect_sync(char const *server, char const *app_name);
  /**
++ * Request a connection to the Mir server.
++ *
++ * The client is responsible for handling event consumption via
++ * mir_connection_dispatch(). Events will be available when the fd returned
++ * by mir_connection_get_event_fd() becomes readable.
++ *
++ * All callbacks for this MirConnection and any objects created on it will be
++ * called from the thread calling mir_connection_dispatch().
++ *
++ * \param [in] server       A string specifying the server to connect to.
++ *                          Connection strings can either be path to the socket file on
++ *                          the filesystem, or an open file descriptor fd://
++ * \param [in] app_name     A name referring to the application
++ * \param [in] callback     Callback function to be invoked when request
++ *                          completes. mir_connection_is_valid() will return false
++ *                          until this callback has completed.
++ * \param [in,out] context  User data passed to the callback function
++ * \returns                 The resulting MirConnection
++ * \todo     Currently manual dispatch interacts awkwardly with *_sync() calls;
++ *           Synchronous calls do *not* automatically dispatch, so unless client
++ *           code has a separate thread running dispatch, any *_sync() call will
++ *           deadlock. This restriction will be fixed in a later release.
++ */
++MirConnection* mir_connect_with_manual_dispatch(char const* server,
++                                                char const* app_name,
++                                                mir_connected_callback callback,
++                                                void* context);
++
++/**
++ * Synchronously connect to the Mir server.
++ *
++ * The client is responsible for handling event consumption via
++ * mir_connection_dispatch(). Events will be available when the fd returned
++ * by mir_connection_get_event_fd() becomes readable.
++ *
++ * All callbacks for this MirConnection and any objects created on it will be
++ * called from the thread calling mir_connection_dispatch().
++ *
++ * \param [in] server       A string specifying the server to connect to.
++ *                          Connection strings can either be path to the socket file on
++ *                          the filesystem, or an open file descriptor fd://
++ * \param [in] app_name     A name referring to the application
++ * \returns                 The resulting MirConnection
++ */
++MirConnection* mir_connect_with_manual_dispatch_sync(char const* server,
++    char const* app_name);
++
++/**
   * Test for a valid connection
   * \param [in] connection  The connection
   * \return                 True if the supplied connection is valid, or
@@ -87,6 +135,28 @@
  void mir_connection_release(MirConnection *connection);
  /**
++ * \brief Get the notification fd for this connection
++ * \param [in] connection   The connection. This connection must have been created by
++ *                          mir_connect_with_manual_dispatch().
++ * \return                  A file descriptor that supports select/poll/epoll and similar
++ *                          APIs that becomes readable when there are events to dispatch,
++ *                          or -1 if \ref connection was not created by
++ *                          mir_connect_with_manual_dispatch();
++ * \note    This fd is owned by the MirConnection. Do not close the fd yourself.
++ *          The fd remains valid until mir_connection_release() returns.
++ */
++int mir_connection_get_event_fd(MirConnection* connection);
++
++/**
++ * \brief Dispatch a single pending event on the connection
++ * \param [in] connection   The connection. This connection must have been created by
++ *                          mir_connect_with_manual_dispatch().
++ * \note    It is an error to call this on a \ref connection not created by
++ *          mir_connect_with_manual_dispatch().
++ */
++void mir_connection_dispatch(MirConnection* connection);
++
++/**
   * Query platform-specific data and/or file descriptors that are required to
   * initialize GL/EGL features.
   *   \param [in]  connection        The connection
 === modified file 'include/client/mir_toolkit/mir_wait.h'
 --- include/client/mir_toolkit/mir_wait.h	2017-01-19 23:17:56 +0000
 +++ include/client/mir_toolkit/mir_wait.h	2017-03-28 00:17:49 +0000
@@ -49,6 +49,7 @@
  void mir_wait_for_one(MirWaitHandle *wait_handle)
  __attribute__ ((deprecated("No longer supported - use callbacks or wait for state changes")));
++bool mir_wait_handle_ready(MirWaitHandle* wait_handle);
  #ifdef __cplusplus
+ }
 === modified file 'include/client/mir_toolkit/rs/mir_render_surface.h'
 --- include/client/mir_toolkit/rs/mir_render_surface.h	2017-03-14 04:41:33 +0000
 +++ include/client/mir_toolkit/rs/mir_render_surface.h	2017-03-28 00:17:49 +0000
@@ -118,13 +118,30 @@
  /**
   * Release the specified render surface
+  *
-- * \param [in] render_surface                   The render surface to be released
++ * \param [in] render_surface   The render surface to be released
++ * \param [in] callback         Callback to be run when the operation completes
++ * \param [in,out] ctx          Context passed to callback
   */
  void mir_render_surface_release(
++<<<<<<< TREE
      MirRenderSurface* render_surface)
  __attribute__((deprecated("This function is slated for rename due to MirRenderSurface-->MirSurface transition")));
--
--/**
++=======
++    MirRenderSurface* render_surface,
++    mir_render_surface_callback callback,
++    void* ctx);
++
++/**
++ * Release the specified render surface and wait for the operation to complete
++ *
++ * \param [in] render_surface   The render surface to be released
++ */
++void mir_render_surface_release_sync(
++    MirRenderSurface* render_surface);
++>>>>>>> MERGE-SOURCE
++
++/**
++<<<<<<< TREE
   * Obtain the buffer stream backing a given render surface.
   * The MirBufferStream will contain buffers suitable for writing via the CPU.
+  *
@@ -143,10 +160,57 @@
      int width, int height,
      MirPixelFormat format)
  __attribute__((deprecated("This function is slated for rename due to MirRenderSurface-->MirSurface transition")));
--
--/**
++=======
++ * Obtain a buffer stream backing a given render surface
++ *
++ * \pre The MirRenderSurface does not have a backing object.
++ *
++ * \param [in] render_surface    The render surface
++ * \param [in] width             Requested width
++ * \param [in] height            Requested height
++ * \param [in] format            Requested pixel format
++ * \param [in] usage             Requested buffer usage
++ * \param [in] callback         Callback to be run when operation completes
++ * \param [in,out]  context     Context passed to callback
++ */
++void mir_render_surface_get_buffer_stream(
++    MirRenderSurface* render_surface,
++    int width,
++    int height,
++    MirPixelFormat format,
++    MirBufferUsage usage,
++    mir_buffer_stream_callback callback,
++    void* context);
++
++/**
++ * Back the render surface with a buffer stream and wait for the operation to complete.
++ *
++ * \pre The MirRenderSurface does not have a backing object.
++ *
++ * \param [in] render_surface    The render surface
++ * \param [in] width             Requested width
++ * \param [in] height            Requested height
++ * \param [in] format            Requested pixel format
++ * \param [in] usage             Requested buffer usage
++ * \return      The new MirBufferStream backing the MirRenderSurface.
++ *              If a backing object for this MirRenderSurface has already been realised
++ *              this returns NULL, otherwise it returns a non-null MirBufferStream
++ */
++MirBufferStream* mir_render_surface_get_buffer_stream_sync(
++    MirRenderSurface* render_surface,
++    int width,
++    int height,
++    MirPixelFormat format,
++    MirBufferUsage usage);
++>>>>>>> MERGE-SOURCE
++
++/**
++<<<<<<< TREE
   * Obtain the presentation chain backing a given render surface.
   * The MirPresentationChain is created in mir_present_mode_fifo submission mode.
++=======
++ * Obtain a presentation chain backing a given render surface
++>>>>>>> MERGE-SOURCE
+  *
   * \return                       The chain contained in the given render surface
   *                               or 'nullptr' if it, or
 === added file 'include/common/mir/dispatch/threaded_dispatcher.h.moved'
 --- include/common/mir/dispatch/threaded_dispatcher.h.moved	1970-01-01 00:00:00 +0000
 +++ include/common/mir/dispatch/threaded_dispatcher.h.moved	2017-03-28 00:17:49 +0000
@@ -0,0 +1,75 @@
++/*
++ * Copyright © 2015 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: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_DISPATCH_SIMPLE_DISPATCH_THREAD_H_
++#define MIR_DISPATCH_SIMPLE_DISPATCH_THREAD_H_
++
++#include <string>
++#include <memory>
++#include <thread>
++#include <vector>
++#include <mutex>
++#include <condition_variable>
++
++#include "mir/dispatch/multiplexing_dispatchable.h"
++#include "mir/fd.h"
++
++namespace mir
++{
++namespace dispatch
++{
++class Dispatchable;
++
++class ThreadedDispatcher
++{
++public:
++    ThreadedDispatcher(std::string const& name, std::shared_ptr<Dispatchable> const& dispatchee);
++    ThreadedDispatcher(std::string const& name,
++                       std::shared_ptr<Dispatchable> const& dispatchee,
++                       std::function<void()> const& exception_handler);
++    ~ThreadedDispatcher() noexcept;
++
++    void add_thread();
++    void remove_thread();
++
++private:
++    class ThreadShutdownRequestHandler;
++    friend class ThreadShutdownRequestHandler;
++
++    std::string const name_base;
++
++    std::shared_ptr<ThreadShutdownRequestHandler> thread_exiter;
++    std::shared_ptr<MultiplexingDispatchable> dispatcher;
++
++    std::mutex thread_pool_mutex;
++    std::vector<std::thread> threadpool;
++
++    std::function<void()> const exception_handler;
++
++    static void dispatch_loop(std::string const& name,
++                              std::shared_ptr<ThreadShutdownRequestHandler> thread_register,
++                              std::shared_ptr<Dispatchable> dispatcher,
++                              std::function<void()> const& exception_handler);
++
++};
++
++}
++}
++
++
++#endif // MIR_DISPATCH_SIMPLE_DISPATCH_THREAD_H_
 === renamed file 'tests/include/mir/test/fd_utils.h' => 'include/test/mir/test/fd_utils.h'
 === modified file 'include/test/mir/test/validity_matchers.h'
 --- include/test/mir/test/validity_matchers.h	2017-01-18 02:29:37 +0000
 +++ include/test/mir/test/validity_matchers.h	2017-03-28 00:17:49 +0000
@@ -23,6 +23,8 @@
  #include "mir_toolkit/mir_client_library.h"
++class MirRenderSurface;
++
  using ::testing::MakePolymorphicMatcher;
  using ::testing::MatchResultListener;
  using ::testing::NotNull;
@@ -54,6 +56,12 @@
  template<>
  bool IsValidMatcher::MatchAndExplain(MirWindow* surface, MatchResultListener* listener) const;
++template<>
++bool IsValidMatcher::MatchAndExplain(MirBufferStream* stream, MatchResultListener* listener) const;
++
++template<>
++bool IsValidMatcher::MatchAndExplain(MirRenderSurface* stream, MatchResultListener* listener) const;
++
  // To construct a polymorphic matcher, pass an instance of the class
  // to MakePolymorphicMatcher().  Note the return type.
  inline PolymorphicMatcher<IsValidMatcher> IsValid()
 === modified file 'playground/egldiamond_render_surface.c'
 --- playground/egldiamond_render_surface.c	2017-03-14 04:41:33 +0000
 +++ playground/egldiamond_render_surface.c	2017-03-28 00:17:49 +0000
@@ -322,8 +322,13 @@
          future_driver_eglTerminate(egldisplay);
      else
          eglTerminate(egldisplay);
++<<<<<<< TREE
      mir_render_surface_release(render_surface);
      mir_window_release_sync(window);
++=======
++    mir_render_surface_release_sync(render_surface);
++    mir_surface_release_sync(surface);
++>>>>>>> MERGE-SOURCE
      mir_connection_release(connection);
      return 0;
+ }
 === modified file 'playground/mir_egl_platform_shim.c'
 --- playground/mir_egl_platform_shim.c	2017-03-10 19:47:57 +0000
 +++ playground/mir_egl_platform_shim.c	2017-03-28 00:17:49 +0000
@@ -72,10 +72,19 @@
      MirPixelFormat pixel_format = mir_connection_get_egl_pixel_format(info->connection, display, config);
      //this particular [silly] driver has chosen the buffer stream as the way it wants to post
      //its hardware content. I'd think most drivers would want MirPresentationChain for flexibility
++<<<<<<< TREE
      info->stream = ext->get_hardware_buffer_stream(surface,
          info->current_physical_width,
          info->current_physical_height,
          pixel_format);
++=======
++
++    info->stream = mir_render_surface_get_buffer_stream_sync(
++        surface,
++        info->current_physical_width, info->current_physical_height,
++        pixel_format,
++        mir_buffer_usage_hardware);
++>>>>>>> MERGE-SOURCE
      printf("The driver chose pixel format %d.\n", pixel_format);
      return eglCreateWindowSurface(display, config, (EGLNativeWindowType) surface, attr);
 === modified file 'src/client/CMakeLists.txt'
 --- src/client/CMakeLists.txt	2017-03-21 05:51:47 +0000
 +++ src/client/CMakeLists.txt	2017-03-28 00:17:49 +0000
@@ -81,12 +81,15 @@
    screencast_stream.cpp
    buffer_vault.cpp
    mir_buffer_stream_api.cpp
++  synchronous_helper.cpp
    error_stream.cpp
    error_render_surface.cpp
    buffer.cpp
    error_buffer.cpp
    mir_render_surface_api.cpp
    render_surface.cpp
++  mir_render_surface.h
++  ${CMAKE_SOURCE_DIR}/src/include/client/mir_toolkit/mir_render_surface.h
    presentation_chain.cpp
    mir_presentation_chain_api.cpp
    mir_buffer_api.cpp
@@ -104,7 +107,11 @@
    ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/mir_error.h
    mir_extension_core.cpp
    ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/mir_extension_core.h
++<<<<<<< TREE
    ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/extensions/drag_and_drop.h
++=======
++  no_tls_future-inl.h
++>>>>>>> MERGE-SOURCE
+ )
  # Ensure protobuf C++ headers have been produced before
@@ -160,6 +167,8 @@
  add_library(mirclient-debug-extension SHARED
    mir_debug_api.cpp
++  $<TARGET_OBJECTS:mirclientobjects>
++  $<TARGET_OBJECTS:mirsharedinput>
+ )
  target_link_libraries(mirclient-debug-extension
 === modified file 'src/client/buffer_factory.cpp'
 --- src/client/buffer_factory.cpp	2017-03-10 19:47:57 +0000
 +++ src/client/buffer_factory.cpp	2017-03-28 00:17:49 +0000
@@ -22,6 +22,7 @@
  #include <algorithm>
  #include <boost/throw_exception.hpp>
  #include "protobuf_to_native_buffer.h"
++#include <sstream>
  namespace mcl = mir::client;
  namespace geom = mir::geometry;
@@ -92,7 +93,16 @@
          });
      if (request_it == allocation_requests.end())
--        BOOST_THROW_EXCEPTION(std::logic_error("unrequested buffer received"));
++    {
++        std::stringstream message;
++        message << "Unrequested buffer received. Expected a buffer with one of the following sizes:" << std::endl;
++        for (auto const& request : allocation_requests)
++        {
++            message << "\t(" << request->size.width << "×" << request->size.height << ")" << std::endl;
++        }
++        message << "Received buffer has size: (" << buffer.width() << "×" << buffer.height() << ")" << std::endl;
++        BOOST_THROW_EXCEPTION(std::logic_error{message.str()});
++    }
      std::unique_ptr<mcl::MirBuffer> b;
      if (buffer.has_error())
 === modified file 'src/client/buffer_stream.cpp'
 --- src/client/buffer_stream.cpp	2017-03-20 11:24:19 +0000
 +++ src/client/buffer_stream.cpp	2017-03-28 00:17:49 +0000
@@ -142,37 +142,52 @@
  //Should be merged with mcl::BufferVault
  struct BufferDepository
+ {
--    BufferDepository(
++    static NoTLSFuture<std::unique_ptr<BufferDepository>> create(
          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),
--        size_(size)
++        unsigned int initial_nbuffers)
+     {
--        future = vault.withdraw();
++        auto vault = std::make_unique<mcl::BufferVault>(
++            factory,
++            mirbuffer_factory,
++            requests,
++            surface_map,
++            size,
++            format,
++            usage,
++            initial_nbuffers);
++
++        auto future_buffer = vault->withdraw();
++
++        // Because NoTLSFuture<>.then() internally uses a std::function<void()> for the
++        // continuation the lambda passed in has to be CopyConstructible, which means we can't
++        // move-capture a std::unique_ptr<>. Dance around it with release().
++        return future_buffer.then(
++            [raw_vault = vault.release(), size](auto&& resolved_buffer)
++            {
++                std::unique_ptr<mcl::BufferVault> vault{raw_vault};
++                return std::unique_ptr<BufferDepository>(
++                    new BufferDepository{
++                        resolved_buffer.get(),
++                        std::move(vault),
++                        size});
++            });
+     }
      void deposit(mp::Buffer const&, mir::optional_value<geom::Size>, MirPixelFormat)
+     {
+     }
--    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()
+     {
          std::unique_lock<std::mutex> lk(mutex);
          if (!current)
--            advance_current_buffer(lk);
++            BOOST_THROW_EXCEPTION(
++                std::logic_error{
++                    "Current buffer requested before waiting for buffer to arrive"});
          return current->client_buffer();
+     }
@@ -180,7 +195,9 @@
+     {
          std::unique_lock<std::mutex> lk(mutex);
          if (!current)
--            advance_current_buffer(lk);
++            BOOST_THROW_EXCEPTION(
++                std::logic_error{
++                    "Current buffer requested before waiting for buffer to arrive"});
          return current->rpc_id();
+     }
@@ -188,16 +205,23 @@
+     {
          std::unique_lock<std::mutex> lk(mutex);
          if (!current)
--            advance_current_buffer(lk);
++            BOOST_THROW_EXCEPTION(
++                std::logic_error{
++                    "Attempted to submit current buffer without waiting for a buffer to become current"});
          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);
++        vault->deposit(c);
++        auto wh = vault->wire_transfer_outbound(c, done);
++
++        vault->withdraw().then(
++            [this](auto&& new_buffer)
++            {
++                std::lock_guard<std::mutex> lk{mutex};
++
++                current = new_buffer.get();
++            }).detach();
          return wh;
+     }
@@ -207,7 +231,7 @@
              std::unique_lock<std::mutex> lk(mutex);
              size_ = size;
+         }
--        vault.set_size(size);
++        vault->set_size(size);
+     }
      geom::Size size() const
@@ -218,14 +242,14 @@
      void lost_connection()
+     {
--        vault.disconnected();
++        vault->disconnected();
+     }
      MirWaitHandle* set_scale(float scale, mf::BufferStreamId)
+     {
          scale_wait_handle.expect_result();
          scale_wait_handle.result_received();
--        vault.set_scale(scale);
++        vault->set_scale(scale);
          return &scale_wait_handle;
+     }
@@ -233,15 +257,24 @@
+     {
          std::unique_lock<decltype(mutex)> lk(mutex);
          interval = std::max(0, std::min(1, interval));
--        vault.set_interval(interval);
--    }
--
--    // Future must be before vault, to ensure vault's destruction marks future
--    // as ready.
--    mir::client::NoTLSFuture<std::shared_ptr<mcl::MirBuffer>> future;
--
--    mcl::BufferVault vault;
++        vault->set_interval(interval);
++    }
++
++
++private:
++    BufferDepository(
++        std::shared_ptr<mcl::MirBuffer> initial_buffer,
++        std::unique_ptr<mcl::BufferVault>&& vault,
++        geom::Size size) :
++        vault{std::move(vault)},
++        current{initial_buffer},
++        size_{size}
++    {
++    }
++
++    std::unique_ptr<mcl::BufferVault> vault;
      std::mutex mutable mutex;
++    std::mutex current_buffer_mutex;
      std::shared_ptr<mcl::MirBuffer> current{nullptr};
      MirWaitHandle scale_wait_handle;
      geom::Size size_;
@@ -249,12 +282,17 @@
+ }
+ }
++<<<<<<< TREE
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  mcl::BufferStream::BufferStream(
++=======
++mcl::NoTLSFuture<std::unique_ptr<mcl::BufferStream>>
++mcl::BufferStream::create(
++>>>>>>> MERGE-SOURCE
      MirConnection* connection,
      MirRenderSurface* render_surface,
--    std::shared_ptr<MirWaitHandle> creation_wait_handle,
++    std::shared_ptr<MirWaitHandle> const& creation_wait_handle,
      mclr::DisplayServer& server,
      std::shared_ptr<mcl::ClientPlatform> const& client_platform,
      std::weak_ptr<mcl::SurfaceMap> const& map,
@@ -264,22 +302,87 @@
      std::string const& surface_name,
      geom::Size ideal_size,
      size_t nbuffers)
++{
++    auto protobuf_bs = mcl::make_protobuf_object(a_protobuf_bs);
++
++    if (!protobuf_bs->has_id())
++    {
++        if (!protobuf_bs->has_error())
++            protobuf_bs->set_error("Error processing buffer stream create response, no ID (disconnected?)");
++    }
++
++    if (protobuf_bs->has_error())
++    {
++        if (protobuf_bs->has_buffer())
++        {
++            for (int i = 0; i < protobuf_bs->buffer().fd_size(); i++)
++                ::close(protobuf_bs->buffer().fd(i));
++        }
++
++        BOOST_THROW_EXCEPTION(std::runtime_error("Can not create buffer stream: " + std::string(protobuf_bs->error())));
++    }
++
++
++    auto future_depository = BufferDepository::create(
++        client_platform->create_buffer_factory(), factory,
++        std::make_shared<Requests>(server, protobuf_bs->id().value()), map,
++        ideal_size, static_cast<MirPixelFormat>(protobuf_bs->pixel_format()),
++        protobuf_bs->buffer_usage(), nbuffers);
++
++    return future_depository.then(
++        [=, raw_protobuf_bs = protobuf_bs.release(), raw_server = &server](auto&& depository)
++        {
++            std::unique_ptr<mp::BufferStream> protobuf_bs{raw_protobuf_bs};
++            // Can't use make_unique because the constructor is private to it.
++            return std::unique_ptr<BufferStream>{
++                new BufferStream{
++                    *raw_server,
++                    connection,
++                    render_surface,
++                    creation_wait_handle,
++                    depository.get(),
++                    client_platform,
++                    map,
++                    std::move(protobuf_bs),
++                    perf_report,
++                    surface_name,
++                    ideal_size}};
++        }
++    );
++}
++
++mcl::BufferStream::BufferStream(
++    rpc::DisplayServer& server,
++    MirConnection* connection,
++    MirRenderSurface* render_surface,
++    std::shared_ptr<MirWaitHandle> const& creation_wait_handle,
++    std::unique_ptr<BufferDepository>&& depository,
++    std::shared_ptr<mcl::ClientPlatform> const& client_platform,
++    std::weak_ptr<mcl::SurfaceMap> const& map,
++    std::unique_ptr<mp::BufferStream>&& incoming_protobuf_bs,
++    std::shared_ptr<mcl::PerfReport> const& perf_report,
++    std::string const& surface_name,
++    geom::Size ideal_size)
      : connection_(connection),
        client_platform(client_platform),
--      protobuf_bs{mcl::make_protobuf_object<mir::protobuf::BufferStream>(a_protobuf_bs)},
++      protobuf_bs{std::move(incoming_protobuf_bs)},
        user_swap_interval(parse_env_for_swap_interval()),
++<<<<<<< TREE
        using_client_side_vsync(false),
        interval_config{server, frontend::BufferStreamId{a_protobuf_bs.id().value()}},
++=======
++      interval_config{server, frontend::BufferStreamId{this->protobuf_bs->id().value()}},
++>>>>>>> MERGE-SOURCE
        scale_(1.0f),
        perf_report(perf_report),
        protobuf_void{mcl::make_protobuf_object<mir::protobuf::Void>()},
++      buffer_depository{std::move(depository)},
        ideal_buffer_size(ideal_size),
--      nbuffers(nbuffers),
--      creation_wait_handle(creation_wait_handle),
++      creation_wait_handle{creation_wait_handle},
        map(map),
--      factory(factory),
        render_surface_(render_surface)
+ {
++<<<<<<< TREE
      /*
       * Since we try to use client-side vsync where possible, a separate
       * copy of the current swap interval is required to represent that
@@ -306,9 +409,12 @@
          BOOST_THROW_EXCEPTION(std::runtime_error("Can not create buffer stream: " + std::string(protobuf_bs->error())));
+     }
++=======
++>>>>>>> MERGE-SOURCE
      try
+     {
++<<<<<<< TREE
          buffer_depository = std::make_unique<BufferDepository>(
              client_platform->create_buffer_factory(), factory,
              std::make_shared<Requests>(server, protobuf_bs->id().value(), client_platform),
@@ -316,6 +422,8 @@
              ideal_buffer_size, static_cast<MirPixelFormat>(protobuf_bs->pixel_format()),
              protobuf_bs->buffer_usage(), nbuffers);
++=======
++>>>>>>> MERGE-SOURCE
          egl_native_window_ = client_platform->create_egl_native_window(this);
          // This might seem like something to provide during creation but
 === modified file 'src/client/buffer_stream.h'
 --- src/client/buffer_stream.h	2017-03-20 11:24:19 +0000
 +++ src/client/buffer_stream.h	2017-03-28 00:17:49 +0000
@@ -26,10 +26,15 @@
  #include "mir/geometry/size.h"
  #include "mir/optional_value.h"
  #include "buffer_stream_configuration.h"
++<<<<<<< TREE
  #include "frame_clock.h"
++=======
++#include "no_tls_future-inl.h"
++>>>>>>> MERGE-SOURCE
  #include "mir_toolkit/client_types.h"
++
  #include <EGL/eglplatform.h>
  #include <unordered_set>
@@ -74,15 +79,19 @@
  class BufferStream : public EGLNativeSurface, public MirBufferStream
+ {
  public:
++<<<<<<< TREE
      BufferStream(
          mir::client::rpc::DisplayServer& server,
          std::weak_ptr<SurfaceMap> const& map);
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      BufferStream(
++=======
++    static NoTLSFuture<std::unique_ptr<BufferStream>> create(
++>>>>>>> MERGE-SOURCE
          MirConnection* connection,
          MirRenderSurface* render_surface,
--        std::shared_ptr<MirWaitHandle> creation_wait_handle,
++        std::shared_ptr<MirWaitHandle> const& creation_wait_handle,
          mir::client::rpc::DisplayServer& server,
          std::shared_ptr<ClientPlatform> const& native_window_factory,
          std::weak_ptr<SurfaceMap> const& map,
@@ -139,6 +148,19 @@
      BufferStream& operator=(BufferStream const&) = delete;
  private:
++    BufferStream(
++        rpc::DisplayServer& server,
++        MirConnection* connection,
++        MirRenderSurface* render_surface,
++        std::shared_ptr<MirWaitHandle> const& creation_wait_handle,
++        std::unique_ptr<BufferDepository>&& depository,
++        std::shared_ptr<ClientPlatform> const& native_window_factory,
++        std::weak_ptr<SurfaceMap> const& map,
++        std::unique_ptr<mir::protobuf::BufferStream>&& protobuf_bs,
++        std::shared_ptr<PerfReport> const& perf_report,
++        std::string const& surface_name,
++        geometry::Size ideal_size);
++
      void process_buffer(protobuf::Buffer const& buffer);
      void process_buffer(protobuf::Buffer const& buffer, std::unique_lock<std::mutex>&);
      MirWaitHandle* set_server_swap_interval(int i);
@@ -165,13 +187,15 @@
      std::unique_ptr<BufferDepository> buffer_depository;
      geometry::Size ideal_buffer_size;
--    size_t const nbuffers;
      std::string error_message;
--    std::shared_ptr<MirWaitHandle> creation_wait_handle;
++    std::shared_ptr<MirWaitHandle> const creation_wait_handle;
      std::weak_ptr<SurfaceMap> const map;
++<<<<<<< TREE
      std::shared_ptr<AsyncBufferFactory> const factory;
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
++=======
++>>>>>>> MERGE-SOURCE
      MirRenderSurface* render_surface_;
  #pragma GCC diagnostic pop
 === modified file 'src/client/buffer_stream_configuration.cpp'
 --- src/client/buffer_stream_configuration.cpp	2017-01-18 02:29:37 +0000
 +++ src/client/buffer_stream_configuration.cpp	2017-03-28 00:17:49 +0000
@@ -29,6 +29,14 @@
+ {
+ }
++mcl::BufferStreamConfiguration::BufferStreamConfiguration(
++    BufferStreamConfiguration&& from)
++    : server{from.server},
++      id{from.id},
++      protobuf_void{std::move(from.protobuf_void)}
++{
++}
++
  void mcl::BufferStreamConfiguration::on_swap_interval_set(int interval)
+ {
      std::unique_lock<decltype(mutex)> lock(mutex);
 === modified file 'src/client/buffer_stream_configuration.h'
 --- src/client/buffer_stream_configuration.h	2017-01-18 02:29:37 +0000
 +++ src/client/buffer_stream_configuration.h	2017-03-28 00:17:49 +0000
@@ -33,6 +33,7 @@
+ {
  public:
      BufferStreamConfiguration(rpc::DisplayServer& server, frontend::BufferStreamId id);
++    BufferStreamConfiguration(BufferStreamConfiguration&& from);
      void on_swap_interval_set(int interval);
      int swap_interval() const;
 === modified file 'src/client/buffer_vault.cpp'
 --- src/client/buffer_vault.cpp	2017-01-30 08:13:20 +0000
 +++ src/client/buffer_vault.cpp	2017-03-28 00:17:49 +0000
@@ -28,6 +28,7 @@
  #include "buffer_factory.h"
  #include "buffer.h"
  #include <algorithm>
++#include <experimental/optional>
  #include <boost/throw_exception.hpp>
  namespace mcl = mir::client;
@@ -271,14 +272,30 @@
+         }
+     }
++    auto cb = deferred_cb;
++    deferred_cb = {};
++    std::experimental::optional<decltype(promises)::value_type> buffer_promise;
++
      if (!promises.empty())
+     {
          buffers[buffer_id] = Owner::ContentProducer;
--        promises.front().set_value(buffer);
--        promises.pop_front();
--    }
--
--    trigger_callback(std::move(lk));
++        // Satisfying a promise might call continuation code on this stack.
++        // We need to
++        buffer_promise = std::move(promises.front());
++        promises.pop_front();;
++    }
++
++    lk.unlock();
++
++    if (buffer_promise)
++    {
++        buffer_promise->set_value(buffer);
++    }
++    if (cb)
++    {
++        cb();
++        swap_buffers_wait_handle.result_received();
++    }
+ }
  void mcl::BufferVault::disconnected()
 === added file 'src/client/client_buffer_stream_factory.h.THIS'
 --- src/client/client_buffer_stream_factory.h.THIS	1970-01-01 00:00:00 +0000
 +++ src/client/client_buffer_stream_factory.h.THIS	2017-03-28 00:17:49 +0000
@@ -0,0 +1,66 @@
++/*
++ * Copyright © 2015 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: Robert Carr <robert.carr@canonical.com>
++ */
++
++#ifndef MIR_CLIENT_CLIENT_BUFFER_STREAM_FACTORY_H_
++#define MIR_CLIENT_CLIENT_BUFFER_STREAM_FACTORY_H_
++
++#include "mir_protobuf.pb.h"
++
++#include "mir_toolkit/client_types.h"
++
++#include <memory>
++
++class MirConnection;
++
++namespace mir
++{
++namespace client
++{
++class ClientBufferStream;
++class BufferStream;
++class ClientBufferStreamFactory
++{
++public:
++    virtual std::shared_ptr<ClientBufferStream> make_consumer_stream(
++        MirConnection* allocating_connection,
++        protobuf::DisplayServer& server,
++        protobuf::BufferStream const& protobuf_bs,
++        std::string const& surface_name) = 0;
++    virtual std::shared_ptr<ClientBufferStream> make_producer_stream(
++       MirConnection* allocating_connection,
++       protobuf::DisplayServer& server,
++       protobuf::BufferStream const& protobuf_bs,
++       std::string const& surface_name) = 0;
++
++    // For creating buffer stream owned by client.
++    virtual ClientBufferStream* make_producer_stream(
++       MirConnection* allocating_connection,
++       protobuf::DisplayServer& server,
++       protobuf::BufferStreamParameters const& params,
++       mir_buffer_stream_callback callback, void* context) = 0;
++
++protected:
++    ClientBufferStreamFactory() = default;
++    virtual ~ClientBufferStreamFactory() = default;
++    ClientBufferStreamFactory(const ClientBufferStreamFactory&) = delete;
++    ClientBufferStreamFactory& operator=(const ClientBufferStreamFactory&) = delete;
++};
++}
++}
++
++#endif // MIR_CLIENT_CLIENT_BUFFER_STREAM_FACTORY_H_
 === modified file 'src/client/connection_configuration.h'
 --- src/client/connection_configuration.h	2017-02-15 14:45:41 +0000
 +++ src/client/connection_configuration.h	2017-03-28 00:17:49 +0000
@@ -37,6 +37,11 @@
  class Logger;
+ }
++namespace dispatch
++{
++class ActionQueue;
++}
++
  namespace client
+ {
  namespace rpc
@@ -51,11 +56,17 @@
  class EventHandlerRegister;
  class AsyncBufferFactory;
++namespace rpc
++{
++class MirBasicRpcChannel;
++}
++
  class ConnectionConfiguration
+ {
  public:
      virtual ~ConnectionConfiguration() = default;
++    virtual std::shared_ptr<dispatch::ActionQueue> the_delayed_queue() = 0;
      virtual std::shared_ptr<ConnectionSurfaceMap> the_surface_map() = 0;
      virtual std::shared_ptr<mir::client::rpc::MirBasicRpcChannel> the_rpc_channel() = 0;
      virtual std::shared_ptr<mir::logging::Logger> the_logger() = 0;
 === modified file 'src/client/connection_surface_map.cpp'
 --- src/client/connection_surface_map.cpp	2017-03-14 04:41:33 +0000
 +++ src/client/connection_surface_map.cpp	2017-03-28 00:17:49 +0000
@@ -20,26 +20,78 @@
  #include "mir_surface.h"
  #include "presentation_chain.h"
++#include "mir/dispatch/action_queue.h"
++
  #include <boost/throw_exception.hpp>
  #include <sstream>
  namespace mcl=mir::client;
  namespace mf=mir::frontend;
++<<<<<<< TREE
  using mir::client::ConnectionSurfaceMap;
  using mir::frontend::SurfaceId;
  using mir::frontend::BufferStreamId;
  std::shared_ptr<MirWindow> ConnectionSurfaceMap::surface(SurfaceId id) const
--{
++=======
++mcl::ConnectionSurfaceMap::ConnectionSurfaceMap(
++    std::shared_ptr<dispatch::ActionQueue> delayed_queue)
++    : delayed_queue{delayed_queue}
++{
++}
++
++void mcl::ConnectionSurfaceMap::with_surface_do(
++    mf::SurfaceId surface_id, std::function<void(MirSurface*)> const& exec) const
++>>>>>>> MERGE-SOURCE
++{
++    {
++        std::lock_guard<decltype(reserved_guard)> lock{reserved_guard};
++        auto const it = surface_reservations.find(surface_id);
++        if (it != surface_reservations.end())
++        {
++            it->second.push_back(exec);
++            return;
++        }
++    }
++
      std::shared_lock<decltype(guard)> lk(guard);
      auto const found = surfaces.find(id);
      return found != surfaces.end() ? found->second : nullptr;
+ }
++<<<<<<< TREE
  void mcl::ConnectionSurfaceMap::insert(mf::SurfaceId surface_id, std::shared_ptr<MirWindow> const& surface)
++=======
++void mcl::ConnectionSurfaceMap::reserve(mf::SurfaceId surface_id)
++{
++    std::lock_guard<decltype(reserved_guard)> lock{reserved_guard};
++    surface_reservations[surface_id] = {};
++}
++
++
++
++void mcl::ConnectionSurfaceMap::insert(mf::SurfaceId surface_id, std::shared_ptr<MirSurface> const& surface)
++>>>>>>> MERGE-SOURCE
+ {
      std::lock_guard<decltype(guard)> lk(guard);
++    std::lock_guard<decltype(reserved_guard)> lock{reserved_guard};
++    for (auto& func : surface_reservations[surface_id])
++    {
++        delayed_queue->enqueue(
++            [this, surface_id, exec = std::move(func)]()
++            {
++                std::shared_lock<decltype(guard)> lk(guard);
++                auto const it = surfaces.find(surface_id);
++                if (it != surfaces.end())
++                {
++                    auto const surface = it->second;
++                    lk.unlock();
++                    exec(surface.get());
++                }
++            });
++    }
++    surface_reservations.erase(surface_id);
      surfaces[surface_id] = surface;
+ }
 === modified file 'src/client/connection_surface_map.h'
 --- src/client/connection_surface_map.h	2017-03-14 04:41:33 +0000
 +++ src/client/connection_surface_map.h	2017-03-28 00:17:49 +0000
@@ -23,19 +23,43 @@
  #include <shared_mutex>
  #include <unordered_map>
++#include <vector>
  class MirPresentationChain;
  class MirRenderSurface;
  namespace mir
+ {
++namespace dispatch
++{
++class ActionQueue;
++}
  namespace client
+ {
  class MirBuffer;
  class ConnectionSurfaceMap : public SurfaceMap
+ {
  public:
++<<<<<<< TREE
      virtual std::shared_ptr<MirWindow> surface(frontend::SurfaceId) const override;
      void insert(frontend::SurfaceId surface_id, std::shared_ptr<MirWindow> const& surface);
++=======
++    ConnectionSurfaceMap(std::shared_ptr<dispatch::ActionQueue> delayed_queue);
++
++    void with_surface_do(frontend::SurfaceId surface_id, std::function<void(MirSurface*)> const& exec) const override;
++    /**
++     * Notify the surface map that a surface will be constructed.
++     *
++     * After this call, calls to with_surface_do(surface_id, functor) will succeed, but defer execution
++     * of functor until a subsequent call to insert(surface_id, surf).
++     *
++     * Any functor queued will be executed on the delayed queue, not in the stack of
++     * the insert() call.
++     *
++     * \param [in] surface_id   ID of the surface about to be created.
++     */
++    void reserve(frontend::SurfaceId surface_id);
++    void insert(frontend::SurfaceId surface_id, std::shared_ptr<MirSurface> const& surface);
++>>>>>>> MERGE-SOURCE
      void erase(frontend::SurfaceId surface_id);
      virtual std::shared_ptr<MirBufferStream> stream(frontend::BufferStreamId) const override;
@@ -57,8 +81,16 @@
      std::shared_ptr<MirRenderSurface> render_surface(void* render_surface_key) const;
  #pragma GCC diagnostic pop
  private:
++    std::shared_ptr<dispatch::ActionQueue> const delayed_queue;
++
      std::shared_timed_mutex mutable guard;
++<<<<<<< TREE
      std::unordered_map<frontend::SurfaceId, std::shared_ptr<MirWindow>> surfaces;
++=======
++    std::unordered_map<frontend::SurfaceId, std::shared_ptr<MirSurface>> surfaces;
++    std::mutex mutable reserved_guard;
++    std::unordered_map<frontend::SurfaceId, std::vector<std::function<void(MirSurface*)>>> mutable surface_reservations;
++>>>>>>> MERGE-SOURCE
      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;
 === added file 'src/client/default_client_buffer_stream_factory.cpp.THIS'
 --- src/client/default_client_buffer_stream_factory.cpp.THIS	1970-01-01 00:00:00 +0000
 +++ src/client/default_client_buffer_stream_factory.cpp.THIS	2017-03-28 00:17:49 +0000
@@ -0,0 +1,87 @@
++/*
++ * Copyright © 2015 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: Robert Carr <robert.carr@canonical.com>
++ */
++#include "default_client_buffer_stream_factory.h"
++#include "buffer_stream.h"
++#include "perf_report.h"
++#include "logging/perf_report.h"
++#include "lttng/perf_report.h"
++
++namespace mcl = mir::client;
++namespace ml = mir::logging;
++namespace mp = mir::protobuf;
++
++namespace
++{
++
++std::shared_ptr<mcl::PerfReport>
++make_perf_report(std::shared_ptr<ml::Logger> const& logger)
++{
++    // TODO: It seems strange that this directly uses getenv
++    const char* report_target = getenv("MIR_CLIENT_PERF_REPORT");
++    if (report_target && !strncmp(report_target, "log", strlen(report_target)))
++    {
++        return std::make_shared<mcl::logging::PerfReport>(logger);
++    }
++    else if (report_target && !strncmp(report_target, "lttng", strlen(report_target)))
++    {
++        return std::make_shared<mcl::lttng::PerfReport>();
++    }
++    else
++    {
++        return std::make_shared<mcl::NullPerfReport>();
++    }
++}
++
++}
++
++mcl::DefaultClientBufferStreamFactory::DefaultClientBufferStreamFactory(
++    std::shared_ptr<mcl::ClientPlatform> const& client_platform,
++    std::shared_ptr<ml::Logger> const& logger)
++    : client_platform(client_platform),
++      logger(logger)
++{
++}
++
++std::shared_ptr<mcl::ClientBufferStream> mcl::DefaultClientBufferStreamFactory::make_consumer_stream(
++    MirConnection* allocating_connection,
++    mp::DisplayServer& server,
++    mp::BufferStream const& protobuf_bs,
++    std::string const& surface_name)
++{
++    return std::make_shared<mcl::BufferStream>(allocating_connection, server, mcl::BufferStreamMode::Consumer, client_platform, protobuf_bs, make_perf_report(logger), surface_name);
++}
++
++std::shared_ptr<mcl::ClientBufferStream> mcl::DefaultClientBufferStreamFactory::make_producer_stream(
++    MirConnection* allocating_connection,
++    mp::DisplayServer& server,
++    mp::BufferStream const& protobuf_bs,
++    std::string const& surface_name)
++{
++    return std::make_shared<mcl::BufferStream>(allocating_connection, server, mcl::BufferStreamMode::Producer, client_platform, protobuf_bs, make_perf_report(logger), surface_name);
++}
++
++
++mcl::ClientBufferStream* mcl::DefaultClientBufferStreamFactory::make_producer_stream(
++    MirConnection* allocating_connection,
++    mp::DisplayServer& server,
++    mp::BufferStreamParameters const& params,
++    mir_buffer_stream_callback callback,
++    void* context)
++{
++    return new mcl::BufferStream(allocating_connection, server, client_platform, params, make_perf_report(logger), callback, context);
++}
 === added file 'src/client/default_client_buffer_stream_factory.h.THIS'
 --- src/client/default_client_buffer_stream_factory.h.THIS	1970-01-01 00:00:00 +0000
 +++ src/client/default_client_buffer_stream_factory.h.THIS	2017-03-28 00:17:49 +0000
@@ -0,0 +1,70 @@
++/*
++ * Copyright © 2015 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: Robert Carr <robert.carr@canonical.com>
++ */
++
++#ifndef MIR_CLIENT_DEFAULT_CLIENT_BUFFER_STREAM_FACTORY_H_
++#define MIR_CLIENT_DEFAULT_CLIENT_BUFFER_STREAM_FACTORY_H_
++
++#include "client_buffer_stream_factory.h"
++
++class MirConnection;
++
++namespace mir
++{
++namespace logging
++{
++class Logger;
++}
++namespace client
++{
++class ClientBufferFactory;
++class ClientPlatform;
++
++class DefaultClientBufferStreamFactory : public ClientBufferStreamFactory
++{
++public:
++    DefaultClientBufferStreamFactory(
++        std::shared_ptr<ClientPlatform> const& native_window_factory,
++        std::shared_ptr<logging::Logger> const& logger);
++    virtual ~DefaultClientBufferStreamFactory() = default;
++
++    std::shared_ptr<ClientBufferStream> make_consumer_stream(
++        MirConnection* allocating_connection,
++        protobuf::DisplayServer& server,
++        protobuf::BufferStream const& protobuf_bs,
++        std::string const& surface_name) override;
++    std::shared_ptr<ClientBufferStream> make_producer_stream(
++       MirConnection* allocating_connection,
++       protobuf::DisplayServer& server,
++       protobuf::BufferStream const& protobuf_bs,
++       std::string const& surface_name) override;
++
++    ClientBufferStream* make_producer_stream(
++       MirConnection* allocating_connection,
++       protobuf::DisplayServer& server,
++       protobuf::BufferStreamParameters const& params,
++       mir_buffer_stream_callback callback, void* context) override;
++
++private:
++    std::shared_ptr<ClientPlatform> const client_platform;
++    std::shared_ptr<logging::Logger> const logger;
++
++};
++}
++}
++
++#endif // MIR_CLIENT_DEFAULT_CLIENT_BUFFER_STREAM_FACTORY_H_
 === modified file 'src/client/default_connection_configuration.cpp'
 --- src/client/default_connection_configuration.cpp	2017-02-15 14:45:41 +0000
 +++ src/client/default_connection_configuration.cpp	2017-03-28 00:17:49 +0000
@@ -37,8 +37,10 @@
  #include "probing_client_platform_factory.h"
  #include "mir_event_distributor.h"
  #include "buffer_factory.h"
++#include "mir/dispatch/action_queue.h"
  namespace mcl = mir::client;
++namespace md = mir::dispatch;
  namespace
+ {
@@ -53,12 +55,23 @@
+ {
+ }
++std::shared_ptr<md::ActionQueue>
++mcl::DefaultConnectionConfiguration::the_delayed_queue()
++{
++    return delayed_queue(
++        []()
++        {
++            return std::make_shared<md::ActionQueue>();
++        });
++}
++
  std::shared_ptr<mcl::ConnectionSurfaceMap>
  mcl::DefaultConnectionConfiguration::the_surface_map()
+ {
--    return surface_map([]
++    return surface_map(
++        [this]()
+         {
--            return std::make_shared<mcl::ConnectionSurfaceMap>();
++            return std::make_shared<mcl::ConnectionSurfaceMap>(the_delayed_queue());
          });
+ }
 === modified file 'src/client/default_connection_configuration.h'
 --- src/client/default_connection_configuration.h	2017-02-15 14:45:41 +0000
 +++ src/client/default_connection_configuration.h	2017-03-28 00:17:49 +0000
@@ -50,6 +50,7 @@
  public:
      DefaultConnectionConfiguration(std::string const& socket_file);
++    std::shared_ptr<dispatch::ActionQueue> the_delayed_queue() override;
      std::shared_ptr<ConnectionSurfaceMap> the_surface_map() override;
      std::shared_ptr<mir::client::rpc::MirBasicRpcChannel> the_rpc_channel() override;
      std::shared_ptr<mir::logging::Logger> the_logger() override;
@@ -69,6 +70,7 @@
      virtual std::shared_ptr<input::receiver::InputReceiverReport> the_input_receiver_report();
  protected:
++    CachedPtr<dispatch::ActionQueue> delayed_queue;
      CachedPtr<mir::client::rpc::MirBasicRpcChannel> rpc_channel;
      CachedPtr<mir::logging::Logger> logger;
      CachedPtr<ClientPlatformFactory> client_platform_factory;
 === modified file 'src/client/error_render_surface.cpp'
 --- src/client/error_render_surface.cpp	2017-01-18 02:29:37 +0000
 +++ src/client/error_render_surface.cpp	2017-03-28 00:17:49 +0000
@@ -54,10 +54,7 @@
      return false;
+ }
--MirBufferStream* mcl::ErrorRenderSurface::get_buffer_stream(
--    int /*width*/, int /*height*/,
--    MirPixelFormat /*format*/,
--    MirBufferUsage /*buffer_usage*/)
++void mcl::ErrorRenderSurface::get_buffer_stream(int, int, MirPixelFormat, MirBufferUsage, mir_buffer_stream_callback, void*)
+ {
      BOOST_THROW_EXCEPTION(std::runtime_error(error));
+ }
 === modified file 'src/client/error_render_surface.h'
 --- src/client/error_render_surface.h	2017-03-10 19:47:57 +0000
 +++ src/client/error_render_surface.h	2017-03-28 00:17:49 +0000
@@ -39,10 +39,13 @@
      void set_size(mir::geometry::Size) override;
      bool valid() const override;
      char const* get_error_message() const override;
--    MirBufferStream* get_buffer_stream(
--        int width, int height,
++    void get_buffer_stream(
++        int width,
++        int height,
          MirPixelFormat format,
--        MirBufferUsage buffer_usage) override;
++        MirBufferUsage buffer_usage,
++        mir_buffer_stream_callback callback,
++        void* context) override;
      MirPresentationChain* get_presentation_chain() override;
  private:
      std::string const error;
 === modified file 'src/client/mir_buffer_stream_api.cpp'
 --- src/client/mir_buffer_stream_api.cpp	2017-01-24 07:37:03 +0000
 +++ src/client/mir_buffer_stream_api.cpp	2017-03-28 00:17:49 +0000
@@ -30,25 +30,14 @@
  #include "mir/uncaught.h"
  #include "mir/require.h"
++#include "synchronous_helper.h"
++
  #include <stdexcept>
  #include <boost/throw_exception.hpp>
  namespace mcl = mir::client;
  namespace mp = mir::protobuf;
--namespace
--{
--// assign_result is compatible with all 2-parameter callbacks
--void assign_result(void* result, void** context)
--{
--    if (context)
--        *context = result;
--}
--
--}
--
--
--
  MirWaitHandle* mir_connection_create_buffer_stream(MirConnection *connection,
      int width, int height,
      MirPixelFormat format,
@@ -72,9 +61,20 @@
      MirBufferUsage buffer_usage)
  try
+ {
++<<<<<<< TREE
      MirBufferStream *stream = nullptr;
      mir_connection_create_buffer_stream(connection, width, height, format, buffer_usage,
          reinterpret_cast<MirBufferStreamCallback>(assign_result), &stream)->wait_for_all();
++=======
++    MirBufferStream* stream = nullptr;
++    make_synchronous_call(
++        connection,
++        mir_connection_create_buffer_stream,
++        connection,
++        width, height, format, buffer_usage,
++        &assign_result<MirBufferStream>,
++        &stream);
++>>>>>>> MERGE-SOURCE
      return stream;
+ }
  catch (std::exception const& ex)
@@ -94,7 +94,12 @@
  void mir_buffer_stream_release_sync(MirBufferStream *buffer_stream)
+ {
--    mir_buffer_stream_release(buffer_stream, nullptr, nullptr)->wait_for_all();
++    make_synchronous_call(
++        buffer_stream->connection(),
++        &mir_buffer_stream_release,
++        buffer_stream,
++        &assign_result<MirBufferStream>,
++        static_cast<void*>(nullptr));
+ }
  void mir_buffer_stream_get_current_buffer(MirBufferStream* buffer_stream, MirNativeBuffer** buffer_package_out)
@@ -132,6 +137,7 @@
+ }
  void mir_buffer_stream_swap_buffers_sync(MirBufferStream* buffer_stream)
++<<<<<<< TREE
  try
+ {
      buffer_stream->swap_buffers_sync();
@@ -139,6 +145,15 @@
  catch (std::exception const& ex)
+ {
      MIR_LOG_UNCAUGHT_EXCEPTION(ex);
++=======
++{
++    make_synchronous_call(
++        buffer_stream->connection(),
++        &mir_buffer_stream_swap_buffers,
++        buffer_stream,
++        &assign_result<MirBufferStream>,
++        static_cast<void*>(nullptr));
++>>>>>>> MERGE-SOURCE
+ }
  bool mir_buffer_stream_get_graphics_region(
 === modified file 'src/client/mir_connection.cpp'
 --- src/client/mir_connection.cpp	2017-03-21 05:51:47 +0000
 +++ src/client/mir_connection.cpp	2017-03-28 00:17:49 +0000
@@ -27,8 +27,12 @@
  #include "mir/client_platform.h"
  #include "mir/client_platform_factory.h"
  #include "rpc/mir_basic_rpc_channel.h"
++#include "rpc/mir_protobuf_rpc_channel.h"
  #include "mir/dispatch/dispatchable.h"
++#include "mir/dispatch/multiplexing_dispatchable.h"
  #include "mir/dispatch/threaded_dispatcher.h"
++#include "mir/dispatch/multiplexing_dispatchable.h"
++#include "mir/dispatch/action_queue.h"
  #include "mir/input/input_devices.h"
  #include "connection_configuration.h"
  #include "display_configuration.h"
@@ -53,6 +57,7 @@
  #include "mir/logging/logger.h"
  #include "mir/platform_message.h"
  #include "mir_error.h"
++#include "mir/require.h"
  #include <algorithm>
  #include <cstddef>
@@ -63,6 +68,7 @@
  #include <boost/throw_exception.hpp>
  namespace mcl = mir::client;
++namespace mclr = mir::client::rpc;
  namespace md = mir::dispatch;
  namespace mircv = mir::input::receiver;
  namespace mev = mir::events;
@@ -309,8 +315,13 @@
+ {
+ }
++MirConnection::MirConnection(mir::client::ConnectionConfiguration& conf) :
++    MirConnection(conf, DispatchType::automatic)
++{
++}
++
  MirConnection::MirConnection(
--    mir::client::ConnectionConfiguration& conf) :
++    mir::client::ConnectionConfiguration& conf, DispatchType dispatch) :
          deregisterer{this},
          surface_map(conf.the_surface_map()),
          buffer_factory(conf.the_buffer_factory()),
@@ -330,13 +341,26 @@
          display_configuration(conf.the_display_configuration()),
          input_devices{conf.the_input_devices()},
          lifecycle_control(conf.the_lifecycle_control()),
++        event_handler_register(conf.the_event_handler_register()),
++        dispatcher{std::make_shared<md::MultiplexingDispatchable>()},
++        eventloop{dispatch == DispatchType::automatic ?
++                  std::make_unique<md::ThreadedDispatcher>("RPC Dispatch", dispatcher) :
++                  nullptr
++        },
          ping_handler{conf.the_ping_handler()},
++        pong_callback(google::protobuf::NewPermanentCallback(&google::protobuf::DoNothing)),
++        delayed_queue{conf.the_delayed_queue()},
          error_handler{conf.the_error_handler()},
--        event_handler_register(conf.the_event_handler_register()),
--        pong_callback(google::protobuf::NewPermanentCallback(&google::protobuf::DoNothing)),
--        eventloop{new md::ThreadedDispatcher{"RPC Thread", std::dynamic_pointer_cast<md::Dispatchable>(channel)}},
          nbuffers(get_nbuffers_from_env())
+ {
++    dispatcher->add_watch(channel);
++    dispatcher->add_watch(delayed_queue);
++    if (eventloop)
++    {
++        // Need a second thread ensure RPC is not blocked if the delayed_queue blocks,
++        // as it does when waiting for surface creation.
++        eventloop->add_thread();
++    }
      connect_result->set_error("connect not called");
+     {
          std::lock_guard<std::mutex> lock(connection_guard);
@@ -419,38 +443,41 @@
      if (request_it == surface_requests.end())
          return;
--    auto surface_proto = request->response;
--    auto callback = request->cb;
--    auto context = request->context;
++    auto surface_proto = request->response;
      auto const& spec = request->spec;
      std::string name{spec.surface_name.is_set() ?
                       spec.surface_name.value() : ""};
++    surface_map->reserve(mf::SurfaceId{surface_proto->id().value()});
--    std::shared_ptr<MirBufferStream> default_stream {nullptr};
++    mcl::NoTLSFuture<std::unique_ptr<mcl::BufferStream>> default_stream;
      if (surface_proto->buffer_stream().has_id())
+     {
          try
+         {
--            default_stream = std::make_shared<mcl::BufferStream>(
++            default_stream = mcl::BufferStream::create(
                  this, nullptr, request->wh, server, platform, surface_map, buffer_factory,
                  surface_proto->buffer_stream(), make_perf_report(logger), name,
--                mir::geometry::Size{surface_proto->width(), surface_proto->height()}, nbuffers);
--            surface_map->insert(default_stream->rpc_id(), default_stream);
++                mir::geometry::Size{surface_proto->width(), surface_proto->height()},
++                nbuffers);
+         }
          catch (std::exception const& error)
+         {
              if (!surface_proto->has_error())
                  surface_proto->set_error(error.what());
--            // Clean up surface_proto's direct fds; BufferStream has cleaned up any owned by
--            // surface_proto->buffer_stream()
--            for (auto i = 0; i < surface_proto->fd_size(); i++)
--                ::close(surface_proto->fd(i));
+         }
+     }
++<<<<<<< TREE
      std::shared_ptr<MirWindow> surf {nullptr};
++=======
++>>>>>>> MERGE-SOURCE
      if (surface_proto->has_error() || !surface_proto->has_id())
+     {
++        // Clean up surface_proto's direct fds; BufferStream has cleaned up any owned by
++        // surface_proto->buffer_stream()
++        for (auto i = 0; i < surface_proto->fd_size(); i++)
++            ::close(surface_proto->fd(i));
++
          std::string reason;
          if (surface_proto->has_error())
              reason += surface_proto->error();
@@ -459,19 +486,63 @@
          if (!surface_proto->has_id())
              reason +=  "Server assigned surface no id";
          auto id = next_error_id(lock);
++<<<<<<< TREE
          surf = std::make_shared<MirWindow>(reason, this, id, request->wh);
++=======
++        auto surf = std::make_shared<MirSurface>(reason, this, id, request->wh);
++>>>>>>> MERGE-SOURCE
          surface_map->insert(id, surf);
++
++        request->cb(surf.get(), request->context);
++        request->wh->result_received();
++    }
++    else if (default_stream.valid())
++    {
++        default_stream.then(
++            [this, request = *request_it](auto&& resolved_stream) -> void
++            {
++                std::shared_ptr<MirSurface> surf;
++                std::shared_ptr<MirBufferStream> stream;
++                try
++                {
++                    stream = resolved_stream.get();
++                    surface_map->insert(stream->rpc_id(), stream);
++                }
++                catch (std::exception const& error)
++                {
++                    request->response->set_error(error.what());
++                }
++
++                surf = std::make_shared<MirSurface>(
++                    this,
++                    server,
++                    &debug,
++                    stream,
++                    input_platform,
++                    request->spec,
++                    *request->response,
++                    request->wh);
++                surface_map->insert(mf::SurfaceId{request->response->id().value()}, surf);
++
++                request->cb(surf.get(), request->context);
++                request->wh->result_received();
++            }).detach();
+     }
      else
+     {
++<<<<<<< TREE
          surf = std::make_shared<MirWindow>(
              this, server, &debug, default_stream, spec, *surface_proto, request->wh);
++=======
++        auto surf = std::make_shared<MirSurface>(
++            this, server, &debug, nullptr, input_platform, spec, *surface_proto, request->wh);
++>>>>>>> MERGE-SOURCE
          surface_map->insert(mf::SurfaceId{surface_proto->id().value()}, surf);
++
++        request->cb(surf.get(), request->context);
++        request->wh->result_received();
+     }
--    callback(surf.get(), context);
--    request->wh->result_received();
--
      surface_requests.erase(request_it);
+ }
@@ -515,17 +586,17 @@
  void MirConnection::released(StreamRelease data)
+ {
++    {
++        std::unique_lock<decltype(mutex)> lk(mutex);
++        if (data.rs)
++            surface_map->erase(data.rs);
++        surface_map->erase(mf::BufferStreamId(data.rpc_id));
++    }
++
      if (data.callback)
          data.callback(data.stream, data.context);
      if (data.handle)
          data.handle->result_received();
--
--    {
--        std::unique_lock<decltype(mutex)> lk(mutex);
--        if (data.rs)
--            surface_map->erase(data.rs);
--        surface_map->erase(mf::BufferStreamId(data.rpc_id));
--    }
+ }
  void MirConnection::released(SurfaceRelease data)
@@ -701,6 +772,36 @@
      return &disconnect_wait_handle;
+ }
++mir::Fd MirConnection::watch_fd() const
++{
++    return eventloop ? mir::Fd{} : dispatcher->watch_fd();
++}
++
++void MirConnection::dispatch()
++{
++    mir::require(!eventloop);
++
++    dispatcher->dispatch(md::FdEvent::readable);
++}
++
++void MirConnection::add_dispatchee(std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchee)
++{
++    dispatcher->add_watch(dispatchee);
++    if (eventloop)
++    {
++        eventloop->add_thread();
++    }
++}
++
++void MirConnection::remove_dispatchee(std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchee)
++{
++    dispatcher->remove_watch(dispatchee);
++    if (eventloop)
++    {
++        eventloop->remove_thread();
++    }
++}
++
  void MirConnection::done_platform_operation(
      MirPlatformOperationCallback callback, void* context)
+ {
@@ -880,16 +981,34 @@
      try
+     {
--        auto stream = std::make_shared<mcl::BufferStream>(
--            this, request->rs, request->wh, server, platform, surface_map, buffer_factory,
--            *protobuf_bs, make_perf_report(logger), std::string{},
--            mir::geometry::Size{request->parameters.width(), request->parameters.height()}, nbuffers);
--        surface_map->insert(mf::BufferStreamId(protobuf_bs->id().value()), stream);
--
--        if (request->mbs_callback)
--            request->mbs_callback(stream.get(), request->context);
--
--        request->wh->result_received();
++        auto future_stream = mcl::BufferStream::create(
++            this,
++            request->rs,
++            request->wh,
++            server,
++            platform,
++            surface_map,
++            buffer_factory,
++            *protobuf_bs,
++            make_perf_report(logger),
++            std::string{},
++            mir::geometry::Size{request->parameters.width(), request->parameters.height()},
++            nbuffers);
++
++        future_stream.then(
++            [this, request](auto&& resolved_stream) -> void
++            {
++                std::shared_ptr<mcl::BufferStream> stream{resolved_stream.get()};
++                auto& protobuf_bs = request->response;
++
++                surface_map->insert(mf::BufferStreamId(protobuf_bs->id().value()), stream);
++
++                request->mbs_callback(
++                    static_cast<MirBufferStream*>(stream.get()),
++                    request->context);
++
++                request->wh->result_received();
++            }).detach();
+     }
      catch (std::exception const& error)
+     {
@@ -939,17 +1058,25 @@
      return request->wh.get();
+ }
--std::shared_ptr<mir::client::BufferStream> MirConnection::create_client_buffer_stream_with_id(
++mcl::NoTLSFuture<std::unique_ptr<mcl::BufferStream>>
++MirConnection::create_client_buffer_stream_with_id(
      int width, int height,
      MirRenderSurface* render_surface,
      mir::protobuf::BufferStream const& a_protobuf_bs)
+ {
--    auto stream = std::make_shared<mcl::BufferStream>(
--        this, render_surface, nullptr, server, platform, surface_map, buffer_factory,
--        a_protobuf_bs, make_perf_report(logger), std::string{},
--        mir::geometry::Size{width, height}, nbuffers);
--    surface_map->insert(render_surface->stream_id(), stream);
--    return stream;
++    return mcl::BufferStream::create(
++        this,
++        render_surface,
++        nullptr,
++        server,
++        platform,
++        surface_map,
++        buffer_factory,
++        a_protobuf_bs,
++        make_perf_report(logger),
++        std::string{},
++        mir::geometry::Size{width, height},
++        nbuffers);
+ }
  #pragma GCC diagnostic pop
@@ -1322,8 +1449,15 @@
      server.release_buffers(&request, ignored.get(), gp::NewCallback(ignore));
+ }
++void MirConnection::process_next_request_first()
++{
++    channel->process_next_request_first();
++}
++
  void MirConnection::release_render_surface_with_content(
--    void* render_surface)
++    void* render_surface,
++    mir_render_surface_callback callback,
++    void* ctx)
+ {
      auto rs = surface_map->render_surface(render_surface);
      if (!rs->valid())
@@ -1332,13 +1466,23 @@
          return;
+     }
--    StreamRelease stream_release{
--        nullptr,
--        nullptr,
--        nullptr,
--        nullptr,
--        rs->stream_id().as_value(),
--        render_surface};
++<<<<<<< TREE
++    StreamRelease stream_release{
++        nullptr,
++        nullptr,
++        nullptr,
++        nullptr,
++        rs->stream_id().as_value(),
++        render_surface};
++=======
++    StreamRelease stream_release{
++        reinterpret_cast<MirBufferStream*>(render_surface),
++        nullptr,
++        reinterpret_cast<mir_buffer_stream_callback>(callback),
++        ctx,
++        rs->stream_id().as_value(),
++        render_surface};
++>>>>>>> MERGE-SOURCE
      mp::BufferStreamId buffer_stream_id;
      buffer_stream_id.set_value(rs->stream_id().as_value());
 === modified file 'src/client/mir_connection.h'
 --- src/client/mir_connection.h	2017-03-14 04:41:33 +0000
 +++ src/client/mir_connection.h	2017-03-28 00:17:49 +0000
@@ -34,6 +34,7 @@
  #include "mir_surface.h"
  #include "display_configuration.h"
  #include "error_handler.h"
++#include "no_tls_future-inl.h"
  #include <atomic>
  #include <memory>
@@ -42,6 +43,8 @@
  #include <unordered_set>
  #include <unordered_map>
++#include "mir/fd.h"
++
  namespace mir
+ {
  namespace input
@@ -85,8 +88,17 @@
  namespace dispatch
+ {
  class ThreadedDispatcher;
--}
--}
++class Dispatchable;
++class MultiplexingDispatchable;
++class ActionQueue;
++}
++}
++
++enum class DispatchType
++{
++    automatic,
++    manual
++};
  struct MirConnection : mir::client::ClientContext
+ {
@@ -94,6 +106,7 @@
      MirConnection(std::string const& error_message);
      MirConnection(mir::client::ConnectionConfiguration& conf);
++    MirConnection(mir::client::ConnectionConfiguration &conf, DispatchType dispatch);
      ~MirConnection() noexcept;
      MirConnection(MirConnection const &) = delete;
@@ -119,6 +132,12 @@
      MirWaitHandle* disconnect();
++    mir::Fd watch_fd() const;
++    void dispatch();
++
++    void add_dispatchee(std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchee);
++    void remove_dispatchee(std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchee);
++
      MirWaitHandle* platform_operation(
          MirPlatformMessage const* request,
          MirPlatformOperationCallback callback, void* context) override;
@@ -151,7 +170,7 @@
          MirRenderSurface* render_surface,
          MirBufferStreamCallback mbs_callback,
          void *context);
--    std::shared_ptr<mir::client::BufferStream> create_client_buffer_stream_with_id(
++    mir::client::NoTLSFuture<std::unique_ptr<mir::client::BufferStream>> create_client_buffer_stream_with_id(
          int width, int height,
          MirRenderSurface* render_surface,
          mir::protobuf::BufferStream const& a_protobuf_bs);
@@ -221,10 +240,13 @@
          void* context) -> MirRenderSurface*;
  #pragma GCC diagnostic pop
      void release_render_surface_with_content(
--        void* render_surface);
++        void* render_surface,
++        mir_render_surface_callback callback,
++        void* ctx);
      void* request_interface(char const* name, int version);
++    void process_next_request_first();
  private:
      //google cant have callbacks with more than 2 args
      struct SurfaceCreationRequest
@@ -242,7 +264,7 @@
          std::shared_ptr<MirWaitHandle> wh;
      };
      std::vector<std::shared_ptr<SurfaceCreationRequest>> surface_requests;
--    void surface_created(SurfaceCreationRequest*);
++    void    surface_created(SurfaceCreationRequest*);
      struct StreamCreationRequest
+     {
@@ -350,16 +372,20 @@
      std::shared_ptr<mir::client::LifecycleControl> const lifecycle_control;
++
++    std::shared_ptr<mir::client::EventHandlerRegister> const event_handler_register;
++
++    std::shared_ptr<mir::dispatch::MultiplexingDispatchable> const dispatcher;
++    std::unique_ptr<mir::dispatch::ThreadedDispatcher> const eventloop;
++
      std::shared_ptr<mir::client::PingHandler> const ping_handler;
++    std::unique_ptr<google::protobuf::Closure> const pong_callback;
++
++    std::shared_ptr<mir::dispatch::ActionQueue> const delayed_queue;
++
      std::shared_ptr<mir::client::ErrorHandler> error_handler;
--    std::shared_ptr<mir::client::EventHandlerRegister> const event_handler_register;
--
--    std::unique_ptr<google::protobuf::Closure> const pong_callback;
--
--    std::unique_ptr<mir::dispatch::ThreadedDispatcher> const eventloop;
--
      struct SurfaceRelease;
      struct StreamRelease;
 === modified file 'src/client/mir_connection_api.cpp'
 --- src/client/mir_connection_api.cpp	2017-02-15 07:38:33 +0000
 +++ src/client/mir_connection_api.cpp	2017-03-28 00:17:49 +0000
@@ -29,9 +29,11 @@
  #include "display_configuration.h"
  #include "error_connections.h"
  #include "mir/uncaught.h"
++#include "synchronous_helper.h"
  #include <cstddef>
  #include <cstring>
++#include <poll.h>
  namespace mcl = mir::client;
  namespace mp = mir::protobuf;
@@ -39,12 +41,105 @@
  namespace
+ {
++<<<<<<< TREE
  // assign_result is compatible with all 2-parameter callbacks
  void assign_result(void* result, void** context)
+ {
      if (context)
          *context = result;
+ }
++=======
++class DefaultMirConnectionAPI : public mcl::MirConnectionAPI
++{
++public:
++    MirWaitHandle* connect(
++        mcl::ConfigurationFactory configuration,
++        char const* socket_file,
++        char const* name,
++        mir_connected_callback callback,
++        void* context) override
++    {
++        try
++        {
++            std::string sock;
++            if (socket_file)
++                sock = socket_file;
++            else
++            {
++                auto socket_env = getenv("MIR_SOCKET");
++                if (socket_env && socket_env[0])
++                    sock = socket_env;
++                else
++                    sock = mir::default_server_socket;
++            }
++
++            auto const conf = configuration(sock);
++
++            auto connection = std::make_unique<MirConnection>(*conf);
++            auto const result = connection->connect(name, callback, context);
++            connection.release();
++            return result;
++        }
++        catch (std::exception const& x)
++        {
++            MirConnection* error_connection = new MirConnection(x.what());
++            mcl::ErrorConnections::instance().insert(error_connection);
++            callback(error_connection, context);
++            return nullptr;
++        }
++    }
++
++    void release(MirConnection* connection) override
++    {
++        if (!mcl::ErrorConnections::instance().contains(connection))
++        {
++            try
++            {
++                auto wait_handle = connection->disconnect();
++                if (connection->watch_fd() != mir::Fd::invalid)
++                {
++                    pollfd fd;
++                    fd.fd = connection->watch_fd();
++                    fd.events = POLLIN;
++                    while(wait_handle->is_pending() && (poll(&fd, 1, -1) > 0))
++                    {
++                        connection->dispatch();
++                    }
++                }
++                else
++                {
++                    wait_handle->wait_for_all();
++                }
++            }
++            catch (std::exception const& ex)
++            {
++                // We're implementing a C API so no exceptions are to be
++                // propagated. And that's OK because if disconnect() fails,
++                // we don't care why. We're finished with the connection anyway.
++
++                MIR_LOG_UNCAUGHT_EXCEPTION(ex);
++            }
++        }
++        else
++        {
++            mcl::ErrorConnections::instance().remove(connection);
++        }
++
++        delete connection;
++    }
++
++    mcl::ConfigurationFactory configuration_factory() override
++    {
++        return [](std::string const& socket) {
++            return std::unique_ptr<mcl::ConnectionConfiguration>{
++                new mcl::DefaultConnectionConfiguration{socket}
++            };
++        };
++    }
++};
++
++DefaultMirConnectionAPI default_api;
++>>>>>>> MERGE-SOURCE
+ }
  MirWaitHandle* mir_connect(
@@ -94,6 +189,7 @@
      char const* app_name)
+ {
      MirConnection* conn = nullptr;
++<<<<<<< TREE
      auto wh = mir_connect(server, app_name,
                            reinterpret_cast<MirConnectedCallback>
                            (assign_result),
@@ -104,9 +200,62 @@
          wh->wait_for_all();
+     }
++=======
++    mir_wait_for(mir_connect(server, app_name,
++                             assign_result,
++                             &conn));
++>>>>>>> MERGE-SOURCE
      return conn;
+ }
++MirConnection* mir_connect_with_manual_dispatch(
++        char const* server,
++        char const* app_name,
++        mir_connected_callback callback,
++        void* context)
++{
++    try
++    {
++        std::string sock;
++        if (server)
++            sock = server;
++        else
++        {
++            auto socket_env = getenv("MIR_SOCKET");
++            if (socket_env)
++                sock = socket_env;
++            else
++                sock = mir::default_server_socket;
++        }
++
++        mcl::DefaultConnectionConfiguration conf{sock};
++
++        std::unique_ptr<MirConnection> connection{new MirConnection(conf, DispatchType::manual)};
++        connection->connect(app_name, callback, context);
++        return connection.release();
++    }
++    catch (std::exception const& x)
++    {
++        MirConnection* error_connection = new MirConnection(x.what());
++        mcl::ErrorConnections::instance().insert(error_connection);
++        callback(error_connection, context);
++        return error_connection;
++    }
++}
++
++MirConnection* mir_connect_with_manual_dispatch_sync(
++    char const* server,
++    char const* app_name)
++{
++    MirConnection* result = nullptr;
++
++    auto connection = mir_connect_with_manual_dispatch(server, app_name, &assign_result, &result);
++
++    dispatch_connection_until(connection, [&result]() { return result != nullptr; });
++
++    return connection;
++}
++
  bool mir_connection_is_valid(MirConnection* connection)
+ {
      return MirConnection::is_valid(connection);
@@ -139,6 +288,16 @@
      MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+ }
++int mir_connection_get_event_fd(MirConnection* connection)
++{
++    return connection->watch_fd();
++}
++
++void mir_connection_dispatch(MirConnection* connection)
++{
++    connection->dispatch();
++}
++
  void mir_connection_get_platform(
      MirConnection* connection,
      MirPlatformPackage* platform_package)
 === modified file 'src/client/mir_prompt_session_api.cpp'
 --- src/client/mir_prompt_session_api.cpp	2017-03-10 19:47:57 +0000
 +++ src/client/mir_prompt_session_api.cpp	2017-03-28 00:17:49 +0000
@@ -25,6 +25,8 @@
  #include "mir/require.h"
  #include "mir/uncaught.h"
++#include "synchronous_helper.h"
++
  #include <stdexcept>
  #include <boost/throw_exception.hpp>
@@ -46,6 +48,17 @@
              prompt_session->register_prompt_session_state_change_callback(state_change_callback, context);
          prompt_session->start(application_pid, null_callback, nullptr)->wait_for_all();
++<<<<<<< TREE
++=======
++        make_synchronous_call(
++            connection,
++            std::mem_fn(&MirPromptSession::start),
++            prompt_session,
++            application_pid,
++            &assign_result<MirPromptSession>,
++            static_cast<void*>(nullptr));
++
++>>>>>>> MERGE-SOURCE
          return prompt_session;
+     }
      catch (std::exception const& ex)
 === modified file 'src/client/mir_render_surface_api.cpp'
 --- src/client/mir_render_surface_api.cpp	2017-03-14 04:41:33 +0000
 +++ src/client/mir_render_surface_api.cpp	2017-03-28 00:17:49 +0000
@@ -163,10 +163,13 @@
+ }
  void mir_render_surface_release(
--    MirRenderSurface* render_surface)
++    MirRenderSurface* render_surface,
++    mir_render_surface_callback callback,
++    void* ctx)
  try
+ {
      mir::require(render_surface);
++<<<<<<< TREE
      auto connection = connection_map.connection(render_surface);
      connection_map.erase(render_surface);
      connection->release_render_surface_with_content(render_surface);
@@ -180,17 +183,114 @@
      MirRenderSurface* render_surface,
      int width, int height,
      MirPixelFormat format)
--try
--{
++=======
++    auto connection = connection_map.connection(static_cast<void*>(render_surface));
++    connection_map.erase(static_cast<void*>(render_surface));
++    connection->release_render_surface_with_content(render_surface, callback, ctx);
++}
++catch (std::exception const& ex)
++{
++    callback(render_surface, ctx);
++    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
++}
++
++void mir_render_surface_get_buffer_stream(
++    MirRenderSurface* render_surface,
++    int width,
++    int height,
++    MirPixelFormat format,
++    MirBufferUsage usage,
++    mir_buffer_stream_callback callback,
++    void* context)
++try
++{
++    mir::require(render_surface);
++    auto connection = connection_map.connection(static_cast<void*>(render_surface));
++    auto rs = connection->connection_surface_map()->render_surface(render_surface);
++    rs->get_buffer_stream(width, height, format, usage, callback, context);
++}
++catch (std::exception const& ex)
++{
++    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
++}
++
++MirBufferStream* mir_render_surface_get_buffer_stream_sync(
++    MirRenderSurface* render_surface,
++    int width,
++    int height,
++    MirPixelFormat format,
++    MirBufferUsage usage)
++>>>>>>> MERGE-SOURCE
++try
++{
++<<<<<<< TREE
      mir::require(render_surface);
      auto connection = connection_map.connection(render_surface);
      auto rs = connection->connection_surface_map()->render_surface(render_surface);
      return rs->get_buffer_stream(width, height, format, mir_buffer_usage_software);
++=======
++    struct BufferStreamResult
++    {
++        std::mutex lock;
++        std::condition_variable notify;
++        bool done{false};
++        MirBufferStream* result;
++    } ready;
++
++    mir_render_surface_get_buffer_stream(
++        render_surface,
++        width, height,
++        format,
++        usage,
++        [](MirBufferStream* stream, void* context)
++        {
++            auto result = reinterpret_cast<BufferStreamResult*>(context);
++
++            {
++                std::lock_guard<std::mutex> lock{result->lock};
++                result->result = stream;
++                result->done = true;
++            }
++            result->notify.notify_all();
++        },
++        &ready);
++
++    std::unique_lock<std::mutex> lock{ready.lock};
++    ready.notify.wait(lock, [&ready]() { return ready.done; });
++
++    return ready.result;
++>>>>>>> MERGE-SOURCE
+ }
  catch (std::exception const& ex)
+ {
      MIR_LOG_UNCAUGHT_EXCEPTION(ex);
--    return nullptr;
++    std::terminate();
++}
++
++void mir_render_surface_release_sync(MirRenderSurface* render_surface)
++{
++    struct Waiter
++    {
++        std::condition_variable notifier;
++        std::mutex lock;
++        bool done{false};
++    } waiter;
++
++    mir_render_surface_release(
++        render_surface,
++        [](MirRenderSurface*, void* ctx)
++        {
++            auto waiter = reinterpret_cast<Waiter*>(ctx);
++            {
++                std::lock_guard<std::mutex> lock{waiter->lock};
++                waiter->done = true;
++            }
++            waiter->notifier.notify_all();
++        },
++        &waiter);
++
++    std::unique_lock<std::mutex> lock(waiter.lock);
++    waiter.notifier.wait(lock, [&waiter]() { return waiter.done; });
+ }
  MirPresentationChain* mir_render_surface_get_presentation_chain(
 === modified file 'src/client/mir_screencast.cpp'
 --- src/client/mir_screencast.cpp	2017-03-10 19:47:57 +0000
 +++ src/client/mir_screencast.cpp	2017-03-28 00:17:49 +0000
@@ -104,8 +104,9 @@
+ {
+ }
--MirScreencast::MirScreencast(std::string const& error)
--    : protobuf_screencast{mcl::make_protobuf_object<mir::protobuf::Screencast>()}
++MirScreencast::MirScreencast(MirConnection* connection, std::string const& error)
++    : connection{connection},
++      protobuf_screencast{mcl::make_protobuf_object<mir::protobuf::Screencast>()}
+ {
      protobuf_screencast->set_error(error);
+ }
@@ -178,7 +179,12 @@
+ }
  void MirScreencast::screencast_created(
++<<<<<<< TREE
      MirScreencastCallback callback, void* context)
++=======
++    mir_screencast_callback callback,
++    void* context)
++>>>>>>> MERGE-SOURCE
+ {
      if (!protobuf_screencast->has_error() && connection)
+     {
@@ -219,3 +225,8 @@
      std::lock_guard<decltype(mutex)> lock(mutex);
      return buffer_stream.get();
+ }
++
++MirConnection* MirScreencast::get_connection()
++{
++    return connection;
++}
 === modified file 'src/client/mir_screencast.h'
 --- src/client/mir_screencast.h	2017-01-24 07:37:03 +0000
 +++ src/client/mir_screencast.h	2017-03-28 00:17:49 +0000
@@ -68,7 +68,7 @@
  struct MirScreencast
+ {
  public:
--    MirScreencast(std::string const& error);
++    MirScreencast(MirConnection* connection, std::string const& error);
      MirScreencast(
          MirScreencastSpec const& spec,
          mir::client::rpc::DisplayServer& server,
@@ -85,6 +85,7 @@
      MirBufferStream* get_buffer_stream();
++    MirConnection* get_connection();
  private:
      void screencast_created(
          MirScreencastCallback callback, void* context);
 === modified file 'src/client/mir_screencast_api.cpp'
 --- src/client/mir_screencast_api.cpp	2017-01-18 02:29:37 +0000
 +++ src/client/mir_screencast_api.cpp	2017-03-28 00:17:49 +0000
@@ -25,6 +25,8 @@
  #include "mir/require.h"
  #include "mir/uncaught.h"
++#include "synchronous_helper.h"
++
  #include <stdexcept>
  #include <boost/throw_exception.hpp>
@@ -35,7 +37,18 @@
+ {
      auto& server = spec->connection->display_server();
      auto screencast = std::make_unique<MirScreencast>(*spec, server, null_callback, nullptr);
--    screencast->creation_wait_handle()->wait_for_all();
++
++    if (spec->connection->watch_fd() != mir::Fd::invalid)
++    {
++        dispatch_connection_until(spec->connection, [&screencast]()
++        {
++            return !screencast->creation_wait_handle()->is_pending();
++        });
++    }
++    else
++    {
++        screencast->creation_wait_handle()->wait_for_all();
++    }
      auto raw_screencast = screencast.get();
      screencast.release();
@@ -92,7 +105,7 @@
  catch (std::exception const& ex)
+ {
      MIR_LOG_UNCAUGHT_EXCEPTION(ex);
--    return new MirScreencast(ex.what());
++    return new MirScreencast(spec->connection, ex.what());
+ }
  bool mir_screencast_is_valid(MirScreencast *screencast)
@@ -117,7 +130,11 @@
  void mir_screencast_release_sync(MirScreencast* screencast)
+ {
--    screencast->release(null_callback, nullptr)->wait_for_all();
++    make_synchronous_call(screencast->get_connection(),
++                          std::mem_fn(&MirScreencast::release),
++                          screencast,
++                          &assign_result<MirScreencast>,
++                          static_cast<void*>(nullptr));
      delete screencast;
+ }
 === modified file 'src/client/mir_surface.cpp'
 --- src/client/mir_surface.cpp	2017-03-23 17:23:58 +0000
 +++ src/client/mir_surface.cpp	2017-03-28 00:17:49 +0000
@@ -194,6 +194,15 @@
              spec.event_handler.value().context);
+     }
++<<<<<<< TREE
++=======
++    if (surface_proto.fd_size() > 0 && handle_event_callback)
++    {
++        input_dispatcher = input_platform->create_input_receiver(surface_proto.fd(0), keymapper, handle_event_callback);
++        connection()->add_dispatchee(input_dispatcher);
++    }
++
++>>>>>>> MERGE-SOURCE
      std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
      valid_surfaces.insert(this);
@@ -220,7 +229,10 @@
      std::lock_guard<decltype(mutex)> lock(mutex);
--    input_thread.reset();
++    if (input_dispatcher)
++    {
++        connection()->remove_dispatchee(input_dispatcher);
++    }
      for (auto i = 0, end = surface->fd_size(); i != end; ++i)
          close(surface->fd(i));
@@ -466,7 +478,12 @@
+ {
      std::lock_guard<decltype(mutex)> lock(mutex);
--    input_thread.reset();
++    if (input_dispatcher)
++    {
++        connection()->remove_dispatchee(input_dispatcher);
++        input_dispatcher.reset();
++    }
++
      handle_event_callback = [](auto){};
      if (callback)
@@ -474,6 +491,17 @@
          handle_event_callback = std::bind(callback, this,
                                            std::placeholders::_1,
                                            context);
++<<<<<<< TREE
++=======
++
++        if (surface->fd_size() > 0 && handle_event_callback)
++        {
++            input_dispatcher = input_platform->create_input_receiver(surface->fd(0),
++                                                                     keymapper,
++                                                                     handle_event_callback);
++            connection()->add_dispatchee(input_dispatcher);
++        }
++>>>>>>> MERGE-SOURCE
+     }
+ }
 === modified file 'src/client/mir_surface.h'
 --- src/client/mir_surface.h	2017-03-23 17:23:58 +0000
 +++ src/client/mir_surface.h	2017-03-28 00:17:49 +0000
@@ -44,7 +44,7 @@
+ {
  namespace dispatch
+ {
--class ThreadedDispatcher;
++class Dispatchable;
+ }
  namespace input
+ {
@@ -263,9 +263,13 @@
      std::shared_ptr<mir::client::FrameClock> const frame_clock;
      std::function<void(MirEvent const*)> handle_event_callback;
++<<<<<<< TREE
      std::function<void(MirWindowEvent const*)> handle_drag_and_drop_start_callback = [](auto){};
      std::shared_ptr<mir::dispatch::ThreadedDispatcher> input_thread;
++=======
++    std::shared_ptr<mir::dispatch::Dispatchable> input_dispatcher;
++>>>>>>> MERGE-SOURCE
      //a bit batty, but the creation handle has to exist for as long as the MirSurface does,
      //as we don't really manage the lifetime of MirWaitHandle sensibly.
@@ -274,7 +278,6 @@
      MirPixelFormat format;
      MirBufferUsage usage;
      uint32_t output_id;
--
  };
  #pragma GCC diagnostic pop
 === modified file 'src/client/mir_surface_api.cpp'
 --- src/client/mir_surface_api.cpp	2017-03-14 04:41:33 +0000
 +++ src/client/mir_surface_api.cpp	2017-03-28 00:17:49 +0000
@@ -30,6 +30,7 @@
  #include "error_connections.h"
  #include "connection_surface_map.h"
  #include "mir/uncaught.h"
++#include "synchronous_helper.h"
  #include <boost/exception/diagnostic_information.hpp>
  #include <functional>
@@ -37,6 +38,7 @@
  namespace mcl = mir::client;
++<<<<<<< TREE
  namespace
+ {
  MirWaitHandle* mir_configure_cursor_helper(MirWindow* window, MirCursorConfiguration const* cursor)
@@ -895,6 +897,8 @@
      MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+ }
++=======
++>>>>>>> MERGE-SOURCE
  MirSurfaceSpec* mir_connection_create_spec_for_normal_surface(MirConnection* connection,
                                                                int width, int height,
                                                                MirPixelFormat format)
@@ -969,7 +973,20 @@
  MirSurface* mir_surface_create_sync(MirSurfaceSpec* requested_specification)
+ {
++<<<<<<< TREE
      return mir_create_window_sync(requested_specification);
++=======
++    MirSurface* surface = nullptr;
++
++    make_synchronous_call(
++        requested_specification->connection,
++        &mir_surface_create,
++        requested_specification,
++        &assign_result<MirSurface>,
++        &surface);
++
++    return surface;
++>>>>>>> MERGE-SOURCE
+ }
  MirWaitHandle* mir_surface_create(MirSurfaceSpec* requested_specification,
@@ -1172,7 +1189,15 @@
  void mir_surface_release_sync(MirSurface* surface)
+ {
++<<<<<<< TREE
      mir_window_release_sync(surface);
++=======
++    make_synchronous_call(surface->connection(),
++                          mir_surface_release,
++                          surface,
++                          &assign_result<MirSurface>,
++                          static_cast<void*>(nullptr));
++>>>>>>> MERGE-SOURCE
+ }
  MirSurfaceType mir_surface_get_type(MirSurface* surf)
 === modified file 'src/client/mir_wait_api.cpp'
 --- src/client/mir_wait_api.cpp	2014-03-31 14:36:08 +0000
 +++ src/client/mir_wait_api.cpp	2017-03-28 00:17:49 +0000
@@ -30,3 +30,12 @@
      if (wait_handle)
          wait_handle->wait_for_one();
+ }
++
++bool mir_wait_handle_ready(MirWaitHandle* wait_handle)
++{
++    if (wait_handle)
++    {
++        return !wait_handle->is_pending();
++    }
++    return true;
++}
 === modified file 'src/client/no_tls_future-inl.h'
 --- src/client/no_tls_future-inl.h	2017-01-18 02:29:37 +0000
 +++ src/client/no_tls_future-inl.h	2017-03-28 00:17:49 +0000
@@ -395,6 +395,7 @@
      NoTLSPromiseBase& operator=(NoTLSPromiseBase&& other)
+     {
          state = std::move(other.state);
++        return *this;
+     }
      NoTLSPromiseBase(NoTLSPromiseBase const&) = delete;
 === modified file 'src/client/render_surface.cpp'
 --- src/client/render_surface.cpp	2017-03-14 02:26:28 +0000
 +++ src/client/render_surface.cpp	2017-03-28 00:17:49 +0000
@@ -25,6 +25,7 @@
  #include "mir/client_platform.h"
  #include <boost/throw_exception.hpp>
++#include <mir/require.h>
  namespace mcl = mir::client;
  namespace geom = mir::geometry;
@@ -55,27 +56,46 @@
      return mf::BufferStreamId(protobuf_bs->id().value());
+ }
--MirBufferStream* mcl::RenderSurface::get_buffer_stream(
--    int width, int height,
++void mcl::RenderSurface::get_buffer_stream(
++    int width,
++    int height,
      MirPixelFormat format,
--    MirBufferUsage buffer_usage)
++    MirBufferUsage buffer_usage,
++    mir_buffer_stream_callback callback,
++    void* context)
+ {
      if (chain_from_id || stream_from_id)
++    {
++        callback(nullptr, context);
          BOOST_THROW_EXCEPTION(std::logic_error("Content already handed out"));
++    }
      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);
--    if (buffer_usage == mir_buffer_usage_hardware)
--    {
--        platform->use_egl_native_window(
--            wrapped_native_window, dynamic_cast<EGLNativeSurface*>(stream_from_id.get()));
--    }
--
--    return stream_from_id.get();
++
++    connection_->create_client_buffer_stream_with_id(
++        width,
++        height,
++        this,
++        *protobuf_bs).then(
++        [
++            this,
++            buffer_usage,
++            callback,
++            context
++        ](auto&& resolved_future)
++        {
++            auto bs = resolved_future.get();
++
++            if (buffer_usage == mir_buffer_usage_hardware)
++            {
++                platform->use_egl_native_window(
++                    wrapped_native_window, dynamic_cast<EGLNativeSurface*>(bs.get()));
++            }
++
++            stream_from_id = std::move(bs);
++            callback(static_cast<MirBufferStream*>(stream_from_id.get()), context);
++        }).detach();
+ }
  MirPresentationChain* mcl::RenderSurface::get_presentation_chain()
 === modified file 'src/client/render_surface.h'
 --- src/client/render_surface.h	2017-03-10 19:47:57 +0000
 +++ src/client/render_surface.h	2017-03-28 00:17:49 +0000
@@ -56,10 +56,13 @@
      mir::frontend::BufferStreamId stream_id() const override;
      char const* get_error_message() const override;
      bool valid() const override;
--    MirBufferStream* get_buffer_stream(
--        int width, int height,
++    void get_buffer_stream(
++        int width,
++        int height,
          MirPixelFormat format,
--        MirBufferUsage buffer_usage) override;
++        MirBufferUsage buffer_usage,
++        mir_buffer_stream_callback callback,
++        void* context) override;
      MirPresentationChain* get_presentation_chain() override;
  private:
 === modified file 'src/client/rpc/make_rpc_channel.h'
 --- src/client/rpc/make_rpc_channel.h	2017-01-18 02:29:37 +0000
 +++ src/client/rpc/make_rpc_channel.h	2017-03-28 00:17:49 +0000
@@ -41,6 +41,7 @@
+ {
  class MirBasicRpcChannel;
  class RpcReport;
++class MirBasicRpcChannel;
  std::shared_ptr<mir::client::rpc::MirBasicRpcChannel>
  make_rpc_channel(
 === modified file 'src/client/rpc/mir_basic_rpc_channel.h'
 --- src/client/rpc/mir_basic_rpc_channel.h	2017-01-30 05:18:36 +0000
 +++ src/client/rpc/mir_basic_rpc_channel.h	2017-03-28 00:17:49 +0000
@@ -19,6 +19,8 @@
  #ifndef MIR_CLIENT_RPC_MIR_BASIC_RPC_CHANNEL_H_
  #define MIR_CLIENT_RPC_MIR_BASIC_RPC_CHANNEL_H_
++#include "mir/dispatch/dispatchable.h"
++
  #include <memory>
  #include <map>
  #include <mutex>
@@ -105,6 +107,7 @@
+ }
  class MirBasicRpcChannel
++    : public mir::dispatch::Dispatchable
+ {
  public:
      virtual ~MirBasicRpcChannel();
@@ -115,11 +118,16 @@
          google::protobuf::MessageLite* response,
          google::protobuf::Closure* complete) = 0;
++<<<<<<< TREE
      virtual void discard_future_calls() = 0;
      virtual void wait_for_outstanding_calls() = 0;
++=======
++    virtual void process_next_request_first() = 0;
++>>>>>>> MERGE-SOURCE
  protected:
      MirBasicRpcChannel();
++
      mir::protobuf::wire::Invocation invocation_for(
          std::string const& method_name,
          google::protobuf::MessageLite const* request,
 === modified file 'src/client/rpc/mir_protobuf_rpc_channel.cpp'
 --- src/client/rpc/mir_protobuf_rpc_channel.cpp	2017-03-17 17:20:09 +0000
 +++ src/client/rpc/mir_protobuf_rpc_channel.cpp	2017-03-28 00:17:49 +0000
@@ -374,7 +374,7 @@
+             {
                  for(auto i = 0; i < seq.buffer_request().buffer().fd_size(); i++)
                      close(seq.buffer_request().buffer().fd(i));
--                throw e;
++                throw;
+             }
+         }
          else
@@ -395,13 +395,22 @@
              // But that's a job for later...
              try
+             {
++<<<<<<< TREE
                  auto e = MirEvent::deserialize(event.raw());
++=======
++                std::shared_ptr<MirEvent> e = mev::deserialize_event(event.raw());
++>>>>>>> MERGE-SOURCE
                  if (e)
+                 {
                      rpc_report->event_parsing_succeeded(*e);
++<<<<<<< TREE
                      int window_id = 0;
                      bool is_window_event = true;
++=======
++                    auto const send_e = [e](MirSurface* surface)
++                        { surface->handle_event(*e); };
++>>>>>>> MERGE-SOURCE
                      switch (e->type())
+                     {
 === modified file 'src/client/rpc/mir_protobuf_rpc_channel.h'
 --- src/client/rpc/mir_protobuf_rpc_channel.h	2017-01-30 05:18:36 +0000
 +++ src/client/rpc/mir_protobuf_rpc_channel.h	2017-03-28 00:17:49 +0000
@@ -53,8 +53,7 @@
  class MirProtobufRpcChannel :
          public MirBasicRpcChannel,
--        public StreamTransport::Observer,
--        public dispatch::Dispatchable
++        public StreamTransport::Observer
+ {
  public:
      MirProtobufRpcChannel(std::unique_ptr<StreamTransport> transport,
@@ -91,7 +90,7 @@
+      *
       * No messages are discarded, only delayed.
       */
--    void process_next_request_first();
++    void process_next_request_first() override;
      void call_method(
          std::string const& method_name,
@@ -112,6 +111,7 @@
      detail::SendBuffer header_bytes;
      detail::SendBuffer body_bytes;
++
      void receive_file_descriptors(google::protobuf::MessageLite* response);
      template<class MessageType>
      void receive_any_file_descriptors_for(MessageType* response);
 === modified file 'src/client/symbols.map'
 --- src/client/symbols.map	2017-03-21 05:51:47 +0000
 +++ src/client/symbols.map	2017-03-28 00:17:49 +0000
@@ -346,17 +346,23 @@
      mir_connection_create_render_surface;
      mir_connection_create_render_surface_sync;
      mir_render_surface_get_buffer_stream;
++    mir_render_surface_get_buffer_stream_sync;
      mir_render_surface_get_presentation_chain;
      mir_render_surface_is_valid;
      mir_render_surface_get_error_message;
      mir_render_surface_get_size;
      mir_render_surface_set_size;
      mir_render_surface_release;
++<<<<<<< TREE
      mir_connection_present_mode_supported;
      mir_presentation_chain_set_mode;
      mir_window_spec_add_render_surface;
      mir_window_spec_set_cursor_render_surface;
      mir_cursor_configuration_from_render_surface;
++=======
++    mir_render_surface_release_sync;
++    mir_surface_spec_add_render_surface;
++>>>>>>> MERGE-SOURCE
      #private functions needed temporarily by nested passthrough
      #should not be published along with the rest of the NBS symbols
@@ -395,6 +401,11 @@
      mir_input_device_state_event_time;
      mir_input_device_state_event_device_pointer_buttons;
      mir_surface_spec_set_pointer_confinement;
++    mir_connect_with_manual_dispatch;
++    mir_connect_with_manual_dispatch_sync;
++    mir_connection_get_event_fd;
++    mir_connection_dispatch;
++    mir_wait_handle_ready;
  } MIR_CLIENT_0.22;
  MIR_CLIENT_0.25 {  # New functions in Mir 0.25
@@ -552,6 +563,7 @@
      mir_window_request_persistent_id;
      mir_window_request_persistent_id_sync;
  } MIR_CLIENT_0.25;
++<<<<<<< TREE
  MIR_CLIENT_0.26.1 { # New functions in Mir 0.26.1
    global:
@@ -616,3 +628,12 @@
      mir_touchscreen_config_set_mapping_mode;
      mir_touchscreen_config_set_output_id;
  } MIR_CLIENT_0.26.1;
++=======
++
++MIR_CLIENT_DETAIL_0.26 {
++  global:
++    extern "C++" {
++      mir::client::DefaultConnectionConfiguration::the_delayed_queue*;
++    };
++} MIR_CLIENT_DETAIL_0.25;
++>>>>>>> MERGE-SOURCE
 === added file 'src/client/synchronous_helper.cpp'
 --- src/client/synchronous_helper.cpp	1970-01-01 00:00:00 +0000
 +++ src/client/synchronous_helper.cpp	2017-03-28 00:17:49 +0000
@@ -0,0 +1,33 @@
++/*
++ * Copyright © 2015 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: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include "synchronous_helper.h"
++
++#include <poll.h>
++
++void dispatch_connection_until(MirConnection* connection, std::function<bool()> predicate)
++{
++    pollfd fd;
++    fd.fd = connection->watch_fd();
++    fd.events = POLLIN;
++    while(!predicate() && (poll(&fd, 1, -1) > 0))
++    {
++        connection->dispatch();
++    }
++}
++
 === added file 'src/client/synchronous_helper.h'
 --- src/client/synchronous_helper.h	1970-01-01 00:00:00 +0000
 +++ src/client/synchronous_helper.h	2017-03-28 00:17:49 +0000
@@ -0,0 +1,160 @@
++/*
++ * Copyright © 2015 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: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_CLIENT_SYNCHRONOUS_H_
++#define MIR_CLIENT_SYNCHRONOUS_H_
++
++#include "mir_connection.h"
++#include "mir_wait_handle.h"
++
++#include <functional>
++#include <type_traits>
++
++template<typename Result>
++void assign_result(Result* result, void* ctx)
++{
++    auto assignee = reinterpret_cast<Result**>(ctx);
++    if (assignee)
++    {
++        *assignee = result;
++    }
++}
++
++template<typename Callback>
++struct SynchronousContext
++{
++    Callback real_callback;
++    bool complete;
++    void* userdata;
++};
++
++template<typename Callable, class Tuple, std::size_t...I>
++void apply_substituting_last_arg(
++    Callable&& function,
++    Tuple&& args,
++    std::index_sequence<I...>,
++    void* context)
++{
++    return std::forward<Callable>(function)(
++        std::get<I>(std::forward<Tuple>(args))...,
++        context);
++}
++
++
++template<typename... Args>
++void synchronous_wrapper(Args... args)
++{
++    std::tuple<Args...> arguments{args...};
++    constexpr std::size_t arg_count = sizeof...(Args);
++
++    auto wrapped_context = reinterpret_cast<SynchronousContext<void(*)(Args...)>*>(std::get<arg_count - 1>(arguments));
++    if (wrapped_context->real_callback)
++    {
++        apply_substituting_last_arg(
++               wrapped_context->real_callback,
++               std::forward_as_tuple(args...),
++               std::make_index_sequence<arg_count - 1>(),
++               wrapped_context->userdata);
++    }
++    wrapped_context->complete = true;
++}
++
++
++template<typename Callable, typename Tuple, std::size_t...I>
++constexpr decltype(auto) call_impl(Callable&& function, Tuple&& args, std::index_sequence<I...>)
++{
++    return std::forward<Callable>(function)(std::get<I>(std::forward<Tuple>((args)))...);
++}
++
++template<typename Callable, typename Tuple>
++constexpr decltype(auto) apply(Callable&& function, Tuple&& args)
++{
++    return call_impl(
++        std::forward<Callable>(function),
++        std::forward<Tuple>(args),
++        std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>{}>{});
++}
++
++void dispatch_connection_until(MirConnection* connection, std::function<bool()> predicate);
++
++
++/**
++ * \brief Make a synchronous RPC call
++ *
++ * This wrapper takes care of manually dispatching the MirConnection if it is in
++ * manual dispatch mode, or waiting for the operation to complete if in automatic
++ * dispatch mode.
++ *
++ * Given a function mir_foo_do_thing(MirFoo* target, int arg, foo_callback callback, void* context)
++ * the correct way to call this function is
++ * make_synchronous_call(connection,
++ *                       &mir_foo_do_thing,
++ *                       target,
++ *                       arg,
++ *                       callback,
++ *                       static_cast<void*>(context));
++ *
++ * The last two parameters must be the callback function and the void* to pass to that callback.
++ * The last argument must have a pointer type; NULL or nullptr must be explicitly cast to
++ * void*.
++ */
++template<typename Callable, typename... Args>
++void make_synchronous_call(MirConnection* connection,
++                           Callable&& function,
++                           Args&&... args)
++{
++    static_assert(
++        std::is_same<typename std::result_of<Callable(Args...)>::type, MirWaitHandle*>::value,
++        "Second parameter must be a function that returns a MirWaitHandle*");
++
++    if (connection->watch_fd() != mir::Fd::invalid)
++    {
++        std::tuple<Args...> arguments{args...};
++        constexpr int arg_count = sizeof...(Args);
++        auto callback = std::get<arg_count - 2>(arguments);
++        auto context = std::get<arg_count - 1>(arguments);
++
++        static_assert(
++            std::is_pointer<typename std::tuple_element<arg_count - 1, std::tuple<Args...>>::type>::value,
++            "The final argument must be a pointer type");
++        static_assert(
++            std::is_pointer<typename std::tuple_element<arg_count - 2, std::tuple<Args...>>::type>::value,
++            "The second last argument must be a function pointer");
++
++        SynchronousContext<decltype(callback)> wrapper_context {
++            callback,
++            false,
++            context
++        };
++
++        std::get<arg_count - 2>(arguments) = &synchronous_wrapper;
++        std::get<arg_count - 1>(arguments) =
++            reinterpret_cast<typename std::tuple_element<arg_count - 1, std::tuple<Args...>>::type>(&wrapper_context);
++
++        connection->process_next_request_first();
++        apply(std::forward<Callable>(function), arguments);
++
++        dispatch_connection_until(connection, [&wrapper_context](){ return wrapper_context.complete; });
++    }
++    else
++    {
++        mir_wait_for(std::forward<Callable>(function)(std::forward<Args>(args)...));
++    }
++}
++
++#endif // MIR_CLIENT_SYNCHRONOUS_H_
 === added file 'src/common/dispatch/threaded_dispatcher.cpp.moved'
 --- src/common/dispatch/threaded_dispatcher.cpp.moved	1970-01-01 00:00:00 +0000
 +++ src/common/dispatch/threaded_dispatcher.cpp.moved	2017-03-28 00:17:49 +0000
@@ -0,0 +1,294 @@
++/*
++ * Copyright © 2015 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: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include "mir/dispatch/threaded_dispatcher.h"
++#include "mir/dispatch/dispatchable.h"
++#include "mir/thread_name.h"
++
++#include "mir/raii.h"
++#include "mir/logging/logger.h"
++
++#include <fcntl.h>
++#include <poll.h>
++#include <unistd.h>
++#include <system_error>
++#include <signal.h>
++#include <boost/exception/all.hpp>
++#include <algorithm>
++#include <unordered_map>
++#include <sys/eventfd.h>
++
++namespace md = mir::dispatch;
++
++class md::ThreadedDispatcher::ThreadShutdownRequestHandler : public md::Dispatchable
++{
++public:
++    ThreadShutdownRequestHandler()
++        : event_semaphore{eventfd(0, EFD_CLOEXEC | EFD_SEMAPHORE)},
++          shutting_down{false}
++    {
++        if (event_semaphore == mir::Fd::invalid)
++        {
++            BOOST_THROW_EXCEPTION((std::system_error{errno,
++                                                     std::system_category(),
++                                                     "Failed to create shutdown eventfd"}));
++        }
++    }
++
++    mir::Fd watch_fd() const override
++    {
++        return event_semaphore;
++    }
++
++    bool dispatch(md::FdEvents events) override
++    {
++        if (events & md::FdEvent::error)
++        {
++            return false;
++        }
++
++        eventfd_t dummy;
++        if (eventfd_read(event_semaphore, &dummy) < 0)
++        {
++            BOOST_THROW_EXCEPTION((std::system_error{errno,
++                                                     std::system_category(),
++                                                     "Failed to clear shutdown notification"}));
++        }
++        std::lock_guard<decltype(running_flag_guard)> lock{running_flag_guard};
++        *running_flags.at(std::this_thread::get_id()) = false;
++
++        return true;
++    }
++
++    md::FdEvents relevant_events() const override
++    {
++        return md::FdEvent::readable;
++    }
++
++    std::thread::id terminate_one_thread()
++    {
++        // First we tell a thread to die, any thread...
++        if (eventfd_write(event_semaphore, 1) < 0)
++        {
++            BOOST_THROW_EXCEPTION((std::system_error{errno,
++                                                     std::system_category(),
++                                                     "Failed to trigger thread shutdown"}));
++        }
++
++        // ...now we wait for a thread to die and tell us its ID...
++        // We wait for a surprisingly long time because our threads are potentially blocked
++        // in client code that we don't control.
++        //
++        // If the client is entirely unresponsive for a whole minute, it deserves to die.
++        std::unique_lock<decltype(terminating_thread_mutex)> lock{terminating_thread_mutex};
++        if (!thread_terminating.wait_for (lock,
++                                          std::chrono::seconds{60},
++                                          [this]() { return !terminating_threads.empty(); }))
++        {
++            BOOST_THROW_EXCEPTION((std::runtime_error{"Thread failed to shutdown"}));
++        }
++
++        auto killed_thread_id = terminating_threads.back();
++        terminating_threads.pop_back();
++        return killed_thread_id;
++    }
++
++    void terminate_all_threads_async()
++    {
++        eventfd_t thread_count;
++        {
++            std::lock_guard<std::mutex> lock(running_flag_guard);
++            thread_count = running_flags.size();
++            shutting_down = true;
++        }
++        if (eventfd_write(event_semaphore, thread_count) < 0)
++        {
++            BOOST_THROW_EXCEPTION((std::system_error{errno,
++                                                     std::system_category(),
++                                                     "Failed to trigger thread shutdown"}));
++        }
++    }
++
++    void register_thread(bool& run_flag)
++    {
++        std::lock_guard<decltype(running_flag_guard)> lock{running_flag_guard};
++
++        running_flags[std::this_thread::get_id()] = &run_flag;
++        if (shutting_down)
++        {
++            if (eventfd_write(event_semaphore, 1) < 0)
++            {
++                BOOST_THROW_EXCEPTION((std::system_error{errno,
++                                                         std::system_category(),
++                                                         "Failed to trigger thread shutdown"}));
++            }
++        }
++    }
++
++    void unregister_thread()
++    {
++        {
++            std::lock_guard<decltype(terminating_thread_mutex)> lock{terminating_thread_mutex};
++            terminating_threads.push_back(std::this_thread::get_id());
++        }
++        thread_terminating.notify_one();
++        {
++            std::lock_guard<decltype(running_flag_guard)> lock{running_flag_guard};
++
++            if (running_flags.erase(std::this_thread::get_id()) != 1)
++            {
++                BOOST_THROW_EXCEPTION((std::logic_error{"Attempted to unregister a not-registered thread"}));
++            }
++        }
++    }
++
++private:
++    mir::Fd event_semaphore;
++
++    std::mutex terminating_thread_mutex;
++    std::condition_variable thread_terminating;
++    std::vector<std::thread::id> terminating_threads;
++
++    std::mutex running_flag_guard;
++    std::unordered_map<std::thread::id, bool*> running_flags;
++    bool shutting_down;
++};
++
++md::ThreadedDispatcher::ThreadedDispatcher(std::string const& name, std::shared_ptr<Dispatchable> const& dispatchee)
++    : ThreadedDispatcher(name, dispatchee, [](){ throw; })
++{
++}
++
++md::ThreadedDispatcher::ThreadedDispatcher(std::string const& name,
++                                           std::shared_ptr<md::Dispatchable> const& dispatchee,
++                                           std::function<void()> const& exception_handler)
++    : name_base{name},
++      thread_exiter{std::make_shared<ThreadShutdownRequestHandler>()},
++      dispatcher{std::make_shared<MultiplexingDispatchable>()},
++      exception_handler{exception_handler}
++{
++
++    // We rely on exactly one thread at a time getting a shutdown message
++    dispatcher->add_watch(thread_exiter, md::DispatchReentrancy::sequential);
++
++    // But our target dispatchable is welcome to be dispatched on as many threads
++    // as desired.
++    dispatcher->add_watch(dispatchee, md::DispatchReentrancy::reentrant);
++
++    threadpool.emplace_back(&dispatch_loop, name_base, thread_exiter, dispatcher, exception_handler);
++}
++
++md::ThreadedDispatcher::~ThreadedDispatcher() noexcept
++{
++    std::lock_guard<decltype(thread_pool_mutex)> lock{thread_pool_mutex};
++
++    thread_exiter->terminate_all_threads_async();
++
++    for (auto& thread : threadpool)
++    {
++        if (thread.get_id() == std::this_thread::get_id())
++        {
++            // We're being destroyed from within the dispatch callback
++            // Attempting to join the eventloop will result in a trivial deadlock.
++            //
++            // The std::thread destructor will call std::terminate() for us, let's
++            // leave a useful message.
++            mir::logging::log(mir::logging::Severity::critical,
++                              "Destroying ThreadedDispatcher from within a dispatch callback. This is a programming error.",
++                              "Dispatch");
++        }
++        else
++        {
++            thread.join();
++        }
++    }
++}
++
++void md::ThreadedDispatcher::add_thread()
++{
++    std::lock_guard<decltype(thread_pool_mutex)> lock{thread_pool_mutex};
++    threadpool.emplace_back(&dispatch_loop, name_base, thread_exiter, dispatcher, exception_handler);
++}
++
++void md::ThreadedDispatcher::remove_thread()
++{
++    auto terminated_thread_id = thread_exiter->terminate_one_thread();
++
++    // Find that thread in our vector, join() it, then remove it.
++    std::lock_guard<decltype(thread_pool_mutex)> threadpool_lock{thread_pool_mutex};
++
++    auto dying_thread = std::find_if(threadpool.begin(),
++                                     threadpool.end(),
++                                     [this, &terminated_thread_id](std::thread const& candidate)
++    {
++            return candidate.get_id() == terminated_thread_id;
++    });
++    dying_thread->join();
++    threadpool.erase(dying_thread);
++}
++
++void md::ThreadedDispatcher::dispatch_loop(std::string const& name,
++                                           std::shared_ptr<ThreadShutdownRequestHandler> thread_register,
++                                           std::shared_ptr<Dispatchable> dispatcher,
++                                           std::function<void()> const& exception_handler)
++{
++    sigset_t all_signals;
++    sigfillset(&all_signals);
++
++    if (auto error = pthread_sigmask(SIG_BLOCK, &all_signals, NULL))
++        BOOST_THROW_EXCEPTION((std::system_error{error,
++                                                 std::system_category(),
++                                                 "Failed to block signals on IO thread"}));
++
++    mir::set_thread_name(name);
++
++    // This does not have to be std::atomic<bool> because thread_register is guaranteed to
++    // only ever be dispatch()ed from one thread at a time.
++    bool running{true};
++
++    auto thread_registrar = mir::raii::paired_calls(
++    [&running, thread_register]()
++    {
++        thread_register->register_thread(running);
++    },
++    [thread_register]()
++    {
++        thread_register->unregister_thread();
++    });
++
++    try
++    {
++        struct pollfd waiter;
++        waiter.fd = dispatcher->watch_fd();
++        waiter.events = POLL_IN;
++        while (running)
++        {
++            if (poll(&waiter, 1, -1) < 0)
++            {
++                BOOST_THROW_EXCEPTION((std::system_error{errno,
++                                                         std::system_category(),
++                                                         "Failed to wait for event"}));
++            }
++            dispatcher->dispatch(md::FdEvent::readable);
++        }
++    }
++    catch(...)
++    {
++        exception_handler();
++    }
++}
 === modified file 'src/include/client/mir/mir_render_surface.h'
 --- src/include/client/mir/mir_render_surface.h	2017-03-10 19:47:57 +0000
 +++ src/include/client/mir/mir_render_surface.h	2017-03-28 00:17:49 +0000
@@ -32,10 +32,13 @@
      virtual mir::geometry::Size size() const = 0;
      virtual void set_size(mir::geometry::Size) = 0;
      virtual bool valid() const = 0;
--    virtual MirBufferStream* get_buffer_stream(
--        int width, int height,
++    virtual void get_buffer_stream(
++        int width,
++        int height,
          MirPixelFormat format,
--        MirBufferUsage buffer_usage) = 0;
++        MirBufferUsage buffer_usage,
++        mir_buffer_stream_callback callback,
++        void* context) = 0;
      virtual MirPresentationChain* get_presentation_chain() = 0;
      virtual char const* get_error_message() const = 0;
      virtual ~MirRenderSurface() = default;
 === modified file 'src/server/scene/mediating_display_changer.cpp'
 --- src/server/scene/mediating_display_changer.cpp	2017-03-13 08:12:52 +0000
 +++ src/server/scene/mediating_display_changer.cpp	2017-03-28 00:17:49 +0000
@@ -336,7 +336,7 @@
           */
          previously_set_alarm = std::move(preview_configuration_timeout);
          preview_configuration_timeout = nullptr;
--        currently_previewing_session = std::weak_ptr<frontend::Session>{};
++        currently_previewing_session = std::weak_ptr<frontend::Session>{}   ;
+     }
      if (previously_set_alarm->cancel())
 === modified file 'tests/acceptance-tests/CMakeLists.txt'
 --- tests/acceptance-tests/CMakeLists.txt	2017-03-15 09:30:18 +0000
 +++ tests/acceptance-tests/CMakeLists.txt	2017-03-28 00:17:49 +0000
@@ -1,5 +1,13 @@
  include(CMakeDependentOption)
++<<<<<<< TREE
++=======
++include_directories(
++  ${CMAKE_SOURCE_DIR}
++  ${UMOCKDEV_INCLUDE_DIRS}
++)
++
++>>>>>>> MERGE-SOURCE
  set(
    SOURCES
 === modified file 'tests/acceptance-tests/test_client_library.cpp'
 --- tests/acceptance-tests/test_client_library.cpp	2017-03-10 19:47:57 +0000
 +++ tests/acceptance-tests/test_client_library.cpp	2017-03-28 00:17:49 +0000
@@ -20,9 +20,19 @@
  #include "mir_test_framework/headless_in_process_server.h"
  #include "mir_test_framework/stub_platform_helpers.h"
++<<<<<<< TREE
++=======
++#include "mir_test_framework/using_stub_client_platform.h"
++#include "mir_test_framework/fake_input_device.h"
++#include "mir_test_framework/stub_server_platform_factory.h"
++>>>>>>> MERGE-SOURCE
  #include "mir_test_framework/any_surface.h"
++#include "mir/test/fd_utils.h"
++#include "mir/test/signal.h"
  #include "mir/test/validity_matchers.h"
++#include "mir/test/signal.h"
  #include "src/include/common/mir/protobuf/protocol_version.h"
++#include "mir/test/signal.h"
  #include "mir_protobuf.pb.h"
@@ -38,10 +48,16 @@
  #include <fcntl.h>
  #include <errno.h>
++#include <mir/input/input_device_info.h>
++#include <mir/input/device_capability.h>
  namespace mf = mir::frontend;
  namespace mc = mir::compositor;
  namespace mtf = mir_test_framework;
++namespace mt = mir::test;
++namespace mi = mir::input;
++namespace mis = mir::input::synthesis;
++
  namespace
+ {
  #pragma GCC diagnostic push
@@ -1120,8 +1136,371 @@
      mir_connection_release(connection);
+ }
++<<<<<<< TREE
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
++=======
++namespace
++{
++struct ThreadTrackingCallbacks
++{
++    ThreadTrackingCallbacks()
++        : client_thread{pthread_self()}
++    {
++    }
++
++    static void connection_ready(MirConnection* /*connection*/, void* ctx)
++    {
++        auto data = reinterpret_cast<ThreadTrackingCallbacks*>(ctx);
++        EXPECT_EQ(pthread_self(), data->client_thread);
++        data->connection_ready_called.raise();
++    }
++
++    static void event_delegate(MirSurface* /*surf*/, MirEvent const* event, void* ctx)
++    {
++        auto data = reinterpret_cast<ThreadTrackingCallbacks*>(ctx);
++
++        EXPECT_THAT(pthread_self(), Eq(data->client_thread));
++        data->event_received.raise();
++        if (mir_event_get_type(event) == mir_event_type_input)
++        {
++            data->input_event_received.raise();
++        }
++    }
++
++    static void surface_created(MirSurface* surf, void* ctx)
++    {
++        auto data = reinterpret_cast<ThreadTrackingCallbacks*>(ctx);
++        EXPECT_THAT(pthread_self(), Eq(data->client_thread));
++        data->surf = surf;
++
++        mir_surface_set_event_handler(data->surf, &ThreadTrackingCallbacks::event_delegate, data);
++    }
++
++    static void swap_buffers_complete(MirBufferStream* /*stream*/, void* ctx)
++    {
++        auto data = reinterpret_cast<ThreadTrackingCallbacks*>(ctx);
++        EXPECT_EQ(pthread_self(), data->client_thread);
++        data->buffers_swapped.raise();
++    }
++
++    pthread_t const client_thread;
++    MirSurface* surf{nullptr};
++    mt::Signal buffers_swapped;
++    mt::Signal connection_ready_called;
++    mt::Signal event_received;
++    mt::Signal input_event_received;
++};
++
++void pump_eventloop_until(MirConnection* connection, std::function<bool()> predicate, std::chrono::steady_clock::time_point timeout)
++{
++    using namespace std::literals::chrono_literals;
++
++    auto fd = mir::Fd{mir::IntOwnedFd{mir_connection_get_event_fd(connection)}};
++
++    while (!predicate() && (std::chrono::steady_clock::now() < timeout))
++    {
++        if (mt::fd_becomes_readable(fd, 10ms))
++        {
++            mir_connection_dispatch(connection);
++        }
++    }
++    if (!predicate())
++    {
++        BOOST_THROW_EXCEPTION((std::runtime_error{"Timeout waiting for state change"}));
++    }
++}
++}
++
++TEST_F(ClientLibrary, manual_dispatch_handles_callbacks_in_parent_thread)
++{
++    using namespace std::literals::chrono_literals;
++
++    auto const test_timeout = std::chrono::steady_clock::now() + 10min;
++
++    ThreadTrackingCallbacks data;
++
++    auto connection = mir_connect_with_manual_dispatch(new_connection().c_str(), __PRETTY_FUNCTION__, &ThreadTrackingCallbacks::connection_ready, &data);
++
++    ASSERT_THAT(connection, Ne(nullptr));
++
++    pump_eventloop_until(
++        connection,
++        [&data]()
++        {
++            return data.connection_ready_called.raised();
++        },
++        test_timeout);
++
++    ASSERT_THAT(connection, IsValid());
++
++    auto surface_spec = mir_connection_create_spec_for_normal_surface(connection,
++                                                                      233, 355,
++                                                                      mir_pixel_format_argb_8888);
++    auto surf_wh = mir_surface_create(surface_spec,
++                                      &ThreadTrackingCallbacks::surface_created,
++                                      &data);
++    mir_surface_spec_release(surface_spec);
++
++    pump_eventloop_until(
++        connection,
++        [surf_wh]()
++        {
++            return mir_wait_handle_ready(surf_wh);
++        },
++        test_timeout);
++
++    EXPECT_THAT(data.surf, IsValid());
++
++    auto buffer_stream = mir_surface_get_buffer_stream(data.surf);
++    auto swap_wh = mir_buffer_stream_swap_buffers(buffer_stream, ThreadTrackingCallbacks::swap_buffers_complete, &data);
++
++    pump_eventloop_until(
++        connection,
++        [swap_wh]()
++        {
++            return mir_wait_handle_ready(swap_wh);
++        },
++        test_timeout);
++    EXPECT_TRUE(data.buffers_swapped.raised());
++
++    mir_surface_release_sync(data.surf);
++    mir_connection_release(connection);
++}
++
++TEST_F(ClientLibrary, manual_dispatch_handles_events_in_parent_thread)
++{
++    using namespace testing;
++    using namespace std::literals::chrono_literals;
++
++    auto const test_timeout = std::chrono::steady_clock::now() + 10min;
++
++    auto fake_keyboard = mtf::add_fake_input_device(
++        mi::InputDeviceInfo{"keyboard", "keyboard-unique-id", mi::DeviceCapability::keyboard});
++
++    ThreadTrackingCallbacks data;
++
++    connection = mir_connect_with_manual_dispatch(new_connection().c_str(), __PRETTY_FUNCTION__, &ThreadTrackingCallbacks::connection_ready, &data);
++
++    ASSERT_THAT(connection, Ne(nullptr));
++
++    pump_eventloop_until(
++        connection,
++        [&data]()
++        {
++            return data.connection_ready_called.raised();
++        },
++        test_timeout);
++
++    ASSERT_THAT(connection, IsValid());
++
++    auto surface_spec = mir_connection_create_spec_for_normal_surface(connection,
++                                                                      233, 355,
++                                                                      mir_pixel_format_argb_8888);
++    auto surf_wh = mir_surface_create(surface_spec,
++                                      &ThreadTrackingCallbacks::surface_created,
++                                      &data);
++    mir_surface_spec_release(surface_spec);
++
++
++    pump_eventloop_until(
++        connection,
++        [surf_wh]()
++        {
++            return mir_wait_handle_ready(surf_wh);
++        },
++        test_timeout);
++
++    EXPECT_THAT(data.surf, IsValid());
++
++    // We need to swap buffers so that the surface is fully realised and
++    // will be a valid focus target.
++    //
++    // The shell will not focus a surface with no content.
++    auto buffer_stream = mir_surface_get_buffer_stream(data.surf);
++    mir_buffer_stream_swap_buffers_sync(buffer_stream);
++
++    pump_eventloop_until(
++        connection,
++        [&data]()
++        {
++            return mir_surface_get_focus(data.surf) == mir_surface_focused;
++        },
++        test_timeout);
++
++    ASSERT_THAT(mir_surface_get_focus(data.surf), Eq(mir_surface_focused));
++
++    fake_keyboard->emit_event(mis::a_key_down_event());
++
++    pump_eventloop_until(
++        connection,
++        [&data]()
++        {
++            return data.input_event_received.raised();
++        },
++        test_timeout);
++
++    mir_surface_release_sync(data.surf);
++    mir_connection_release(connection);
++}
++
++namespace
++{
++struct SignalData
++{
++    mir::test::Signal focus_received;
++    mir::test::Signal now_blocking;
++    mir::test::Signal event_received;
++    mir::test::Signal buffer_stream_destroyed;
++};
++
++void notifying_event_handler(MirSurface*, MirEvent const* ev, void* ctx)
++{
++    auto signals = *reinterpret_cast<std::shared_ptr<SignalData>*>(ctx);
++    // We trigger an input event once we've noticed the surface callback is blocking
++    // so we need to only raise the flag on an input event; otherwise we may spuriously
++    // fail if we receive a surface event (like the focus event) before we hit
++    // the wait in blocking_surface_callback()
++    if (mir_event_get_type(ev) == mir_event_type_input)
++    {
++        signals->event_received.raise();
++    }
++    if (mir_event_get_type(ev) == mir_event_type_surface)
++    {
++        auto surface_event = mir_event_get_surface_event(ev);
++        if (mir_surface_event_get_attribute(surface_event) == mir_surface_attrib_focus &&
++            mir_surface_event_get_attribute_value(surface_event) == mir_surface_focused)
++        {
++            signals->focus_received.raise();
++        }
++    }
++}
++
++void notify_buffer_stream_destroyed(MirBufferStream*, void* ctx)
++{
++    auto& signal = *reinterpret_cast<mt::Signal*>(ctx);
++    signal.raise();
++}
++
++void blocking_buffer_stream_callback(MirBufferStream* stream, void* ctx)
++{
++    auto signals = *reinterpret_cast<std::shared_ptr<SignalData>*>(ctx);
++    signals->now_blocking.raise();
++    EXPECT_TRUE(signals->event_received.wait_for(std::chrono::seconds{5}));
++    mir_buffer_stream_release(stream, &notify_buffer_stream_destroyed, &signals->buffer_stream_destroyed);
++}
++}
++
++TEST_F(ClientLibrary, rpc_blocking_doesnt_block_event_delivery_with_auto_dispatch)
++{
++    using namespace testing;
++
++    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
++
++    auto fake_keyboard = mtf::add_fake_input_device(
++        mi::InputDeviceInfo{"keyboard", "keyboard-unique-id", mi::DeviceCapability::keyboard});
++
++
++    ASSERT_THAT(connection, IsValid());
++    auto signals = std::make_shared<SignalData>();
++
++    auto surface_spec = mir_connection_create_spec_for_normal_surface(connection,
++                                                                      233, 355,
++                                                                      mir_pixel_format_argb_8888);
++    mir_surface_spec_set_event_handler(surface_spec, &notifying_event_handler, &signals);
++
++    auto surf = mir_surface_create_sync(surface_spec);
++    mir_surface_spec_release(surface_spec);
++
++    ASSERT_THAT(surf, IsValid());
++
++    auto buffer_stream = mir_surface_get_buffer_stream(surf);
++
++    // Ensure that the surface is focused.
++    mir_buffer_stream_swap_buffers_sync(buffer_stream);
++    ASSERT_TRUE(signals->focus_received.wait_for(std::chrono::seconds{5}));
++
++    auto wh = mir_connection_create_buffer_stream(
++        connection,
++        800, 600,
++        mir_pixel_format_abgr_8888,
++        mir_buffer_usage_software,
++        &blocking_buffer_stream_callback, &signals);
++
++    EXPECT_TRUE(signals->now_blocking.wait_for(std::chrono::seconds{5}));
++    EXPECT_FALSE(signals->event_received.raised());
++
++    fake_keyboard->emit_event(mis::a_key_down_event());
++
++    EXPECT_TRUE(signals->event_received.wait_for(std::chrono::seconds{5}));
++    EXPECT_TRUE(signals->buffer_stream_destroyed.wait_for(std::chrono::seconds{5}));
++
++    mir_wait_for(wh);
++    mir_surface_release_sync(surf);
++    mir_connection_release(connection);
++}
++
++namespace
++{
++void async_release_completed(MirSurface*, void* ctx)
++{
++    auto called = reinterpret_cast<bool*>(ctx);
++    *called = true;
++}
++
++void async_creation_completed(MirSurface* surf, void* ctx)
++{
++    mir_surface_release(surf, &async_release_completed, ctx);
++}
++}
++
++TEST_F(ClientLibrary, sync_call_completes_before_previous_undispatched_call)
++{
++    using namespace std::literals::chrono_literals;
++    using namespace testing;
++
++    auto timeout = std::chrono::steady_clock::now() + 60s;
++
++    ThreadTrackingCallbacks data;
++
++    auto connection = mir_connect_with_manual_dispatch(new_connection().c_str(), __PRETTY_FUNCTION__, &ThreadTrackingCallbacks::connection_ready, &data);
++    ASSERT_THAT(connection, Ne(nullptr));
++
++    pump_eventloop_until(connection, [connection]() { return mir_connection_is_valid(connection); }, timeout);
++
++    bool async_call_completed{false};
++
++    auto surface_spec = mir_connection_create_spec_for_normal_surface(connection,
++                                                                      233, 355,
++                                                                      mir_pixel_format_argb_8888);
++    mir_surface_create(surface_spec, &async_creation_completed, &async_call_completed);
++
++    EXPECT_FALSE(async_call_completed);
++    auto surf = mir_surface_create_sync(surface_spec);
++    mir_surface_spec_release(surface_spec);
++
++    EXPECT_THAT(surf, IsValid());
++    EXPECT_FALSE(async_call_completed);
++
++    mir_surface_release_sync(surf);
++    EXPECT_FALSE(async_call_completed);
++
++    pump_eventloop_until(connection, [&async_call_completed]() { return async_call_completed;}, timeout);
++
++}
++
++TEST_F(ClientLibrary, can_connect_synchronously_with_manual_dispatch)
++{
++    using namespace testing;
++
++    auto connection = mir_connect_with_manual_dispatch_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
++
++    EXPECT_THAT(connection, IsValid());
++
++    mir_connection_release(connection);
++}
++
++>>>>>>> MERGE-SOURCE
  TEST_F(ClientLibrary, can_get_persistent_surface_id)
+ {
      auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
@@ -1225,6 +1604,7 @@
      mir_buffer_stream_release_sync(stream);
      mir_connection_release(connection);
+ }
++<<<<<<< TREE
  TEST_F(ClientLibrary, client_api_version)
+ {
@@ -1232,3 +1612,117 @@
                                      MIR_CLIENT_API_VERSION_MINOR,
                                      MIR_CLIENT_API_VERSION_PATCH) == mir_get_client_api_version());
+ }
++=======
++
++TEST_F(ClientLibrary, synchronously_creating_buffer_stream_results_in_valid_buffer_stream)
++{
++    using namespace testing;
++
++    auto connection = mir_connect_with_manual_dispatch_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
++
++    ASSERT_THAT(connection, IsValid());
++
++    int const width{640}, height{480};
++    auto stream = mir_connection_create_buffer_stream_sync(
++        connection,
++        width, height,
++        mir_pixel_format_abgr_8888,
++        mir_buffer_usage_software);
++
++    EXPECT_THAT(stream, IsValid());
++
++    MirGraphicsRegion region;
++    mir_buffer_stream_get_graphics_region(stream, &region);
++
++    EXPECT_THAT(region.vaddr, NotNull());
++    EXPECT_THAT(region.width, Eq(width));
++    EXPECT_THAT(region.height, Eq(height));
++    EXPECT_THAT(region.stride, Ge(width));
++    EXPECT_THAT(region.pixel_format, Eq(mir_pixel_format_abgr_8888));
++
++    mir_buffer_stream_release_sync(stream);
++    mir_connection_release(connection);
++}
++
++TEST_F(ClientLibrary, default_surface_stream_is_valid_in_created_callback)
++{
++    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
++    ASSERT_TRUE(mir_connection_is_valid(connection));
++
++    auto surface_spec = mir_connection_create_spec_for_normal_surface(
++        connection,
++        800, 600,
++        mir_pixel_format_argb_8888);
++
++    mt::Signal done;
++
++    mir_surface_create(
++        surface_spec,
++        [](MirSurface* surf, void* ctx)
++        {
++            auto stream = mir_surface_get_buffer_stream(surf);
++            EXPECT_THAT(stream, NotNull());
++            EXPECT_TRUE(mir_buffer_stream_is_valid(stream));
++
++            MirNativeBuffer* package;
++            mir_buffer_stream_get_current_buffer(stream, &package);
++
++            EXPECT_THAT(package, NotNull());
++
++            mir_surface_release(
++                surf,
++                [](MirSurface*, void* ctx)
++                {
++                    auto done = reinterpret_cast<mt::Signal*>(ctx);
++
++                    done->raise();
++                },
++                ctx);
++        },
++        &done);
++    mir_surface_spec_release(surface_spec);
++
++    // ASSERT_TRUE rather than EXPECT_TRUE so that the test dies on client deadlock.
++    ASSERT_TRUE(done.wait_for(std::chrono::seconds{20}));
++
++    mir_connection_release(connection);
++}
++
++TEST_F(ClientLibrary, buffer_stream_is_valid_in_created_callback)
++{
++    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
++    ASSERT_TRUE(mir_connection_is_valid(connection));
++
++    mt::Signal done;
++
++    mir_connection_create_buffer_stream(
++        connection,
++        800, 600,
++        mir_pixel_format_argb_8888,
++        mir_buffer_usage_software,
++        [](MirBufferStream* stream, void* ctx)
++        {
++            EXPECT_THAT(stream, IsValid());
++
++            MirNativeBuffer* package;
++            mir_buffer_stream_get_current_buffer(stream, &package);
++
++            EXPECT_THAT(package, NotNull());
++
++            mir_buffer_stream_release(
++                stream,
++                [](MirBufferStream*, void* ctx)
++                {
++                    auto done = reinterpret_cast<mt::Signal*>(ctx);
++
++                    done->raise();
++                },
++                ctx);
++        },
++        &done);
++
++    ASSERT_TRUE(done.wait_for(std::chrono::seconds{20}));
++
++    mir_connection_release(connection);
++}
++>>>>>>> MERGE-SOURCE
 === modified file 'tests/acceptance-tests/test_client_surfaces.cpp'
 --- tests/acceptance-tests/test_client_surfaces.cpp	2017-03-14 04:41:33 +0000
 +++ tests/acceptance-tests/test_client_surfaces.cpp	2017-03-28 00:17:49 +0000
@@ -28,6 +28,7 @@
  #include "mir_test_framework/any_surface.h"
  #include "mir/test/validity_matchers.h"
  #include "mir/test/fake_shared.h"
++#include "mir/test/signal.h"
  #include <gmock/gmock.h>
  #include <gtest/gtest.h>
@@ -391,4 +392,43 @@
      mir_connection_release(im_connection);
+ }
++<<<<<<< TREE
  #pragma GCC diagnostic pop
++=======
++
++TEST_F(ClientSurfaces, default_buffer_stream_is_fully_constructed_in_surface_created_callback)
++{
++    using namespace testing;
++    using namespace std::chrono_literals;
++
++    auto surface_spec = mir_connection_create_spec_for_normal_surface(
++        connection,
++        800, 600,
++        mir_pixel_format_argb_8888);
++
++    mt::Signal surface_released;
++    mir_surface_create(
++        surface_spec,
++        [](MirSurface* surf, void* ctx)
++        {
++            EXPECT_THAT(surf, IsValid());
++            auto buffer_stream = mir_surface_get_buffer_stream(surf);
++            MirGraphicsRegion region;
++            mir_buffer_stream_get_graphics_region(buffer_stream, &region);
++            EXPECT_THAT(region.vaddr, NotNull());
++
++            mir_surface_release(
++                surf,
++                [](MirSurface*, void* ctx)
++                {
++                    auto& done = *reinterpret_cast<mt::Signal*>(ctx);
++                    done.raise();
++                },
++                ctx);
++        },
++        &surface_released);
++    mir_surface_spec_release(surface_spec);
++
++    EXPECT_TRUE(surface_released.wait_for(10s));
++}
++>>>>>>> MERGE-SOURCE
 === modified file 'tests/acceptance-tests/test_render_surface.cpp'
 --- tests/acceptance-tests/test_render_surface.cpp	2017-03-10 19:47:57 +0000
 +++ tests/acceptance-tests/test_render_surface.cpp	2017-03-28 00:17:49 +0000
@@ -23,11 +23,14 @@
  #include "mir/geometry/size.h"
  #include "mir_test_framework/headless_in_process_server.h"
  #include "mir/test/validity_matchers.h"
++#include "mir/test/signal.h"
  #include <gtest/gtest.h>
  #include <gmock/gmock.h>
++#include "mir/test/signal.h"
  namespace mtf = mir_test_framework;
++namespace mt = mir::test;
  namespace geom = mir::geometry;
  namespace
@@ -54,7 +57,7 @@
      EXPECT_TRUE(mir_render_surface_is_valid(rs));
      EXPECT_THAT(mir_render_surface_get_error_message(rs), StrEq(""));
--    mir_render_surface_release(rs);
++    mir_render_surface_release_sync(rs);
      mir_connection_release(connection);
+ }
@@ -73,9 +76,13 @@
          return {width, height};
      };
      auto physical_size = determine_physical_size(rs);
--    auto bs = mir_render_surface_get_buffer_stream(
++
++    mt::Signal done;
++
++    mir_render_surface_get_buffer_stream(
          rs,
          physical_size.width.as_int(), physical_size.height.as_int(),
++<<<<<<< TREE
          mir_pixel_format_abgr_8888);
      ASSERT_THAT(bs, NotNull());
@@ -83,6 +90,22 @@
      EXPECT_THAT(mir_buffer_stream_get_error_message(bs), StrEq(""));
      mir_render_surface_release(rs);
++=======
++        mir_pixel_format_abgr_8888,
++        mir_buffer_usage_hardware,
++        [](MirBufferStream* bs, void* ctx)
++        {
++            ASSERT_THAT(bs, NotNull());
++            EXPECT_THAT(bs, IsValid());
++
++            reinterpret_cast<mt::Signal*>(ctx)->raise();
++        },
++        &done);
++
++    ASSERT_TRUE(done.wait_for(std::chrono::seconds{20}));
++
++    mir_render_surface_release_sync(rs);
++>>>>>>> MERGE-SOURCE
      mir_connection_release(connection);
+ }
@@ -94,23 +117,21 @@
      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(
++    auto bs = mir_render_surface_get_buffer_stream_sync(
          rs,
          physical_size.width.as_int(), physical_size.height.as_int(),
          mir_pixel_format_abgr_8888);
--    ASSERT_THAT(bs, NotNull());
--    EXPECT_TRUE(mir_buffer_stream_is_valid(bs));
--    EXPECT_THAT(mir_buffer_stream_get_error_message(bs), StrEq(""));
++    EXPECT_THAT(bs, IsValid());
--    auto bs2 = mir_render_surface_get_buffer_stream(
++    auto bs2 = mir_render_surface_get_buffer_stream_sync(
          rs,
          physical_size.width.as_int(), physical_size.height.as_int(),
          mir_pixel_format_abgr_8888);
      EXPECT_THAT(bs2, Eq(nullptr));
--    mir_render_surface_release(rs);
++    mir_render_surface_release_sync(rs);
      mir_connection_release(connection);
+ }
@@ -121,9 +142,13 @@
      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(
++
++    mt::Signal done;
++
++    mir_render_surface_get_buffer_stream(
          rs,
          physical_size.width.as_int(), physical_size.height.as_int(),
++<<<<<<< TREE
          mir_pixel_format_abgr_8888);
      ASSERT_THAT(bs, NotNull());
@@ -131,6 +156,22 @@
      EXPECT_THAT(mir_buffer_stream_get_error_message(bs), StrEq(""));
      mir_render_surface_release(rs);
++=======
++        mir_pixel_format_abgr_8888,
++        mir_buffer_usage_hardware,
++        [](MirBufferStream* bs, void* ctx)
++        {
++            ASSERT_THAT(bs, NotNull());
++            EXPECT_THAT(bs, IsValid());
++
++            reinterpret_cast<mt::Signal*>(ctx)->raise();
++        },
++        &done);
++
++    ASSERT_TRUE(done.wait_for(std::chrono::seconds{20}));
++
++    mir_render_surface_release_sync(rs);
++>>>>>>> MERGE-SOURCE
      mir_connection_release(connection);
+ }
@@ -152,8 +193,13 @@
      EXPECT_THAT(window, IsValid());
      EXPECT_THAT(mir_window_get_buffer_stream(window), Eq(nullptr));
++<<<<<<< TREE
      mir_render_surface_release(rs);
      mir_window_release_sync(window);
++=======
++    mir_render_surface_release_sync(rs);
++    mir_surface_release_sync(surface);
++>>>>>>> MERGE-SOURCE
      mir_connection_release(connection);
+ }
@@ -166,19 +212,55 @@
      auto rs = mir_connection_create_render_surface_sync(
          connection, logical_size.width.as_int(), logical_size.height.as_int());
++<<<<<<< TREE
      auto spec = mir_create_normal_window_spec(connection, width, height);
      mir_window_spec_set_pixel_format(spec, format);
      mir_window_spec_add_render_surface(spec, rs, width, height, 0, 0);
      auto window = mir_create_window_sync(spec);
      mir_window_spec_release(spec);
      auto bs = mir_render_surface_get_buffer_stream(rs, 640, 480, format);
--
++=======
++    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);
++    mt::Signal done;
++
++    mir_render_surface_get_buffer_stream(
++        rs,
++        640, 480,
++        format,
++        usage,
++        [](MirBufferStream* bs, void* ctx)
++        {
++            ASSERT_THAT(bs, NotNull());
++            EXPECT_THAT(bs, IsValid());
++
++            reinterpret_cast<mt::Signal*>(ctx)->raise();
++        },
++        &done);
++
++>>>>>>> MERGE-SOURCE
++
++<<<<<<< TREE
      EXPECT_THAT(window, IsValid());
      EXPECT_THAT(mir_window_get_buffer_stream(window), Eq(nullptr));
      EXPECT_TRUE(mir_buffer_stream_is_valid(bs));
      mir_render_surface_release(rs);
      mir_window_release_sync(window);
++=======
++    EXPECT_THAT(surface, IsValid());
++
++    EXPECT_THAT(mir_surface_get_buffer_stream(surface), Eq(nullptr));
++
++    ASSERT_TRUE(done.wait_for(std::chrono::seconds{20}));
++
++    mir_render_surface_release_sync(rs);
++    mir_surface_release_sync(surface);
++>>>>>>> MERGE-SOURCE
      mir_connection_release(connection);
+ }
@@ -194,7 +276,7 @@
      ASSERT_THAT(pc, NotNull());
      EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
--    mir_render_surface_release(rs);
++    mir_render_surface_release_sync(rs);
      mir_connection_release(connection);
+ }
@@ -214,7 +296,7 @@
      EXPECT_THAT(pc2, Eq(nullptr));
--    mir_render_surface_release(rs);
++    mir_render_surface_release_sync(rs);
      mir_connection_release(connection);
+ }
@@ -238,8 +320,13 @@
      EXPECT_THAT(mir_window_get_buffer_stream(window), Eq(nullptr));
      EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
++<<<<<<< TREE
      mir_render_surface_release(rs);
      mir_window_release_sync(window);
++=======
++    mir_render_surface_release_sync(rs);
++    mir_surface_release_sync(surface);
++>>>>>>> MERGE-SOURCE
      mir_connection_release(connection);
+ }
@@ -254,7 +341,7 @@
      ASSERT_THAT(pc, NotNull());
      EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
--    mir_render_surface_release(rs);
++    mir_render_surface_release_sync(rs);
      mir_connection_release(connection);
+ }
@@ -270,14 +357,14 @@
      ASSERT_THAT(pc, NotNull());
      EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
--    auto bs = mir_render_surface_get_buffer_stream(
++    auto bs = mir_render_surface_get_buffer_stream_sync(
          rs,
          physical_size.width.as_int(), physical_size.height.as_int(),
          mir_pixel_format_abgr_8888);
      EXPECT_THAT(bs, Eq(nullptr));
--    mir_render_surface_release(rs);
++    mir_render_surface_release_sync(rs);
      mir_connection_release(connection);
+ }
@@ -288,20 +375,148 @@
      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(
++    auto bs = mir_render_surface_get_buffer_stream_sync(
          rs,
          physical_size.width.as_int(), physical_size.height.as_int(),
          mir_pixel_format_abgr_8888);
--    ASSERT_THAT(bs, NotNull());
--    EXPECT_TRUE(mir_buffer_stream_is_valid(bs));
++    EXPECT_THAT(bs, IsValid());
      auto pc = mir_render_surface_get_presentation_chain(rs);
      EXPECT_THAT(pc, Eq(nullptr));
--    mir_render_surface_release(rs);
--    mir_connection_release(connection);
++    mir_render_surface_release_sync(rs);
++    mir_connection_release(connection);
++}
++
++TEST_F(RenderSurfaceTest, asynchronous_render_surface_destruction_works_with_realised_buffer_stream)
++{
++    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());
++    mir_render_surface_get_buffer_stream_sync(
++        rs,
++        physical_size.width.as_int(), physical_size.height.as_int(),
++        mir_pixel_format_abgr_8888,
++        mir_buffer_usage_hardware);
++
++    struct Context
++    {
++        MirRenderSurface* rs;
++        mt::Signal done;
++    } context;
++
++    context.rs = rs;
++
++    mir_render_surface_release(
++        rs,
++        [](MirRenderSurface* rs, void* ctx)
++        {
++            auto& context = *reinterpret_cast<Context*>(ctx);
++            EXPECT_THAT(rs, Eq(context.rs));
++            /*
++             * Should really test that the render surface isn't valid here, but that fails.
++             *
++            EXPECT_THAT(rs, Not(IsValid()));
++             */
++            context.done.raise();
++        },
++        &context);
++
++    ASSERT_TRUE(context.done.wait_for(std::chrono::seconds{20}));
++
++    mir_connection_release(connection);
++}
++
++TEST_F(RenderSurfaceTest, asynchronous_render_surface_destruction_works_with_realised_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());
++    mir_render_surface_get_presentation_chain(rs);
++
++    struct Context
++    {
++        MirRenderSurface* rs;
++        mt::Signal done;
++    } context;
++
++    context.rs = rs;
++
++    mir_render_surface_release(
++        rs,
++        [](MirRenderSurface* rs, void* ctx)
++        {
++            auto& context = *reinterpret_cast<Context*>(ctx);
++            EXPECT_THAT(rs, Eq(context.rs));
++            /*
++             * Should really test that the render surface isn't valid here, but that fails.
++             *
++            EXPECT_THAT(rs, Not(IsValid()));
++             */
++            context.done.raise();
++        },
++        &context);
++
++    ASSERT_TRUE(context.done.wait_for(std::chrono::seconds{20}));
++
++    mir_connection_release(connection);
++}
++
++TEST_F(RenderSurfaceTest, asynchronous_render_surface_destruction_works_with_no_backing_object)
++{
++    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());
++
++    struct Context
++    {
++        MirRenderSurface* rs;
++        mt::Signal done;
++    } context;
++
++    context.rs = rs;
++
++    mir_render_surface_release(
++        rs,
++        [](MirRenderSurface* rs, void* ctx)
++        {
++            auto& context = *reinterpret_cast<Context*>(ctx);
++            EXPECT_THAT(rs, Eq(context.rs));
++            /*
++             * Should really test that the render surface isn't valid here, but that fails.
++             *
++            EXPECT_THAT(rs, Not(IsValid()));
++             */
++            context.done.raise();
++        },
++        &context);
++
++    ASSERT_TRUE(context.done.wait_for(std::chrono::seconds{20}));
++
++    mir_connection_release(connection);
++}
++
++TEST_F(RenderSurfaceTest, asynchronous_destruction_calls_callback_on_failure)
++{
++    auto not_a_valid_client_side_rs = reinterpret_cast<MirRenderSurface*>(0x0ff01bb1);
++
++    mt::Signal callback_called;
++
++    mir_render_surface_release(
++        not_a_valid_client_side_rs,
++        [](MirRenderSurface*, void* ctx)
++        {
++            reinterpret_cast<mt::Signal*>(ctx)->raise();
++        },
++        &callback_called);
++
++    EXPECT_TRUE(callback_called.wait_for(std::chrono::seconds{20}));
+ }
  TEST_F(RenderSurfaceTest, stores_user_set_size_for_driver_to_access)
 === modified file 'tests/acceptance-tests/test_server_shutdown.cpp'
 --- tests/acceptance-tests/test_server_shutdown.cpp	2017-03-09 12:52:48 +0000
 +++ tests/acceptance-tests/test_server_shutdown.cpp	2017-03-28 00:17:49 +0000
@@ -25,7 +25,7 @@
  #include "mir_test_framework/executable_path.h"
  #include "mir/test/doubles/null_logger.h"
--#include <gtest/gtest.h>
++#include </usr/include/gtest/gtest.h>
  namespace mt = mir::test;
  namespace mtf = mir_test_framework;
 === added file 'tests/include/mir/test/doubles/mock_client_buffer_stream_factory.h.THIS'
 --- tests/include/mir/test/doubles/mock_client_buffer_stream_factory.h.THIS	1970-01-01 00:00:00 +0000
 +++ tests/include/mir/test/doubles/mock_client_buffer_stream_factory.h.THIS	2017-03-28 00:17:49 +0000
@@ -0,0 +1,59 @@
++/*
++ * Copyright © 2015 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Robert Carr <robert.carr@canonical.com>
++ */
++
++#ifndef MIR_TEST_DOUBLES_MOCK_CLIENT_BUFFER_STREAM_FACTORY_H_
++#define MIR_TEST_DOUBLES_MOCK_CLIENT_BUFFER_STREAM_FACTORY_H_
++
++#include "src/client/client_buffer_stream_factory.h"
++#include "src/client/buffer_stream.h"
++
++#include <gtest/gtest.h>
++#include <gmock/gmock.h>
++
++namespace mir
++{
++namespace test
++{
++namespace doubles
++{
++
++struct MockClientBufferStreamFactory : public client::ClientBufferStreamFactory
++{
++    MOCK_METHOD4(make_consumer_stream, std::shared_ptr<client::ClientBufferStream>(
++        MirConnection*,
++        protobuf::DisplayServer&,
++        protobuf::BufferStream const&,
++        std::string const&));
++    MOCK_METHOD4(make_producer_stream, std::shared_ptr<client::ClientBufferStream>(
++        MirConnection*,
++        protobuf::DisplayServer&,
++        protobuf::BufferStream const&,
++        std::string const&));
++    MOCK_METHOD5(make_producer_stream, client::ClientBufferStream*(
++        MirConnection*,
++        protobuf::DisplayServer&,
++        protobuf::BufferStreamParameters const&,
++        mir_buffer_stream_callback callback,
++        void* context));
++};
++
++}
++}
++}
++
++#endif // MIR_TEST_DOUBLES_MOCK_CLIENT_BUFFER_STREAM_FACTORY_H_
 === modified file 'tests/include/mir/test/doubles/mock_mir_buffer_stream.h'
 --- tests/include/mir/test/doubles/mock_mir_buffer_stream.h	2017-03-10 19:47:57 +0000
 +++ tests/include/mir/test/doubles/mock_mir_buffer_stream.h	2017-03-28 00:17:49 +0000
@@ -50,6 +50,7 @@
      MOCK_METHOD0(get_create_wait_handle, MirWaitHandle*(void));
      MOCK_CONST_METHOD0(rpc_id, frontend::BufferStreamId(void));
      MOCK_CONST_METHOD0(valid, bool(void));
++    MOCK_CONST_METHOD0(has_buffer, bool(void));
      MOCK_METHOD1(buffer_available, void(mir::protobuf::Buffer const&));
      MOCK_METHOD0(buffer_unavailable, void());
      MOCK_METHOD1(set_size, void(geometry::Size));
 === modified file 'tests/include/mir/test/doubles/stub_buffer_stream_factory.h'
 --- tests/include/mir/test/doubles/stub_buffer_stream_factory.h	2017-03-13 08:12:52 +0000
 +++ tests/include/mir/test/doubles/stub_buffer_stream_factory.h	2017-03-28 00:17:49 +0000
@@ -21,7 +21,10 @@
  #include "mir/frontend/client_buffers.h"
  #include "mir/scene/buffer_stream_factory.h"
++#include "mir/frontend/buffer_sink.h"
  #include "stub_buffer_stream.h"
++#include "stub_buffer.h"
++#include "mir_test_framework/stub_platform_native_buffer.h"
  namespace mir
+ {
@@ -32,8 +35,20 @@
  struct StubClientBuffers : frontend::ClientBuffers
+ {
++<<<<<<< TREE
      graphics::BufferID add_buffer(std::shared_ptr<graphics::Buffer> const&) override
+     {
++=======
++    StubClientBuffers(std::shared_ptr<frontend::BufferSink> const& sink)
++        : sink{sink}
++    {
++    }
++
++    graphics::BufferID add_buffer(graphics::BufferProperties const& props) override
++    {
++        StubBuffer buf{std::make_shared<mir_test_framework::NativeBuffer>(props), props.size};
++        sink->add_buffer(buf);
++>>>>>>> MERGE-SOURCE
          return {};
+     }
      void remove_buffer(graphics::BufferID) override
@@ -50,6 +65,7 @@
+     {
+     }
      std::shared_ptr<graphics::Buffer> buffer;
++    std::shared_ptr<frontend::BufferSink> const sink;
  };
  struct StubBufferStreamFactory : public scene::BufferStreamFactory
@@ -61,9 +77,9 @@
          frontend::BufferStreamId, std::shared_ptr<frontend::ClientBuffers> const&,
          graphics::BufferProperties const&) { return std::make_shared<StubBufferStream>(); }
      std::shared_ptr<frontend::ClientBuffers> create_buffer_map(
--        std::shared_ptr<frontend::BufferSink> const&)
++        std::shared_ptr<frontend::BufferSink> const& sink)
+     {
--        return std::make_shared<StubClientBuffers>();
++        return std::make_shared<StubClientBuffers>(sink);
+     }
  };
+ }
 === added file 'tests/include/mir/test/doubles/stub_client_buffer_stream_factory.h.THIS'
 --- tests/include/mir/test/doubles/stub_client_buffer_stream_factory.h.THIS	1970-01-01 00:00:00 +0000
 +++ tests/include/mir/test/doubles/stub_client_buffer_stream_factory.h.THIS	2017-03-28 00:17:49 +0000
@@ -0,0 +1,66 @@
++/*
++ * Copyright © 2015 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Robert Carr <robert.carr@canonical.com>
++ */
++
++#ifndef MIR_TEST_DOUBLES_STUB_CLIENT_BUFFER_STREAM_FACTORY_H_
++#define MIR_TEST_DOUBLES_STUB_CLIENT_BUFFER_STREAM_FACTORY_H_
++
++#include "src/client/client_buffer_stream_factory.h"
++#include "src/client/buffer_stream.h"
++
++namespace mir
++{
++namespace test
++{
++namespace doubles
++{
++
++struct StubClientBufferStreamFactory : public client::ClientBufferStreamFactory
++{
++    std::shared_ptr<client::ClientBufferStream> make_consumer_stream(
++        MirConnection* /* allocating_connection */,
++        protobuf::DisplayServer& /* server */,
++        protobuf::BufferStream const& /* protobuf_bs */,
++        std::string const& /* surface_name */) override
++    {
++        return nullptr;
++    }
++
++    std::shared_ptr<client::ClientBufferStream> make_producer_stream(
++        MirConnection* /* allocating_connection */,
++        protobuf::DisplayServer& /* server */,
++        protobuf::BufferStream const& /* protobuf_bs */,
++        std::string const& /* surface_name */) override
++    {
++        return nullptr;
++    }
++
++    client::ClientBufferStream* make_producer_stream(
++       MirConnection* /* allocating_connection */,
++       protobuf::DisplayServer& /* server */,
++       protobuf::BufferStreamParameters const& /* params */,
++       mir_buffer_stream_callback /* callback */, void* /* context */) override
++    {
++        return nullptr;
++    }
++};
++
++}
++}
++}
++
++#endif // MIR_TEST_DOUBLES_STUB_CLIENT_BUFFER_STREAM_FACTORY_H_
 === modified file 'tests/integration-tests/test_buffer_scheduling.cpp'
 --- tests/integration-tests/test_buffer_scheduling.cpp	2017-03-13 08:12:52 +0000
 +++ tests/integration-tests/test_buffer_scheduling.cpp	2017-03-28 00:17:49 +0000
@@ -27,6 +27,7 @@
  #include "src/client/connection_surface_map.h"
  #include "src/server/compositor/stream.h"
  #include "src/server/compositor/buffer_map.h"
++#include "mir/dispatch/action_queue.h"
  #include "mir/test/doubles/stub_client_buffer_factory.h"
  #include "mir/test/doubles/mock_client_buffer_factory.h"
  #include "mir/test/doubles/stub_buffer_allocator.h"
@@ -37,6 +38,7 @@
  namespace mt  = mir::test;
  namespace mtd = mir::test::doubles;
++namespace md = mir::dispatch;
  namespace mcl = mir::client;
  namespace mc = mir::compositor;
  namespace mg = mir::graphics;
@@ -290,7 +292,7 @@
+ {
      ScheduledProducer(std::shared_ptr<StubIpcSystem> const& ipc_stub, int nbuffers) :
          ipc(ipc_stub),
--        map(std::make_shared<mcl::ConnectionSurfaceMap>()),
++        map(std::make_shared<mcl::ConnectionSurfaceMap>(std::make_shared<md::ActionQueue>())),
          factory(std::make_shared<mcl::BufferFactory>()),
          vault(
              std::make_shared<mtd::StubClientBufferFactory>(), factory,
 === modified file 'tests/integration-tests/test_surfaceloop.cpp'
 --- tests/integration-tests/test_surfaceloop.cpp	2017-01-18 02:29:37 +0000
 +++ tests/integration-tests/test_surfaceloop.cpp	2017-03-28 00:17:49 +0000
@@ -17,6 +17,7 @@
   */
  #include "mir_toolkit/mir_client_library.h"
++#include "mir/graphics/buffer_ipc_message.h"
  #include "mir/test/doubles/stub_buffer.h"
  #include "mir/test/doubles/stub_buffer_allocator.h"
@@ -33,6 +34,7 @@
  #include <condition_variable>
  #include <gmock/gmock.h>
  #include <gtest/gtest.h>
++#include <src/client/lttng/shared_library_prober_report_tp.h>
  #include "mir/test/gmock_fixes.h"
  namespace mc = mir::compositor;
@@ -44,35 +46,6 @@
  namespace
+ {
--geom::Size const size{640, 480};
--MirPixelFormat const format{mir_pixel_format_abgr_8888};
--mg::BufferUsage const usage{mg::BufferUsage::hardware};
--mg::BufferProperties const buffer_properties{size, format, usage};
--
--
--class MockGraphicBufferAllocator : public mtd::StubBufferAllocator
--{
-- public:
--    MockGraphicBufferAllocator()
--    {
--        using testing::_;
--        ON_CALL(*this, alloc_buffer(_))
--            .WillByDefault(testing::Invoke(this, &MockGraphicBufferAllocator::on_create_swapper));
--    }
--
--    MOCK_METHOD1(
--        alloc_buffer,
--        std::shared_ptr<mg::Buffer> (mg::BufferProperties const&));
--
--
--    std::shared_ptr<mg::Buffer> on_create_swapper(mg::BufferProperties const&)
--    {
--        return std::make_shared<mtd::StubBuffer>(::buffer_properties);
--    }
--
--    ~MockGraphicBufferAllocator() noexcept {}
--};
--
  class StubDisplay : public mtd::NullDisplay
+ {
  public:
@@ -96,11 +69,13 @@
+     {
      public:
--        CountingStubBuffer()
++        CountingStubBuffer(mg::BufferProperties const& props)
++            : StubBuffer(props)
+         {
              std::lock_guard<std::mutex> lock{buffers_mutex};
              ++buffers_created;
              buffers_cv.notify_one();
++            std::cout << "Created buffer with size " << size() << std::endl;
+         }
          ~CountingStubBuffer()
+         {
@@ -118,11 +93,61 @@
      class StubGraphicBufferAllocator : public mtd::StubBufferAllocator
+     {
       public:
--        std::shared_ptr<mg::Buffer> alloc_buffer(mg::BufferProperties const&) override
--        {
--            return std::make_shared<CountingStubBuffer>();
--        }
--    };
++        std::shared_ptr<mg::Buffer> alloc_buffer(mg::BufferProperties const& props) override
++        {
++            return std::make_shared<CountingStubBuffer>(props);
++        }
++    };
++<<<<<<< TREE
++=======
++
++    class StubPlatform : public mtd::NullPlatform
++    {
++    public:
++        mir::UniqueModulePtr<mg::GraphicBufferAllocator> create_buffer_allocator() override
++        {
++            return mir::make_module_ptr<StubGraphicBufferAllocator>();
++        }
++
++        mir::UniqueModulePtr<mg::Display> create_display(
++            std::shared_ptr<mg::DisplayConfigurationPolicy> const&,
++            std::shared_ptr<mg::GLConfig> const&) override
++        {
++            return mir::make_module_ptr<StubDisplay>();
++        }
++
++        mir::UniqueModulePtr<mg::PlatformIpcOperations> make_ipc_operations() const override
++        {
++            class BufferPackingIPCOperations : public mtd::NullPlatformIpcOperations
++            {
++            public:
++                void pack_buffer(
++                    mg::BufferIpcMessage& message,
++                    mg::Buffer const& buffer,
++                    mg::BufferIpcMsgType msg_type) const override
++                {
++                    if (msg_type == mg::BufferIpcMsgType::full_msg)