Merge lp:~alan-griffiths/mir/remove-force_requests_to_complete into lp:mir

[Alan Griffiths]

Strip out all the force_requests_to_complete() code that became obsolete

Strip out all the force_requests_to_complete() code that became obsolete with lp:~alan-griffiths/mir/SwitchingBundle-controls-completion-of-client_acquire-without-blocking

Unmerged revisions

1372. By Alan Griffiths on 2014-02-06

Try extending lifetime of session mediator until callback processed

1371. By Alan Griffiths on 2014-02-06

merge lp:~alan-griffiths/mir/SwitchingBundle-controls-completion-of-client_acquire-without-blocking

1370. By Alan Griffiths on 2014-02-05

Strip out all the force_requests_to_complete() code that became obsolete with lp:~alan-griffiths/mir/SwitchingBundle-controls-completion-of-client_acquire-without-blocking

1369. By Alan Griffiths on 2014-02-05

merge lp:~alan-griffiths/mir/SwitchingBundle-controls-completion-of-client_acquire-without-blocking

=== modified file 'examples/demo-inprocess-surface-client/inprocess_egl_client.cpp'
--- examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2014-01-13 06:12:33 +0000
+++ examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2014-02-06 14:45:58 +0000
@@ -69,8 +69,6 @@
 {
     terminate = true;
     auto session = focus_controller->focussed_application().lock();
-    if (session)
-        session->force_requests_to_complete();
     client_thread.join();
 }
 

=== modified file 'include/server/mir/compositor/buffer_stream.h'
--- include/server/mir/compositor/buffer_stream.h	2014-02-06 14:45:58 +0000
+++ include/server/mir/compositor/buffer_stream.h	2014-02-06 14:45:58 +0000
@@ -49,7 +49,6 @@
     virtual geometry::Size stream_size() = 0;
     virtual void resize(geometry::Size const& size) = 0;
     virtual void allow_framedropping(bool) = 0;
-    virtual void force_requests_to_complete() = 0;
 };
 
 }

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-01-29 18:02:33 +0000
+++ include/server/mir/default_server_configuration.h	2014-02-06 14:45:58 +0000
@@ -313,7 +313,6 @@
     std::shared_ptr<scene::SessionManager>       the_session_manager();
     std::shared_ptr<scene::SurfaceBuilder>       the_surface_builder();
     std::shared_ptr<scene::SurfaceController>    the_surface_controller();
-    std::function<void()> force_threads_to_unblock_callback();
 };
 }
 

=== modified file 'include/server/mir/frontend/surface.h'
--- include/server/mir/frontend/surface.h	2014-02-06 14:45:58 +0000
+++ include/server/mir/frontend/surface.h	2014-02-06 14:45:58 +0000
@@ -51,8 +51,6 @@
 
     virtual ~Surface() {}
 
-    virtual void force_requests_to_complete() = 0;
-
     virtual geometry::Size size() const = 0;
     virtual MirPixelFormat pixel_format() const = 0;
 

=== modified file 'include/server/mir/shell/session.h'
--- include/server/mir/shell/session.h	2014-01-13 06:12:33 +0000
+++ include/server/mir/shell/session.h	2014-02-06 14:45:58 +0000
@@ -33,8 +33,6 @@
 {
 public:
     virtual std::string name() const = 0;
-    virtual void force_requests_to_complete() = 0;
-
     virtual void take_snapshot(SnapshotCallback const& snapshot_taken) = 0;
     virtual std::shared_ptr<Surface> default_surface() const = 0;
     virtual void set_lifecycle_state(MirLifecycleState state) = 0;

=== modified file 'include/test/mir_test_doubles/stub_buffer_stream.h'
--- include/test/mir_test_doubles/stub_buffer_stream.h	2014-02-06 14:45:58 +0000
+++ include/test/mir_test_doubles/stub_buffer_stream.h	2014-02-06 14:45:58 +0000
@@ -64,10 +64,6 @@
     {
     }
 
-    void force_requests_to_complete() override
-    {
-    }
-
     void allow_framedropping(bool) override
     {
     }

=== modified file 'include/test/mir_test_doubles/stub_session.h'
--- include/test/mir_test_doubles/stub_session.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/stub_session.h	2014-02-06 14:45:58 +0000
@@ -45,9 +45,6 @@
     {
         return std::string();
     }
-    void force_requests_to_complete()
-    {
-    }
     void hide()
     {
     }

=== modified file 'include/test/mir_test_doubles/stub_shell_session.h'
--- include/test/mir_test_doubles/stub_shell_session.h	2014-01-13 06:12:33 +0000
+++ include/test/mir_test_doubles/stub_shell_session.h	2014-02-06 14:45:58 +0000
@@ -45,9 +45,6 @@
     {
         return std::string();
     }
-    void force_requests_to_complete() override
-    {
-    }
     void hide() override
     {
     }

=== modified file 'src/server/compositor/buffer_bundle.h'
--- src/server/compositor/buffer_bundle.h	2014-02-06 14:45:58 +0000
+++ src/server/compositor/buffer_bundle.h	2014-02-06 14:45:58 +0000
@@ -44,7 +44,6 @@
 
     virtual graphics::BufferProperties properties() const = 0;
     virtual void allow_framedropping(bool dropping_allowed) = 0;
-    virtual void force_requests_to_complete() = 0;
     virtual void resize(const geometry::Size &newsize) = 0;
 protected:
     BufferBundle() = default;

=== modified file 'src/server/compositor/buffer_stream_surfaces.cpp'
--- src/server/compositor/buffer_stream_surfaces.cpp	2014-02-06 14:45:58 +0000
+++ src/server/compositor/buffer_stream_surfaces.cpp	2014-02-06 14:45:58 +0000
@@ -34,7 +34,6 @@
 
 mc::BufferStreamSurfaces::~BufferStreamSurfaces()
 {
-    force_requests_to_complete();
 }
 
 std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_compositor_buffer(
@@ -74,11 +73,6 @@
     buffer_bundle->resize(size);
 }
 
-void mc::BufferStreamSurfaces::force_requests_to_complete()
-{
-    buffer_bundle->force_requests_to_complete();
-}
-
 void mc::BufferStreamSurfaces::allow_framedropping(bool allow)
 {
     buffer_bundle->allow_framedropping(allow);

=== modified file 'src/server/compositor/buffer_stream_surfaces.h'
--- src/server/compositor/buffer_stream_surfaces.h	2014-02-06 14:45:58 +0000
+++ src/server/compositor/buffer_stream_surfaces.h	2014-02-06 14:45:58 +0000
@@ -49,7 +49,6 @@
     geometry::Size stream_size() override;
     void resize(geometry::Size const& size) override;
     void allow_framedropping(bool) override;
-    void force_requests_to_complete() override;
 
 protected:
     BufferStreamSurfaces(const BufferStreamSurfaces&) = delete;

=== modified file 'src/server/compositor/switching_bundle.cpp'
--- src/server/compositor/switching_bundle.cpp	2014-02-06 14:45:58 +0000
+++ src/server/compositor/switching_bundle.cpp	2014-02-06 14:45:58 +0000
@@ -398,15 +398,6 @@
     cond.notify_all();
 }
 
-void mc::SwitchingBundle::force_requests_to_complete()
-{
-    std::unique_lock<std::mutex> lock(guard);
-    client_acquire_todo = nullptr;
-    drop_frames(nready);
-    force_drop = nbuffers + 1;
-    cond.notify_all();
-}
-
 void mc::SwitchingBundle::allow_framedropping(bool allow_dropping)
 {
     std::unique_lock<std::mutex> lock(guard);

=== modified file 'src/server/compositor/switching_bundle.h'
--- src/server/compositor/switching_bundle.h	2014-02-06 14:45:58 +0000
+++ src/server/compositor/switching_bundle.h	2014-02-06 14:45:58 +0000
@@ -56,7 +56,6 @@
     void compositor_release(std::shared_ptr<graphics::Buffer> const& released_buffer);
     std::shared_ptr<graphics::Buffer> snapshot_acquire();
     void snapshot_release(std::shared_ptr<graphics::Buffer> const& released_buffer);
-    void force_requests_to_complete();
     void allow_framedropping(bool dropping_allowed);
     bool framedropping_allowed() const;
 

=== modified file 'src/server/frontend/default_configuration.cpp'
--- src/server/frontend/default_configuration.cpp	2014-01-30 13:27:59 +0000
+++ src/server/frontend/default_configuration.cpp	2014-02-06 14:45:58 +0000
@@ -114,14 +114,11 @@
         {
             auto const threads = the_options()->get<int>(frontend_threads_opt);
 
-            auto const& force_threads_to_unblock = force_threads_to_unblock_callback();
-
             if (the_options()->is_set(no_server_socket_opt))
             {
                 return std::make_shared<mf::BasicConnector>(
                     the_session_creator(),
                     threads,
-                    force_threads_to_unblock,
                     the_connector_report());
             }
             else
@@ -130,7 +127,6 @@
                     the_socket_file(),
                     the_session_creator(),
                     threads,
-                    force_threads_to_unblock,
                     the_connector_report());
             }
         });

=== modified file 'src/server/frontend/published_socket_connector.cpp'
--- src/server/frontend/published_socket_connector.cpp	2014-01-22 17:05:48 +0000
+++ src/server/frontend/published_socket_connector.cpp	2014-02-06 14:45:58 +0000
@@ -35,9 +35,8 @@
     const std::string& socket_file,
     std::shared_ptr<SessionCreator> const& session_creator,
     int threads,
-    std::function<void()> const& force_threads_to_unblock,
     std::shared_ptr<ConnectorReport> const& report)
-:   BasicConnector(session_creator, threads, force_threads_to_unblock, report),
+:   BasicConnector(session_creator, threads, report),
     socket_file(socket_file),
     acceptor(io_service, socket_file)
 {
@@ -83,12 +82,10 @@
 mf::BasicConnector::BasicConnector(
     std::shared_ptr<SessionCreator> const& session_creator,
     int threads,
-    std::function<void()> const& force_threads_to_unblock,
     std::shared_ptr<ConnectorReport> const& report)
 :   work(io_service),
     report(report),
     io_service_threads(threads),
-    force_threads_to_unblock(force_threads_to_unblock),
     session_creator{session_creator}
 {
 }
@@ -123,12 +120,6 @@
     /* Stop processing new requests */
     io_service.stop();
 
-    /*
-     * Ensure that any pending requests will complete (i.e., that they
-     * will not block indefinitely waiting for a resource from the server)
-     */
-    force_threads_to_unblock();
-
     report->stopping_threads(io_service_threads.size());
 
     /* Wait for all io processing threads to finish */

=== modified file 'src/server/frontend/published_socket_connector.h'
--- src/server/frontend/published_socket_connector.h	2014-01-22 17:05:48 +0000
+++ src/server/frontend/published_socket_connector.h	2014-02-06 14:45:58 +0000
@@ -50,7 +50,6 @@
     explicit BasicConnector(
         std::shared_ptr<SessionCreator> const& session_creator,
         int threads,
-        std::function<void()> const& force_threads_to_unblock,
         std::shared_ptr<ConnectorReport> const& report);
     ~BasicConnector() noexcept;
     void start() override;
@@ -67,7 +66,6 @@
 
 private:
     std::vector<std::thread> io_service_threads;
-    std::function<void()> const force_threads_to_unblock;
     std::shared_ptr<SessionCreator> const session_creator;
 };
 
@@ -79,7 +77,6 @@
         const std::string& socket_file,
         std::shared_ptr<SessionCreator> const& session_creator,
         int threads,
-        std::function<void()> const& force_threads_to_unblock,
         std::shared_ptr<ConnectorReport> const& report);
     ~PublishedSocketConnector() noexcept;
 

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2014-02-06 14:45:58 +0000
+++ src/server/frontend/session_mediator.cpp	2014-02-06 14:45:58 +0000
@@ -174,20 +174,22 @@
     if (surface->supports_input())
         response->add_fd(surface->client_input_fd());
 
+    auto const self = shared_from_this();
+
     advance_buffer(surf_id, *surface,
-        [lock, this, response, done, session](graphics::Buffer* client_buffer, bool need_full_ipc)
+        [lock, self, response, done, session](graphics::Buffer* client_buffer, bool need_full_ipc)
         {
             lock->unlock();
 
             auto buffer = response->mutable_buffer();
-            pack_protobuf_buffer(*buffer, client_buffer, need_full_ipc);
+            self->pack_protobuf_buffer(*buffer, client_buffer, need_full_ipc);
 
             // TODO: NOTE: We use the ordering here to ensure the shell acts on the surface after the surface ID is sent over the wire.
             // This guarantees that notifications such as, gained focus, etc, can be correctly interpreted by the client.
             // To achieve this order we rely on done->Run() sending messages synchronously. As documented in mfd::SocketMessenger::send.
             // this will require additional synchronization if mfd::SocketMessenger::send changes.
             done->Run();
-            shell->handle_surface_created(session);
+            self->shell->handle_surface_created(session);
         });
 }
 
@@ -216,12 +218,14 @@
 
     auto surface = session->get_surface(surf_id);
 
+    auto const self = shared_from_this();
+
     advance_buffer(surf_id, *surface,
-        [lock, this, response, done, session](graphics::Buffer* client_buffer, bool need_full_ipc)
+        [lock, self, response, done, session](graphics::Buffer* client_buffer, bool need_full_ipc)
         {
             lock->unlock();
 
-            pack_protobuf_buffer(*response, client_buffer, need_full_ipc);
+            self->pack_protobuf_buffer(*response, client_buffer, need_full_ipc);
 
             done->Run();
         });

=== modified file 'src/server/frontend/session_mediator.h'
--- src/server/frontend/session_mediator.h	2014-02-06 14:45:58 +0000
+++ src/server/frontend/session_mediator.h	2014-02-06 14:45:58 +0000
@@ -56,7 +56,8 @@
 class Screencast;
 
 // SessionMediator relays requests from the client process into the server.
-class SessionMediator : public mir::protobuf::DisplayServer
+class SessionMediator : public mir::protobuf::DisplayServer,
+    public std::enable_shared_from_this<SessionMediator>
 {
 public:
     SessionMediator(

=== modified file 'src/server/scene/application_session.cpp'
--- src/server/scene/application_session.cpp	2014-01-13 06:12:33 +0000
+++ src/server/scene/application_session.cpp	2014-02-06 14:45:58 +0000
@@ -125,15 +125,6 @@
     return session_name;
 }
 
-void ms::ApplicationSession::force_requests_to_complete()
-{
-    std::unique_lock<std::mutex> lock(surfaces_mutex);
-    for (auto& id_s : surfaces)
-    {
-        id_s.second->force_requests_to_complete();
-    }
-}
-
 void ms::ApplicationSession::hide()
 {
     std::unique_lock<std::mutex> lock(surfaces_mutex);

=== modified file 'src/server/scene/application_session.h'
--- src/server/scene/application_session.h	2014-01-13 06:12:33 +0000
+++ src/server/scene/application_session.h	2014-02-06 14:45:58 +0000
@@ -61,8 +61,6 @@
 
     std::string name() const;
 
-    void force_requests_to_complete();
-
     void hide();
     void show();
 

=== modified file 'src/server/scene/basic_surface.cpp'
--- src/server/scene/basic_surface.cpp	2014-02-06 14:45:58 +0000
+++ src/server/scene/basic_surface.cpp	2014-02-06 14:45:58 +0000
@@ -49,11 +49,6 @@
     report->surface_created(this);
 }
 
-void ms::BasicSurface::force_requests_to_complete()
-{
-    surface_buffer_stream->force_requests_to_complete();
-}
-
 ms::BasicSurface::~BasicSurface()
 {
     report->surface_deleted(this);

=== modified file 'src/server/scene/basic_surface.h'
--- src/server/scene/basic_surface.h	2014-02-06 14:45:58 +0000
+++ src/server/scene/basic_surface.h	2014-02-06 14:45:58 +0000
@@ -74,7 +74,6 @@
 
     virtual std::shared_ptr<graphics::Buffer> snapshot_buffer() const;
     virtual void swap_buffers(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete);
-    virtual void force_requests_to_complete();
 
     virtual bool supports_input() const;
     virtual int client_input_fd() const;

=== modified file 'src/server/scene/default_configuration.cpp'
--- src/server/scene/default_configuration.cpp	2014-01-29 15:20:07 +0000
+++ src/server/scene/default_configuration.cpp	2014-02-06 14:45:58 +0000
@@ -205,19 +205,6 @@
     return the_mediating_display_changer();
 }
 
-std::function<void()>
-mir::DefaultServerConfiguration::force_threads_to_unblock_callback()
-{
-    auto shell_sessions = the_session_container();
-    return [shell_sessions]
-    {
-        shell_sessions->for_each([](std::shared_ptr<msh::Session> const& session)
-        {
-            session->force_requests_to_complete();
-        });
-    };
-}
-
 std::shared_ptr<mf::EventSink>
 mir::DefaultServerConfiguration::the_global_event_sink()
 {

=== modified file 'src/server/scene/surface_impl.cpp'
--- src/server/scene/surface_impl.cpp	2014-02-06 14:45:58 +0000
+++ src/server/scene/surface_impl.cpp	2014-02-06 14:45:58 +0000
@@ -73,11 +73,6 @@
     surface->set_hidden(false);
 }
 
-void ms::SurfaceImpl::force_requests_to_complete()
-{
-    surface->force_requests_to_complete();
-}
-
 mir::geometry::Size ms::SurfaceImpl::size() const
 {
     return surface->size();

=== modified file 'src/server/scene/surface_impl.h'
--- src/server/scene/surface_impl.h	2014-02-06 14:45:58 +0000
+++ src/server/scene/surface_impl.h	2014-02-06 14:45:58 +0000
@@ -57,8 +57,6 @@
     virtual void hide();
     virtual void show();
 
-    virtual void force_requests_to_complete();
-
     virtual std::string name() const;
 
     virtual void move_to(geometry::Point const& top_left);

=== modified file 'tests/integration-tests/compositor/test_buffer_stream.cpp'
--- tests/integration-tests/compositor/test_buffer_stream.cpp	2014-02-06 14:45:58 +0000
+++ tests/integration-tests/compositor/test_buffer_stream.cpp	2014-02-06 14:45:58 +0000
@@ -326,8 +326,6 @@
 
     done = true;
 
-    buffer_stream.force_requests_to_complete();
-
     compositor.join();
 
     for (auto &s : snapshotters)

=== modified file 'tests/integration-tests/test_swapinterval.cpp'
--- tests/integration-tests/test_swapinterval.cpp	2014-02-06 14:45:58 +0000
+++ tests/integration-tests/test_swapinterval.cpp	2014-02-06 14:45:58 +0000
@@ -70,7 +70,6 @@
 
     geom::Size stream_size() override { return geom::Size{}; }
     void resize(geom::Size const&) override {}
-    void force_requests_to_complete() override {}
     void allow_framedropping(bool) override
     {
         while (write(render_operations_fd, "a", 1) != 1) continue;

=== modified file 'tests/mir_test_doubles/test_protobuf_socket_server.cpp'
--- tests/mir_test_doubles/test_protobuf_socket_server.cpp	2014-01-22 15:54:11 +0000
+++ tests/mir_test_doubles/test_protobuf_socket_server.cpp	2014-02-06 14:45:58 +0000
@@ -42,7 +42,6 @@
             std::make_shared<mtd::StubSessionAuthorizer>(),
             std::make_shared<mf::NullMessageProcessorReport>()),
         10,
-        []{},
         report);
 }
 }

=== modified file 'tests/unit-tests/compositor/test_buffer_stream.cpp'
--- tests/unit-tests/compositor/test_buffer_stream.cpp	2014-02-06 14:45:58 +0000
+++ tests/unit-tests/compositor/test_buffer_stream.cpp	2014-02-06 14:45:58 +0000
@@ -39,10 +39,6 @@
     {
         mock_buffer = std::make_shared<mtd::StubBuffer>();
         mock_bundle = std::make_shared<mtd::MockBufferBundle>();
-
-        // Two of the tests care about this, the rest should not...
-        EXPECT_CALL(*mock_bundle, force_requests_to_complete())
-            .Times(::testing::AnyNumber());
     }
 
     std::shared_ptr<mtd::StubBuffer> mock_buffer;
@@ -75,23 +71,6 @@
     EXPECT_EQ(format, returned_pf);
 }
 
-TEST_F(BufferStreamTest, force_requests_to_complete)
-{
-    EXPECT_CALL(*mock_bundle, force_requests_to_complete())
-        .Times(2);  // Once explcit, once on destruction
-
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
-    buffer_stream.force_requests_to_complete();
-}
-
-TEST_F(BufferStreamTest, requests_are_completed_before_destruction)
-{
-    EXPECT_CALL(*mock_bundle, force_requests_to_complete())
-        .Times(1);
-
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
-}
-
 TEST_F(BufferStreamTest, get_buffer_for_compositor_handles_resources)
 {
     using namespace testing;

=== modified file 'tests/unit-tests/compositor/test_switching_bundle.cpp'
--- tests/unit-tests/compositor/test_switching_bundle.cpp	2014-02-06 14:45:58 +0000
+++ tests/unit-tests/compositor/test_switching_bundle.cpp	2014-02-06 14:45:58 +0000
@@ -293,8 +293,6 @@
         unsigned long frameno = 0;
         const int N = 100;
 
-        bundle.force_requests_to_complete();
-
         std::shared_ptr<mg::Buffer> buf[N];
         for (int i = 0; i < N; i++)
             buf[i] = bundle.compositor_acquire(++frameno);
@@ -713,7 +711,6 @@
          * unblock clients. The latter only temporarily unblock clients.
          * But that requires interface changes all over the place...
          */
-        bundle.force_requests_to_complete();
         client.join();
     }
 }
@@ -729,7 +726,6 @@
         bundle.allow_framedropping(false);
 
         std::thread client(client_thread, std::ref(bundle), nbuffers);
-        bundle.force_requests_to_complete();
         client.join();
 
         EXPECT_FALSE(bundle.framedropping_allowed());

=== modified file 'tests/unit-tests/frontend/test_published_socket_connector.cpp'
--- tests/unit-tests/frontend/test_published_socket_connector.cpp	2014-01-22 15:54:11 +0000
+++ tests/unit-tests/frontend/test_published_socket_connector.cpp	2014-02-06 14:45:58 +0000
@@ -342,27 +342,11 @@
     EXPECT_EQ(magic.magic(), stub_server_tool->drm_magic);
 }
 
-namespace
-{
-
-class MockForceRequests
-{
-public:
-    MOCK_METHOD0(force_requests_to_complete, void());
-};
-
-}
-
 TEST_F(PublishedSocketConnector, forces_requests_to_complete_when_stopping)
 {
-    MockForceRequests mock_force_requests;
     auto stub_server_tool = std::make_shared<mt::StubServerTool>();
     auto ipc_factory = std::make_shared<mtd::StubIpcFactory>(*stub_server_tool);
 
-    /* Once for the explicit stop() and once when the communicator is destroyed */
-    EXPECT_CALL(mock_force_requests, force_requests_to_complete())
-        .Times(2);
-
     auto comms = std::make_shared<mf::PublishedSocketConnector>(
         "./test_socket1",
         std::make_shared<mf::ProtobufSessionCreator>(
@@ -370,7 +354,6 @@
                     std::make_shared<mtd::StubSessionAuthorizer>(),
                     std::make_shared<mf::NullMessageProcessorReport>()),
         10,
-        std::bind(&MockForceRequests::force_requests_to_complete, &mock_force_requests),
         std::make_shared<mf::NullConnectorReport>());
 
     comms->start();

=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2014-02-06 14:45:58 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2014-02-06 14:45:58 +0000
@@ -206,10 +206,10 @@
           report{std::make_shared<mf::NullSessionMediatorReport>()},
           resource_cache{std::make_shared<mf::ResourceCache>()},
           stub_screencast{std::make_shared<StubScreencast>()},
-          mediator{shell, graphics_platform, graphics_changer,
+          mediator{std::make_shared<mf::SessionMediator>(shell, graphics_platform, graphics_changer,
                    surface_pixel_formats, report,
                    std::make_shared<mtd::NullEventSink>(),
-                   resource_cache, stub_screencast},
+                   resource_cache, stub_screencast)},
           stubbed_session{std::make_shared<StubbedSession>()},
           null_callback{google::protobuf::NewPermanentCallback(google::protobuf::DoNothing)}
     {
@@ -227,7 +227,7 @@
     std::shared_ptr<mf::SessionMediatorReport> const report;
     std::shared_ptr<mf::ResourceCache> const resource_cache;
     std::shared_ptr<StubScreencast> const stub_screencast;
-    mf::SessionMediator mediator;
+    std::shared_ptr<mf::SessionMediator> const mediator;
     std::shared_ptr<StubbedSession> const stubbed_session;
 
     std::unique_ptr<google::protobuf::Closure> null_callback;
@@ -243,8 +243,8 @@
 
     EXPECT_CALL(*shell, close_session(_)).Times(1);
 
-    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
-    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
+    mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
 }
 
 TEST_F(SessionMediatorTest, calling_methods_before_connect_throws)
@@ -253,31 +253,31 @@
         mp::SurfaceParameters request;
         mp::Surface response;
 
-        mediator.create_surface(nullptr, &request, &response, null_callback.get());
+        mediator->create_surface(nullptr, &request, &response, null_callback.get());
     }, std::logic_error);
 
     EXPECT_THROW({
         mp::SurfaceId request;
         mp::Buffer response;
 
-        mediator.next_buffer(nullptr, &request, &response, null_callback.get());
+        mediator->next_buffer(nullptr, &request, &response, null_callback.get());
     }, std::logic_error);
 
     EXPECT_THROW({
         mp::SurfaceId request;
 
-        mediator.release_surface(nullptr, &request, nullptr, null_callback.get());
+        mediator->release_surface(nullptr, &request, nullptr, null_callback.get());
     }, std::logic_error);
 
     EXPECT_THROW({
         mp::DRMMagic request;
         mp::DRMAuthMagicStatus response;
 
-        mediator.drm_auth_magic(nullptr, &request, &response, null_callback.get());
+        mediator->drm_auth_magic(nullptr, &request, &response, null_callback.get());
     }, std::logic_error);
 
     EXPECT_THROW({
-        mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
+        mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
     }, std::logic_error);
 }
 
@@ -286,23 +286,23 @@
     mp::ConnectParameters connect_parameters;
     mp::Connection connection;
 
-    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
     {
         mp::SurfaceParameters request;
         mp::Surface surface_response;
 
-        mediator.create_surface(nullptr, &request, &surface_response, null_callback.get());
+        mediator->create_surface(nullptr, &request, &surface_response, null_callback.get());
 
         mp::SurfaceId surface = surface_response.id();
         mp::Buffer buffer_response;
 
-        mediator.next_buffer(nullptr, &surface, &buffer_response, null_callback.get());
+        mediator->next_buffer(nullptr, &surface, &buffer_response, null_callback.get());
 
-        mediator.release_surface(nullptr, &surface, nullptr, null_callback.get());
+        mediator->release_surface(nullptr, &surface, nullptr, null_callback.get());
     }
 
-    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
+    mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
 }
 
 TEST_F(SessionMediatorTest, calling_methods_after_disconnect_throws)
@@ -310,39 +310,39 @@
     mp::ConnectParameters connect_parameters;
     mp::Connection connection;
 
-    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
-    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
+    mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
 
     EXPECT_THROW({
         mp::SurfaceParameters surface_parameters;
         mp::Surface surface;
 
-        mediator.create_surface(nullptr, &surface_parameters, &surface, null_callback.get());
+        mediator->create_surface(nullptr, &surface_parameters, &surface, null_callback.get());
     }, std::logic_error);
 
     EXPECT_THROW({
         mp::SurfaceId request;
         mp::Buffer response;
 
-        mediator.next_buffer(nullptr, &request, &response, null_callback.get());
+        mediator->next_buffer(nullptr, &request, &response, null_callback.get());
     }, std::logic_error);
 
     EXPECT_THROW({
         mp::SurfaceId request;
 
-        mediator.release_surface(nullptr, &request, nullptr, null_callback.get());
+        mediator->release_surface(nullptr, &request, nullptr, null_callback.get());
     }, std::logic_error);
 
     EXPECT_THROW({
         mp::DRMMagic request;
         mp::DRMAuthMagicStatus response;
 
-        mediator.drm_auth_magic(nullptr, &request, &response, null_callback.get());
+        mediator->drm_auth_magic(nullptr, &request, &response, null_callback.get());
     }, std::logic_error);
 
     EXPECT_THROW({
-        mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
+        mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
     }, std::logic_error);
 }
 
@@ -351,11 +351,11 @@
     mp::ConnectParameters connect_parameters;
     mp::Connection connection;
 
-    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
-
-    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
-
-    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
+
+    mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
+
+    mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
 }
 
 TEST_F(SessionMediatorTest, connect_packs_display_configuration)
@@ -369,7 +369,7 @@
     EXPECT_CALL(*mock_display, active_configuration())
         .Times(1)
         .WillOnce(Return(mt::fake_shared(config)));
-    mf::SessionMediator mediator(
+    auto const mediator = std::make_shared<mf::SessionMediator>(
         shell, graphics_platform, mock_display,
         surface_pixel_formats, report,
         std::make_shared<mtd::NullEventSink>(),
@@ -382,7 +382,7 @@
     connection.clear_display_output();
     connection.clear_display_configuration();
 
-    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
     EXPECT_THAT(connection.display_configuration(),
                 mt::DisplayConfigMatches(std::cref(config)));
@@ -393,17 +393,17 @@
     mp::ConnectParameters connect_parameters;
     mp::Connection connection;
 
-    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
     {
         mp::SurfaceParameters request;
         mp::Surface response;
 
-        mediator.create_surface(nullptr, &request, &response, null_callback.get());
+        mediator->create_surface(nullptr, &request, &response, null_callback.get());
         EXPECT_EQ(StubbedSession::testing_client_input_fd, response.fd(0));
     }
 
-    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
+    mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
 }
 
 TEST_F(SessionMediatorTest, no_input_channel_is_nonfatal)
@@ -416,16 +416,16 @@
     EXPECT_CALL(*stubbed_session->mock_surface, client_input_fd())
         .Times(0);
 
-    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
     {
         mp::SurfaceParameters request;
         mp::Surface response;
 
-        mediator.create_surface(nullptr, &request, &response, null_callback.get());
+        mediator->create_surface(nullptr, &request, &response, null_callback.get());
     }
 
-    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
+    mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
 }
 
 TEST_F(SessionMediatorTest, session_only_sends_needed_buffers)
@@ -435,7 +435,7 @@
     mp::ConnectParameters connect_parameters;
     mp::Connection connection;
 
-    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
     {
         EXPECT_CALL(*stubbed_session->mock_buffer, id())
@@ -456,14 +456,14 @@
             .Times(2);
 
         mp::SurfaceParameters surface_request;
-        mediator.create_surface(nullptr, &surface_request, &surface_response, null_callback.get());
+        mediator->create_surface(nullptr, &surface_request, &surface_response, null_callback.get());
         buffer_request = surface_response.id();
-        mediator.next_buffer(nullptr, &buffer_request, &buffer_response[0], null_callback.get());
-        mediator.next_buffer(nullptr, &buffer_request, &buffer_response[1], null_callback.get());
-        mediator.next_buffer(nullptr, &buffer_request, &buffer_response[2], null_callback.get());
+        mediator->next_buffer(nullptr, &buffer_request, &buffer_response[0], null_callback.get());
+        mediator->next_buffer(nullptr, &buffer_request, &buffer_response[1], null_callback.get());
+        mediator->next_buffer(nullptr, &buffer_request, &buffer_response[2], null_callback.get());
     }
 
-    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
+    mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
 }
 
 TEST_F(SessionMediatorTest, session_with_multiple_surfaces_only_sends_needed_buffers)
@@ -473,7 +473,7 @@
     mp::ConnectParameters connect_parameters;
     mp::Connection connection;
 
-    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
     {
         // AFAICS these values are stubs to set up the test condition,
@@ -504,19 +504,19 @@
             .Times(4);
 
         mp::SurfaceParameters surface_request;
-        mediator.create_surface(nullptr, &surface_request, &surface_response[0], null_callback.get());
-        mediator.create_surface(nullptr, &surface_request, &surface_response[1], null_callback.get());
+        mediator->create_surface(nullptr, &surface_request, &surface_response[0], null_callback.get());
+        mediator->create_surface(nullptr, &surface_request, &surface_response[1], null_callback.get());
         buffer_request[0] = surface_response[0].id();
         buffer_request[1] = surface_response[1].id();
-        mediator.next_buffer(nullptr, &buffer_request[0], &buffer_response[0], null_callback.get());
-        mediator.next_buffer(nullptr, &buffer_request[1], &buffer_response[1], null_callback.get());
-        mediator.next_buffer(nullptr, &buffer_request[0], &buffer_response[2], null_callback.get());
-        mediator.next_buffer(nullptr, &buffer_request[1], &buffer_response[3], null_callback.get());
-        mediator.next_buffer(nullptr, &buffer_request[0], &buffer_response[4], null_callback.get());
-        mediator.next_buffer(nullptr, &buffer_request[1], &buffer_response[5], null_callback.get());
+        mediator->next_buffer(nullptr, &buffer_request[0], &buffer_response[0], null_callback.get());
+        mediator->next_buffer(nullptr, &buffer_request[1], &buffer_response[1], null_callback.get());
+        mediator->next_buffer(nullptr, &buffer_request[0], &buffer_response[2], null_callback.get());
+        mediator->next_buffer(nullptr, &buffer_request[1], &buffer_response[3], null_callback.get());
+        mediator->next_buffer(nullptr, &buffer_request[0], &buffer_response[4], null_callback.get());
+        mediator->next_buffer(nullptr, &buffer_request[1], &buffer_response[5], null_callback.get());
     }
 
-    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
+    mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
 }
 
 TEST_F(SessionMediatorTest, buffer_resource_for_surface_unaffected_by_other_surfaces)
@@ -527,7 +527,7 @@
     mp::ConnectParameters connect_parameters;
     mp::Connection connection;
 
-    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
     mp::SurfaceParameters surface_request;
     mp::Surface surface_response;
 
@@ -539,28 +539,28 @@
     EXPECT_CALL(*stubbed_session->mock_surface, swap_buffers(_, _))
         .WillOnce(InvokeArgument<1>(&buffer));
 
-    mediator.create_surface(nullptr, &surface_request, &surface_response, null_callback.get());
+    mediator->create_surface(nullptr, &surface_request, &surface_response, null_callback.get());
     mp::SurfaceId our_surface{surface_response.id()};
 
     Mock::VerifyAndClearExpectations(stubbed_session->mock_surface.get());
 
     /* Creating a new surface should not affect our surfaces' buffers */
     EXPECT_CALL(*stubbed_session->mock_surface, swap_buffers(_, _)).Times(0);
-    mediator.create_surface(nullptr, &surface_request, &surface_response, null_callback.get());
+    mediator->create_surface(nullptr, &surface_request, &surface_response, null_callback.get());
 
     mp::SurfaceId new_surface{surface_response.id()};
     mp::Buffer buffer_response;
 
     /* Getting the next buffer of new surface should not affect our surfaces' buffers */
-    mediator.next_buffer(nullptr, &new_surface, &buffer_response, null_callback.get());
+    mediator->next_buffer(nullptr, &new_surface, &buffer_response, null_callback.get());
 
     Mock::VerifyAndClearExpectations(stubbed_session->mock_surface.get());
 
     /* Getting the next buffer of our surface should post the original */
     EXPECT_CALL(*stubbed_session->mock_surface, swap_buffers(Eq(&buffer), _)).Times(1);
 
-    mediator.next_buffer(nullptr, &our_surface, &buffer_response, null_callback.get());
-    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
+    mediator->next_buffer(nullptr, &our_surface, &buffer_response, null_callback.get());
+    mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
 }
 
 TEST_F(SessionMediatorTest, display_config_request)
@@ -601,13 +601,13 @@
         .InSequence(seq)
         .WillOnce(Return(mt::fake_shared(stub_display_config)));
 
-    mf::SessionMediator session_mediator{
+    auto const session_mediator = std::make_shared<mf::SessionMediator>(
         shell, graphics_platform, mock_display_selector,
         surface_pixel_formats, report,
         std::make_shared<mtd::NullEventSink>(), resource_cache,
-        std::make_shared<mtd::NullScreencast>()};
+        std::make_shared<mtd::NullScreencast>());
 
-    session_mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
+    session_mediator->connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
     mp::DisplayConfiguration configuration_response;
     mp::DisplayConfiguration configuration;
@@ -631,12 +631,12 @@
     disp1->set_power_mode(static_cast<uint32_t>(mir_power_mode_off));
     disp1->set_orientation(mir_orientation_inverted);
 
-    session_mediator.configure_display(nullptr, &configuration,
+    session_mediator->configure_display(nullptr, &configuration,
                                        &configuration_response, null_callback.get());
 
     EXPECT_THAT(configuration_response, mt::DisplayConfigMatches(std::cref(stub_display_config)));
 
-    session_mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
+    session_mediator->disconnect(nullptr, nullptr, nullptr, null_callback.get());
 }
 
 TEST_F(SessionMediatorTest, fully_packs_buffer_for_create_screencast)
@@ -649,7 +649,7 @@
 
     EXPECT_CALL(*graphics_platform, fill_ipc_package(_, &stub_buffer));
 
-    mediator.create_screencast(nullptr, &screencast_parameters,
+    mediator->create_screencast(nullptr, &screencast_parameters,
                                &screencast, null_callback.get());
 
     EXPECT_EQ(stub_buffer.id().as_uint32_t(),
@@ -667,7 +667,7 @@
     EXPECT_CALL(*graphics_platform, fill_ipc_package(_, &stub_buffer))
         .Times(0);
 
-    mediator.screencast_buffer(nullptr, &screencast_id,
+    mediator->screencast_buffer(nullptr, &screencast_id,
                                &protobuf_buffer, null_callback.get());
 
     EXPECT_EQ(stub_buffer.id().as_uint32_t(),

=== modified file 'tests/unit-tests/scene/test_surface.cpp'
--- tests/unit-tests/scene/test_surface.cpp	2014-02-06 14:45:58 +0000
+++ tests/unit-tests/scene/test_surface.cpp	2014-02-06 14:45:58 +0000
@@ -377,16 +377,6 @@
     EXPECT_FLOAT_EQ(alpha, compositing_criteria->alpha());
 }
 
-TEST_F(SurfaceCreation, test_surface_force_requests_to_complete)
-{
-    using namespace testing;
-
-    EXPECT_CALL(*mock_buffer_stream, force_requests_to_complete()).Times(Exactly(1));
-
-    ms::BasicSurface surf(stub_data, mock_buffer_stream, std::shared_ptr<mi::InputChannel>(), report);
-    surf.force_requests_to_complete();
-}
-
 TEST_F(SurfaceCreation, test_surface_allow_framedropping)
 {
     using namespace testing;

=== modified file 'tests/unit-tests/scene/test_surface_stack.cpp'
--- tests/unit-tests/scene/test_surface_stack.cpp	2014-02-06 14:45:58 +0000
+++ tests/unit-tests/scene/test_surface_stack.cpp	2014-02-06 14:45:58 +0000
@@ -75,7 +75,6 @@
     virtual std::shared_ptr<mg::Buffer> snapshot_acquire(){ return std::shared_ptr<mg::Buffer>(); };
     virtual void snapshot_release(std::shared_ptr<mg::Buffer> const&){}
     virtual void force_client_abort() {}
-    void force_requests_to_complete() {}
     virtual void allow_framedropping(bool) {}
     virtual mg::BufferProperties properties() const { return mg::BufferProperties{}; };
     void resize(const geom::Size &) override {}