Merge lp:~kdub/mir/prepare-for-display-notifications into lp:~mir-team/mir/trunk

[Kevin DuBois]

prepare for global event sending (like display resizing) by separating the ability to send messages into distinct classes that is used in the client request service loops

clean up constructors that aren't used, functions that aren't needed as well.

From a high level, we have a server right now that is mostly oriented towards receiving a request from a client, then responding to the request. The exception to this is EventSink, where we send messages to the client based upon server events, not upon a client request. The area of the code that needs the EventSink interface at the moment is the shell, and it uses it to send out shell-related events to the client.

This branch essentially decouples the send/receive code so there's distinct interfaces that have to do with sending, that is used by the code that is involved in the send/receive code. This allows us to hand out objects implementing the 'sending' interfaces to the rest of the system (at this time, just to the shell for the MirEvents). So, we send out an EventSink interface to the client now that is just a sender object, not a ProtobufSocketCommunicator object.

clean up constructors that aren't used, functions that aren't needed as well. a lot of the churn is from EventSink moving namespaces.

I scraped this change off my bigger iteration to support display change notifications. (hopefully is easier to review that way) the plan for moving forward the Communicator to be able to hand out an object implementing a display notification interface. The object will own the same SocketSender interface that is used to respond to clients or to send Events. This new object will be collected on a global level so we can iterate over the senders to send out global events to all clients. The per-surface events coming from the shell system don't see any change to the way they currently work.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:891
http://jenkins.qa.ubuntu.com/job/mir-ci/1107/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1451
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1336
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/345
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/345/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/719

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

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

1256 mfd::SocketSession::SocketSession(
1257 - boost::asio::io_service& io_service,
1258 + std::shared_ptr<mfd::MessageSender> const& sender,

836 +class MessageSender
837 +{
841 + virtual boost::asio::local::stream_protocol::socket& get_socket() = 0;

SocketSession doesn't really need a MessageSender, just the socket to use. With this change we can move the get_socket() method (perhaps renamed to just socket()) to SocketSender, leaving MessageSender implementation agnostic. However, this creates problem with the ownership and lifetime of communication resources (e.g. the socket). How about something like:

class MessageSender; // sender interface
class MessageReceiver; // receiver interface
class SocketSenderReceiver : public MessageSender, public MessageReceiver; // concrete class, sole owner of socket resources

EventSender::EventSender(std::shared_ptr<MessageSender> const& sender);
detail::ProtobufMessageProcessor::ProtobufMessageProcessor(std::shared_ptr<MessageSender> const& sender, ...);
SocketSession::SocketSession(std::shared_ptr<MessageReceiver> const& receiver, ...);

Initialization in start_accept():

auto socket_send_receive = std::make_shared<SocketSenderReceiver>(io_service);
auto event_sink = std::make_shared<detail::EventSender>(socket_send_receive);
auto msg_proc = std::make_shared<detail::ProtobufMessageProcessor>(socket_send_receive, ...);
auto session = std::make_shared<SocketSession>(socket_send_receive, ...);

We could even consider removing SocketSession and handling everything in ProtobufSocketCommunicator by passing all the needed state in the async callbacks (the session id, the message processor etc).

review: Needs Fixing

[Kevin DuBois (kdub)]

was working on this today, it is possible to remove the get_socket method with a bit of refactoring. should have it working tomorrow

[Kevin DuBois (kdub)]

@alexandros, wrote a test (test_socket_session.cpp) to tease out the receiving functionality from the socket session, and ended up with a class structure very close to the suggestion. Also, we now initialize the client resources after the accept (as the acceptor needed the socket to accept the connection, then we transfer the socket to the SocketMessenger class for the lifetime of the connection.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:901
http://jenkins.qa.ubuntu.com/job/mir-ci/1132/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1485/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1370/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/370/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:903
http://jenkins.qa.ubuntu.com/job/mir-ci/1134/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1487
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1372
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/372/console

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

review: Needs Fixing (continuous-integration)

[Kevin DuBois (kdub)]

strange, http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/372/console picked up rev 901 again (when the others in the batch were rev 903, without the conflict)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:903
http://jenkins.qa.ubuntu.com/job/mir-ci/1135/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1488
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1373/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/373/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/737

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:904
http://jenkins.qa.ubuntu.com/job/mir-ci/1136/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1489
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1374
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/374
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/374/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/738/console

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Nit:

726 + EventSender(std::shared_ptr<MessageSender> const& socket_sender);

Ought to be explicit.

review: Approve

[Alexandros Frantzis (afrantzis)]

Enough nits for a "Nits Fixing" (har har har) :)

19 - * Copyright © 2013 Canonical Ltd.
20 + * Copyright © 2012 Canonical Ltd.

?

232 + std::shared_ptr<frontend::EventSink> const& sink);

Incorrect alignment.

1066 + auto sender = std::make_shared<detail::SocketMessenger>(socket);

auto messenger = ...

1072 + auto session = std::make_shared<detail::ProtobufMessageProcessor>(

auto msg_processor = ...

1327 + std::shared_ptr<mfd::MessageReceiver> const& sender,
1336 + : socket_receiver(sender),

s/sender/receiver/

review: Needs Fixing

[Alexandros Frantzis (afrantzis)]

Looks good.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:906
http://jenkins.qa.ubuntu.com/job/mir-ci/1150/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1512
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1397/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/388/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/749

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:907
http://jenkins.qa.ubuntu.com/job/mir-ci/1151/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1513
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1398
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/389
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/389/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/mir-autolanding/516/
Executed test runs:
    FAILURE: http://s-jenkins:8080/job/generic-cleanup-mbs/1169/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1517
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1402
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-autolanding/170/console

review: Needs Fixing (continuous-integration)

[Kevin DuBois (kdub)]

reproduced failure in lp:mir, filed bug about it https://bugs.launchpad.net/mir/+bug/1207083. retriggering landing

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'examples/demo-inprocess-surface-client/inprocess_egl_client.cpp'
--- examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2013-07-30 15:37:33 +0000
+++ examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2013-07-31 16:00:57 +0000
@@ -97,7 +97,7 @@
         .of_buffer_usage(mc::BufferUsage::hardware)
         .of_pixel_format(geom::PixelFormat::argb_8888);
     auto session = session_manager->open_session("Inprocess client",
-                                                 std::shared_ptr<mir::events::EventSink>());
+                                                 std::shared_ptr<mf::EventSink>());
     // TODO: Why do we get an ID? ~racarr
     auto surface = session->get_surface(session_manager->create_surface_for(session, params));
 

=== renamed file 'include/shared/mir/events/event_sink.h' => 'include/server/mir/frontend/event_sink.h'
--- include/shared/mir/events/event_sink.h	2013-04-23 11:56:42 +0000
+++ include/server/mir/frontend/event_sink.h	2013-07-31 16:00:57 +0000
@@ -1,16 +1,16 @@
 /*
  * Copyright © 2013 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 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 Lesser General Public License for more details.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * 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: Daniel van Vugt <[e-mail]>
@@ -23,9 +23,8 @@
 
 namespace mir
 {
-namespace events
+namespace frontend
 {
-
 class EventSink
 {
 public:

=== modified file 'include/server/mir/frontend/protobuf_ipc_factory.h'
--- include/server/mir/frontend/protobuf_ipc_factory.h	2013-04-25 09:48:54 +0000
+++ include/server/mir/frontend/protobuf_ipc_factory.h	2013-07-31 16:00:57 +0000
@@ -23,16 +23,13 @@
 
 namespace mir
 {
-namespace events
-{
-class EventSink;
-}
 namespace protobuf
 {
 class DisplayServer;
 }
 namespace frontend
 {
+class EventSink;
 class ResourceCache;
 class MessageProcessorReport;
 
@@ -40,7 +37,7 @@
 {
 public:
     virtual std::shared_ptr<protobuf::DisplayServer> make_ipc_server(
-        std::shared_ptr<events::EventSink> const& sink) = 0;
+        std::shared_ptr<EventSink> const& sink) = 0;
     virtual std::shared_ptr<ResourceCache> resource_cache() = 0;
     virtual std::shared_ptr<MessageProcessorReport> report() = 0;
 

=== modified file 'include/server/mir/frontend/session_mediator.h'
--- include/server/mir/frontend/session_mediator.h	2013-07-22 02:18:21 +0000
+++ include/server/mir/frontend/session_mediator.h	2013-07-31 16:00:57 +0000
@@ -28,10 +28,6 @@
 
 namespace mir
 {
-namespace events
-{
-class EventSink;
-}
 namespace graphics
 {
 class Buffer;
@@ -54,19 +50,19 @@
 class ResourceCache;
 class SessionMediatorReport;
 class ClientBufferTracker;
+class EventSink;
 
 // SessionMediator relays requests from the client process into the server.
 class SessionMediator : public mir::protobuf::DisplayServer
 {
 public:
-
     SessionMediator(
         std::shared_ptr<Shell> const& shell,
         std::shared_ptr<graphics::Platform> const& graphics_platform,
         std::shared_ptr<graphics::Display> const& display,
         std::shared_ptr<compositor::GraphicBufferAllocator> const& buffer_allocator,
         std::shared_ptr<SessionMediatorReport> const& report,
-        std::shared_ptr<events::EventSink> const& event_sink,
+        std::shared_ptr<EventSink> const& event_sink,
         std::shared_ptr<ResourceCache> const& resource_cache);
 
     ~SessionMediator() noexcept;
@@ -119,7 +115,7 @@
     std::shared_ptr<compositor::GraphicBufferAllocator> const buffer_allocator;
 
     std::shared_ptr<SessionMediatorReport> const report;
-    std::shared_ptr<events::EventSink> const event_sink;
+    std::shared_ptr<EventSink> const event_sink;
     std::shared_ptr<ResourceCache> const resource_cache;
     std::shared_ptr<ClientBufferTracker> const client_tracker;
 

=== modified file 'include/server/mir/frontend/shell.h'
--- include/server/mir/frontend/shell.h	2013-05-21 17:16:43 +0000
+++ include/server/mir/frontend/shell.h	2013-07-31 16:00:57 +0000
@@ -24,16 +24,13 @@
 
 namespace mir
 {
-namespace events
-{
-class EventSink;
-}
 namespace shell
 {
 struct SurfaceCreationParameters;
 }
 namespace frontend
 {
+class EventSink;
 class Session;
 
 class Shell
@@ -41,7 +38,8 @@
 public:
     virtual ~Shell() {}
 
-    virtual std::shared_ptr<Session> open_session(std::string const& name, std::shared_ptr<events::EventSink> const& sink) = 0;
+    virtual std::shared_ptr<Session> open_session(
+        std::string const& name, std::shared_ptr<EventSink> const& sink) = 0;
     virtual void close_session(std::shared_ptr<Session> const& session)  = 0;
 
     virtual SurfaceId create_surface_for(std::shared_ptr<Session> const& session,

=== modified file 'include/server/mir/shell/application_session.h'
--- include/server/mir/shell/application_session.h	2013-07-24 03:59:44 +0000
+++ include/server/mir/shell/application_session.h	2013-07-31 16:00:57 +0000
@@ -25,7 +25,7 @@
 
 namespace mir
 {
-namespace events
+namespace frontend
 {
 class EventSink;
 }
@@ -43,14 +43,8 @@
         std::shared_ptr<SurfaceFactory> const& surface_factory,
         std::string const& session_name,
         std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
-        std::shared_ptr<SessionListener> const& session_listener);
-
-    ApplicationSession(
-        std::shared_ptr<SurfaceFactory> const& surface_factory,
-        std::string const& session_name,
-        std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
         std::shared_ptr<SessionListener> const& session_listener,
-        std::shared_ptr<events::EventSink> const& sink);
+        std::shared_ptr<frontend::EventSink> const& sink);
 
     ~ApplicationSession();
 
@@ -79,7 +73,7 @@
     std::string const session_name;
     std::shared_ptr<SnapshotStrategy> const snapshot_strategy;
     std::shared_ptr<SessionListener> const session_listener;
-    std::shared_ptr<events::EventSink> const event_sink;
+    std::shared_ptr<frontend::EventSink> const event_sink;
 
     frontend::SurfaceId next_id();
 

=== modified file 'include/server/mir/shell/organising_surface_factory.h'
--- include/server/mir/shell/organising_surface_factory.h	2013-05-21 17:16:43 +0000
+++ include/server/mir/shell/organising_surface_factory.h	2013-07-31 16:00:57 +0000
@@ -39,7 +39,7 @@
     std::shared_ptr<Surface> create_surface(
         shell::SurfaceCreationParameters const& params,
         frontend::SurfaceId id,
-        std::shared_ptr<events::EventSink> const& sink) override;
+        std::shared_ptr<frontend::EventSink> const& sink) override;
 
 protected:
     OrganisingSurfaceFactory(OrganisingSurfaceFactory const&) = delete;

=== modified file 'include/server/mir/shell/session_manager.h'
--- include/server/mir/shell/session_manager.h	2013-07-04 04:53:57 +0000
+++ include/server/mir/shell/session_manager.h	2013-07-31 16:00:57 +0000
@@ -30,6 +30,10 @@
 namespace mir
 {
 
+namespace frontend
+{
+class EventSink;
+}
 /// Management of sessions and surfaces
 namespace shell
 {
@@ -54,7 +58,8 @@
                             std::shared_ptr<SessionListener> const& session_listener);
     virtual ~SessionManager();
 
-    virtual std::shared_ptr<frontend::Session> open_session(std::string const& name, std::shared_ptr<events::EventSink> const& sink);
+    virtual std::shared_ptr<frontend::Session> open_session(
+        std::string const& name, std::shared_ptr<frontend::EventSink> const& sink);
     virtual void close_session(std::shared_ptr<frontend::Session> const& session);
 
     frontend::SurfaceId create_surface_for(std::shared_ptr<frontend::Session> const& session,

=== modified file 'include/server/mir/shell/surface.h'
--- include/server/mir/shell/surface.h	2013-07-22 02:18:21 +0000
+++ include/server/mir/shell/surface.h	2013-07-31 16:00:57 +0000
@@ -31,11 +31,10 @@
 
 namespace mir
 {
-namespace events
+namespace frontend
 {
 class EventSink;
 }
-
 namespace shell
 {
 class InputTargeter;
@@ -47,13 +46,9 @@
 public:
     Surface(
         std::shared_ptr<SurfaceBuilder> const& builder,
-        SurfaceCreationParameters const& params);
-
-    Surface(
-        std::shared_ptr<SurfaceBuilder> const& builder,
         SurfaceCreationParameters const& params,
         frontend::SurfaceId id,
-        std::shared_ptr<events::EventSink> const& sink);
+        std::shared_ptr<frontend::EventSink> const& event_sink);
 
     ~Surface() noexcept;
 
@@ -97,7 +92,7 @@
     std::weak_ptr<mir::surfaces::Surface> const surface;
 
     frontend::SurfaceId const id;
-    std::shared_ptr<events::EventSink> const event_sink;
+    std::shared_ptr<frontend::EventSink> const event_sink;
 
     MirSurfaceType type_value;
     MirSurfaceState state_value;

=== modified file 'include/server/mir/shell/surface_factory.h'
--- include/server/mir/shell/surface_factory.h	2013-05-21 17:16:43 +0000
+++ include/server/mir/shell/surface_factory.h	2013-07-31 16:00:57 +0000
@@ -24,11 +24,10 @@
 
 namespace mir
 {
-namespace events
+namespace frontend
 {
 class EventSink;
 }
-
 namespace shell
 {
 class Surface;
@@ -40,7 +39,7 @@
     virtual std::shared_ptr<Surface> create_surface(
         SurfaceCreationParameters const& params,
         frontend::SurfaceId id,
-        std::shared_ptr<events::EventSink> const& sink) = 0;
+        std::shared_ptr<frontend::EventSink> const& sink) = 0;
 
 protected:
     virtual ~SurfaceFactory() {}

=== modified file 'include/server/mir/shell/surface_source.h'
--- include/server/mir/shell/surface_source.h	2013-05-21 22:03:29 +0000
+++ include/server/mir/shell/surface_source.h	2013-07-31 16:00:57 +0000
@@ -39,7 +39,7 @@
     std::shared_ptr<Surface> create_surface(
         shell::SurfaceCreationParameters const& params,
         frontend::SurfaceId id,
-        std::shared_ptr<events::EventSink> const& sink);
+        std::shared_ptr<frontend::EventSink> const& sink);
 
 protected:
     SurfaceSource(const SurfaceSource&) = delete;

=== removed directory 'include/shared/mir/events'
=== added file 'include/test/mir_test_doubles/mock_frontend_surface.h'
--- include/test/mir_test_doubles/mock_frontend_surface.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_frontend_surface.h	2013-07-31 16:00:57 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_FRONTEND_SURFACE_H_
+#define MIR_TEST_DOUBLES_MOCK_FRONTEND_SURFACE_H_
+
+#include "mir/frontend/surface.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+struct MockFrontendSurface : public frontend::Surface
+{
+    MockFrontendSurface()
+    {
+    }
+
+    ~MockFrontendSurface() noexcept {}
+
+    MOCK_METHOD0(destroy, void());
+    MOCK_METHOD0(force_requests_to_complete, void());
+    MOCK_METHOD0(advance_client_buffer, std::shared_ptr<graphics::Buffer>());
+
+    MOCK_CONST_METHOD0(size, geometry::Size());
+    MOCK_CONST_METHOD0(pixel_format, geometry::PixelFormat());
+
+    MOCK_CONST_METHOD0(supports_input, bool());
+    MOCK_CONST_METHOD0(client_input_fd, int());
+
+    MOCK_METHOD2(configure, int(MirSurfaceAttrib, int));
+};
+}
+}
+} // namespace mir
+#endif // MIR_TEST_DOUBLES_MOCK_FRONTEND_SURFACE_H_

=== modified file 'include/test/mir_test_doubles/mock_shell.h'
--- include/test/mir_test_doubles/mock_shell.h	2013-05-21 17:16:43 +0000
+++ include/test/mir_test_doubles/mock_shell.h	2013-07-31 16:00:57 +0000
@@ -34,7 +34,8 @@
 
 struct MockShell : public frontend::Shell
 {
-    MOCK_METHOD2(open_session, std::shared_ptr<frontend::Session>(std::string const&, std::shared_ptr<events::EventSink> const&));
+    MOCK_METHOD2(open_session, std::shared_ptr<frontend::Session>(
+        std::string const&, std::shared_ptr<frontend::EventSink> const&));
     MOCK_METHOD1(close_session, void(std::shared_ptr<frontend::Session> const&));
 
     MOCK_METHOD2(create_surface_for, frontend::SurfaceId(std::shared_ptr<frontend::Session> const&, shell::SurfaceCreationParameters const&));

=== modified file 'include/test/mir_test_doubles/mock_surface.h'
--- include/test/mir_test_doubles/mock_surface.h	2013-07-17 16:31:45 +0000
+++ include/test/mir_test_doubles/mock_surface.h	2013-07-31 16:00:57 +0000
@@ -22,6 +22,7 @@
 #include "mir/shell/surface.h"
 
 #include "mir/shell/surface_creation_parameters.h"
+#include "null_event_sink.h"
 
 #include <gmock/gmock.h>
 
@@ -37,7 +38,7 @@
 struct MockSurface : public shell::Surface
 {
     MockSurface(std::shared_ptr<shell::SurfaceBuilder> const& builder) :
-        shell::Surface(builder, shell::a_surface())
+        shell::Surface(builder, shell::a_surface(), frontend::SurfaceId{}, std::make_shared<NullEventSink>())
     {
     }
 

=== modified file 'include/test/mir_test_doubles/mock_surface_factory.h'
--- include/test/mir_test_doubles/mock_surface_factory.h	2013-05-21 17:16:43 +0000
+++ include/test/mir_test_doubles/mock_surface_factory.h	2013-07-31 16:00:57 +0000
@@ -36,7 +36,7 @@
     MOCK_METHOD3(create_surface, std::shared_ptr<shell::Surface>(
         const shell::SurfaceCreationParameters&,
         frontend::SurfaceId,
-        std::shared_ptr<events::EventSink> const&));
+        std::shared_ptr<frontend::EventSink> const&));
 };
 
 }

=== added file 'include/test/mir_test_doubles/null_event_sink.h'
--- include/test/mir_test_doubles/null_event_sink.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/null_event_sink.h	2013-07-31 16:00:57 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_NULL_EVENT_SINK_H_
+#define MIR_TEST_DOUBLES_NULL_EVENT_SINK_H_
+
+#include "mir/frontend/event_sink.h"
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+struct NullEventSink : public frontend::EventSink
+{
+    void handle_event(MirEvent const&) {}
+};
+}
+}
+}
+#endif /* MIR_TEST_DOUBLES_NULL_EVENT_SINK_H_*/

=== modified file 'include/test/mir_test_doubles/stub_ipc_factory.h'
--- include/test/mir_test_doubles/stub_ipc_factory.h	2013-04-25 09:48:54 +0000
+++ include/test/mir_test_doubles/stub_ipc_factory.h	2013-07-31 16:00:57 +0000
@@ -42,7 +42,7 @@
     }
 
     std::shared_ptr<protobuf::DisplayServer> make_ipc_server(
-        std::shared_ptr<events::EventSink> const&)
+        std::shared_ptr<frontend::EventSink> const&)
     {
         return server;
     }

=== modified file 'include/test/mir_test_doubles/stub_session.h'
--- include/test/mir_test_doubles/stub_session.h	2013-05-21 17:16:43 +0000
+++ include/test/mir_test_doubles/stub_session.h	2013-07-31 16:00:57 +0000
@@ -58,7 +58,7 @@
     {
         return 0;
     }
-    void set_event_sink(std::shared_ptr<events::EventSink> const&)
+    void set_event_sink(std::shared_ptr<frontend::EventSink> const&)
     {
     }
 };

=== modified file 'include/test/mir_test_doubles/stub_shell.h'
--- include/test/mir_test_doubles/stub_shell.h	2013-05-21 17:16:43 +0000
+++ include/test/mir_test_doubles/stub_shell.h	2013-07-31 16:00:57 +0000
@@ -31,7 +31,7 @@
 
 class StubShell : public frontend::Shell
 {
-    std::shared_ptr<frontend::Session> open_session(std::string const& /* name */, std::shared_ptr<events::EventSink> const& /* sink */) override
+    std::shared_ptr<frontend::Session> open_session(std::string const& /* name */, std::shared_ptr<frontend::EventSink> const& /* sink */) override
     {
         return std::make_shared<StubSession>();
     }

=== modified file 'src/client/mir_connection.h'
--- src/client/mir_connection.h	2013-07-26 05:12:14 +0000
+++ src/client/mir_connection.h	2013-07-31 16:00:57 +0000
@@ -34,7 +34,6 @@
 #include "client_context.h"
 
 #include "mir_wait_handle.h"
-#include "mir/events/event_sink.h"
 
 namespace mir
 {

=== modified file 'src/client/rpc/mir_basic_rpc_channel.h'
--- src/client/rpc/mir_basic_rpc_channel.h	2013-07-26 05:12:14 +0000
+++ src/client/rpc/mir_basic_rpc_channel.h	2013-07-31 16:00:57 +0000
@@ -29,10 +29,6 @@
 
 namespace mir
 {
-namespace events
-{
-class EventSink;
-}
 namespace protobuf
 {
 namespace wire

=== modified file 'src/client/rpc/mir_socket_rpc_channel.cpp'
--- src/client/rpc/mir_socket_rpc_channel.cpp	2013-07-26 05:12:14 +0000
+++ src/client/rpc/mir_socket_rpc_channel.cpp	2013-07-31 16:00:57 +0000
@@ -41,7 +41,6 @@
 
 namespace mcl = mir::client;
 namespace mclr = mir::client::rpc;
-namespace me = mir::events;
 
 mclr::MirSocketRpcChannel::MirSocketRpcChannel(
     std::string const& endpoint,

=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2013-07-30 12:21:46 +0000
+++ src/server/default_server_configuration.cpp	2013-07-31 16:00:57 +0000
@@ -83,7 +83,6 @@
 #include <map>
 
 namespace mc = mir::compositor;
-namespace me = mir::events;
 namespace geom = mir::geometry;
 namespace mf = mir::frontend;
 namespace mg = mir::graphics;
@@ -131,7 +130,7 @@
     std::shared_ptr<mc::GraphicBufferAllocator> const buffer_allocator;
 
     virtual std::shared_ptr<mir::protobuf::DisplayServer> make_ipc_server(
-        std::shared_ptr<me::EventSink> const& sink)
+        std::shared_ptr<mf::EventSink> const& sink)
     {
         return std::make_shared<mf::SessionMediator>(
             shell,

=== modified file 'src/server/frontend/CMakeLists.txt'
--- src/server/frontend/CMakeLists.txt	2013-05-30 19:24:29 +0000
+++ src/server/frontend/CMakeLists.txt	2013-07-31 16:00:57 +0000
@@ -8,9 +8,10 @@
   protobuf_message_processor.cpp
   protobuf_buffer_packer.cpp
   null_message_processor.cpp
-  event_pipe.cpp
 
   resource_cache.cpp
+  socket_messenger.cpp
+  event_sender.cpp
   ${PROTO_HDRS}
 )
 

=== removed file 'src/server/frontend/event_pipe.h'
--- src/server/frontend/event_pipe.h	2013-04-23 11:56:42 +0000
+++ src/server/frontend/event_pipe.h	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-/*
- * Copyright © 2013 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: Daniel van Vugt <[e-mail]>
- */
-
-#ifndef MIR_FRONTEND_EVENT_PIPE_H_
-#define MIR_FRONTEND_EVENT_PIPE_H_
-
-#include "mir_toolkit/event.h"
-#include "mir/events/event_sink.h"
-#include <memory>
-
-namespace mir
-{
-namespace frontend
-{
-class EventPipe : public events::EventSink
-{
-public:
-    void set_target(std::weak_ptr<events::EventSink> const& s);
-    void handle_event(MirEvent const& e) override;
-
-private:
-    std::weak_ptr<events::EventSink> target;
-};
-}
-}
-
-#endif // MIR_FRONTEND_EVENT_PIPE_H_

=== renamed file 'src/server/frontend/event_pipe.cpp' => 'src/server/frontend/event_sender.cpp'
--- src/server/frontend/event_pipe.cpp	2013-04-24 08:51:31 +0000
+++ src/server/frontend/event_sender.cpp	2013-07-31 16:00:57 +0000
@@ -16,21 +16,40 @@
  * Authored by: Daniel van Vugt <[e-mail]>
  */
 
-#include "event_pipe.h"
-
-namespace mf = mir::frontend;
-
-void mf::EventPipe::set_target(std::weak_ptr<EventSink> const& s)
+#include "mir/frontend/client_constants.h"
+#include "event_sender.h"
+#include "message_sender.h"
+#include "mir_protobuf_wire.pb.h"
+#include "mir_protobuf.pb.h"
+
+namespace mfd = mir::frontend::detail;
+namespace mp = mir::protobuf;
+
+mfd::EventSender::EventSender(std::shared_ptr<MessageSender> const& socket_sender)
+ : sender(socket_sender)
 {
-    target = s;
 }
 
-void mf::EventPipe::handle_event(MirEvent const& e)
+void mfd::EventSender::handle_event(MirEvent const& e)
 {
-    // In future, we might put e on a queue and wait for some background
-    // thread to push it through to target. But that's not required right now.
-
-    std::shared_ptr<EventSink> p = target.lock();
-    if (p)
-        p->handle_event(e);
+    // Limit the types of events we wish to send over protobuf, for now.
+    if (e.type == mir_event_type_surface)
+    {
+        // In future we might send multiple events, or insert them into messages
+        // containing other responses, but for now we send them individually.
+        mp::EventSequence seq;
+        mp::Event *ev = seq.add_event();
+        ev->set_raw(&e, sizeof(MirEvent));
+
+        std::string buffer;
+        buffer.reserve(serialization_buffer_size);
+        seq.SerializeToString(&buffer);
+
+        mir::protobuf::wire::Result result;
+        result.add_events(buffer);
+
+        result.SerializeToString(&buffer);
+
+        sender->send(buffer);
+    }
 }

=== added file 'src/server/frontend/event_sender.h'
--- src/server/frontend/event_sender.h	1970-01-01 00:00:00 +0000
+++ src/server/frontend/event_sender.h	2013-07-31 16:00:57 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by:
+ *   Kevin DuBois <[e-mail]>
+ */
+#ifndef MIR_FRONTEND_EVENT_SENDER_H_
+#define MIR_FRONTEND_EVENT_SENDER_H_
+
+#include "mir/frontend/event_sink.h"
+#include <memory>
+
+namespace mir
+{
+namespace frontend
+{
+namespace detail
+{
+class MessageSender;
+
+class EventSender : public  mir::frontend::EventSink
+{
+public:
+    explicit EventSender(std::shared_ptr<MessageSender> const& socket_sender);
+    void handle_event(MirEvent const& e);
+
+private:
+    std::shared_ptr<MessageSender> const sender;
+};
+ 
+}
+}
+}
+#endif /* MIR_FRONTEND_EVENT_SENDER_H_ */

=== modified file 'src/server/frontend/message_processor.h'
--- src/server/frontend/message_processor.h	2013-06-27 18:58:31 +0000
+++ src/server/frontend/message_processor.h	2013-07-31 16:00:57 +0000
@@ -16,16 +16,10 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
-
 #ifndef MIR_FRONTEND_MESSAGE_PROCESSOR_H_
 #define MIR_FRONTEND_MESSAGE_PROCESSOR_H_
 
-#include <vector>
-#include <memory>
 #include <iosfwd>
-#include <cstdint>
-
-#include <sys/types.h>
 
 namespace mir
 {
@@ -33,21 +27,10 @@
 {
 namespace detail
 {
-struct MessageSender
-{
-    virtual void send(std::string const& body) = 0;
-    virtual void send_fds(std::vector<int32_t> const& fd) = 0;
-
-    virtual pid_t client_pid() = 0;
-protected:
-    MessageSender() = default;
-    virtual ~MessageSender() { /* TODO: make nothrow */ }
-    MessageSender(MessageSender const&) = delete;
-    MessageSender& operator=(MessageSender const&) = delete;
-};
-
-struct MessageProcessor
-{
+
+class MessageProcessor
+{
+public:
     virtual bool process_message(std::istream& msg) = 0;
 protected:
     MessageProcessor() = default;
@@ -56,15 +39,13 @@
     MessageProcessor& operator=(MessageProcessor const&) = delete;
 };
 
-struct NullMessageProcessor : MessageProcessor
+class NullMessageProcessor : MessageProcessor
 {
+public:
     bool process_message(std::istream&);
 };
 
 }
 }
 }
-
-
-
 #endif /* PROTOBUF_MESSAGE_PROCESSOR_H_ */

=== added file 'src/server/frontend/message_receiver.h'
--- src/server/frontend/message_receiver.h	1970-01-01 00:00:00 +0000
+++ src/server/frontend/message_receiver.h	2013-07-31 16:00:57 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]> 
+ */
+#ifndef MIR_FRONTEND_MESSAGE_RECEIVER_H_
+#define MIR_FRONTEND_MESSAGE_RECEIVER_H_
+
+#include <functional>
+#include <boost/asio.hpp>
+
+namespace mir
+{
+namespace frontend
+{
+namespace detail
+{
+class MessageReceiver
+{
+public:
+    //receive message from the socket. 'handler' will be called when 'buffer' has been filled with exactly 'size'
+    typedef std::function<void(boost::system::error_code const&, size_t)> MirReadHandler;
+    virtual void async_receive_msg(MirReadHandler const& handler, boost::asio::streambuf& buffer, size_t size) = 0; 
+    virtual pid_t client_pid() = 0;
+
+protected:
+    MessageReceiver() = default;
+    virtual ~MessageReceiver() = default;
+    MessageReceiver(MessageReceiver const&) = delete;
+    MessageReceiver& operator=(MessageReceiver const&) = delete;
+};
+
+}
+}
+}
+#endif /* MIR_FRONTEND_MESSAGE_RECEIVER_H_ */

=== added file 'src/server/frontend/message_sender.h'
--- src/server/frontend/message_sender.h	1970-01-01 00:00:00 +0000
+++ src/server/frontend/message_sender.h	2013-07-31 16:00:57 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2012 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: Alan Griffiths <[e-mail]>
+ */
+#ifndef MIR_FRONTEND_MESSAGE_SENDER_H_
+#define MIR_FRONTEND_MESSAGE_SENDER_H_
+
+#include <vector>
+#include <boost/asio.hpp>
+
+namespace mir
+{
+namespace frontend
+{
+namespace detail
+{
+class MessageSender
+{
+public:
+    virtual void send(std::string const& body) = 0;
+    virtual void send_fds(std::vector<int32_t> const& fd) = 0;
+
+protected:
+    MessageSender() = default;
+    virtual ~MessageSender() = default;
+    MessageSender(MessageSender const&) = delete;
+    MessageSender& operator=(MessageSender const&) = delete;
+};
+
+}
+}
+}
+#endif /* MIR_FRONTEND_MESSAGE_SENDER_H_ */

=== modified file 'src/server/frontend/protobuf_message_processor.cpp'
--- src/server/frontend/protobuf_message_processor.cpp	2013-07-15 09:29:14 +0000
+++ src/server/frontend/protobuf_message_processor.cpp	2013-07-31 16:00:57 +0000
@@ -29,7 +29,7 @@
 namespace mfd = mir::frontend::detail;
 
 mfd::ProtobufMessageProcessor::ProtobufMessageProcessor(
-    MessageSender* sender,
+    std::shared_ptr<MessageSender> const& sender,
     std::shared_ptr<protobuf::DisplayServer> const& display_server,
     std::shared_ptr<ResourceCache> const& resource_cache,
     std::shared_ptr<MessageProcessorReport> const& report) :
@@ -136,35 +136,6 @@
     sender->send(send_response_buffer);
 }
 
-void mfd::ProtobufMessageProcessor::send_event(MirEvent const& e)
-{
-    // In future we might send multiple events, or insert them into messages
-    // containing other responses, but for now we send them individually.
-    mir::protobuf::EventSequence seq;
-    mir::protobuf::Event *ev = seq.add_event();
-    ev->set_raw(&e, sizeof(MirEvent));
-
-    std::string buffer;
-    buffer.reserve(serialization_buffer_size);
-    seq.SerializeToString(&buffer);
-
-    mir::protobuf::wire::Result result;
-    result.add_events(buffer);
-
-    result.SerializeToString(&buffer);
-
-    sender->send(buffer);
-}
-
-void mfd::ProtobufMessageProcessor::handle_event(MirEvent const& e)
-{
-    // Limit the types of events we wish to send over protobuf, for now.
-    if (e.type == mir_event_type_surface)
-    {
-        send_event(e);
-    }
-}
-
 bool mfd::ProtobufMessageProcessor::dispatch(mir::protobuf::wire::Invocation const& invocation)
 {
     report->received_invocation(display_server.get(), invocation.id(), invocation.method_name());

=== modified file 'src/server/frontend/protobuf_message_processor.h'
--- src/server/frontend/protobuf_message_processor.h	2013-07-15 09:29:14 +0000
+++ src/server/frontend/protobuf_message_processor.h	2013-07-31 16:00:57 +0000
@@ -21,10 +21,11 @@
 #define MIR_FRONTEND_PROTOBUF_MESSAGE_PROCESSOR_H_
 
 #include "message_processor.h"
+#include "message_sender.h"
 
 #include "mir_protobuf.pb.h"
 #include "mir_protobuf_wire.pb.h"
-#include "mir/events/event_sink.h"
+#include "mir/frontend/event_sink.h"
 
 #include <vector>
 #include <memory>
@@ -43,11 +44,11 @@
 namespace detail
 {
 
-struct ProtobufMessageProcessor : MessageProcessor,
-                                  public events::EventSink
+class ProtobufMessageProcessor : public MessageProcessor
 {
+public:
     ProtobufMessageProcessor(
-        MessageSender* sender,
+        std::shared_ptr<MessageSender> const& sender,
         std::shared_ptr<protobuf::DisplayServer> const& display_server,
         std::shared_ptr<ResourceCache> const& resource_cache,
         std::shared_ptr<MessageProcessorReport> const& report);
@@ -72,10 +73,6 @@
     // OTOH until we have a real requirement it is hard to see how best to generalise.
     void send_response(::google::protobuf::uint32 id, mir::protobuf::Surface* response);
 
-    void send_event(MirEvent const& e);
-
-    void handle_event(MirEvent const& e);
-
     template<class Response>
     std::vector<int32_t> extract_fds_from(Response* response);
 
@@ -92,7 +89,7 @@
             ::google::protobuf::Closure* done),
         mir::protobuf::wire::Invocation const& invocation);
 
-    MessageSender* const sender;
+    std::shared_ptr<MessageSender> const sender;
     std::shared_ptr<protobuf::DisplayServer> const display_server;
     std::shared_ptr<ResourceCache> const resource_cache;
     std::shared_ptr<MessageProcessorReport> const report;

=== modified file 'src/server/frontend/protobuf_socket_communicator.cpp'
--- src/server/frontend/protobuf_socket_communicator.cpp	2013-07-17 21:42:30 +0000
+++ src/server/frontend/protobuf_socket_communicator.cpp	2013-07-31 16:00:57 +0000
@@ -23,8 +23,9 @@
 #include "mir/frontend/communicator_report.h"
 #include "mir/frontend/protobuf_ipc_factory.h"
 #include "mir/frontend/session_authorizer.h"
+#include "socket_messenger.h"
+#include "event_sender.h"
 #include "mir/protobuf/google_protobuf_guard.h"
-#include "event_pipe.h"
 
 #include <boost/signals2.hpp>
 
@@ -54,28 +55,14 @@
 
 void mf::ProtobufSocketCommunicator::start_accept()
 {
-    auto const& event_pipe = std::make_shared<EventPipe>();
-
-    auto const& socket_session = std::make_shared<mfd::SocketSession>(
-        io_service,
-        next_id(),
-        connected_sessions);
-
-    auto session = std::make_shared<detail::ProtobufMessageProcessor>(
-        socket_session.get(),
-        ipc_factory->make_ipc_server(event_pipe),
-        ipc_factory->resource_cache(),
-        ipc_factory->report());
-
-    event_pipe->set_target(session);
-    socket_session->set_processor(session);
+    auto socket = std::make_shared<boost::asio::local::stream_protocol::socket>(io_service);
 
     acceptor.async_accept(
-        socket_session->get_socket(),
+        *socket,
         boost::bind(
             &ProtobufSocketCommunicator::on_new_connection,
             this,
-            socket_session,
+            socket,
             ba::placeholders::error));
 }
 
@@ -143,13 +130,25 @@
 }
 
 void mf::ProtobufSocketCommunicator::on_new_connection(
-    std::shared_ptr<mfd::SocketSession> const& session,
-    const boost::system::error_code& ec)
+    std::shared_ptr<boost::asio::local::stream_protocol::socket> const& socket,
+    boost::system::error_code const& ec)
 {
     if (!ec)
     {
-        if (session_authorizer->connection_is_allowed(session->client_pid()))
+        auto messenger = std::make_shared<detail::SocketMessenger>(socket); 
+        if (session_authorizer->connection_is_allowed(messenger->client_pid()))
         {
+            auto event_sink = std::make_shared<detail::EventSender>(messenger);
+            auto msg_processor = std::make_shared<detail::ProtobufMessageProcessor>(
+                messenger,
+                ipc_factory->make_ipc_server(event_sink),
+                ipc_factory->resource_cache(),
+                ipc_factory->report());
+            auto const& session = std::make_shared<mfd::SocketSession>(
+                messenger,
+                next_id(),
+                connected_sessions,
+                msg_processor);
             connected_sessions->add(session);
             session->read_next_message();
         }

=== modified file 'src/server/frontend/protobuf_socket_communicator.h'
--- src/server/frontend/protobuf_socket_communicator.h	2013-07-09 18:56:51 +0000
+++ src/server/frontend/protobuf_socket_communicator.h	2013-07-31 16:00:57 +0000
@@ -50,6 +50,7 @@
 namespace detail
 {
 struct SocketSession;
+class MessageSender;
 }
 
 class CommunicatorReport;
@@ -72,7 +73,8 @@
 
 private:
     void start_accept();
-    void on_new_connection(std::shared_ptr<detail::SocketSession> const& session, const boost::system::error_code& ec);
+    void on_new_connection(std::shared_ptr<boost::asio::local::stream_protocol::socket> const& socket,
+                           boost::system::error_code const& ec);
     int next_id();
 
     const std::string socket_file;

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2013-07-24 03:59:44 +0000
+++ src/server/frontend/session_mediator.cpp	2013-07-31 16:00:57 +0000
@@ -52,14 +52,14 @@
     std::shared_ptr<graphics::Display> const& display,
     std::shared_ptr<compositor::GraphicBufferAllocator> const& buffer_allocator,
     std::shared_ptr<SessionMediatorReport> const& report,
-    std::shared_ptr<events::EventSink> const& event_sink,
+    std::shared_ptr<EventSink> const& sender,
     std::shared_ptr<ResourceCache> const& resource_cache) :
     shell(shell),
     graphics_platform(graphics_platform),
     display(display),
     buffer_allocator(buffer_allocator),
     report(report),
-    event_sink(event_sink),
+    event_sink(sender),
     resource_cache(resource_cache),
     client_tracker(std::make_shared<ClientBufferTracker>(frontend::client_buffer_cache_size))
 {

=== added file 'src/server/frontend/socket_messenger.cpp'
--- src/server/frontend/socket_messenger.cpp	1970-01-01 00:00:00 +0000
+++ src/server/frontend/socket_messenger.cpp	2013-07-31 16:00:57 +0000
@@ -0,0 +1,109 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "socket_messenger.h"
+#include "mir/frontend/client_constants.h"
+
+namespace mfd = mir::frontend::detail;
+namespace bs = boost::system;
+namespace ba = boost::asio;
+
+mfd::SocketMessenger::SocketMessenger(std::shared_ptr<ba::local::stream_protocol::socket> const& socket)
+    : socket(socket)
+{
+    whole_message.reserve(serialization_buffer_size);
+}
+
+pid_t mfd::SocketMessenger::client_pid()
+{
+    struct ucred cr;
+    socklen_t cl = sizeof(cr);
+    
+    auto status = getsockopt(socket->native_handle(), SOL_SOCKET, SO_PEERCRED, &cr, &cl);
+    
+    if (status)
+        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to query client socket credentials"));
+    return cr.pid;
+}
+
+void mfd::SocketMessenger::send(std::string const& body)
+{
+    const size_t size = body.size();
+    const unsigned char header_bytes[2] =
+    {
+        static_cast<unsigned char>((size >> 8) & 0xff),
+        static_cast<unsigned char>((size >> 0) & 0xff)
+    };
+
+    whole_message.resize(sizeof header_bytes + size);
+    std::copy(header_bytes, header_bytes + sizeof header_bytes, whole_message.begin());
+    std::copy(body.begin(), body.end(), whole_message.begin() + sizeof header_bytes);
+
+    // TODO: This should be asynchronous, but we are not making sure
+    // that a potential call to send_fds is executed _after_ this
+    // function has completed (if it would be executed asynchronously.
+    ba::write(*socket, ba::buffer(whole_message));
+}
+
+void mfd::SocketMessenger::send_fds(std::vector<int32_t> const& fds)
+{
+    auto n_fds = fds.size();
+    if (n_fds > 0)
+    {
+        // We send dummy data
+        struct iovec iov;
+        char dummy_iov_data = 'M';
+        iov.iov_base = &dummy_iov_data;
+        iov.iov_len = 1;
+
+        // Allocate space for control message
+        std::vector<char> control(sizeof(struct cmsghdr) + sizeof(int) * n_fds);
+
+        // Message to send
+        struct msghdr header;
+        header.msg_name = NULL;
+        header.msg_namelen = 0;
+        header.msg_iov = &iov;
+        header.msg_iovlen = 1;
+        header.msg_controllen = control.size();
+        header.msg_control = control.data();
+        header.msg_flags = 0;
+
+        // Control message contains file descriptors
+        struct cmsghdr *message = CMSG_FIRSTHDR(&header);
+        message->cmsg_len = header.msg_controllen;
+        message->cmsg_level = SOL_SOCKET;
+        message->cmsg_type = SCM_RIGHTS;
+        int *data = (int *)CMSG_DATA(message);
+        int i = 0;
+        for (auto &fd: fds)
+            data[i++] = fd;
+
+        sendmsg(socket->native_handle(), &header, 0);
+    }
+}
+
+void mfd::SocketMessenger::async_receive_msg(
+    MirReadHandler const& handler, ba::streambuf& buffer, size_t size)
+{
+    boost::asio::async_read(
+         *socket,
+         buffer,
+         boost::asio::transfer_exactly(size),
+         handler);
+} 

=== added file 'src/server/frontend/socket_messenger.h'
--- src/server/frontend/socket_messenger.h	1970-01-01 00:00:00 +0000
+++ src/server/frontend/socket_messenger.h	2013-07-31 16:00:57 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_FRONTEND_SOCKET_MESSENGER_H_ 
+#define MIR_FRONTEND_SOCKET_MESSENGER_H_ 
+#include "message_sender.h"
+#include "message_receiver.h"
+#include <mutex>
+
+namespace mir
+{
+namespace frontend
+{
+namespace detail
+{
+class SocketMessenger : public MessageSender,
+                        public MessageReceiver
+{
+public:
+    SocketMessenger(std::shared_ptr<boost::asio::local::stream_protocol::socket> const& socket);
+
+    void send(std::string const& body);
+    void send_fds(std::vector<int32_t> const& fds);
+
+    void async_receive_msg(MirReadHandler const& handler, boost::asio::streambuf& buffer, size_t size); 
+    pid_t client_pid();
+
+private:
+    std::shared_ptr<boost::asio::local::stream_protocol::socket> socket;
+    std::vector<char> whole_message;
+};
+}
+}
+}
+
+#endif /* MIR_FRONTEND_SOCKET_MESSENGER_H_ */ 

=== modified file 'src/server/frontend/socket_session.cpp'
--- src/server/frontend/socket_session.cpp	2013-07-15 09:29:14 +0000
+++ src/server/frontend/socket_session.cpp	2013-07-31 16:00:57 +0000
@@ -17,6 +17,9 @@
  */
 
 #include "socket_session.h"
+#include "message_processor.h"
+#include "message_sender.h"
+#include "message_receiver.h"
 
 #include <boost/signals2.hpp>
 #include <boost/throw_exception.hpp>
@@ -26,92 +29,34 @@
 #include <sys/types.h>
 #include <sys/socket.h>
 
-#include "mir/frontend/client_constants.h"
-
 namespace ba = boost::asio;
 namespace bs = boost::system;
 
 namespace mfd = mir::frontend::detail;
 
 mfd::SocketSession::SocketSession(
-    boost::asio::io_service& io_service,
+    std::shared_ptr<mfd::MessageReceiver> const& receiver,
     int id_,
-    std::shared_ptr<ConnectedSessions<SocketSession>> const& connected_sessions) :
-    socket(io_service),
-    id_(id_),
-    connected_sessions(connected_sessions),
-    processor(std::make_shared<NullMessageProcessor>())
+    std::shared_ptr<ConnectedSessions<SocketSession>> const& connected_sessions,
+    std::shared_ptr<MessageProcessor> const& processor)
+     : socket_receiver(receiver),
+       id_(id_),
+       connected_sessions(connected_sessions),
+       processor(processor)
 {
-    whole_message.reserve(serialization_buffer_size);
 }
 
 mfd::SocketSession::~SocketSession() noexcept
 {
 }
 
-void mfd::SocketSession::send(std::string const& body)
-{
-    const size_t size = body.size();
-    const unsigned char header_bytes[2] =
-    {
-        static_cast<unsigned char>((size >> 8) & 0xff),
-        static_cast<unsigned char>((size >> 0) & 0xff)
-    };
-
-    whole_message.resize(sizeof header_bytes + size);
-    std::copy(header_bytes, header_bytes + sizeof header_bytes, whole_message.begin());
-    std::copy(body.begin(), body.end(), whole_message.begin() + sizeof header_bytes);
-
-    // TODO: This should be asynchronous, but we are not making sure
-    // that a potential call to send_fds is executed _after_ this
-    // function has completed (if it would be executed asynchronously.
-    ba::write(socket, ba::buffer(whole_message));
-}
-
-void mfd::SocketSession::send_fds(std::vector<int32_t> const& fds)
-{
-    auto n_fds = fds.size();
-    if (n_fds > 0)
-    {
-        // We send dummy data
-        struct iovec iov;
-        char dummy_iov_data = 'M';
-        iov.iov_base = &dummy_iov_data;
-        iov.iov_len = 1;
-
-        // Allocate space for control message
-        std::vector<char> control(sizeof(struct cmsghdr) + sizeof(int) * n_fds);
-
-        // Message to send
-        struct msghdr header;
-        header.msg_name = NULL;
-        header.msg_namelen = 0;
-        header.msg_iov = &iov;
-        header.msg_iovlen = 1;
-        header.msg_controllen = control.size();
-        header.msg_control = control.data();
-        header.msg_flags = 0;
-
-        // Control message contains file descriptors
-        struct cmsghdr *message = CMSG_FIRSTHDR(&header);
-        message->cmsg_len = header.msg_controllen;
-        message->cmsg_level = SOL_SOCKET;
-        message->cmsg_type = SCM_RIGHTS;
-        int *data = (int *)CMSG_DATA(message);
-        int i = 0;
-        for (auto &fd: fds)
-            data[i++] = fd;
-
-        sendmsg(socket.native_handle(), &header, 0);
-    }
-}
 
 void mfd::SocketSession::read_next_message()
 {
-    ba::async_read(socket,
-        ba::buffer(message_header_bytes),
-        boost::bind(&mfd::SocketSession::on_read_size,
-                    this, ba::placeholders::error));
+    size_t const header_size = 2;
+    auto callback = std::bind(&mfd::SocketSession::on_read_size,
+                        this, std::placeholders::_1);
+    socket_receiver->async_receive_msg(callback, message, header_size);
 }
 
 void mfd::SocketSession::on_read_size(const boost::system::error_code& error)
@@ -121,15 +66,14 @@
         connected_sessions->remove(id());
         BOOST_THROW_EXCEPTION(std::runtime_error(error.message()));
     }
-
-    size_t const body_size = (message_header_bytes[0] << 8) + message_header_bytes[1];
-
-    ba::async_read(
-         socket,
-         message,
-         ba::transfer_exactly(body_size),
-         boost::bind(&mfd::SocketSession::on_new_message,
-                     this, ba::placeholders::error));
+  
+    unsigned char high_byte = message.sbumpc();
+    unsigned char low_byte = message.sbumpc();
+    size_t const body_size = (high_byte << 8) + low_byte;
+
+    auto callback = std::bind(&mfd::SocketSession::on_new_message,
+                        this, std::placeholders::_1);
+    socket_receiver->async_receive_msg(callback, message, body_size);
 }
 
 void mfd::SocketSession::on_new_message(const boost::system::error_code& error)
@@ -160,15 +104,3 @@
         BOOST_THROW_EXCEPTION(std::runtime_error(error.message()));
     }
 }
-
-pid_t mfd::SocketSession::client_pid()
-{
-    struct ucred cr;
-    socklen_t cl = sizeof(cr);
-    
-    auto status = getsockopt(socket.native_handle(), SOL_SOCKET, SO_PEERCRED, &cr, &cl);
-    
-    if (status)
-        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to query client socket credentials"));
-    return cr.pid;
-}

=== modified file 'src/server/frontend/socket_session.h'
--- src/server/frontend/socket_session.h	2013-07-10 16:29:06 +0000
+++ src/server/frontend/socket_session.h	2013-07-31 16:00:57 +0000
@@ -34,12 +34,15 @@
 namespace detail
 {
 
-struct SocketSession : public MessageSender
+class MessageReceiver;
+
+struct SocketSession
 {
     SocketSession(
-        boost::asio::io_service& io_service,
+        std::shared_ptr<MessageReceiver> const& socket_receiver,
         int id_,
-        std::shared_ptr<ConnectedSessions<SocketSession>> const& connected_sessions);
+        std::shared_ptr<ConnectedSessions<SocketSession>> const& connected_sessions,
+        std::shared_ptr<MessageProcessor> const& processor);
 
     ~SocketSession() noexcept;
 
@@ -47,34 +50,18 @@
 
     void read_next_message();
 
-    void set_processor(std::shared_ptr<MessageProcessor> const& processor)
-    {
-        this->processor = processor;
-    }
-
-    boost::asio::local::stream_protocol::socket& get_socket()
-    {
-        return socket;
-    }
-
-    pid_t client_pid();
-
 private:
-    void send(std::string const& body);
-    void send_fds(std::vector<int32_t> const& fd);
-
     void on_response_sent(boost::system::error_code const& error, std::size_t);
     void on_new_message(const boost::system::error_code& ec);
     void on_read_size(const boost::system::error_code& ec);
 
-    boost::asio::local::stream_protocol::socket socket;
+    std::shared_ptr<MessageReceiver> const socket_receiver;
     int const id_;
     std::shared_ptr<ConnectedSessions<SocketSession>> const connected_sessions;
     std::shared_ptr<MessageProcessor> processor;
+
+    boost::asio::streambuf header;
     boost::asio::streambuf message;
-    static size_t const size_of_header = 2;
-    unsigned char message_header_bytes[size_of_header];
-    std::vector<char> whole_message;
 };
 
 }

=== modified file 'src/server/shell/application_session.cpp'
--- src/server/shell/application_session.cpp	2013-07-24 03:59:44 +0000
+++ src/server/shell/application_session.cpp	2013-07-31 16:00:57 +0000
@@ -29,7 +29,6 @@
 #include <cassert>
 #include <algorithm>
 
-namespace me = mir::events;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 
@@ -38,7 +37,7 @@
     std::string const& session_name,
     std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
     std::shared_ptr<msh::SessionListener> const& session_listener,
-    std::shared_ptr<me::EventSink> const& sink) :
+    std::shared_ptr<mf::EventSink> const& sink) :
     surface_factory(surface_factory),
     session_name(session_name),
     snapshot_strategy(snapshot_strategy),
@@ -49,15 +48,6 @@
     assert(surface_factory);
 }
 
-msh::ApplicationSession::ApplicationSession(
-    std::shared_ptr<SurfaceFactory> const& surface_factory,
-    std::string const& session_name,
-    std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
-    std::shared_ptr<msh::SessionListener> const& session_listener) :
-    ApplicationSession(surface_factory, session_name, snapshot_strategy, session_listener, std::shared_ptr<me::EventSink>())
-{
-}
-
 msh::ApplicationSession::~ApplicationSession()
 {
     std::unique_lock<std::mutex> lock(surfaces_mutex);

=== modified file 'src/server/shell/organising_surface_factory.cpp'
--- src/server/shell/organising_surface_factory.cpp	2013-05-21 17:16:43 +0000
+++ src/server/shell/organising_surface_factory.cpp	2013-07-31 16:00:57 +0000
@@ -37,10 +37,10 @@
 std::shared_ptr<msh::Surface> msh::OrganisingSurfaceFactory::create_surface(
     shell::SurfaceCreationParameters const& params,
     frontend::SurfaceId id,
-    std::shared_ptr<events::EventSink> const& sink)
+    std::shared_ptr<mf::EventSink> const& sender)
 {
     auto placed_params = placement_strategy->place(params);
 
-    return underlying_factory->create_surface(placed_params, id, sink);
+    return underlying_factory->create_surface(placed_params, id, sender);
 }
 

=== modified file 'src/server/shell/session_manager.cpp'
--- src/server/shell/session_manager.cpp	2013-07-24 03:59:44 +0000
+++ src/server/shell/session_manager.cpp	2013-07-31 16:00:57 +0000
@@ -73,13 +73,12 @@
         close_session(session);
 }
 
-std::shared_ptr<mf::Session> msh::SessionManager::open_session(
-    std::string const& name,
-    std::shared_ptr<events::EventSink> const& sink)
+std::shared_ptr<mf::Session> msh::SessionManager::open_session(std::string const& name,
+                                                std::shared_ptr<mf::EventSink> const& sender)
 {
     std::shared_ptr<msh::Session> new_session =
         std::make_shared<msh::ApplicationSession>(
-            surface_factory, name, snapshot_strategy, session_listener, sink);
+            surface_factory, name, snapshot_strategy, session_listener, sender);
 
     app_container->insert_session(new_session);
     

=== modified file 'src/server/shell/surface.cpp'
--- src/server/shell/surface.cpp	2013-07-19 09:47:28 +0000
+++ src/server/shell/surface.cpp	2013-07-31 16:00:57 +0000
@@ -20,7 +20,7 @@
 #include "mir/shell/surface_builder.h"
 #include "mir/shell/input_targeter.h"
 #include "mir/input/input_channel.h"
-#include "mir/events/event_sink.h"
+#include "mir/frontend/event_sink.h"
 
 #include "mir_toolkit/event.h"
 
@@ -35,28 +35,17 @@
 namespace mi = mir::input;
 namespace ms = mir::surfaces;
 namespace geom = mir::geometry;
+namespace mf = mir::frontend;
 
 msh::Surface::Surface(
     std::shared_ptr<SurfaceBuilder> const& builder,
     shell::SurfaceCreationParameters const& params,
     frontend::SurfaceId id,
-    std::shared_ptr<events::EventSink> const& sink)
+    std::shared_ptr<mf::EventSink> const& event_sink)
   : builder(builder),
     surface(builder->create_surface(params)),
     id(id),
-    event_sink(sink),
-    type_value(mir_surface_type_normal),
-    state_value(mir_surface_state_restored)
-{
-}
-
-msh::Surface::Surface(
-    std::shared_ptr<SurfaceBuilder> const& builder,
-    shell::SurfaceCreationParameters const& params)
-  : builder(builder),
-    surface(builder->create_surface(params)),
-    id(),
-    event_sink(),
+    event_sink(event_sink),
     type_value(mir_surface_type_normal),
     state_value(mir_surface_state_restored)
 {
@@ -302,22 +291,19 @@
 
 void msh::Surface::notify_change(MirSurfaceAttrib attrib, int value)
 {
-    if (event_sink)
-    {
-        MirEvent e;
-
-        // This memset is not really required. However it does avoid some
-        // harmless uninitialized memory reads that valgrind will complain
-        // about, due to gaps in MirEvent.
-        memset(&e, 0, sizeof e);
-
-        e.type = mir_event_type_surface;
-        e.surface.id = id.as_value();
-        e.surface.attrib = attrib;
-        e.surface.value = value;
-
-        event_sink->handle_event(e);
-    }
+    MirEvent e;
+
+    // This memset is not really required. However it does avoid some
+    // harmless uninitialized memory reads that valgrind will complain
+    // about, due to gaps in MirEvent.
+    memset(&e, 0, sizeof e);
+
+    e.type = mir_event_type_surface;
+    e.surface.id = id.as_value();
+    e.surface.attrib = attrib;
+    e.surface.value = value;
+
+    event_sink->handle_event(e);
 }
 
 void msh::Surface::take_input_focus(std::shared_ptr<msh::InputTargeter> const& targeter)

=== modified file 'src/server/shell/surface_source.cpp'
--- src/server/shell/surface_source.cpp	2013-05-21 22:03:29 +0000
+++ src/server/shell/surface_source.cpp	2013-07-31 16:00:57 +0000
@@ -39,12 +39,8 @@
 std::shared_ptr<msh::Surface> msh::SurfaceSource::create_surface(
     shell::SurfaceCreationParameters const& params,
     frontend::SurfaceId id,
-    std::shared_ptr<events::EventSink> const& sink)
+    std::shared_ptr<mf::EventSink> const& sender)
 {
-    return std::make_shared<Surface>(
-        surface_builder,
-        params,
-        id,
-        sink);
+    return std::make_shared<Surface>(surface_builder, params, id, sender);
 }
 

=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2013-07-29 15:13:09 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2013-07-31 16:00:57 +0000
@@ -54,7 +54,6 @@
 namespace mis = mi::synthesis;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
-namespace me = mir::events;
 namespace ms = mir::surfaces;
 namespace mg = mir::graphics;
 namespace geom = mir::geometry;
@@ -621,7 +620,7 @@
     
     std::shared_ptr<msh::Surface> create_surface(msh::SurfaceCreationParameters const& params,
                                                  mf::SurfaceId id,
-                                                 std::shared_ptr<me::EventSink> const& sink)
+                                                 std::shared_ptr<mf::EventSink> const& sink)
     {
         auto surface = underlying_factory->create_surface(params, id, sink);
 

=== modified file 'tests/integration-tests/graphics/android/test_internal_client.cpp'
--- tests/integration-tests/graphics/android/test_internal_client.cpp	2013-07-30 15:37:33 +0000
+++ tests/integration-tests/graphics/android/test_internal_client.cpp	2013-07-31 16:00:57 +0000
@@ -112,7 +112,7 @@
     auto surface_controller = std::make_shared<ms::SurfaceController>(ss);
     auto surface_source = std::make_shared<msh::SurfaceSource>(surface_controller);
     auto mir_surface = std::make_shared<ForwardingInternalSurface>(
-        surface_source->create_surface(params, id, std::shared_ptr<mir::events::EventSink>()));
+        surface_source->create_surface(params, id, std::shared_ptr<mf::EventSink>()));
 
     auto options = std::shared_ptr<mo::ProgramOption>(); 
     auto report = std::shared_ptr<mg::NullDisplayReport>(); 

=== modified file 'tests/integration-tests/shell/test_session.cpp'
--- tests/integration-tests/shell/test_session.cpp	2013-07-30 09:11:45 +0000
+++ tests/integration-tests/shell/test_session.cpp	2013-07-31 16:00:57 +0000
@@ -33,6 +33,7 @@
 
 #include "mir_test_doubles/stub_buffer.h"
 #include "mir_test_doubles/null_display.h"
+#include "mir_test_doubles/null_event_sink.h"
 #include "mir_test_doubles/stub_display_buffer.h"
 
 #include <gtest/gtest.h>
@@ -175,8 +176,10 @@
         conf.the_shell_surface_factory(),
         "stress",
         conf.the_shell_snapshot_strategy(),
-        std::make_shared<msh::NullSessionListener>()};
-    session.create_surface(msh::a_surface().of_size({50,50}));
+        std::make_shared<msh::NullSessionListener>(),
+        std::make_shared<mtd::NullEventSink>()
+    };
+    session.create_surface(msh::a_surface());
 
     auto compositor = conf.the_compositor();
 

=== modified file 'tests/integration-tests/shell/test_session_manager.cpp'
--- tests/integration-tests/shell/test_session_manager.cpp	2013-06-25 13:19:15 +0000
+++ tests/integration-tests/shell/test_session_manager.cpp	2013-07-31 16:00:57 +0000
@@ -33,12 +33,12 @@
 #include "mir_test_doubles/mock_surface_factory.h"
 #include "mir_test_doubles/mock_focus_setter.h"
 #include "mir_test_doubles/null_snapshot_strategy.h"
+#include "mir_test_doubles/null_event_sink.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 namespace mc = mir::compositor;
-namespace me = mir::events;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 namespace ms = mir::surfaces;
@@ -66,9 +66,9 @@
 
     EXPECT_CALL(focus_setter, set_focus_to(_)).Times(3);
 
-    auto session1 = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
-    auto session2 = session_manager.open_session("Microsoft Access", std::shared_ptr<me::EventSink>());
-    auto session3 = session_manager.open_session("WordPerfect", std::shared_ptr<me::EventSink>());
+    auto session1 = session_manager.open_session("Visual Basic Studio", std::make_shared<mtd::NullEventSink>());
+    auto session2 = session_manager.open_session("Microsoft Access", std::make_shared<mtd::NullEventSink>());
+    auto session3 = session_manager.open_session("WordPerfect", std::make_shared<mtd::NullEventSink>());
 
     Mock::VerifyAndClearExpectations(&focus_setter);
 
@@ -110,9 +110,9 @@
 
     EXPECT_CALL(focus_setter, set_focus_to(_)).Times(3);
 
-    auto session1 = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
-    auto session2 = session_manager.open_session("Microsoft Access", std::shared_ptr<me::EventSink>());
-    auto session3 = session_manager.open_session("WordPerfect", std::shared_ptr<me::EventSink>());
+    auto session1 = session_manager.open_session("Visual Basic Studio", std::make_shared<mtd::NullEventSink>());
+    auto session2 = session_manager.open_session("Microsoft Access", std::make_shared<mtd::NullEventSink>());
+    auto session3 = session_manager.open_session("WordPerfect", std::make_shared<mtd::NullEventSink>());
 
     Mock::VerifyAndClearExpectations(&focus_setter);
 

=== modified file 'tests/unit-tests/client/test_mir_connection.cpp'
--- tests/unit-tests/client/test_mir_connection.cpp	2013-07-26 05:12:14 +0000
+++ tests/unit-tests/client/test_mir_connection.cpp	2013-07-31 16:00:57 +0000
@@ -66,8 +66,6 @@
 
     MOCK_METHOD1(drm_auth_magic, void(const mp::DRMMagic*));
     MOCK_METHOD2(connect, void(mp::ConnectParameters const*,mp::Connection*));
-
-    void set_event_handler(mir::events::EventSink *) {}
 };
 
 struct MockClientPlatform : public mcl::ClientPlatform

=== modified file 'tests/unit-tests/frontend/CMakeLists.txt'
--- tests/unit-tests/frontend/CMakeLists.txt	2013-05-30 03:50:54 +0000
+++ tests/unit-tests/frontend/CMakeLists.txt	2013-07-31 16:00:57 +0000
@@ -7,7 +7,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_protobuf_buffer_packer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_resource_cache.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_session_mediator.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_event_pipe.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_socket_session.cpp
 )
 
 # TODO this test is a mess - something better is needed.

=== removed file 'tests/unit-tests/frontend/test_event_pipe.cpp'
--- tests/unit-tests/frontend/test_event_pipe.cpp	2013-04-23 11:56:42 +0000
+++ tests/unit-tests/frontend/test_event_pipe.cpp	1970-01-01 00:00:00 +0000
@@ -1,116 +0,0 @@
-/*
- * Copyright © 2013 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: Daniel van Vugt <[e-mail]>
- */
-
-#include "src/server/frontend/event_pipe.h"
-#include <cstring>
-
-#include <gtest/gtest.h>
-
-using mir::frontend::EventPipe;
-
-
-TEST(EventPipe, no_sink)
-{
-    EventPipe q;
-    MirEvent e;
-
-    e.type = mir_event_type_key;
-    q.handle_event(e);
-
-    e.type = mir_event_type_motion;
-    q.handle_event(e);
-
-    e.type = mir_event_type_surface;
-    q.handle_event(e);
-}
-
-namespace
-{
-    class TestSink : public mir::events::EventSink
-    {
-    public:
-        TestSink()
-        {
-            memset(&last_event, 0, sizeof last_event);
-        }
-
-        void handle_event(MirEvent const& e)
-        {
-            last_event = e;
-        }
-
-        MirEvent const& last_event_handled() const
-        {
-            return last_event;
-        }
-
-    private:
-        MirEvent last_event;
-    };
-}
-
-TEST(EventPipe, events_get_handled)
-{
-    EventPipe q;
-    std::shared_ptr<TestSink> s(new TestSink);
-
-    q.set_target(s);
-
-    MirEvent e;
-    memset(&e, 0, sizeof e);
-
-    e.type = mir_event_type_key;
-    q.handle_event(e);
-    EXPECT_EQ(mir_event_type_key, s->last_event_handled().type);
-
-    e.type = mir_event_type_motion;
-    q.handle_event(e);
-    EXPECT_EQ(mir_event_type_motion, s->last_event_handled().type);
-
-    e.type = mir_event_type_surface;
-    q.handle_event(e);
-    EXPECT_EQ(mir_event_type_surface, s->last_event_handled().type);
-}
-
-TEST(EventPipe, sink_is_changeable)
-{
-    EventPipe q;
-    std::shared_ptr<TestSink> a(new TestSink);
-    std::shared_ptr<TestSink> b(new TestSink);
-
-    q.set_target(a);
-
-    MirEvent e;
-    memset(&e, 0, sizeof e);
-
-    e.type = mir_event_type_motion;
-    q.handle_event(e);
-    EXPECT_EQ(mir_event_type_motion, a->last_event_handled().type);
-
-    q.set_target(b);
-
-    e.type = mir_event_type_surface;
-    q.handle_event(e);
-    EXPECT_EQ(mir_event_type_surface, b->last_event_handled().type);
-    EXPECT_EQ(mir_event_type_motion, a->last_event_handled().type);
-
-    e.type = mir_event_type_key;
-    q.handle_event(e);
-    EXPECT_EQ(mir_event_type_key, b->last_event_handled().type);
-    EXPECT_EQ(mir_event_type_motion, a->last_event_handled().type);
-}

=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2013-07-24 03:59:44 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2013-07-31 16:00:57 +0000
@@ -28,12 +28,12 @@
 #include "mir/surfaces/surface.h"
 #include "mir_test_doubles/null_display.h"
 #include "mir_test_doubles/mock_shell.h"
-#include "mir_test_doubles/mock_surface.h"
+#include "mir_test_doubles/mock_frontend_surface.h"
 #include "mir_test_doubles/mock_buffer.h"
 #include "mir_test_doubles/stub_session.h"
 #include "mir_test_doubles/stub_surface_builder.h"
 #include "mir_test/fake_shared.h"
-#include "mir/events/event_sink.h"
+#include "mir/frontend/event_sink.h"
 #include "mir/shell/surface.h"
 
 #include <gtest/gtest.h>
@@ -61,7 +61,7 @@
     {
         using namespace ::testing;
 
-        mock_surface = std::make_shared<mtd::MockSurface>(mt::fake_shared(surface_builder));
+        mock_surface = std::make_shared<mtd::MockFrontendSurface>();
         mock_buffer = std::make_shared<NiceMock<mtd::MockBuffer>>(geom::Size(), geom::Stride(), geom::PixelFormat());
 
         EXPECT_CALL(*mock_surface, size()).Times(AnyNumber()).WillRepeatedly(Return(geom::Size()));
@@ -78,7 +78,7 @@
     }
 
     mtd::StubSurfaceBuilder surface_builder;
-    std::shared_ptr<mtd::MockSurface> mock_surface;
+    std::shared_ptr<mtd::MockFrontendSurface> mock_surface;
     std::shared_ptr<mtd::MockBuffer> mock_buffer;
     static int const testing_client_input_fd;
 };
@@ -127,7 +127,7 @@
                                               std::shared_ptr<mg::Buffer> const&));
 };
 
-class NullEventSink : public mir::events::EventSink
+class NullEventSink : public mir::frontend::EventSink
 {
 public:
     void handle_event(MirEvent const& ) override {}

=== modified file 'tests/unit-tests/frontend/test_session_mediator_android.cpp'
--- tests/unit-tests/frontend/test_session_mediator_android.cpp	2013-07-17 16:31:45 +0000
+++ tests/unit-tests/frontend/test_session_mediator_android.cpp	2013-07-31 16:00:57 +0000
@@ -31,8 +31,7 @@
 #include "mir_test_doubles/mock_session.h"
 #include "mir_test_doubles/stub_shell.h"
 #include "mir_test_doubles/null_platform.h"
-
-#include "mir/events/event_sink.h"
+#include "mir_test_doubles/null_event_sink.h"
 
 #include <gtest/gtest.h>
 
@@ -63,12 +62,6 @@
     }
 };
 
-class NullEventSink : public mir::events::EventSink
-{
-public:
-    void handle_event(MirEvent const& ) override {}
-};
-
 struct SessionMediatorAndroidTest : public ::testing::Test
 {
     SessionMediatorAndroidTest()
@@ -80,7 +73,7 @@
           resource_cache{std::make_shared<mf::ResourceCache>()},
           mediator{shell, graphics_platform, graphics_display,
                    buffer_allocator, report,
-                   std::make_shared<NullEventSink>(),
+                   std::make_shared<mtd::NullEventSink>(),
                    resource_cache},
           null_callback{google::protobuf::NewPermanentCallback(google::protobuf::DoNothing)}
     {

=== modified file 'tests/unit-tests/frontend/test_session_mediator_gbm.cpp'
--- tests/unit-tests/frontend/test_session_mediator_gbm.cpp	2013-07-17 16:31:45 +0000
+++ tests/unit-tests/frontend/test_session_mediator_gbm.cpp	2013-07-31 16:00:57 +0000
@@ -24,7 +24,7 @@
 #include "mir/frontend/shell.h"
 #include "mir/graphics/display.h"
 #include "mir/graphics/drm_authenticator.h"
-#include "mir/events/event_sink.h"
+#include "mir/frontend/event_sink.h"
 
 #include <boost/exception/errinfo_errno.hpp>
 #include <boost/throw_exception.hpp>
@@ -74,7 +74,7 @@
     MOCK_METHOD1(drm_auth_magic, void(drm_magic_t));
 };
 
-class NullEventSink : public mir::events::EventSink
+class NullEventSink : public mir::frontend::EventSink
 {
 public:
     void handle_event(MirEvent const& ) override {}

=== added file 'tests/unit-tests/frontend/test_socket_session.cpp'
--- tests/unit-tests/frontend/test_socket_session.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/frontend/test_socket_session.cpp	2013-07-31 16:00:57 +0000
@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "src/server/frontend/socket_session.h"
+#include "src/server/frontend/message_receiver.h"
+#include "src/server/frontend/message_processor.h"
+
+#include "mir_test/fake_shared.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace mfd = mir::frontend::detail;
+namespace ba = boost::asio;
+namespace mt = mir::test;
+
+namespace
+{
+struct MockReceiver : public mfd::MessageReceiver
+{
+    MOCK_METHOD3(async_receive_msg, void(std::function<void(boost::system::error_code const&, size_t)> const&,
+                                         boost::asio::streambuf&, size_t)); 
+    MOCK_METHOD0(client_pid, pid_t());
+};
+
+struct MockProcessor : public mfd::MessageProcessor
+{
+    MOCK_METHOD1(process_message, bool(std::istream&));
+};
+}
+struct SocketSessionTest : public ::testing::Test
+{
+    testing::NiceMock<MockProcessor> mock_processor;
+    testing::NiceMock<MockReceiver> mock_receiver;
+};
+
+TEST_F(SocketSessionTest, basic_msg)
+{
+    using namespace testing;
+
+    std::shared_ptr<mfd::ConnectedSessions<mfd::SocketSession>> null_sessions;
+    std::function<void(boost::system::error_code const&, size_t)> header_read, body_read;
+
+    size_t header_size = 2;
+    EXPECT_CALL(mock_receiver, async_receive_msg(_,_, header_size))
+        .Times(1)
+        .WillOnce(SaveArg<0>(&header_read));
+
+    mfd::SocketSession session(mt::fake_shared(mock_receiver), 0, null_sessions, mt::fake_shared(mock_processor));
+
+    //trigger wait for header
+    session.read_next_message();
+    testing::Mock::VerifyAndClearExpectations(&mock_receiver);
+
+    //trigger body read
+    EXPECT_CALL(mock_receiver, async_receive_msg(_,_,_))
+        .Times(1)
+        .WillOnce(SaveArg<0>(&body_read));
+
+    boost::system::error_code code;
+    header_read(code, 2);
+ 
+    testing::Mock::VerifyAndClearExpectations(&mock_receiver);
+
+    //trigger message process
+    EXPECT_CALL(mock_processor, process_message(_))
+        .Times(1)
+        .WillOnce(Return(true));
+    body_read(code, 9);
+}

=== modified file 'tests/unit-tests/graphics/gbm/test_internal_native_surface.cpp'
--- tests/unit-tests/graphics/gbm/test_internal_native_surface.cpp	2013-07-30 15:37:33 +0000
+++ tests/unit-tests/graphics/gbm/test_internal_native_surface.cpp	2013-07-31 16:00:57 +0000
@@ -25,7 +25,7 @@
 
 #include "mir_test/fake_shared.h"
 #include "mir_test_doubles/stub_surface_builder.h"
-#include "mir_test_doubles/mock_surface.h"
+#include "mir_test_doubles/mock_frontend_surface.h"
 #include "mir_test_doubles/mock_buffer.h"
 
 #include <gtest/gtest.h>

=== modified file 'tests/unit-tests/shell/test_application_session.cpp'
--- tests/unit-tests/shell/test_application_session.cpp	2013-07-24 03:59:44 +0000
+++ tests/unit-tests/shell/test_application_session.cpp	2013-07-31 16:00:57 +0000
@@ -27,6 +27,7 @@
 #include "mir_test_doubles/stub_surface_builder.h"
 #include "mir_test_doubles/stub_surface.h"
 #include "mir_test_doubles/null_snapshot_strategy.h"
+#include "mir_test_doubles/null_event_sink.h"
 
 #include "mir/shell/surface.h"
 
@@ -34,7 +35,6 @@
 #include <gtest/gtest.h>
 
 namespace mc = mir::compositor;
-namespace me = mir::events;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 namespace ms = mir::surfaces;
@@ -46,11 +46,12 @@
 {
     using namespace ::testing;
 
+    mtd::NullEventSink sender;
     mtd::StubSurfaceBuilder surface_builder;
     auto const mock_surface = std::make_shared<mtd::MockSurface>(mt::fake_shared(surface_builder));
 
     mtd::MockSurfaceFactory surface_factory;
-    ON_CALL(surface_factory, create_surface(_, _, _)).WillByDefault(Return(mock_surface));
+    ON_CALL(surface_factory, create_surface(_,_,_)).WillByDefault(Return(mock_surface));
 
     EXPECT_CALL(surface_factory, create_surface(_, _, _));
     EXPECT_CALL(*mock_surface, destroy());
@@ -61,7 +62,7 @@
 
     msh::ApplicationSession session(mt::fake_shared(surface_factory), "Foo",
                                     std::make_shared<mtd::NullSnapshotStrategy>(),
-                                    mt::fake_shared(listener));
+                                    mt::fake_shared(listener), mt::fake_shared(sender));
 
     msh::SurfaceCreationParameters params;
     auto surf = session.create_surface(params);
@@ -73,6 +74,7 @@
 {
     using namespace ::testing;
 
+    mtd::NullEventSink sender;
     mtd::MockSurfaceFactory surface_factory;
     mtd::StubSurfaceBuilder surface_builder;
     {
@@ -87,7 +89,7 @@
 
     msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo",
                                         std::make_shared<mtd::NullSnapshotStrategy>(),
-                                        std::make_shared<msh::NullSessionListener>());
+                                        std::make_shared<msh::NullSessionListener>(), mt::fake_shared(sender));
                                         
 
     msh::SurfaceCreationParameters params;
@@ -112,6 +114,7 @@
 {
     using namespace ::testing;
 
+    mtd::NullEventSink sender;
     mtd::StubSurfaceBuilder surface_builder;
     auto const mock_surface = std::make_shared<mtd::MockSurface>(mt::fake_shared(surface_builder));
 
@@ -120,7 +123,7 @@
 
     msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo",
                                         std::make_shared<mtd::NullSnapshotStrategy>(),
-                                        std::make_shared<msh::NullSessionListener>());
+                                        std::make_shared<msh::NullSessionListener>(), mt::fake_shared(sender));
 
     EXPECT_CALL(surface_factory, create_surface(_, _, _));
 
@@ -144,10 +147,11 @@
 {
     using namespace ::testing;
 
+    mtd::NullEventSink sender;
     mtd::MockSurfaceFactory surface_factory;
     msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo",
                                         std::make_shared<mtd::NullSnapshotStrategy>(),
-                                        std::make_shared<msh::NullSessionListener>());
+                                        std::make_shared<msh::NullSessionListener>(), mt::fake_shared(sender));
     mf::SurfaceId invalid_surface_id(1);
 
     EXPECT_THROW({
@@ -159,10 +163,11 @@
 {
     using namespace ::testing;
 
+    mtd::NullEventSink sender;
     mtd::MockSurfaceFactory surface_factory;
     msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo",
                                         std::make_shared<mtd::NullSnapshotStrategy>(),
-                                        std::make_shared<msh::NullSessionListener>());
+                                        std::make_shared<msh::NullSessionListener>(), mt::fake_shared(sender));
     mf::SurfaceId invalid_surface_id(1);
 
     EXPECT_THROW({
@@ -186,10 +191,11 @@
     };
 
     auto snapshot_strategy = std::make_shared<MockSnapshotStrategy>();
+    mtd::NullEventSink sender;
     mtd::MockSurfaceFactory surface_factory;
     msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo",
                                         snapshot_strategy,
-                                        std::make_shared<msh::NullSessionListener>());
+                                        std::make_shared<msh::NullSessionListener>(), mt::fake_shared(sender));
 
     EXPECT_CALL(*snapshot_strategy, take_snapshot_of(_,_));
 

=== modified file 'tests/unit-tests/shell/test_organising_surface_factory.cpp'
--- tests/unit-tests/shell/test_organising_surface_factory.cpp	2013-05-21 17:16:43 +0000
+++ tests/unit-tests/shell/test_organising_surface_factory.cpp	2013-07-31 16:00:57 +0000
@@ -17,6 +17,7 @@
  */
 
 #include <mir_test_doubles/mock_surface_factory.h>
+#include <mir_test_doubles/null_event_sink.h>
 
 #include <mir/shell/organising_surface_factory.h>
 #include <mir/shell/placement_strategy.h>
@@ -25,7 +26,6 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
-namespace me = mir::events;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 namespace geom = mir::geometry;
@@ -69,7 +69,7 @@
     EXPECT_CALL(*placement_strategy, place(Ref(params))).Times(1)
         .WillOnce(Return(msh::a_surface()));
 
-    factory.create_surface(params, mf::SurfaceId(), std::shared_ptr<me::EventSink>());
+    factory.create_surface(params, mf::SurfaceId(), std::make_shared<mtd::NullEventSink>());
 }
 
 TEST_F(OrganisingSurfaceFactorySetup, forwards_create_surface_parameters_from_placement_strategy_to_underlying_factory)
@@ -78,14 +78,14 @@
 
     msh::OrganisingSurfaceFactory factory(underlying_surface_factory, placement_strategy);
 
+    std::shared_ptr<mf::EventSink> sink = std::make_shared<mtd::NullEventSink>();
     auto params = msh::a_surface();
     auto placed_params = params;
     placed_params.size.width = geom::Width{100};
 
     EXPECT_CALL(*placement_strategy, place(Ref(params))).Times(1)
         .WillOnce(Return(placed_params));
-    EXPECT_CALL(*underlying_surface_factory, create_surface(placed_params, mf::SurfaceId(), std::shared_ptr<me::EventSink>()));
+    EXPECT_CALL(*underlying_surface_factory, create_surface(placed_params, mf::SurfaceId(), sink));
 
-    factory.create_surface(params, mf::SurfaceId(), std::shared_ptr<me::EventSink>());
+    factory.create_surface(params, mf::SurfaceId(), sink);
 }
-

=== modified file 'tests/unit-tests/shell/test_registration_order_focus_sequence.cpp'
--- tests/unit-tests/shell/test_registration_order_focus_sequence.cpp	2013-07-24 03:59:44 +0000
+++ tests/unit-tests/shell/test_registration_order_focus_sequence.cpp	2013-07-31 16:00:57 +0000
@@ -25,6 +25,7 @@
 
 #include "mir_test_doubles/mock_buffer_stream.h"
 #include "mir_test_doubles/mock_surface_factory.h"
+#include "mir_test_doubles/null_event_sink.h"
 #include "mir_test/fake_shared.h"
 
 #include <gmock/gmock.h>
@@ -32,7 +33,6 @@
 #include <string>
 
 namespace mc = mir::compositor;
-namespace me = mir::events;
 namespace msh = mir::shell;
 namespace ms = mir::surfaces;
 namespace mt = mir::test;
@@ -53,7 +53,8 @@
         return std::make_shared<msh::ApplicationSession>(
             factory, name,
             std::shared_ptr<msh::SnapshotStrategy>(),
-            std::make_shared<msh::NullSessionListener>());
+            std::make_shared<msh::NullSessionListener>(),
+            std::make_shared<mtd::NullEventSink>());
     }
 
     std::shared_ptr<mtd::MockSurfaceFactory> const factory;

=== modified file 'tests/unit-tests/shell/test_session_manager.cpp'
--- tests/unit-tests/shell/test_session_manager.cpp	2013-07-24 03:59:44 +0000
+++ tests/unit-tests/shell/test_session_manager.cpp	2013-07-31 16:00:57 +0000
@@ -39,7 +39,6 @@
 #include <gtest/gtest.h>
 
 namespace mc = mir::compositor;
-namespace me = mir::events;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 namespace ms = mir::surfaces;
@@ -100,7 +99,7 @@
 
     EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
 
-    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
+    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<mf::EventSink>());
     session_manager.close_session(session);
 }
 
@@ -113,7 +112,7 @@
     ON_CALL(surface_factory, create_surface(_, _, _)).WillByDefault(
        Return(std::make_shared<msh::Surface>(
            mt::fake_shared(surface_builder),
-           msh::a_surface())));
+           msh::a_surface(),mf::SurfaceId{}, std::shared_ptr<mf::EventSink>())));
 
 
     EXPECT_CALL(container, insert_session(_)).Times(1);
@@ -124,7 +123,7 @@
 
     EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
 
-    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
+    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<mf::EventSink>());
     session->create_surface(msh::a_surface().of_size(geom::Size{geom::Width{1024}, geom::Height{768}}));
 
     session_manager.close_session(session);
@@ -138,7 +137,7 @@
     EXPECT_CALL(container, insert_session(_)).Times(1);
     EXPECT_CALL(focus_setter, set_focus_to(_)).WillOnce(SaveArg<0>(&new_session));
 
-    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
+    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<mf::EventSink>());
     EXPECT_EQ(session, new_session);
 }
 
@@ -147,8 +146,8 @@
     using namespace ::testing;
     ON_CALL(surface_factory, create_surface(_, _, _)).WillByDefault(
         Return(std::make_shared<msh::Surface>(
-            mt::fake_shared(surface_builder),
-            msh::a_surface())));
+           mt::fake_shared(surface_builder),
+           msh::a_surface(),mf::SurfaceId{}, std::shared_ptr<mf::EventSink>())));
 
     // Once for session creation and once for surface creation
     {
@@ -159,7 +158,7 @@
         EXPECT_CALL(focus_setter, set_focus_to(_)).Times(1); // Post Surface creation
     }
 
-    auto session1 = session_manager.open_session("Weather Report", std::shared_ptr<me::EventSink>());
+    auto session1 = session_manager.open_session("Weather Report", std::shared_ptr<mf::EventSink>());
     session_manager.create_surface_for(session1, msh::a_surface());
 }
 
@@ -200,6 +199,6 @@
 
     EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
     
-    auto session = session_manager.open_session("XPlane", std::shared_ptr<me::EventSink>());
+    auto session = session_manager.open_session("XPlane", std::shared_ptr<mf::EventSink>());
     session_manager.close_session(session);
 }

=== modified file 'tests/unit-tests/shell/test_surface.cpp'
--- tests/unit-tests/shell/test_surface.cpp	2013-07-17 16:31:45 +0000
+++ tests/unit-tests/shell/test_surface.cpp	2013-07-31 16:00:57 +0000
@@ -28,6 +28,7 @@
 #include "mir_test_doubles/stub_buffer.h"
 #include "mir_test_doubles/mock_input_targeter.h"
 #include "mir_test_doubles/stub_input_targeter.h"
+#include "mir_test_doubles/null_event_sink.h"
 #include "mir_test_doubles/mock_surface_state.h"
 #include "mir_test/fake_shared.h"
 
@@ -35,7 +36,6 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-namespace me = mir::events;
 namespace ms = mir::surfaces;
 namespace msh = mir::shell;
 namespace mf = mir::frontend;
@@ -114,7 +114,8 @@
     StubSurfaceBuilder surface_builder;
 
     ShellSurface() :
-        buffer_stream(std::make_shared<StubBufferStream>())
+        buffer_stream(std::make_shared<StubBufferStream>()),
+        stub_sender(std::make_shared<mtd::NullEventSink>())
     {
         using namespace testing;
 
@@ -122,6 +123,8 @@
         ON_CALL(*buffer_stream, get_stream_pixel_format()).WillByDefault(Return(geom::PixelFormat::abgr_8888));
         ON_CALL(*buffer_stream, secure_client_buffer()).WillByDefault(Return(std::shared_ptr<mtd::StubBuffer>()));
     }
+    mf::SurfaceId stub_id;
+    std::shared_ptr<mf::EventSink> stub_sender;
 };
 }
 
@@ -138,7 +141,7 @@
 
     msh::Surface test(
         mt::fake_shared(surface_builder),
-        params);
+        params, stub_id, stub_sender);
 }
 
 TEST_F(ShellSurface, creation_throws_means_no_destroy)
@@ -156,7 +159,7 @@
     EXPECT_THROW({
         msh::Surface test(
             mt::fake_shared(surface_builder),
-            params);
+            params, stub_id, stub_sender);
     }, std::runtime_error);
 }
 
@@ -171,7 +174,7 @@
 
     msh::Surface test(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     Mock::VerifyAndClearExpectations(&test);
     EXPECT_CALL(surface_builder, destroy_surface(_)).Times(1);
@@ -187,7 +190,7 @@
 {
     msh::Surface test(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_NO_THROW({
         test.size();
@@ -204,7 +207,7 @@
 {
     msh::Surface test(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_NO_THROW({
         test.top_left();
@@ -221,7 +224,7 @@
 {
     msh::Surface test(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_NO_THROW({
         test.name();
@@ -238,7 +241,7 @@
 {
     msh::Surface test(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_NO_THROW({
         test.pixel_format();
@@ -255,7 +258,7 @@
 {
     msh::Surface test(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_NO_THROW({
         test.hide();
@@ -272,7 +275,7 @@
 {
     msh::Surface test(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_NO_THROW({
         test.show();
@@ -289,7 +292,7 @@
 {
     msh::Surface test(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_NO_THROW({
         test.destroy();
@@ -306,7 +309,7 @@
 {
     msh::Surface test(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_NO_THROW({
         test.force_requests_to_complete();
@@ -323,7 +326,7 @@
 {
     msh::Surface test(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_NO_THROW({
         test.advance_client_buffer();
@@ -340,7 +343,7 @@
 {
     msh::Surface test(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     surface_builder.reset_surface();
 
@@ -355,7 +358,7 @@
 
     msh::Surface surf(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_THROW({
         surf.configure(static_cast<MirSurfaceAttrib>(111), 222);
@@ -368,7 +371,7 @@
 
     msh::Surface surf(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_EQ(mir_surface_type_normal, surf.type());
 
@@ -402,7 +405,7 @@
 
     msh::Surface surf(
             mt::fake_shared(surface_builder),
-            msh::a_surface());
+            msh::a_surface(), stub_id, stub_sender);
 
     EXPECT_EQ(mir_surface_state_restored, surf.state());
 
@@ -436,7 +439,7 @@
 
     msh::Surface test(
         mt::fake_shared(surface_builder),
-        msh::a_surface());
+        msh::a_surface(), stub_id, stub_sender);
     
     mtd::MockInputTargeter targeter;
     EXPECT_CALL(targeter, focus_changed(_)).Times(1);
@@ -450,7 +453,7 @@
 
     msh::Surface test(
         mt::fake_shared(surface_builder),
-        msh::a_surface());
+        msh::a_surface(), stub_id, stub_sender);
     surface_builder.reset_surface();
 
     mtd::StubInputTargeter targeter;
@@ -466,7 +469,7 @@
     
     msh::Surface test(
         mt::fake_shared(surface_builder),
-        msh::a_surface());
+        msh::a_surface(), stub_id, stub_sender);
     
     EXPECT_NO_THROW({
             test.set_input_region(std::vector<geom::Rectangle>{});
@@ -483,7 +486,7 @@
 {
     msh::Surface test(
         mt::fake_shared(surface_builder),
-        msh::a_surface());
+        msh::a_surface(), stub_id, stub_sender);
 
     mg::Buffer* buf_ptr{nullptr};
 

=== modified file 'tests/unit-tests/shell/test_the_session_container_implementation.cpp'
--- tests/unit-tests/shell/test_the_session_container_implementation.cpp	2013-07-24 03:59:44 +0000
+++ tests/unit-tests/shell/test_the_session_container_implementation.cpp	2013-07-31 16:00:57 +0000
@@ -24,12 +24,12 @@
 #include "mir_test_doubles/mock_buffer_stream.h"
 #include "mir_test_doubles/mock_surface_factory.h"
 #include "mir_test_doubles/null_snapshot_strategy.h"
+#include "mir_test_doubles/null_event_sink.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <string>
 
-namespace me = mir::events;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 namespace mtd = mir::test::doubles;
@@ -44,7 +44,8 @@
     return std::make_shared<msh::ApplicationSession>(
         factory, session_name,
         std::make_shared<mtd::NullSnapshotStrategy>(),
-        std::make_shared<msh::NullSessionListener>());
+        std::make_shared<msh::NullSessionListener>(),
+        std::make_shared<mtd::NullEventSink>());
 }
 
 }