Merge lp:~alan-griffiths/mir/surface-states-simplification into lp:~vanvugt/mir/surface-states

[Alan Griffiths]

frontend, shell, tests: Avoid supplying dependencies through public member functions.

frontend, shell, tests: Avoid supplying dependencies through public member functions.

Where possible, dependencies should be supplied as constructor arguments and held as const members.

(This required updates to a few factory interfaces to supply the dependencies.)

[Daniel van Vugt (vanvugt)]

Firstly, needs fixing:
Text conflict in tests/unit-tests/shell/test_application_session.cpp
1 conflicts encountered.

Secondly, I disagree with the approach. There are no strong "dependencies" here. The information in question is all optional to the class receiving it, so should not be passed in constructors. The classes can function without event sinks or surface IDs. They will work as they already do. Only event emission would not happen. So it's optional relative to those classes, and therefore not something to enforce in the constructor.

Aside from anything else, the degree of coupling introduced here looks very high. It's always better to minimize coupling. You can't call it a simplification if coupling is increased and the diff is "+205/-148".

review: Disapprove

[Daniel van Vugt (vanvugt)]

Also, here's an example use-case for changing the event sink of a surface:

Windows (like the one Flash video uses in a web browser) are implemented using reparenting. If Mir was to support such a thing in future then it would be handy to be able to re-assign a surface to a different session. Hence you'd also need to be able to change a surface's event target (its session).

[Alexandros Frantzis (afrantzis)]

> Secondly, I disagree with the approach. There are no strong "dependencies" here.

As mentioned in an older comment [1], they are effectively dependencies because of how Mir uses the class. That is, in all cases in production code we need to set both the id and the sink for our features to work properly.

> If Mir was to support such a thing in future then it would be handy to be able to re-assign
> a surface to a different session

The key words are "if ... in the future ...". If we need this in the future, we are free to change the code to suit our needs. Right now the values are meant to be set only once at creation time, and accepting them in the constructor enforces this restriction (and, as mentioned above, also enforces that we always get a fully working object).

[1] https://code.launchpad.net/~vanvugt/mir/surface-states/+merge/158289/comments/348068

[Daniel van Vugt (vanvugt)]

There is a difference between a local dependency and a system dependency. On the local scale, the classes do not depend on EventSink to work. So on a local scale, it should not affect the constructor.

A surface can emit events. A surface can have an ID. However those are not required attributes for the surface to be created and work as a surface.

No amount of "modern C++ tradition" supersedes the basic programming ideal of low coupling.

[Alan Griffiths (alan-griffiths)]

> Firstly, needs fixing:
> Text conflict in tests/unit-tests/shell/test_application_session.cpp
> 1 conflicts encountered.

Resolved.

> Secondly, I disagree with the approach. There are no strong "dependencies"
> here. The information in question is all optional to the class receiving it,
> so should not be passed in constructors. The classes can function without
> event sinks or surface IDs. They will work as they already do. Only event
> emission would not happen. So it's optional relative to those classes, and
> therefore not something to enforce in the constructor.

Arguing that a subset of the functionality works without these attributes is an argument that the subset belongs in a class providing just that subset. While we could factor that subset out, I don't think we need to that now.

> Aside from anything else, the degree of coupling introduced here looks very
> high. It's always better to minimize coupling.

I agree that coupling should be reduced - I disagree that this MP increases coupling. For example, the interface used by frontend should not need Session::set_event_sink().

> You can't call it a
> simplification if coupling is increased and the diff is "+205/-148".

You can't measure coupling (or other attributes of the resulting code) by diff size.

[Daniel van Vugt (vanvugt)]

I have stated my opinions strongly. I disagree with this proposal as it significantly decreases readability and maintainability. Those are the traits of high coupling, and things I would like to avoid.

[Kevin DuBois (kdub)]

> > Secondly, I disagree with the approach. There are no strong "dependencies"
> > here. The information in question is all optional to the class receiving it,
> > so should not be passed in constructors. The classes can function without
> > event sinks or surface IDs. They will work as they already do. Only event
> > emission would not happen. So it's optional relative to those classes, and
> > therefore not something to enforce in the constructor.
>
> Arguing that a subset of the functionality works without these attributes is
> an argument that the subset belongs in a class providing just that subset.
> While we could factor that subset out, I don't think we need to that now.

I think we're using the term 'coupling' too broadly to make much progress arguing :) I'll propose re-framing the argument, and then give my 2 cents

I think we can agree on this though:
1) Its better if a function call doesn't have any hidden prerequisites, like "you must call function A before you call function B". This is sort of 'coupling of calling requirements".
2) A class with a lot of constructor parameters has a lot of dependencies and might be trying to do too much. This is sort of 'coupling of object dependencies'

my 2cents...
so we have to find a way to balance.

I think that, with regards to notify_change/set_id, set_id() is a dependency that has to be called before notify_change() is called, so the id may as well be in the constructor. Another possibility (if we really don't want any more construction parameters for Surface) is to have another object with expanded functionality that takes

We've tried to mitigate the problem of #2 by having a lot of mocks and stubs and nulls that are easy to plug in and make the object easy to manipulate in test. Since its easier to read a constructor than it is to trace what the call order is, I'd rather plug in mocks/stubs to the constructor than have to trace a call order to figure out if we've fulfilled our usage requirements.

[Daniel van Vugt (vanvugt)]

You are free to propose and land this directly to lp:mir.

I just don't want code like this landing in a branch with my name on it.

[Daniel van Vugt (vanvugt)]

Just further to Kevin's comment:

"We've tried to mitigate the problem of #2 by having a lot of mocks and stubs and nulls that are easy to plug in and make the object easy to manipulate in test. Since its easier to read a constructor than it is to trace what the call order is, I'd rather plug in mocks/stubs to the constructor than have to trace a call order to figure out if we've fulfilled our usage requirements."

This is false: "lot of mocks and stubs and nulls that are easy to plug in and make the object easy to manipulate in test". You define "easy" by how much effort it requires for someone like you guys (who have been at it for over a year) to modify the code. I define "easy" by how much effort a newcomer requires (with no prior knowledge of the code).

This is false: "Since its easier to read a constructor than it is to trace what the call order is". Constructors do not explicitly state what they're doing, unlike "set_id" or "set_event_sink". And if you did make a mistake somewhere and dereference a null shared_ptr, then the trace would be a call stack. Automatically generated and easier to read.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-04-19 03:20:05 +0000
+++ CMakeLists.txt	2013-04-23 12:15:34 +0000
@@ -205,4 +205,12 @@
 add_subdirectory(guides/)
 add_subdirectory(cmake/)
 
+# There's no nice way to format this. Thanks CMake.
+add_test(LGPL-required
+  /bin/sh -c "! grep -rl 'GNU General' ${PROJECT_SOURCE_DIR}/src/client ${PROJECT_SOURCE_DIR}/include/client ${PROJECT_SOURCE_DIR}/src/shared ${PROJECT_SOURCE_DIR}/include/shared"
+)
+add_test(GPL-required
+  /bin/sh -c "! grep -rl 'GNU Lesser' ${PROJECT_SOURCE_DIR}/src/server ${PROJECT_SOURCE_DIR}/include/server ${PROJECT_SOURCE_DIR}/include/test ${PROJECT_SOURCE_DIR}/tests ${PROJECT_SOURCE_DIR}/examples"
+)
+
 enable_coverage_report(mirserver)

=== modified file 'doc/building_source_for_android.md'
--- doc/building_source_for_android.md	2013-04-04 06:50:04 +0000
+++ doc/building_source_for_android.md	2013-04-23 12:15:34 +0000
@@ -33,12 +33,12 @@
 
 From within the armhf system:
 
-1. Set up Dependencies
+-  Set up Dependencies
 
        $ apt-get install devscripts equivs cmake
        $ mk-build-deps --install --tool "apt-get -y" --build-dep debian/control
 
-2. Build
+-  Build
 
        $ bzr branch lp:mir
        $ mkdir mir/build; cd mir/build
@@ -51,23 +51,37 @@
 ubuntu package) to produce armhf code. This is typically the quickest way to
 compile and run code, and is well suited for a development workflow.
 
-1. Be sure that the cross compiler that you are using matches the target
-   environment. (eg, make sure you're using the quantal toolchain if you're
-   targeting a quantal phablet image)
-
-2. Set up a chroot with the mir dependencies installed. At the moment, you
-   can look at the script and instructions in lp:mir as an
-   example of how to set up a partial chroot you can build mir against.
-
-3. There are a few ways to do this, but here is an example of how to build mir for android
-
-        $ bzr branch lp:mir
+-  Be sure that the cross compiler that you are using matches the target
+   environment. (eg, make sure you're using the raring toolchain if you're
+   targeting a raring phablet image) You can specify the toolchain version
+   thusly:
+
+        $ apt-get install g++-4.7-arm-linux-gnueabihf/raring
+
+-  Get access to armhf packages via apt-get. On an amd64/ia32 system, you can
+   do this by adding a file like the one below to /etc/apt/sources.list.d/
+
+        #example sources.list with armhf dependencies
+        deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports/ raring main restricted universe multiverse
+        deb [arch=armhf] http://ppa.launchpad.net/phablet-team/ppa/ubuntu raring main #for hybris packages 
+    
+    Then you should run:
+
+        $ dpkg --add-architecture armhf
+        $ apt-get update
+
+    To test, try downloading a package like this:
+
+        $ apt-get download my-package:armhf
+
+-  Once you're able to download armhf packages from the repository, the 
+   cross-compile-chroot.sh script provides an example of how to download
+   a partial chroot with the mir dependencies, and compile the source for
+   android targets.
+
+   The script sets up a partial chroot via tools/setup-partial-armhf-chroot.sh
+   and then runs build commands similar to this:
+
         $ mkdir mir/build; cd mir/build
         $ MIR_NDK_PATH=/path/to/depenendcies/chroot cmake -DCMAKE_TOOLCHAIN_FILE=../cmake/LinuxCrossCompile.cmake -DBoost_COMPILER=-gcc -DMIR_ENABLE_DEATH_TESTS=NO -DMIR_PLATFORM=android ..
         $ make
-
-N.B. The `cross-compile-android.sh` script in mir's top level directory
-provides a scripting example of how to cross compile.
-The 'setup-partial-armhf-chroot.sh' will attempt to download all the arm
-dependencies you need. You have to have your APT sources.list files pointed at
-arm repositories.

=== modified file 'doc/footer.html'
--- doc/footer.html	2012-12-28 08:57:38 +0000
+++ doc/footer.html	2013-04-23 12:15:34 +0000
@@ -1,2 +1,2 @@
 <hr>
-<p align="center">Copyright &copy; 2012 Canonical Ltd.</p>
+<p align="center">Copyright &copy; 2012,2013 Canonical Ltd.</p>

=== modified file 'doc/mainpage.md'
--- doc/mainpage.md	2013-04-22 09:50:06 +0000
+++ doc/mainpage.md	2013-04-23 12:15:34 +0000
@@ -57,7 +57,15 @@
 
  - \ref mir_toolkit "Mir API Documentation"
  - \subpage demo_client.c "demo_client.c: A simple mir client"
+
+Writing server applications
+---------------------------
+
+Mir server is written as a library which allows the server code to be adapted
+for bespoke applications.
+
  - \subpage render_surfaces-example "render_surfaces.cpp: A simple program using the mir library"
+ - \ref demo_inprocess_egl
 
 Working on Mir code
 -------------------

=== modified file 'examples/demo-inprocess-egl/demo_inprocess_egl.cpp'
--- examples/demo-inprocess-egl/demo_inprocess_egl.cpp	2013-04-19 03:20:05 +0000
+++ examples/demo-inprocess-egl/demo_inprocess_egl.cpp	2013-04-23 12:15:34 +0000
@@ -26,9 +26,20 @@
 
 namespace me = mir::examples;
 
+///\page demo_inprocess_egl demo_inprocess_egl.cpp: A simple use of egl in process
+///\section main main
+/// The main() function uses a default configuration for Mir and sets up an InprocessEGLClient
+/// that accesses the graphics platform and surface factory.
+/// \snippet demo_inprocess_egl.cpp main_tag
+/// This InprocessEGLClient sets up a single surface
+/// \snippet inprocess_egl_client.cpp setup_tag
+/// And loops updating the surface
+/// \snippet inprocess_egl_client.cpp loop_tag
+
 int main(int argc, char const* argv[])
 try
 {
+    ///\internal [main_tag]
     mir::DefaultServerConfiguration config(argc, argv);
 
     std::shared_ptr<me::InprocessEGLClient> client;
@@ -38,6 +49,7 @@
               config.the_graphics_platform(),
               config.the_shell_surface_factory());
     });
+    ///\internal [main_tag]
 
     return 0;
 }

=== modified file 'examples/demo-inprocess-egl/inprocess_egl_client.cpp'
--- examples/demo-inprocess-egl/inprocess_egl_client.cpp	2013-04-16 09:16:38 +0000
+++ examples/demo-inprocess-egl/inprocess_egl_client.cpp	2013-04-23 12:15:34 +0000
@@ -54,24 +54,27 @@
 {
     geom::Size const surface_size = geom::Size{geom::Width{512},
                                                geom::Height{512}};
-    
+
+    ///\internal [setup_tag]
     auto params = mf::a_surface().of_name("Inprocess EGL Demo")
         .of_size(surface_size)
         .of_buffer_usage(mc::BufferUsage::hardware)
         .of_pixel_format(geom::PixelFormat::argb_8888);
-    auto surface = surface_factory->create_surface(params);
-    
+    auto surface = surface_factory->create_surface(params, mf::SurfaceId(), std::shared_ptr<events::EventSink>());
+
     surface->advance_client_buffer(); // TODO: What a wart!
-    
+
     auto native_display = graphics_platform->shell_egl_display();
     me::EGLHelper helper(reinterpret_cast<EGLNativeDisplayType>(native_display), reinterpret_cast<EGLNativeWindowType>(surface.get()));
 
     auto rc = eglMakeCurrent(helper.the_display(), helper.the_surface(), helper.the_surface(), helper.the_context());
     assert(rc == EGL_TRUE);
-    
+
     mir::draw::glAnimationBasic gl_animation;
     gl_animation.init_gl();
-    
+    ///\internal [setup_tag]
+
+    ///\internal [loop_tag]
     for(;;)
     {
         gl_animation.render_gl();
@@ -80,4 +83,5 @@
 
         gl_animation.step();
     }
+    ///\internal [loop_tag]
 }

=== modified file 'examples/demo_client.c'
--- examples/demo_client.c	2013-04-18 04:23:56 +0000
+++ examples/demo_client.c	2013-04-23 12:15:34 +0000
@@ -25,14 +25,30 @@
 #include <getopt.h>
 
 ///\page demo_client.c demo_client.c: A simple mir client
-/// demo_client shows the use of mir API
+/// demo_client shows the use of mir API.
+/// This program opens a mir connection and creates a surface.
+///\section demo_client demo_client()
+/// Opens a mir connection and creates a surface and advances the
+/// current buffer before closing the surface and connection.
+///\subsection connect request and wait for connection handle
+/// \snippet demo_client.c connect_tag
+///\subsection surface_create request and wait for surface handle
+/// \snippet demo_client.c surface_create_tag
+///\subsection next_buffer exchange the current buffer for a new one
+/// \snippet demo_client.c next_buffer_tag
+///\subsection surface_release We release our surface
+/// \snippet demo_client.c surface_release_tag
+///\subsection connection_release We release our connection
+/// \snippet demo_client.c connection_release_tag
 /// \example demo_client.c A simple mir client
-
-///\page demo_client.c
 ///\section MirDemoState MirDemoState
-/// This program opens a mir connection and creates a surface. The handles
-/// needs to be accessible both to callbacks and to the control function.
+/// The handles needs to be accessible both to callbacks and to the control function.
 /// \snippet demo_client.c MirDemoState_tag
+///\section Callbacks Callbacks
+/// This program opens a mir connection and creates a surface. The handles
+/// needs to be accessible both to callbacks and to the control function.
+/// \snippet demo_client.c Callback_tag
+
 ///\internal [MirDemoState_tag]
 // Utility structure for the state of a single surface session.
 typedef struct MirDemoState
@@ -42,11 +58,6 @@
 } MirDemoState;
 ///\internal [MirDemoState_tag]
 
-///\page demo_client.c
-///\section Callbacks Callbacks
-/// This program opens a mir connection and creates a surface. The handles
-/// needs to be accessible both to callbacks and to the control function.
-/// \snippet demo_client.c Callback_tag
 ///\internal [Callback_tag]
 // Callback to update MirDemoState on connection
 static void connection_callback(MirConnection *new_connection, void *context)
@@ -75,11 +86,6 @@
 }
 ///\internal [Callback_tag]
 
-
-///\page demo_client.c
-///\section demo_client demo_client()
-/// Opens a mir connection and creates a surface and advances the
-/// current buffer before closing the surface and connection.
 void demo_client(const char* server, int buffer_swap_count)
 {
     MirDemoState mcd;
@@ -88,9 +94,6 @@
 
     puts("Starting");
 
-    ///\page demo_client.c
-    ///\subsection connect request and wait for connection handle
-    /// \snippet demo_client.c connect_tag
     ///\internal [connect_tag]
     // Call mir_connect and wait for callback to complete.
     mir_wait_for(mir_connect(server, __PRETTY_FUNCTION__, connection_callback, &mcd));
@@ -124,9 +127,6 @@
     MirSurfaceParameters const request_params =
         {__PRETTY_FUNCTION__, 640, 480, pixel_format, mir_buffer_usage_hardware};
 
-    ///\page demo_client.c
-    ///\subsection surface_create request and wait for surface handle
-    /// \snippet demo_client.c surface_create_tag
     ///\internal [surface_create_tag]
     // ...we create a surface using that format and wait for callback to complete.
     mir_wait_for(mir_connection_create_surface(mcd.connection, &request_params, surface_create_callback, &mcd));
@@ -166,39 +166,29 @@
             // In a real application we'd render into the current buffer
         }
 
-        ///\page demo_client.c
-        ///\subsection next_buffer exchange the current buffer for a new one
-        /// \snippet demo_client.c next_buffer_tag
         ///\internal [next_buffer_tag]
         mir_wait_for(mir_surface_next_buffer(mcd.surface, surface_next_buffer_callback, &mcd));
         ///\internal [next_buffer_tag]
     }
 
-    ///\page demo_client.c
-    ///\subsection surface_release We release our surface
-    /// \snippet demo_client.c surface_release_tag
     ///\internal [surface_release_tag]
     // We should release our surface
     mir_wait_for(mir_surface_release(mcd.surface, surface_release_callback, &mcd));
     puts("Surface released");
     ///\internal [surface_release_tag]
 
-    ///\page demo_client.c
-    ///\subsection connection_release We release our connection
-    /// \snippet demo_client.c connection_release_tag
     ///\internal [connection_release_tag]
     // We should release our connection
     mir_connection_release(mcd.connection);
     puts("Connection released");
     ///\internal [connection_release_tag]
 }
-///\page demo_client.c
 
 // The main() function deals with parsing arguments and defaults
 int main(int argc, char* argv[])
 {
     // Some variables for holding command line options
-    char const *server = "/tmp/mir_socket";
+    char const *server = NULL;
     int buffer_swap_count = 0;
 
     // Parse the command line

=== modified file 'examples/demo_client_accelerated.cpp'
--- examples/demo_client_accelerated.cpp	2013-04-18 04:23:56 +0000
+++ examples/demo_client_accelerated.cpp	2013-04-23 12:15:34 +0000
@@ -28,7 +28,7 @@
 #include <EGL/egl.h>
 #include <GLES2/gl2.h>
 
-static char const *socket_file = "/tmp/mir_socket";
+static char const *socket_file = NULL;
 
 int main(int argc, char* argv[])
 {

=== modified file 'examples/demo_client_unaccelerated.c'
--- examples/demo_client_unaccelerated.c	2013-04-18 04:23:56 +0000
+++ examples/demo_client_unaccelerated.c	2013-04-23 12:15:34 +0000
@@ -26,7 +26,7 @@
 #include <getopt.h>
 #include <stdint.h>
 
-static char const *socket_file = "/tmp/mir_socket";
+static char const *socket_file = NULL;
 
 static void render_pattern(MirGraphicsRegion *region, uint32_t pf)
 {

=== modified file 'examples/eglapp.c'
--- examples/eglapp.c	2013-04-18 04:23:56 +0000
+++ examples/eglapp.c	2013-04-23 12:15:34 +0000
@@ -26,7 +26,6 @@
 
 #include <xkbcommon/xkbcommon-keysyms.h>
 
-static const char servername[] = "/tmp/mir_socket";
 static const char appname[] = "egldemo";
 
 static MirConnection *connection;
@@ -128,13 +127,13 @@
     EGLContext eglctx;
     EGLBoolean ok;
 
-    connection = mir_connect_sync(servername, appname);
+    connection = mir_connect_sync(NULL, appname);
     CHECK(mir_connection_is_valid(connection), "Can't get connection");
 
     mir_connection_get_display_info(connection, &dinfo);
 
-    printf("Connected to display %s: %dx%d, supports %d pixel formats\n",
-           servername, dinfo.width, dinfo.height,
+    printf("Connected to display: %dx%d, supports %d pixel formats\n",
+           dinfo.width, dinfo.height,
            dinfo.supported_pixel_format_items);
 
     surfaceparm.width = *width > 0 ? *width : dinfo.width;

=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2013-04-22 09:50:06 +0000
+++ examples/render_surfaces.cpp	2013-04-23 12:15:34 +0000
@@ -28,6 +28,7 @@
 #include "mir/surfaces/surface.h"
 #include "mir/default_server_configuration.h"
 #include "mir/run_mir.h"
+#include "mir/abnormal_exit.h"
 
 #include "mir_image.h"
 #include "buffer_render_target.h"
@@ -54,13 +55,27 @@
 ///\page render_surfaces-example render_surfaces.cpp: A simple program using the mir library.
 ///\tableofcontents
 ///render_surfaces shows the use of mir to render some moving surfaces
+///\section main main()
+/// The main() function uses a RenderSurfacesServerConfiguration to initialize and run mir.
+/// \snippet render_surfaces.cpp main_tag
+///\section RenderSurfacesServerConfiguration RenderSurfacesServerConfiguration
+/// The configuration stubs out client connectivity and input.
+/// \snippet render_surfaces.cpp RenderSurfacesServerConfiguration_stubs_tag
+/// it also provides a bespoke buffer initializer
+/// \snippet render_surfaces.cpp RenderResourcesBufferInitializer_tag
+/// and a bespoke compositing strategy
+/// \snippet render_surfaces.cpp RenderSurfacesCompositingStrategy_tag
+///\section Utilities Utility classes
+/// For smooth animation we need to track time and move surfaces accordingly
+///\subsection StopWatch StopWatch
+/// \snippet render_surfaces.cpp StopWatch_tag
+///\subsection Moveable Moveable
+/// \snippet render_surfaces.cpp Moveable_tag
+
 ///\example render_surfaces.cpp A simple program using the mir library.
 
 namespace
 {
-///\page render_surfaces-example
-///\section StopWatch StopWatch
-/// \snippet render_surfaces.cpp StopWatch_tag
 ///\internal [StopWatch_tag]
 // tracks elapsed time - for animation.
 class StopWatch
@@ -103,9 +118,6 @@
 };
 ///\internal [StopWatch_tag]
 
-///\page render_surfaces-example
-///\section Moveable Moveable
-/// \snippet render_surfaces.cpp Moveable_tag
 ///\internal [Moveable_tag]
 // Adapter to support movement of surfaces.
 class Moveable
@@ -175,9 +187,6 @@
 };
 ///\internal [Moveable_tag]
 
-///\page render_surfaces-example
-///\section RenderSurfacesServerConfiguration RenderSurfacesServerConfiguration
-/// \snippet render_surfaces.cpp RenderSurfacesServerConfiguration_tag
 ///\internal [RenderSurfacesServerConfiguration_tag]
 // Extend the default configuration to manage moveables.
 class RenderSurfacesServerConfiguration : public mir::DefaultServerConfiguration
@@ -189,17 +198,103 @@
     {
     }
 
-    // Override to stub out the default
-    std::shared_ptr<mf::Communicator> the_communicator() override;
-
-    // Override to stub out the default
-    std::shared_ptr<mi::InputManager> the_input_manager() override;
-
-    // Override for a bespoke initializer
-    std::shared_ptr<mg::BufferInitializer> the_buffer_initializer() override;
-
-    // Override for a bespoke compositing strategy
-    std::shared_ptr<mc::CompositingStrategy> the_compositing_strategy() override;
+    ///\internal [RenderSurfacesServerConfiguration_stubs_tag]
+    // Stub out server connectivity.
+    std::shared_ptr<mf::Communicator> the_communicator() override
+    {
+        struct NullCommunicator : public mf::Communicator
+        {
+            void start() {}
+            void stop() {}
+        };
+
+        return std::make_shared<NullCommunicator>();
+    }
+
+    // Stub out input.
+    std::shared_ptr<mi::InputManager> the_input_manager() override
+    {
+        return std::make_shared<mi::NullInputManager>();
+    }
+    ///\internal [RenderSurfacesServerConfiguration_stubs_tag]
+
+    ///\internal [RenderResourcesBufferInitializer_tag]
+    // Override for a bespoke buffer initializer
+    std::shared_ptr<mg::BufferInitializer> the_buffer_initializer() override
+    {
+        class RenderResourcesBufferInitializer : public mg::BufferInitializer
+        {
+        public:
+            RenderResourcesBufferInitializer()
+                : img_renderer{mir_image.pixel_data,
+                               geom::Size{geom::Width{mir_image.width},
+                                          geom::Height{mir_image.height}},
+                               mir_image.bytes_per_pixel}
+            {
+            }
+
+            void operator()(mc::Buffer& buffer)
+            {
+                mt::BufferRenderTarget brt{buffer};
+                brt.make_current();
+                img_renderer.render();
+            }
+
+        private:
+            mt::ImageRenderer img_renderer;
+        };
+
+        return std::make_shared<RenderResourcesBufferInitializer>();
+    }
+    ///\internal [RenderResourcesBufferInitializer_tag]
+
+    ///\internal [RenderSurfacesCompositingStrategy_tag]
+    // Decorate the DefaultCompositingStrategy in order to move surfaces.
+    std::shared_ptr<mc::CompositingStrategy> the_compositing_strategy() override
+    {
+        class RenderSurfacesCompositingStrategy : public mc::CompositingStrategy
+        {
+        public:
+            RenderSurfacesCompositingStrategy(std::shared_ptr<mc::Renderables> const& renderables,
+                                              std::shared_ptr<mg::Renderer> const& renderer,
+                                              std::vector<Moveable>& moveables)
+                : default_compositing_strategy{renderables, renderer},
+                  frames{0},
+                  moveables(moveables)
+            {
+            }
+
+            void render(mg::DisplayBuffer& display_buffer)
+            {
+                stop_watch.stop();
+                if (stop_watch.elapsed_seconds_since_last_restart() >= 1)
+                {
+                    std::cout << "FPS: " << frames << " Frame Time: " << 1.0 / frames << std::endl;
+                    frames = 0;
+                    stop_watch.restart();
+                }
+
+                glClearColor(0.0, 1.0, 0.0, 1.0);
+                default_compositing_strategy.render(display_buffer);
+
+                for (auto& m : moveables)
+                    m.step();
+
+                frames++;
+            }
+
+        private:
+            mc::DefaultCompositingStrategy default_compositing_strategy;
+            StopWatch stop_watch;
+            uint32_t frames;
+            std::vector<Moveable>& moveables;
+        };
+
+        return std::make_shared<RenderSurfacesCompositingStrategy>(the_renderables(),
+                                                                   the_renderer(),
+                                                                   moveables);
+    }
+    ///\internal [RenderSurfacesCompositingStrategy_tag]
 
     // New function to initialize moveables with surfaces
     void create_surfaces()
@@ -248,13 +343,10 @@
 ///\internal [RenderSurfacesServerConfiguration_tag]
 }
 
-///\page render_surfaces-example
-///\section main main()
-/// \snippet render_surfaces.cpp main_tag
-///\internal [main_tag]
-// Pull the bits together.
 int main(int argc, char **argv)
+try
 {
+    ///\internal [main_tag]
     /* Parse the command line */
     unsigned int num_moveables{5};
 
@@ -269,9 +361,11 @@
     RenderSurfacesServerConfiguration conf{num_moveables};
 
     mir::run_mir(conf, [&](mir::DisplayServer&) {conf.create_surfaces();});
+    ///\internal [main_tag]
 
     return 0;
 }
+<<<<<<< TREE
 ///\internal [main_tag]
 
 ///\page render_surfaces-example
@@ -384,3 +478,15 @@
     return std::make_shared<mi::NullInputManager>();
 }
 ///\internal [NullInputManager_tag]
+=======
+catch (mir::AbnormalExit const& error)
+{
+    std::cerr << error.what() << std::endl;
+    return 1;
+}
+catch (std::exception const& error)
+{
+    std::cerr << "ERROR: " << error.what() << std::endl;
+    return 1;
+}
+>>>>>>> MERGE-SOURCE

=== modified file 'include/client/mir_toolkit/mir_client_library.h'
--- include/client/mir_toolkit/mir_client_library.h	2013-04-18 04:23:56 +0000
+++ include/client/mir_toolkit/mir_client_library.h	2013-04-23 12:15:34 +0000
@@ -35,7 +35,8 @@
  * Request a connection to the Mir server. The supplied callback is called when
  * the connection is established, or fails. The returned wait handle remains
  * valid until the connection has been released.
- *   \param [in] server       A name identifying the server
+ *   \param [in] server       File path of the server socket to connect to, or
+ *                            NULL to choose the default server
  *   \param [in] app_name     A name referring to the application
  *   \param [in] callback     Callback function to be invoked when request
  *                            completes
@@ -50,7 +51,8 @@
 
 /**
  * Perform a mir_connect() but also wait for and return the result.
- *   \param [in] server    A name identifying the server
+ *   \param [in] server    File path of the server socket to connect to, or
+ *                         NULL to choose the default server
  *   \param [in] app_name  A name referring to the application
  *   \return               The resulting MirConnection
  */

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2013-04-22 03:24:56 +0000
+++ include/server/mir/default_server_configuration.h	2013-04-23 12:15:34 +0000
@@ -50,7 +50,7 @@
 {
 class SurfaceFactory;
 class SurfaceBuilder;
-class InputFocusSelector;
+class InputTargetListener;
 class SessionContainer;
 class FocusSetter;
 class FocusSequence;
@@ -156,7 +156,6 @@
     /** @name shell configuration - dependencies
      * dependencies of shell on the rest of the Mir
      *  @{ */
-    virtual std::shared_ptr<shell::InputFocusSelector> the_input_focus_selector();
     virtual std::shared_ptr<shell::SurfaceBuilder>     the_surface_builder();
     /** @} */
 
@@ -178,6 +177,7 @@
      *  @{ */
     virtual std::shared_ptr<input::android::InputConfiguration> the_input_configuration();
     virtual std::initializer_list<std::shared_ptr<input::EventFilter> const> the_event_filters();
+    virtual std::shared_ptr<shell::InputTargetListener> the_input_target_listener();
     /** @} */
 
     /** @name logging configuration - customization
@@ -197,7 +197,7 @@
     CachedPtr<frontend::Shell> session_manager;
     std::shared_ptr<input::android::InputConfiguration> input_configuration;
     CachedPtr<input::InputManager>    input_manager;
-    CachedPtr<shell::InputFocusSelector> input_focus_selector;
+    CachedPtr<shell::InputTargetListener> input_target_listener;
     CachedPtr<graphics::Platform>     graphics_platform;
     CachedPtr<graphics::BufferInitializer> buffer_initializer;
     CachedPtr<compositor::GraphicBufferAllocator> buffer_allocator;

=== modified file 'include/server/mir/frontend/protobuf_ipc_factory.h'
--- include/server/mir/frontend/protobuf_ipc_factory.h	2013-04-19 07:45:44 +0000
+++ include/server/mir/frontend/protobuf_ipc_factory.h	2013-04-23 12:15:34 +0000
@@ -23,8 +23,15 @@
 
 namespace mir
 {
+<<<<<<< TREE
 class EventSink;
 
+=======
+namespace events
+{
+class EventSink;
+}
+>>>>>>> MERGE-SOURCE
 namespace protobuf
 {
 class DisplayServer;
@@ -37,8 +44,13 @@
 class ProtobufIpcFactory
 {
 public:
+<<<<<<< TREE
     virtual std::shared_ptr<protobuf::DisplayServer> make_ipc_server(
         std::shared_ptr<EventSink> const& sink) = 0;
+=======
+    virtual std::shared_ptr<protobuf::DisplayServer> make_ipc_server(
+        std::shared_ptr<events::EventSink> const& sink) = 0;
+>>>>>>> MERGE-SOURCE
     virtual std::shared_ptr<ResourceCache> resource_cache() = 0;
     virtual std::shared_ptr<MessageProcessorReport> report() = 0;
 

=== modified file 'include/server/mir/frontend/session.h'
--- include/server/mir/frontend/session.h	2013-04-22 03:24:56 +0000
+++ include/server/mir/frontend/session.h	2013-04-23 12:15:34 +0000
@@ -29,8 +29,11 @@
 
 namespace mir
 {
+<<<<<<< TREE
 class EventSink;
 
+=======
+>>>>>>> MERGE-SOURCE
 namespace frontend
 {
 class Surface;

=== modified file 'include/server/mir/frontend/session_mediator.h'
--- include/server/mir/frontend/session_mediator.h	2013-04-19 07:45:44 +0000
+++ include/server/mir/frontend/session_mediator.h	2013-04-23 12:15:34 +0000
@@ -27,8 +27,15 @@
 
 namespace mir
 {
+<<<<<<< TREE
 class EventSink;
 
+=======
+namespace events
+{
+class EventSink;
+}
+>>>>>>> MERGE-SOURCE
 namespace graphics
 {
 class Platform;
@@ -62,7 +69,11 @@
         std::shared_ptr<graphics::ViewableArea> const& viewable_area,
         std::shared_ptr<compositor::GraphicBufferAllocator> const& buffer_allocator,
         std::shared_ptr<SessionMediatorReport> const& report,
+<<<<<<< TREE
         std::shared_ptr<EventSink> const& event_sink,
+=======
+        std::shared_ptr<events::EventSink> const& event_sink,
+>>>>>>> MERGE-SOURCE
         std::shared_ptr<ResourceCache> const& resource_cache);
 
     /* Platform independent requests */
@@ -119,7 +130,11 @@
     std::shared_ptr<compositor::GraphicBufferAllocator> const buffer_allocator;
 
     std::shared_ptr<SessionMediatorReport> const report;
+<<<<<<< TREE
     std::shared_ptr<EventSink> const event_sink;
+=======
+    std::shared_ptr<events::EventSink> const event_sink;
+>>>>>>> MERGE-SOURCE
     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-04-22 03:24:56 +0000
+++ include/server/mir/frontend/shell.h	2013-04-23 12:15:34 +0000
@@ -24,7 +24,10 @@
 
 namespace mir
 {
-
+namespace events
+{
+class EventSink;
+}
 namespace frontend
 {
 class Session;
@@ -35,7 +38,7 @@
 public:
     virtual ~Shell() {}
 
-    virtual std::shared_ptr<Session> open_session(std::string const& name) = 0;
+    virtual std::shared_ptr<Session> open_session(std::string const& name, std::shared_ptr<events::EventSink> const& sink) = 0;
     virtual void close_session(std::shared_ptr<Session> const& session)  = 0;
 
     virtual void tag_session_with_lightdm_id(std::shared_ptr<Session> const& session, int id) = 0;

=== modified file 'include/server/mir/input/input_manager.h'
--- include/server/mir/input/input_manager.h	2013-04-16 09:16:38 +0000
+++ include/server/mir/input/input_manager.h	2013-04-23 12:15:34 +0000
@@ -21,7 +21,6 @@
 #define MIR_INPUT_INPUT_MANAGER_H_
 
 #include "mir/input/input_channel_factory.h"
-#include "mir/shell/input_focus_selector.h"
 
 #include <memory>
 

=== modified file 'include/server/mir/input/null_input_manager.h'
--- include/server/mir/input/null_input_manager.h	2013-04-16 09:16:38 +0000
+++ include/server/mir/input/null_input_manager.h	2013-04-23 12:15:34 +0000
@@ -40,11 +40,6 @@
         return std::shared_ptr<InputChannel>();
     }
 
-    virtual void set_input_focus_to(std::shared_ptr<input::SessionTarget> const& /* session */,
-                                    std::shared_ptr<input::SurfaceTarget> const& /* surface */)
-    {
-    }
-
 protected:
     NullInputManager(const NullInputManager&) = delete;
     NullInputManager& operator=(const NullInputManager&) = delete;

=== renamed file 'include/server/mir/input/null_input_focus_selector.h' => 'include/server/mir/input/null_input_target_listener.h'
--- include/server/mir/input/null_input_focus_selector.h	2013-04-17 02:04:35 +0000
+++ include/server/mir/input/null_input_target_listener.h	2013-04-23 12:15:34 +0000
@@ -16,33 +16,48 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_INPUT_NULL_INPUT_FOCUS_SELECTOR_H_
-#define MIR_INPUT_NULL_INPUT_FOCUS_SELECTOR_H_
+#ifndef MIR_INPUT_NULL_INPUT_TARGET_LISTENER_H_
+#define MIR_INPUT_NULL_INPUT_TARGET_LISTENER_H_
 
-#include "mir/shell/input_focus_selector.h"
+#include "mir/shell/input_target_listener.h"
 
 namespace mir
 {
 namespace input
 {
 
-class NullInputFocusSelector : public shell::InputFocusSelector
+class NullInputTargetListener : public shell::InputTargetListener
 {
 public:
-    NullInputFocusSelector() {};
-    virtual ~NullInputFocusSelector() {}
+    NullInputTargetListener() {};
+    virtual ~NullInputTargetListener() noexcept(true) {}
     
-    virtual void set_input_focus_to(std::shared_ptr<input::SessionTarget> const&,
-                                    std::shared_ptr<input::SurfaceTarget> const&)
+    virtual void input_application_opened(std::shared_ptr<input::SessionTarget> const&)
+    {
+    }
+    virtual void input_application_closed(std::shared_ptr<input::SessionTarget> const&)
+    {
+    }
+    virtual void input_surface_opened(std::shared_ptr<input::SessionTarget> const&,
+                                      std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    virtual void input_surface_closed(std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    virtual void focus_changed(std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    virtual void focus_cleared()
     {
     }
 
 protected:
-    NullInputFocusSelector(const NullInputFocusSelector&) = delete;
-    NullInputFocusSelector& operator=(const NullInputFocusSelector&) = delete;
+    NullInputTargetListener(const NullInputTargetListener&) = delete;
+    NullInputTargetListener& operator=(const NullInputTargetListener&) = delete;
 };
 
 }
 }
 
-#endif // MIR_INPUT_NULL_INPUT_FOCUS_SELECTOR_H_
+#endif // MIR_INPUT_NULL_INPUT_TARGET_LISTENER_H_

=== modified file 'include/server/mir/shell/application_session.h'
--- include/server/mir/shell/application_session.h	2013-04-19 08:03:57 +0000
+++ include/server/mir/shell/application_session.h	2013-04-23 12:15:34 +0000
@@ -25,17 +25,29 @@
 
 namespace mir
 {
+<<<<<<< TREE
 class EventSink;
 
+=======
+namespace events
+{
+class EventSink;
+}
+>>>>>>> MERGE-SOURCE
 namespace shell
 {
 class SurfaceFactory;
 class Surface;
+class InputTargetListener;
 
 class ApplicationSession : public Session
 {
 public:
-    explicit ApplicationSession(std::shared_ptr<SurfaceFactory> const& surface_factory, std::string const& session_name);
+    explicit ApplicationSession(
+        std::shared_ptr<SurfaceFactory> const& surface_factory,
+        std::shared_ptr<InputTargetListener> const& input_target_listener,
+        std::string const& session_name,
+        std::shared_ptr<events::EventSink> const& sink);
     ~ApplicationSession();
 
     frontend::SurfaceId create_surface(frontend::SurfaceCreationParameters const& params);
@@ -61,7 +73,9 @@
 
 private:
     std::shared_ptr<SurfaceFactory> const surface_factory;
+    std::shared_ptr<InputTargetListener> const input_target_listener;
     std::string const session_name;
+    std::shared_ptr<events::EventSink> const event_sink;
 
     frontend::SurfaceId next_id();
 

=== removed file 'include/server/mir/shell/input_focus_selector.h'
--- include/server/mir/shell/input_focus_selector.h	2013-04-16 09:16:38 +0000
+++ include/server/mir/shell/input_focus_selector.h	1970-01-01 00:00:00 +0000
@@ -1,52 +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: Robert Carr <[e-mail]>
- */
-
-#ifndef MIR_SHELL_INPUT_FOCUS_SELECTOR_H_
-#define MIR_SHELL_INPUT_FOCUS_SELECTOR_H_
-
-#include <memory>
-
-namespace mir
-{
-namespace input
-{
-class SessionTarget;
-class SurfaceTarget;
-}
-
-namespace shell
-{
-
-class InputFocusSelector
-{
-public:
-    virtual ~InputFocusSelector() {}
-
-    virtual void set_input_focus_to(std::shared_ptr<input::SessionTarget> const& focus_application,
-                                    std::shared_ptr<input::SurfaceTarget> const& focus_surface) = 0;
-
-protected:
-    InputFocusSelector() = default;
-    InputFocusSelector(InputFocusSelector const&) = delete;
-    InputFocusSelector& operator=(InputFocusSelector const&) = delete;
-};
-
-}
-} // namespace mir
-
-#endif // MIR_SHELL_INPUT_FOCUS_SELECTOR_H_

=== added file 'include/server/mir/shell/input_target_listener.h'
--- include/server/mir/shell/input_target_listener.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/shell/input_target_listener.h	2013-04-23 12:15:34 +0000
@@ -0,0 +1,59 @@
+/*
+ * 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: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_SHELL_INPUT_TARGET_LISTENER_H_
+#define MIR_SHELL_INPUT_TARGET_LISTENER_H_
+
+#include <memory>
+
+namespace mir
+{
+namespace input
+{
+class SessionTarget;
+class SurfaceTarget;
+}
+
+namespace shell
+{
+
+class InputTargetListener
+{
+public:
+    virtual ~InputTargetListener() = default;
+    
+    virtual void input_application_opened(std::shared_ptr<input::SessionTarget> const& application) = 0;
+    virtual void input_application_closed(std::shared_ptr<input::SessionTarget> const& application) = 0;
+
+    virtual void input_surface_opened(std::shared_ptr<input::SessionTarget> const& application,
+                                      std::shared_ptr<input::SurfaceTarget> const& opened_surface) = 0;
+    virtual void input_surface_closed(std::shared_ptr<input::SurfaceTarget> const& closed_surface) = 0;
+
+    virtual void focus_changed(std::shared_ptr<input::SurfaceTarget> const& focus_surface) = 0;
+    virtual void focus_cleared() = 0;
+
+protected:
+    InputTargetListener() = default;
+    InputTargetListener(InputTargetListener const&) = delete;
+    InputTargetListener& operator=(InputTargetListener const&) = delete;
+};
+
+}
+} // namespace mir
+
+#endif // MIR_SHELL_INPUT_TARGET_LISTENER_H_

=== modified file 'include/server/mir/shell/organising_surface_factory.h'
--- include/server/mir/shell/organising_surface_factory.h	2013-04-16 09:16:38 +0000
+++ include/server/mir/shell/organising_surface_factory.h	2013-04-23 12:15:34 +0000
@@ -36,7 +36,10 @@
                              std::shared_ptr<PlacementStrategy> const& placement_strategy);
     virtual ~OrganisingSurfaceFactory();
 
-    std::shared_ptr<Surface> create_surface(frontend::SurfaceCreationParameters const& params);
+    std::shared_ptr<Surface> create_surface(
+        frontend::SurfaceCreationParameters const& params,
+        frontend::SurfaceId id,
+        std::shared_ptr<events::EventSink> const& sink) override;
 
 protected:
     OrganisingSurfaceFactory(OrganisingSurfaceFactory const&) = delete;

=== modified file 'include/server/mir/shell/session.h'
--- include/server/mir/shell/session.h	2013-04-22 03:24:56 +0000
+++ include/server/mir/shell/session.h	2013-04-23 12:15:34 +0000
@@ -32,6 +32,7 @@
 class Session : public frontend::Session, public input::SessionTarget
 {
 public:
+    virtual std::string name() const = 0;
     virtual void force_requests_to_complete() = 0;
 
     virtual std::shared_ptr<Surface> default_surface() const = 0;

=== modified file 'include/server/mir/shell/session_manager.h'
--- include/server/mir/shell/session_manager.h	2013-04-22 03:24:56 +0000
+++ include/server/mir/shell/session_manager.h	2013-04-23 12:15:34 +0000
@@ -40,18 +40,20 @@
 class SessionContainer;
 class FocusSequence;
 class FocusSetter;
+class InputTargetListener;
 class Session;
 
 class SessionManager : public frontend::Shell
 {
 public:
     explicit SessionManager(std::shared_ptr<SurfaceFactory> const& surface_factory,
-                            std::shared_ptr<SessionContainer> const& session_container,
+                            std::shared_ptr<SessionContainer> const& app_container,
                             std::shared_ptr<FocusSequence> const& focus_sequence,
-                            std::shared_ptr<FocusSetter> const& focus_setter);
+                            std::shared_ptr<FocusSetter> const& focus_setter,
+                            std::shared_ptr<InputTargetListener> const& input_target_listener);
     virtual ~SessionManager();
 
-    virtual std::shared_ptr<frontend::Session> open_session(std::string const& name);
+    virtual std::shared_ptr<frontend::Session> open_session(std::string const& name, std::shared_ptr<events::EventSink> const& sink);
     virtual void close_session(std::shared_ptr<frontend::Session> const& session);
 
     virtual void tag_session_with_lightdm_id(std::shared_ptr<frontend::Session> const& session, int id);
@@ -71,6 +73,7 @@
     std::shared_ptr<SessionContainer> const app_container;
     std::shared_ptr<FocusSequence> const focus_sequence;
     std::shared_ptr<FocusSetter> const focus_setter;
+    std::shared_ptr<InputTargetListener> const input_target_listener;
 
     std::mutex mutex;
     std::weak_ptr<Session> focus_application;

=== modified file 'include/server/mir/shell/single_visibility_focus_mechanism.h'
--- include/server/mir/shell/single_visibility_focus_mechanism.h	2013-04-16 09:16:38 +0000
+++ include/server/mir/shell/single_visibility_focus_mechanism.h	2013-04-23 12:15:34 +0000
@@ -28,13 +28,11 @@
 namespace shell
 {
 class SessionContainer;
-class InputFocusSelector;
 
 class SingleVisibilityFocusMechanism : public FocusSetter
 {
 public:
-    explicit SingleVisibilityFocusMechanism(std::shared_ptr<SessionContainer> const& app_container,
-                                            std::shared_ptr<shell::InputFocusSelector> const& input_selector);
+    explicit SingleVisibilityFocusMechanism(std::shared_ptr<SessionContainer> const& app_container);
     virtual ~SingleVisibilityFocusMechanism() {}
 
     void set_focus_to(std::shared_ptr<shell::Session> const& new_focus);
@@ -44,7 +42,6 @@
     SingleVisibilityFocusMechanism& operator=(const SingleVisibilityFocusMechanism&) = delete;
 private:
     std::shared_ptr<SessionContainer> const app_container;
-    std::shared_ptr<shell::InputFocusSelector> const input_selector;
 };
 
 }

=== modified file 'include/server/mir/shell/surface.h'
--- include/server/mir/shell/surface.h	2013-04-19 03:20:05 +0000
+++ include/server/mir/shell/surface.h	2013-04-23 12:15:34 +0000
@@ -31,9 +31,16 @@
 
 namespace mir
 {
-
-class EventSink;
-
+<<<<<<< TREE
+
+class EventSink;
+
+=======
+namespace events
+{
+class EventSink;
+}
+>>>>>>> MERGE-SOURCE
 namespace frontend
 {
 struct SurfaceCreationParameters;
@@ -53,7 +60,9 @@
     Surface(
         std::shared_ptr<SurfaceBuilder> const& builder,
         frontend::SurfaceCreationParameters const& params,
-        std::shared_ptr<input::InputChannel> const& input_channel);
+        std::shared_ptr<input::InputChannel> const& input_channel,
+        frontend::SurfaceId id,
+        std::shared_ptr<events::EventSink> const& sink);
     ~Surface();
 
     virtual void hide();
@@ -80,10 +89,14 @@
 
     virtual int configure(MirSurfaceAttrib attrib, int value);
     virtual MirSurfaceType type() const;
+<<<<<<< TREE
     virtual MirSurfaceState state() const;
 
     void set_id(frontend::SurfaceId i);
     void set_event_target(std::shared_ptr<EventSink> const& sink);
+=======
+    virtual MirSurfaceState state() const;
+>>>>>>> MERGE-SOURCE
 
 private:
     bool set_type(MirSurfaceType t);  // Use configure() to make public changes
@@ -94,9 +107,15 @@
     std::shared_ptr<mir::input::InputChannel> const input_channel;
     std::weak_ptr<mir::surfaces::Surface> const surface;
 
+<<<<<<< TREE
     std::shared_ptr<EventSink> event_sink;
     frontend::SurfaceId id;
 
+=======
+    frontend::SurfaceId const id;
+    std::shared_ptr<events::EventSink> const event_sink;
+
+>>>>>>> MERGE-SOURCE
     MirSurfaceType type_value;
     MirSurfaceState state_value;
 };

=== modified file 'include/server/mir/shell/surface_factory.h'
--- include/server/mir/shell/surface_factory.h	2013-04-19 03:20:05 +0000
+++ include/server/mir/shell/surface_factory.h	2013-04-23 12:15:34 +0000
@@ -19,10 +19,15 @@
 #ifndef MIR_SHELL_SURFACE_FACTORY_H_
 #define MIR_SHELL_SURFACE_FACTORY_H_
 
+#include "mir/frontend/surface_id.h"
 #include <memory>
 
 namespace mir
 {
+namespace events
+{
+class EventSink;
+}
 namespace frontend
 {
 struct SurfaceCreationParameters;
@@ -34,7 +39,10 @@
 class SurfaceFactory
 {
 public:
-    virtual std::shared_ptr<Surface> create_surface(const frontend::SurfaceCreationParameters& params) = 0;
+    virtual std::shared_ptr<Surface> create_surface(
+        frontend::SurfaceCreationParameters const& params,
+        frontend::SurfaceId id,
+        std::shared_ptr<events::EventSink> const& sink) = 0;
 
 protected:
     virtual ~SurfaceFactory() {}

=== modified file 'include/server/mir/shell/surface_source.h'
--- include/server/mir/shell/surface_source.h	2013-04-16 09:16:38 +0000
+++ include/server/mir/shell/surface_source.h	2013-04-23 12:15:34 +0000
@@ -40,7 +40,10 @@
     explicit SurfaceSource(std::shared_ptr<SurfaceBuilder> const& surface_builder, std::shared_ptr<input::InputChannelFactory> const& input_factory);
     virtual ~SurfaceSource() {}
 
-    std::shared_ptr<Surface> create_surface(const frontend::SurfaceCreationParameters& params);
+    std::shared_ptr<Surface> create_surface(
+        frontend::SurfaceCreationParameters const& params,
+        frontend::SurfaceId id,
+        std::shared_ptr<events::EventSink> const& sink);
 
 protected:
     SurfaceSource(const SurfaceSource&) = delete;

=== added file 'include/shared/mir/default_configuration.h'
--- include/shared/mir/default_configuration.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/default_configuration.h	2013-04-23 12:15:34 +0000
@@ -0,0 +1,29 @@
+/*
+ * Private internal defaults shared by client and server code.
+ *
+ * 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 distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Daniel van Vugt <[e-mail]>
+ */
+
+#ifndef MIR_DEFAULT_CONFIGURATION_
+#define MIR_DEFAULT_CONFIGURATION_
+
+namespace mir
+{
+const char default_server_socket[] = "/tmp/mir_socket";
+}
+
+#endif

=== added directory 'include/shared/mir/events'
=== renamed file 'include/shared/mir/event_sink.h' => 'include/shared/mir/events/event_sink.h'
--- include/shared/mir/event_sink.h	2013-04-19 04:33:51 +0000
+++ include/shared/mir/events/event_sink.h	2013-04-23 12:15:34 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 /*
  * Copyright © 2013 Canonical Ltd.
  *
@@ -41,3 +42,49 @@
 
 #endif
 
+=======
+/*
+ * 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 distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Daniel van Vugt <[e-mail]>
+ */
+
+#ifndef MIR_EVENTS_EVENT_SINK_H_
+#define MIR_EVENTS_EVENT_SINK_H_
+
+#include "mir_toolkit/event.h"
+
+namespace mir
+{
+namespace events
+{
+
+class EventSink
+{
+public:
+    virtual ~EventSink() = default;
+
+    virtual void handle_event(MirEvent const& e) = 0;
+
+protected:
+    EventSink() = default;
+    EventSink(EventSink const&) = delete;
+    EventSink& operator=(EventSink const&) = delete;
+};
+}
+} // namespace mir
+
+#endif // MIR_EVENTS_EVENT_SINK_H_
+>>>>>>> MERGE-SOURCE

=== modified file 'include/shared/mir/graphics/android/sync_object.h'
--- include/shared/mir/graphics/android/sync_object.h	2013-04-12 16:28:32 +0000
+++ include/shared/mir/graphics/android/sync_object.h	2013-04-23 12:15:34 +0000
@@ -8,7 +8,7 @@
  * 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.
+ * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

=== modified file 'include/test/mir_test_doubles/mock_android_buffer.h'
--- include/test/mir_test_doubles/mock_android_buffer.h	2013-04-11 22:20:59 +0000
+++ include/test/mir_test_doubles/mock_android_buffer.h	2013-04-23 12:15:34 +0000
@@ -2,7 +2,7 @@
  * Copyright © 2012 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,
+ * 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,
@@ -10,7 +10,7 @@
  * 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 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: Thomas Voss <[e-mail]>

=== modified file 'include/test/mir_test_doubles/mock_display_support_provider.h'
--- include/test/mir_test_doubles/mock_display_support_provider.h	2013-04-12 16:28:32 +0000
+++ include/test/mir_test_doubles/mock_display_support_provider.h	2013-04-23 12:15:34 +0000
@@ -2,7 +2,7 @@
  * 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,
+ * 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,
@@ -10,7 +10,7 @@
  * 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 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: Kevin DuBois <[e-mail]>

=== modified file 'include/test/mir_test_doubles/mock_fb_device.h'
--- include/test/mir_test_doubles/mock_fb_device.h	2013-04-22 03:24:56 +0000
+++ include/test/mir_test_doubles/mock_fb_device.h	2013-04-23 12:15:34 +0000
@@ -2,7 +2,7 @@
  * 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,
+ * 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,
@@ -10,7 +10,7 @@
  * 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 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: Kevin DuBois <[e-mail]>

=== modified file 'include/test/mir_test_doubles/mock_input_configuration.h'
--- include/test/mir_test_doubles/mock_input_configuration.h	2013-04-12 16:35:06 +0000
+++ include/test/mir_test_doubles/mock_input_configuration.h	2013-04-23 12:15:34 +0000
@@ -2,15 +2,15 @@
  * 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,
+ * 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: Robert Carr <[e-mail]>

=== modified file 'include/test/mir_test_doubles/mock_input_dispatcher.h'
--- include/test/mir_test_doubles/mock_input_dispatcher.h	2013-04-11 23:04:18 +0000
+++ include/test/mir_test_doubles/mock_input_dispatcher.h	2013-04-23 12:15:34 +0000
@@ -2,15 +2,15 @@
  * 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,
+ * 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: Robert Carr <[e-mail]>

=== removed file 'include/test/mir_test_doubles/mock_input_focus_selector.h'
--- include/test/mir_test_doubles/mock_input_focus_selector.h	2013-04-16 09:16:38 +0000
+++ include/test/mir_test_doubles/mock_input_focus_selector.h	1970-01-01 00:00:00 +0000
@@ -1,40 +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: Robert Carr <[e-mail]>
- */
-
-#ifndef MIR_TEST_DOUBLES_MOCK_INPUT_FOCUS_SELECTOR_H_
-#define MIR_TEST_DOUBLES_MOCK_INPUT_FOCUS_SELECTOR_H_
-
-#include "mir/shell/input_focus_selector.h"
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-struct MockInputFocusSelector : public shell::InputFocusSelector
-{
-    MOCK_METHOD2(set_input_focus_to, void(std::shared_ptr<input::SessionTarget> const&, std::shared_ptr<input::SurfaceTarget> const&));
-};
-
-}
-}
-} // namespace mir
-
-#endif // MIR_TEST_DOUBLES_MOCK_INPUT_FOCUS_SELECTOR_H_

=== added file 'include/test/mir_test_doubles/mock_input_target_listener.h'
--- include/test/mir_test_doubles/mock_input_target_listener.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_input_target_listener.h	2013-04-23 12:15:34 +0000
@@ -0,0 +1,49 @@
+/*
+ * 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: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_INPUT_TARGET_LISTENER_H_
+#define MIR_TEST_DOUBLES_MOCK_INPUT_TARGET_LISTENER_H_
+
+#include "mir/shell/input_target_listener.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct MockInputTargetListener : public shell::InputTargetListener
+{
+    virtual ~MockInputTargetListener() noexcept(true) {}
+    MOCK_METHOD1(input_application_opened, void(std::shared_ptr<input::SessionTarget> const& application));
+    MOCK_METHOD1(input_application_closed, void(std::shared_ptr<input::SessionTarget> const& application));
+    MOCK_METHOD2(input_surface_opened, void(std::shared_ptr<input::SessionTarget> const& application,
+        std::shared_ptr<input::SurfaceTarget> const& opened_surface));
+    MOCK_METHOD1(input_surface_closed, void(std::shared_ptr<input::SurfaceTarget> const& closed_surface));
+    MOCK_METHOD1(focus_changed, void(std::shared_ptr<input::SurfaceTarget> const& focus_surface));
+    MOCK_METHOD0(focus_cleared, void());
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_TEST_DOUBLES_MOCK_INPUT_TARGET_LISTENER_H_

=== modified file 'include/test/mir_test_doubles/mock_shell.h'
--- include/test/mir_test_doubles/mock_shell.h	2013-04-19 03:20:05 +0000
+++ include/test/mir_test_doubles/mock_shell.h	2013-04-23 12:15:34 +0000
@@ -34,7 +34,7 @@
 
 struct MockShell : public frontend::Shell
 {
-    MOCK_METHOD1(open_session, std::shared_ptr<frontend::Session>(std::string const&));
+    MOCK_METHOD2(open_session, std::shared_ptr<frontend::Session>(std::string const&, std::shared_ptr<events::EventSink> const&));
     MOCK_METHOD1(close_session, void(std::shared_ptr<frontend::Session> const&));
 
     MOCK_METHOD2(tag_session_with_lightdm_id, void(std::shared_ptr<frontend::Session> const&, int));

=== modified file 'include/test/mir_test_doubles/mock_surface.h'
--- include/test/mir_test_doubles/mock_surface.h	2013-04-19 03:20:05 +0000
+++ include/test/mir_test_doubles/mock_surface.h	2013-04-23 12:15:34 +0000
@@ -37,7 +37,12 @@
 struct MockSurface : public shell::Surface
 {
     MockSurface(std::shared_ptr<shell::SurfaceBuilder> const& builder) :
-        shell::Surface(builder, frontend::a_surface(), std::shared_ptr<input::InputChannel>())
+        shell::Surface(
+            builder,
+            frontend::a_surface(),
+            std::shared_ptr<input::InputChannel>(),
+            frontend::SurfaceId(),
+            std::shared_ptr<events::EventSink>())
     {
     }
 

=== modified file 'include/test/mir_test_doubles/mock_surface_factory.h'
--- include/test/mir_test_doubles/mock_surface_factory.h	2013-04-16 09:16:38 +0000
+++ include/test/mir_test_doubles/mock_surface_factory.h	2013-04-23 12:15:34 +0000
@@ -33,7 +33,10 @@
 
 struct MockSurfaceFactory : public shell::SurfaceFactory
 {
-    MOCK_METHOD1(create_surface, std::shared_ptr<shell::Surface>(const frontend::SurfaceCreationParameters&));
+    MOCK_METHOD3(create_surface, std::shared_ptr<shell::Surface>(
+        const frontend::SurfaceCreationParameters&,
+        frontend::SurfaceId,
+        std::shared_ptr<events::EventSink> const&));
 };
 
 }

=== modified file 'include/test/mir_test_doubles/null_virtual_terminal.h'
--- include/test/mir_test_doubles/null_virtual_terminal.h	2013-04-22 03:24:56 +0000
+++ include/test/mir_test_doubles/null_virtual_terminal.h	2013-04-23 12:15:34 +0000
@@ -2,7 +2,7 @@
  * 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,
+ * 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,
@@ -10,7 +10,7 @@
  * 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 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: Alexandros Frantzis <[e-mail]>

=== added file 'include/test/mir_test_doubles/stub_input_target_listener.h'
--- include/test/mir_test_doubles/stub_input_target_listener.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_input_target_listener.h	2013-04-23 12:15:34 +0000
@@ -0,0 +1,59 @@
+/*
+ * 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: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_INPUT_LISTENER_H_
+#define MIR_TEST_DOUBLES_STUB_INPUT_LISTENER_H_
+
+#include "mir/shell/input_target_listener.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubInputTargetListener : public shell::InputTargetListener
+{
+    void input_application_opened(std::shared_ptr<input::SessionTarget> const&)
+    {
+    }
+    void input_application_closed(std::shared_ptr<input::SessionTarget> const&)
+    {
+    }
+    void input_surface_opened(std::shared_ptr<input::SessionTarget> const&,
+                              std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    void input_surface_closed(std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    void focus_changed(std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    
+    void focus_cleared()
+    {
+    }
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_TEST_DOUBLES_STUB_INPUT_LISTENER_H_

=== modified file 'include/test/mir_test_doubles/stub_ipc_factory.h'
--- include/test/mir_test_doubles/stub_ipc_factory.h	2013-04-19 07:45:44 +0000
+++ include/test/mir_test_doubles/stub_ipc_factory.h	2013-04-23 12:15:34 +0000
@@ -41,8 +41,13 @@
     {
     }
 
+<<<<<<< TREE
     std::shared_ptr<protobuf::DisplayServer> make_ipc_server(
         std::shared_ptr<EventSink> const&)
+=======
+    std::shared_ptr<protobuf::DisplayServer> make_ipc_server(
+        std::shared_ptr<events::EventSink> const&)
+>>>>>>> MERGE-SOURCE
     {
         return server;
     }

=== modified file 'include/test/mir_test_doubles/stub_session.h'
--- include/test/mir_test_doubles/stub_session.h	2013-04-19 08:03:57 +0000
+++ include/test/mir_test_doubles/stub_session.h	2013-04-23 12:15:34 +0000
@@ -58,9 +58,15 @@
     {
         return 0;
     }
+<<<<<<< TREE
     void set_event_sink(std::shared_ptr<EventSink> const&)
     {
     }
+=======
+    void set_event_sink(std::shared_ptr<events::EventSink> const&)
+    {
+    }
+>>>>>>> MERGE-SOURCE
 };
 
 }

=== modified file 'include/test/mir_test_doubles/stub_shell.h'
--- include/test/mir_test_doubles/stub_shell.h	2013-04-19 03:20:05 +0000
+++ include/test/mir_test_doubles/stub_shell.h	2013-04-23 12:15:34 +0000
@@ -31,7 +31,7 @@
 
 class StubShell : public frontend::Shell
 {
-    std::shared_ptr<frontend::Session> open_session(std::string const& /* name */)
+    std::shared_ptr<frontend::Session> open_session(std::string const& /* name */, std::shared_ptr<events::EventSink> const& /* sink */)
     {
         return std::make_shared<StubSession>();
     }

=== modified file 'include/test/mir_test_framework/testing_server_configuration.h'
--- include/test/mir_test_framework/testing_server_configuration.h	2013-04-16 09:16:38 +0000
+++ include/test/mir_test_framework/testing_server_configuration.h	2013-04-23 12:15:34 +0000
@@ -49,7 +49,7 @@
     // to avoid starting and stopping the full android input stack for tests
     // which do not leverage input.
     std::shared_ptr<input::InputManager> the_input_manager();
-    std::shared_ptr<shell::InputFocusSelector> the_input_focus_selector();
+    std::shared_ptr<shell::InputTargetListener> the_input_target_listener();
 
     virtual std::string the_socket_file() const;
     using DefaultServerConfiguration::the_options;

=== modified file 'src/client/client_buffer_depository.h'
--- src/client/client_buffer_depository.h	2013-04-12 03:36:28 +0000
+++ src/client/client_buffer_depository.h	2013-04-23 12:15:34 +0000
@@ -48,9 +48,9 @@
 
     /// \param factory is the ClientBufferFactory that will be used to convert IPC data to ClientBuffers
     /// \param max_buffers is the number of buffers the depository will cache. After the client has received
-    /// its initial buffers the ClientBufferDepository will always have the last \ref max_buffers buffers
+    /// its initial buffers the ClientBufferDepository will always have the last max_buffers buffers
     /// cached.
-    /// \note The server relies on the depository caching \ref max_buffers buffers to optimise away buffer
+    /// \note The server relies on the depository caching max_buffers buffers to optimise away buffer
     /// passing. As such, this number needs to be shared between the server and client libraries.
     ClientBufferDepository(std::shared_ptr<ClientBufferFactory> const& factory, int max_buffers);
 

=== modified file 'src/client/mir_client_library.cpp'
--- src/client/mir_client_library.cpp	2013-04-18 04:23:56 +0000
+++ src/client/mir_client_library.cpp	2013-04-23 12:15:34 +0000
@@ -16,6 +16,7 @@
  * Authored by: Thomas Guest <[e-mail]>
  */
 
+#include "mir/default_configuration.h"
 #include "mir_toolkit/mir_client_library.h"
 #include "mir_toolkit/mir_client_library_drm.h"
 #include "mir_toolkit/mir_client_library_lightdm.h"
@@ -54,6 +55,8 @@
 
     try
     {
+        const std::string sock = socket_file ? socket_file :
+                                               mir::default_server_socket;
         auto log = std::make_shared<mcl::ConsoleLogger>();
         auto client_platform_factory = std::make_shared<mcl::NativeClientPlatformFactory>();
 

=== modified file 'src/client/mir_connection.h'
--- src/client/mir_connection.h	2013-04-16 09:42:50 +0000
+++ src/client/mir_connection.h	2013-04-23 12:15:34 +0000
@@ -34,7 +34,11 @@
 #include "client_context.h"
 
 #include "mir_wait_handle.h"
+<<<<<<< TREE
 #include "mir/event_sink.h"
+=======
+#include "mir/events/event_sink.h"
+>>>>>>> MERGE-SOURCE
 
 namespace mir
 {
@@ -51,8 +55,12 @@
 }
 }
 
+<<<<<<< TREE
 struct MirConnection : public mir::client::ClientContext,
                        public mir::EventSink
+=======
+struct MirConnection : mir::client::ClientContext, mir::events::EventSink
+>>>>>>> MERGE-SOURCE
 {
 public:
     MirConnection();

=== modified file 'src/client/mir_socket_rpc_channel.cpp'
--- src/client/mir_socket_rpc_channel.cpp	2013-04-18 04:15:05 +0000
+++ src/client/mir_socket_rpc_channel.cpp	2013-04-23 12:15:34 +0000
@@ -330,6 +330,7 @@
     result.ParseFromIstream(&in);
     return result;
 }
+<<<<<<< TREE
 
 void mcl::MirSocketRpcChannel::set_event_handler(mir::EventSink *sink)
 {
@@ -340,3 +341,15 @@
      */
     event_handler = sink;
 }
+=======
+
+void mcl::MirSocketRpcChannel::set_event_handler(events::EventSink *sink)
+{
+    /*
+     * Yes, these have to be regular pointers. Because ownership of the object
+     * (which is actually a MirConnection) is the responsibility of the calling
+     * client. So out of our control.
+     */
+    event_handler = sink;
+}
+>>>>>>> MERGE-SOURCE

=== modified file 'src/client/mir_socket_rpc_channel.h'
--- src/client/mir_socket_rpc_channel.h	2013-04-18 03:54:19 +0000
+++ src/client/mir_socket_rpc_channel.h	2013-04-23 12:15:34 +0000
@@ -22,7 +22,11 @@
 
 #include "mir_basic_rpc_channel.h"
 #include "mir_logger.h"
+<<<<<<< TREE
 #include "mir/event_sink.h"
+=======
+#include "mir/events/event_sink.h"
+>>>>>>> MERGE-SOURCE
 
 #include <boost/asio.hpp>
 
@@ -52,8 +56,13 @@
     MirSocketRpcChannel(const std::string& endpoint, const std::shared_ptr<Logger>& log);
     ~MirSocketRpcChannel();
 
+<<<<<<< TREE
     void set_event_handler(EventSink *sink);
 
+=======
+    void set_event_handler(events::EventSink *sink);
+
+>>>>>>> MERGE-SOURCE
 private:
     virtual void CallMethod(const google::protobuf::MethodDescriptor* method, google::protobuf::RpcController*,
         const google::protobuf::Message* parameters, google::protobuf::Message* response,
@@ -80,8 +89,13 @@
     size_t read_message_header();
 
     mir::protobuf::wire::Result read_message_body(const size_t body_size);
+<<<<<<< TREE
 
     EventSink *event_handler;
+=======
+
+    events::EventSink *event_handler;
+>>>>>>> MERGE-SOURCE
 };
 
 }

=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2013-04-22 03:24:56 +0000
+++ src/server/default_server_configuration.cpp	2013-04-23 12:15:34 +0000
@@ -45,7 +45,7 @@
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/graphics/null_display_report.h"
 #include "mir/input/null_input_manager.h"
-#include "mir/input/null_input_focus_selector.h"
+#include "mir/input/null_input_target_listener.h"
 #include "input/android/default_android_input_configuration.h"
 #include "input/android/android_input_manager.h"
 #include "input/android/android_dispatcher_controller.h"
@@ -59,8 +59,10 @@
 #include "mir/surfaces/surface_stack.h"
 #include "mir/surfaces/surface_controller.h"
 #include "mir/time/high_resolution_clock.h"
+#include "mir/default_configuration.h"
 
 namespace mc = mir::compositor;
+namespace me = mir::events;
 namespace geom = mir::geometry;
 namespace mf = mir::frontend;
 namespace mg = mir::graphics;
@@ -106,8 +108,13 @@
     std::shared_ptr<mg::ViewableArea> const graphics_display;
     std::shared_ptr<mc::GraphicBufferAllocator> const buffer_allocator;
 
+<<<<<<< TREE
     virtual std::shared_ptr<mir::protobuf::DisplayServer> make_ipc_server(
         std::shared_ptr<mir::EventSink> const& sink)
+=======
+    virtual std::shared_ptr<mir::protobuf::DisplayServer> make_ipc_server(
+        std::shared_ptr<me::EventSink> const& sink)
+>>>>>>> MERGE-SOURCE
     {
         return std::make_shared<mf::SessionMediator>(
             shell,
@@ -230,7 +237,7 @@
 
 std::string mir::DefaultServerConfiguration::the_socket_file() const
 {
-    return the_options()->get("file", "/tmp/mir_socket");
+    return the_options()->get("file", mir::default_server_socket);
 }
 
 std::shared_ptr<mir::options::Option> mir::DefaultServerConfiguration::the_options() const
@@ -312,8 +319,7 @@
         [this]
         {
             return std::make_shared<msh::SingleVisibilityFocusMechanism>(
-                the_shell_session_container(),
-                the_input_focus_selector());
+                the_shell_session_container());
         });
 }
 
@@ -349,7 +355,8 @@
                 the_shell_surface_factory(),
                 the_shell_session_container(),
                 the_shell_focus_sequence(),
-                the_shell_focus_setter());
+                the_shell_focus_setter(),
+                the_input_target_listener());
         });
 }
 
@@ -564,15 +571,15 @@
     return the_input_manager();
 }
 
-std::shared_ptr<msh::InputFocusSelector> mir::DefaultServerConfiguration::the_input_focus_selector()
+std::shared_ptr<msh::InputTargetListener> mir::DefaultServerConfiguration::the_input_target_listener()
 {
-    return input_focus_selector(
-        [&]() -> std::shared_ptr<msh::InputFocusSelector>
+    return input_target_listener(
+        [&]() -> std::shared_ptr<msh::InputTargetListener>
         {
             if (the_options()->get("enable-input", false))
                 return std::make_shared<mia::DispatcherController>(the_input_configuration());
             else
-                return std::make_shared<mi::NullInputFocusSelector>();
+                return std::make_shared<mi::NullInputTargetListener>();
         });
 }
 

=== modified file 'src/server/display_server.cpp'
--- src/server/display_server.cpp	2013-04-22 09:50:06 +0000
+++ src/server/display_server.cpp	2013-04-23 12:15:34 +0000
@@ -31,9 +31,9 @@
 
 namespace mc = mir::compositor;
 namespace mf = mir::frontend;
-namespace msh = mir::shell;
 namespace mg = mir::graphics;
 namespace mi = mir::input;
+namespace msh = mir::shell;
 
 namespace
 {

=== modified file 'src/server/frontend/CMakeLists.txt'
--- src/server/frontend/CMakeLists.txt	2013-04-19 04:00:32 +0000
+++ src/server/frontend/CMakeLists.txt	2013-04-23 12:15:34 +0000
@@ -8,6 +8,7 @@
   protobuf_message_processor.cpp
   null_message_processor.cpp
   surface_creation_parameters.cpp
+  event_pipe.cpp
 
   resource_cache.cpp
   ${PROTO_HDRS}

=== renamed file 'src/server/event_queue.cpp' => 'src/server/frontend/event_pipe.cpp'
--- src/server/event_queue.cpp	2013-04-16 05:46:28 +0000
+++ src/server/frontend/event_pipe.cpp	2013-04-23 12:15:34 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 /*
  * Copyright © 2013 Canonical Ltd.
  *
@@ -35,3 +36,41 @@
     if (p)
         p->handle_event(e);
 }
+=======
+/*
+ * 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 "event_pipe.h"
+
+namespace mf = mir::frontend;
+
+void mf::EventPipe::set_target(std::weak_ptr<EventSink> const& s)
+{
+    target = s;
+}
+
+void mf::EventPipe::handle_event(MirEvent const& e)
+{
+    // In future, post might put e on a queue and wait for some background
+    // thread to push it through to sink. But that's not required right now.
+
+    std::shared_ptr<EventSink> p = target.lock();
+    if (p)
+        p->handle_event(e);
+}
+>>>>>>> MERGE-SOURCE

=== renamed file 'include/server/mir/event_queue.h' => 'src/server/frontend/event_pipe.h'
--- include/server/mir/event_queue.h	2013-04-16 05:46:28 +0000
+++ src/server/frontend/event_pipe.h	2013-04-23 12:15:34 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 /*
  * Copyright © 2013 Canonical Ltd.
  *
@@ -38,3 +39,47 @@
 } // namespace mir
 
 #endif
+=======
+/*
+ * 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_
+>>>>>>> MERGE-SOURCE

=== modified file 'src/server/frontend/protobuf_message_processor.cpp'
--- src/server/frontend/protobuf_message_processor.cpp	2013-04-18 04:15:05 +0000
+++ src/server/frontend/protobuf_message_processor.cpp	2013-04-23 12:15:34 +0000
@@ -53,14 +53,6 @@
     resource_cache->free_resource(response);
 }
 
-void mfd::ProtobufMessageProcessor::send_response(::google::protobuf::uint32 id, mir::protobuf::Platform* response)
-{
-    const auto& fd = extract_fds_from(response);
-    send_response(id, static_cast<google::protobuf::Message*>(response));
-    sender->send_fds(fd);
-    resource_cache->free_resource(response);
-}
-
 void mfd::ProtobufMessageProcessor::send_response(::google::protobuf::uint32 id, mir::protobuf::Connection* response)
 {
     const auto& fd = response->has_platform() ?

=== modified file 'src/server/frontend/protobuf_message_processor.h'
--- src/server/frontend/protobuf_message_processor.h	2013-04-18 04:15:05 +0000
+++ src/server/frontend/protobuf_message_processor.h	2013-04-23 12:15:34 +0000
@@ -24,7 +24,11 @@
 
 #include "mir_protobuf.pb.h"
 #include "mir_protobuf_wire.pb.h"
+<<<<<<< TREE
 #include "mir/event_sink.h"
+=======
+#include "mir/events/event_sink.h"
+>>>>>>> MERGE-SOURCE
 
 #include <vector>
 #include <memory>
@@ -43,8 +47,13 @@
 namespace detail
 {
 
+<<<<<<< TREE
 struct ProtobufMessageProcessor : MessageProcessor,
                                   public EventSink
+=======
+struct ProtobufMessageProcessor : MessageProcessor,
+                                  public events::EventSink
+>>>>>>> MERGE-SOURCE
 {
     ProtobufMessageProcessor(
         MessageSender* sender,
@@ -64,10 +73,6 @@
 
     // TODO detecting the message type to see if we send FDs seems a bit of a frig.
     // 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::Platform* response);
-
-    // TODO detecting the message type to see if we send FDs seems a bit of a frig.
-    // 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::Connection* response);
 
     // TODO detecting the message type to see if we send FDs seems a bit of a frig.

=== modified file 'src/server/frontend/protobuf_socket_communicator.cpp'
--- src/server/frontend/protobuf_socket_communicator.cpp	2013-04-22 09:54:07 +0000
+++ src/server/frontend/protobuf_socket_communicator.cpp	2013-04-23 12:15:34 +0000
@@ -22,8 +22,12 @@
 
 #include "mir/frontend/protobuf_ipc_factory.h"
 #include "mir/protobuf/google_protobuf_guard.h"
+<<<<<<< TREE
 #include "mir/event_sink.h"
 #include "mir/event_queue.h"
+=======
+#include "event_pipe.h"
+>>>>>>> MERGE-SOURCE
 
 #include <boost/signals2.hpp>
 
@@ -51,8 +55,13 @@
 
 void mf::ProtobufSocketCommunicator::start_accept()
 {
+<<<<<<< TREE
     std::shared_ptr<EventQueue> event_queue = std::make_shared<EventQueue>();
 
+=======
+    auto const& event_pipe = std::make_shared<EventPipe>();
+
+>>>>>>> MERGE-SOURCE
     auto const& socket_session = std::make_shared<mfd::SocketSession>(
         io_service,
         next_id(),
@@ -60,11 +69,19 @@
 
     auto session = std::make_shared<detail::ProtobufMessageProcessor>(
         socket_session.get(),
+<<<<<<< TREE
         ipc_factory->make_ipc_server(event_queue),
+=======
+        ipc_factory->make_ipc_server(event_pipe),
+>>>>>>> MERGE-SOURCE
         ipc_factory->resource_cache(),
         ipc_factory->report());
 
+<<<<<<< TREE
     event_queue->set_target(session);
+=======
+    event_pipe->set_target(session);
+>>>>>>> MERGE-SOURCE
     socket_session->set_processor(session);
 
     acceptor.async_accept(

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2013-04-19 07:45:44 +0000
+++ src/server/frontend/session_mediator.cpp	2013-04-23 12:15:34 +0000
@@ -44,7 +44,11 @@
     std::shared_ptr<graphics::ViewableArea> const& viewable_area,
     std::shared_ptr<compositor::GraphicBufferAllocator> const& buffer_allocator,
     std::shared_ptr<SessionMediatorReport> const& report,
+<<<<<<< TREE
     std::shared_ptr<EventSink> const& event_sink,
+=======
+    std::shared_ptr<events::EventSink> const& event_sink,
+>>>>>>> MERGE-SOURCE
     std::shared_ptr<ResourceCache> const& resource_cache) :
     shell(shell),
     graphics_platform(graphics_platform),
@@ -65,8 +69,12 @@
 {
     report->session_connect_called(request->application_name());
 
+<<<<<<< TREE
     session = shell->open_session(request->application_name());
     session->set_event_sink(event_sink);
+=======
+    session = shell->open_session(request->application_name(), event_sink);
+>>>>>>> MERGE-SOURCE
 
     auto ipc_package = graphics_platform->get_ipc_package();
     auto platform = response->mutable_platform();

=== modified file 'src/server/graphics/gbm/linux_virtual_terminal.cpp'
--- src/server/graphics/gbm/linux_virtual_terminal.cpp	2013-04-22 03:24:56 +0000
+++ src/server/graphics/gbm/linux_virtual_terminal.cpp	2013-04-23 12:15:34 +0000
@@ -2,7 +2,7 @@
  * 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,
+ * 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,
@@ -10,7 +10,7 @@
  * 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 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: Alexandros Frantzis <[e-mail]>

=== modified file 'src/server/graphics/gbm/linux_virtual_terminal.h'
--- src/server/graphics/gbm/linux_virtual_terminal.h	2013-04-22 03:24:56 +0000
+++ src/server/graphics/gbm/linux_virtual_terminal.h	2013-04-23 12:15:34 +0000
@@ -2,7 +2,7 @@
  * 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,
+ * 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,
@@ -10,7 +10,7 @@
  * 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 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: Alexandros Frantzis <[e-mail]>

=== modified file 'src/server/graphics/gbm/virtual_terminal.h'
--- src/server/graphics/gbm/virtual_terminal.h	2013-04-22 03:24:56 +0000
+++ src/server/graphics/gbm/virtual_terminal.h	2013-04-23 12:15:34 +0000
@@ -2,7 +2,7 @@
  * 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,
+ * 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,
@@ -10,7 +10,7 @@
  * 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 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: Alexandros Frantzis <[e-mail]>

=== modified file 'src/server/input/android/android_dispatcher_controller.cpp'
--- src/server/input/android/android_dispatcher_controller.cpp	2013-04-11 23:06:12 +0000
+++ src/server/input/android/android_dispatcher_controller.cpp	2013-04-23 12:15:34 +0000
@@ -2,15 +2,15 @@
  * 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,
+ * 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: Robert Carr <[e-mail]>
@@ -25,35 +25,85 @@
 
 #include <InputDispatcher.h>
 
+#include <boost/throw_exception.hpp>
+
+#include <stdexcept>
+#include <mutex>
+
 namespace mi = mir::input;
 namespace mia = mi::android;
 
 mia::DispatcherController::DispatcherController(std::shared_ptr<mia::InputConfiguration> const& config) :
-    input_dispatcher(config->the_dispatcher()),
-    focused_window_handle(0),
-    focused_application_handle(0)
-{
-}
-
-void mia::DispatcherController::set_input_focus_to(std::shared_ptr<mi::SessionTarget> const& session,
-    std::shared_ptr<mi::SurfaceTarget> const& surface)
-{
-    if (focused_window_handle.get())
-    {
-        input_dispatcher->unregisterInputChannel(focused_window_handle->getInfo()->inputChannel);
-        focused_window_handle.clear();
-        focused_application_handle.clear();
-    }
+    input_dispatcher(config->the_dispatcher())
+{
+}
+
+void mia::DispatcherController::input_application_opened(std::shared_ptr<mi::SessionTarget> const& session)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+    if (application_handles.find(session) != application_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("An application was opened twice"));
+    application_handles[session] = new mia::InputApplicationHandle(session);
+}
+
+void mia::DispatcherController::input_application_closed(std::shared_ptr<mi::SessionTarget> const& session)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+    if (application_handles.find(session) == application_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("An application was closed twice"));
+    application_handles.erase(session);
+}
+
+void mia::DispatcherController::input_surface_opened(std::shared_ptr<mi::SessionTarget> const& session,
+                                                     std::shared_ptr<input::SurfaceTarget> const& opened_surface)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+    auto application_handle = application_handles.find(session);
+    if (application_handle == application_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("A surface was opened for an unopened application"));
+    if (window_handles.find(opened_surface) != window_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("A surface was opened twice"));
+
+    droidinput::sp<droidinput::InputWindowHandle> window_handle = new mia::InputWindowHandle(application_handle->second, opened_surface);
+    input_dispatcher->registerInputChannel(window_handle->getInfo()->inputChannel, window_handle, false);
+    
+    window_handles[opened_surface] = window_handle;
+}
+
+void mia::DispatcherController::input_surface_closed(std::shared_ptr<input::SurfaceTarget> const& closed_surface)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+    auto it = window_handles.find(closed_surface);
+    if (it == window_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("A surface was closed twice"));
+
+    input_dispatcher->unregisterInputChannel(it->second->getInfo()->inputChannel);
+    window_handles.erase(it);
+}
+
+void mia::DispatcherController::focus_cleared()
+{
+    droidinput::Vector<droidinput::sp<droidinput::InputWindowHandle>> empty_windows;
+    droidinput::sp<droidinput::InputApplicationHandle> null_application = nullptr;
+    
+    input_dispatcher->setFocusedApplication(null_application);
+    input_dispatcher->setInputWindows(empty_windows);
+}
+
+void mia::DispatcherController::focus_changed(std::shared_ptr<mi::SurfaceTarget> const& surface)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+
+    auto window_handle = window_handles[surface];
+
+    if (!window_handle.get())
+        BOOST_THROW_EXCEPTION(std::logic_error("Focus changed to an unopened surface"));
+    auto application_handle = window_handle->inputApplicationHandle;
+    
+    input_dispatcher->setFocusedApplication(application_handle);
 
     droidinput::Vector<droidinput::sp<droidinput::InputWindowHandle>> windows;
-    if (surface)
-    {
-        focused_application_handle = new mia::InputApplicationHandle(session);
-        focused_window_handle = new mia::InputWindowHandle(focused_application_handle, surface);
-        input_dispatcher->setFocusedApplication(focused_application_handle);
+    windows.push_back(window_handle);
 
-        input_dispatcher->registerInputChannel(focused_window_handle->getInfo()->inputChannel, focused_window_handle, false);
-        windows.push_back(focused_window_handle);
-    }
     input_dispatcher->setInputWindows(windows);
 }

=== modified file 'src/server/input/android/android_dispatcher_controller.h'
--- src/server/input/android/android_dispatcher_controller.h	2013-04-11 23:06:12 +0000
+++ src/server/input/android/android_dispatcher_controller.h	2013-04-23 12:15:34 +0000
@@ -2,15 +2,15 @@
  * 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,
+ * 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: Robert Carr <[e-mail]>
@@ -19,10 +19,13 @@
 #ifndef MIR_INPUT_ANDROID_DISPATCHER_CONTROLLER_H_
 #define MIR_INPUT_ANDROID_DISPATCHER_CONTROLLER_H_
 
-#include "mir/shell/input_focus_selector.h"
+#include "mir/shell/input_target_listener.h"
 
 #include <utils/StrongPointer.h>
 
+#include <map>
+#include <mutex>
+
 namespace android
 {
 class InputDispatcherInterface;
@@ -40,13 +43,21 @@
 {
 class InputConfiguration;
 
-class DispatcherController : public shell::InputFocusSelector
+class DispatcherController : public shell::InputTargetListener
 {
 public:
     explicit DispatcherController(std::shared_ptr<InputConfiguration> const& input_configuration);
-    virtual ~DispatcherController() = default;
+    virtual ~DispatcherController() noexcept(true) {}
     
-    void set_input_focus_to(std::shared_ptr<input::SessionTarget> const& session, std::shared_ptr<input::SurfaceTarget> const& surface);
+    void input_application_opened(std::shared_ptr<input::SessionTarget> const& application);
+    void input_application_closed(std::shared_ptr<input::SessionTarget> const& application);
+
+    void input_surface_opened(std::shared_ptr<input::SessionTarget> const& application,
+       std::shared_ptr<input::SurfaceTarget> const& opened_surface);
+    void input_surface_closed(std::shared_ptr<input::SurfaceTarget> const& closed_surface);
+
+    void focus_changed(std::shared_ptr<input::SurfaceTarget> const& focus_surface);
+    void focus_cleared();
 
 protected:
     DispatcherController(const DispatcherController&) = delete;
@@ -55,8 +66,10 @@
 private:
     droidinput::sp<droidinput::InputDispatcherInterface> input_dispatcher;
 
-    droidinput::sp<droidinput::InputWindowHandle> focused_window_handle;
-    droidinput::sp<droidinput::InputApplicationHandle> focused_application_handle;
+    std::map<std::shared_ptr<input::SessionTarget>, droidinput::sp<droidinput::InputApplicationHandle>> application_handles;
+    std::map<std::shared_ptr<input::SurfaceTarget>, droidinput::sp<droidinput::InputWindowHandle>> window_handles;
+
+    std::mutex handles_mutex;
 };
 
 }

=== modified file 'src/server/input/android/default_android_input_configuration.cpp'
--- src/server/input/android/default_android_input_configuration.cpp	2013-04-16 09:16:38 +0000
+++ src/server/input/android/default_android_input_configuration.cpp	2013-04-23 12:15:34 +0000
@@ -98,7 +98,7 @@
     return dispatcher_policy(
         [this]()
         {
-            return new mia::EventFilterDispatcherPolicy(filter_chain);
+            return new mia::EventFilterDispatcherPolicy(filter_chain, is_key_repeat_enabled());
         });
 }
 
@@ -149,3 +149,8 @@
                                                        new droidinput::InputReaderThread(the_reader()));
         });
 }
+
+bool mia::DefaultInputConfiguration::is_key_repeat_enabled()
+{
+    return true;
+}

=== modified file 'src/server/input/android/default_android_input_configuration.h'
--- src/server/input/android/default_android_input_configuration.h	2013-04-16 09:16:38 +0000
+++ src/server/input/android/default_android_input_configuration.h	2013-04-23 12:15:34 +0000
@@ -69,6 +69,8 @@
 
     virtual droidinput::sp<droidinput::InputDispatcherPolicyInterface> the_dispatcher_policy();
     virtual droidinput::sp<droidinput::InputReaderPolicyInterface> the_reader_policy();
+    
+    virtual bool is_key_repeat_enabled();
 
 protected:
     DefaultInputConfiguration(DefaultInputConfiguration const&) = delete;

=== modified file 'src/server/input/android/event_filter_dispatcher_policy.cpp'
--- src/server/input/android/event_filter_dispatcher_policy.cpp	2013-04-17 02:49:53 +0000
+++ src/server/input/android/event_filter_dispatcher_policy.cpp	2013-04-23 12:15:34 +0000
@@ -21,8 +21,9 @@
 namespace mi = mir::input;
 namespace mia = mi::android;
 
-mia::EventFilterDispatcherPolicy::EventFilterDispatcherPolicy(std::shared_ptr<mi::EventFilter> const& event_filter) :
-  event_filter(event_filter)
+mia::EventFilterDispatcherPolicy::EventFilterDispatcherPolicy(std::shared_ptr<mi::EventFilter> const& event_filter, bool key_repeat_enabled) :
+  event_filter(event_filter),
+  key_repeat_enabled(key_repeat_enabled)
 {
 }
 
@@ -46,7 +47,7 @@
 
 bool mia::EventFilterDispatcherPolicy::isKeyRepeatEnabled()
 {
-    return true;
+    return key_repeat_enabled;
 }
 
 bool mia::EventFilterDispatcherPolicy::filterInputEvent(const droidinput::InputEvent* input_event, uint32_t /*policy_flags*/)

=== modified file 'src/server/input/android/event_filter_dispatcher_policy.h'
--- src/server/input/android/event_filter_dispatcher_policy.h	2013-04-16 09:16:38 +0000
+++ src/server/input/android/event_filter_dispatcher_policy.h	2013-04-23 12:15:34 +0000
@@ -40,7 +40,7 @@
 class EventFilterDispatcherPolicy : public droidinput::InputDispatcherPolicyInterface
 {
 public:
-    EventFilterDispatcherPolicy(std::shared_ptr<EventFilter> const& event_filter);
+    EventFilterDispatcherPolicy(std::shared_ptr<EventFilter> const& event_filter, bool key_repeat_enabled);
     virtual ~EventFilterDispatcherPolicy() {}
 
     void notifyConfigurationChanged(nsecs_t when);
@@ -71,6 +71,7 @@
     EventFilterDispatcherPolicy& operator=(const EventFilterDispatcherPolicy&) = delete;
 private:
     std::shared_ptr<EventFilter> event_filter;
+    bool key_repeat_enabled;
 };
 
 }

=== modified file 'src/server/shell/application_session.cpp'
--- src/server/shell/application_session.cpp	2013-04-19 08:03:57 +0000
+++ src/server/shell/application_session.cpp	2013-04-23 12:15:34 +0000
@@ -18,8 +18,8 @@
 
 #include "mir/shell/application_session.h"
 #include "mir/shell/surface.h"
-
 #include "mir/shell/surface_factory.h"
+#include "mir/shell/input_target_listener.h"
 
 #include <boost/throw_exception.hpp>
 
@@ -28,14 +28,19 @@
 #include <cassert>
 #include <algorithm>
 
+namespace me = mir::events;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 
 msh::ApplicationSession::ApplicationSession(
     std::shared_ptr<SurfaceFactory> const& surface_factory,
-    std::string const& session_name) :
+    std::shared_ptr<msh::InputTargetListener> const& input_target_listener,
+    std::string const& session_name,
+    std::shared_ptr<me::EventSink> const& sink) :
     surface_factory(surface_factory),
+    input_target_listener(input_target_listener),
     session_name(session_name),
+    event_sink(sink),
     next_surface_id(0)
 {
     assert(surface_factory);
@@ -46,6 +51,7 @@
     std::unique_lock<std::mutex> lock(surfaces_mutex);
     for (auto const& pair_id_surface : surfaces)
     {
+        input_target_listener->input_surface_closed(pair_id_surface.second);
         pair_id_surface.second->destroy();
     }
 }
@@ -63,8 +69,8 @@
 
 mf::SurfaceId msh::ApplicationSession::create_surface(const mf::SurfaceCreationParameters& params)
 {
-    auto surf = surface_factory->create_surface(params);
     auto const id = next_id();
+    auto surf = surface_factory->create_surface(params, id, event_sink);
 
     surf->set_id(id);
     surf->set_event_target(event_sink);
@@ -104,6 +110,7 @@
     std::unique_lock<std::mutex> lock(surfaces_mutex);
     auto p = checked_find(id);
 
+    input_target_listener->input_surface_closed(p->second);
     p->second->destroy();
     surfaces.erase(p);
 }

=== modified file 'src/server/shell/organising_surface_factory.cpp'
--- src/server/shell/organising_surface_factory.cpp	2013-04-16 09:16:38 +0000
+++ src/server/shell/organising_surface_factory.cpp	2013-04-23 12:15:34 +0000
@@ -34,10 +34,13 @@
 {
 }
 
-std::shared_ptr<msh::Surface> msh::OrganisingSurfaceFactory::create_surface(const mf::SurfaceCreationParameters& params)
+std::shared_ptr<msh::Surface> msh::OrganisingSurfaceFactory::create_surface(
+    frontend::SurfaceCreationParameters const& params,
+    frontend::SurfaceId id,
+    std::shared_ptr<events::EventSink> const& sink)
 {
     auto placed_params = placement_strategy->place(params);
 
-    return underlying_factory->create_surface(placed_params);
+    return underlying_factory->create_surface(placed_params, id, sink);
 }
 

=== modified file 'src/server/shell/session_manager.cpp'
--- src/server/shell/session_manager.cpp	2013-04-22 03:24:56 +0000
+++ src/server/shell/session_manager.cpp	2013-04-23 12:15:34 +0000
@@ -23,6 +23,8 @@
 #include "mir/shell/focus_sequence.h"
 #include "mir/shell/focus_setter.h"
 #include "mir/shell/session.h"
+#include "mir/shell/surface.h"
+#include "mir/shell/input_target_listener.h"
 
 #include <memory>
 #include <cassert>
@@ -31,47 +33,62 @@
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 
-msh::SessionManager::SessionManager(
-    std::shared_ptr<msh::SurfaceFactory> const& surface_factory,
+msh::SessionManager::SessionManager(std::shared_ptr<msh::SurfaceFactory> const& surface_factory,
     std::shared_ptr<msh::SessionContainer> const& container,
     std::shared_ptr<msh::FocusSequence> const& sequence,
-    std::shared_ptr<msh::FocusSetter> const& focus_setter) :
+    std::shared_ptr<msh::FocusSetter> const& focus_setter,
+    std::shared_ptr<msh::InputTargetListener> const& input_target_listener) :
     surface_factory(surface_factory),
     app_container(container),
     focus_sequence(sequence),
-    focus_setter(focus_setter)
+    focus_setter(focus_setter),
+    input_target_listener(input_target_listener)
 {
     assert(surface_factory);
     assert(sequence);
     assert(container);
     assert(focus_setter);
+    assert(input_target_listener);
 }
 
 msh::SessionManager::~SessionManager()
 {
 }
 
-std::shared_ptr<mf::Session> msh::SessionManager::open_session(std::string const& name)
+std::shared_ptr<mf::Session> msh::SessionManager::open_session(
+    std::string const& name,
+    std::shared_ptr<events::EventSink> const& sink)
 {
-    auto new_session = std::make_shared<msh::ApplicationSession>(surface_factory, name);
+    auto new_session = std::make_shared<msh::ApplicationSession>(surface_factory, input_target_listener, name, sink);
 
     app_container->insert_session(new_session);
+    
+    input_target_listener->input_application_opened(new_session);
 
     set_focus_to_locked(std::unique_lock<std::mutex>(mutex), new_session);
 
     return new_session;
 }
 
-inline void msh::SessionManager::set_focus_to_locked(std::unique_lock<std::mutex> const&, std::shared_ptr<Session> const& next_focus)
+inline void msh::SessionManager::set_focus_to_locked(std::unique_lock<std::mutex> const&, std::shared_ptr<Session> const& shell_session)
 {
-    focus_application = next_focus;
-    focus_setter->set_focus_to(next_focus);
+    auto old_focus = focus_application.lock();
+
+    focus_application = shell_session;
+    focus_setter->set_focus_to(shell_session);
+
+    if (shell_session && shell_session->default_surface())
+        input_target_listener->focus_changed(shell_session->default_surface());
+    else if (shell_session == old_focus || !shell_session)
+        input_target_listener->focus_cleared();
 }
 
 void msh::SessionManager::close_session(std::shared_ptr<mf::Session> const& session)
 {
     auto shell_session = std::dynamic_pointer_cast<Session>(session);
 
+    input_target_listener->input_application_closed(shell_session);
+
     app_container->remove_session(shell_session);
 
     std::unique_lock<std::mutex> lock(mutex);
@@ -133,9 +150,11 @@
     mf::SurfaceCreationParameters const& params)
 {
     auto shell_session = std::dynamic_pointer_cast<Session>(session);
-    auto id = session->create_surface(params);
+    auto id = shell_session->create_surface(params);
+
+    input_target_listener->input_surface_opened(shell_session,
+        std::dynamic_pointer_cast<msh::Surface>(shell_session->get_surface(id)));
     set_focus_to_locked(std::unique_lock<std::mutex>(mutex), shell_session);
 
     return id;
 }
-

=== modified file 'src/server/shell/single_visibility_focus_mechanism.cpp'
--- src/server/shell/single_visibility_focus_mechanism.cpp	2013-04-19 03:20:05 +0000
+++ src/server/shell/single_visibility_focus_mechanism.cpp	2013-04-23 12:15:34 +0000
@@ -19,7 +19,6 @@
 #include "mir/shell/session_container.h"
 #include "mir/frontend/session.h"
 #include "mir/shell/single_visibility_focus_mechanism.h"
-#include "mir/shell/input_focus_selector.h"
 
 #include "mir/shell/session.h"
 #include "mir/shell/surface.h"
@@ -27,10 +26,8 @@
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 
-msh::SingleVisibilityFocusMechanism::SingleVisibilityFocusMechanism(std::shared_ptr<msh::SessionContainer> const& app_container,
-    std::shared_ptr<msh::InputFocusSelector> const& input_selector)
-  : app_container(app_container),
-    input_selector(input_selector)
+msh::SingleVisibilityFocusMechanism::SingleVisibilityFocusMechanism(std::shared_ptr<msh::SessionContainer> const& app_container)
+  : app_container(app_container)
 {
 }
 
@@ -41,8 +38,6 @@
         if (session == focus_session)
         {
             session->show();
-
-            input_selector->set_input_focus_to(focus_session, focus_session->default_surface());
         }
         else
         {

=== modified file 'src/server/shell/surface.cpp'
--- src/server/shell/surface.cpp	2013-04-19 03:20:05 +0000
+++ src/server/shell/surface.cpp	2013-04-23 12:15:34 +0000
@@ -19,8 +19,13 @@
 #include "mir/shell/surface.h"
 #include "mir/shell/surface_builder.h"
 #include "mir/input/input_channel.h"
+<<<<<<< TREE
 #include "mir_toolkit/event.h"
 #include "mir/event_sink.h"
+=======
+#include "mir_toolkit/event.h"
+#include "mir/events/event_sink.h"
+>>>>>>> MERGE-SOURCE
 
 #include <boost/throw_exception.hpp>
 
@@ -34,13 +39,22 @@
 msh::Surface::Surface(
     std::shared_ptr<SurfaceBuilder> const& builder,
     frontend::SurfaceCreationParameters const& params,
-    std::shared_ptr<input::InputChannel> const& input_channel)
+    std::shared_ptr<input::InputChannel> const& input_channel,
+    frontend::SurfaceId id,
+    std::shared_ptr<events::EventSink> const& sink)
   : builder(builder),
     input_channel(input_channel),
     surface(builder->create_surface(params)),
+<<<<<<< TREE
     id(0),
     type_value(mir_surface_type_normal),
     state_value(mir_surface_state_restored)
+=======
+    id(id),
+    event_sink(sink),
+    type_value(mir_surface_type_normal),
+    state_value(mir_surface_state_restored)
+>>>>>>> MERGE-SOURCE
 {
 }
 

=== modified file 'src/server/shell/surface_source.cpp'
--- src/server/shell/surface_source.cpp	2013-04-16 09:16:38 +0000
+++ src/server/shell/surface_source.cpp	2013-04-23 12:15:34 +0000
@@ -39,11 +39,16 @@
     assert(surface_builder);
 }
 
-std::shared_ptr<msh::Surface> msh::SurfaceSource::create_surface(const mf::SurfaceCreationParameters& params)
+std::shared_ptr<msh::Surface> msh::SurfaceSource::create_surface(
+    frontend::SurfaceCreationParameters const& params,
+    frontend::SurfaceId id,
+    std::shared_ptr<events::EventSink> const& sink)
 {
     return std::make_shared<Surface>(
         surface_builder,
         params,
-        input_factory->make_input_channel());
+        input_factory->make_input_channel(),
+        id,
+        sink);
 }
 

=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2013-04-18 04:23:56 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2013-04-23 12:15:34 +0000
@@ -65,10 +65,9 @@
 
     }
     
-    void set_input_focus_to(
-        std::shared_ptr<mi::SessionTarget> const& session, std::shared_ptr<mi::SurfaceTarget> const& surface) override
+    void focus_changed(std::shared_ptr<mi::SurfaceTarget> const& surface) override
     {
-        DispatcherController::set_input_focus_to(session, surface);
+        DispatcherController::focus_changed(surface);
         
         // We need a synchronization primitive inorder to halt test event injection
         // until after a surface has taken focus (lest the events be discarded).
@@ -122,10 +121,10 @@
             });
     }
 
-    std::shared_ptr<msh::InputFocusSelector>
-    the_input_focus_selector() override
+    std::shared_ptr<msh::InputTargetListener>
+    the_input_target_listener() override
     {
-        return input_focus_selector(
+        return input_target_listener(
             [this]()
             {
                 return std::make_shared<FocusNotifyingDispatcherController>(mt::fake_shared(input_config), on_focus_set);

=== modified file 'tests/acceptance-tests/test_focus_management_api.cpp'
--- tests/acceptance-tests/test_focus_management_api.cpp	2013-04-22 03:24:56 +0000
+++ tests/acceptance-tests/test_focus_management_api.cpp	2013-04-23 12:15:34 +0000
@@ -126,7 +126,7 @@
     {
         using namespace ::testing;
         using frontend::Shell;
-        ON_CALL(*this, open_session(_)).WillByDefault(Invoke(impl.get(), &Shell::open_session));
+        ON_CALL(*this, open_session(_, _)).WillByDefault(Invoke(impl.get(), &Shell::open_session));
         ON_CALL(*this, close_session(_)).WillByDefault(Invoke(impl.get(), &Shell::close_session));
 
         ON_CALL(*this, tag_session_with_lightdm_id(_, _)).WillByDefault(Invoke(impl.get(), &Shell::tag_session_with_lightdm_id));
@@ -135,7 +135,7 @@
         ON_CALL(*this, create_surface_for(_, _)).WillByDefault(Invoke(impl.get(), &Shell::create_surface_for));
     }
 
-    MOCK_METHOD1(open_session, std::shared_ptr<mf::Session> (std::string const& name));
+    MOCK_METHOD2(open_session, std::shared_ptr<mf::Session> (std::string const& name, std::shared_ptr<mir::events::EventSink> const&));
     MOCK_METHOD1(close_session, void (std::shared_ptr<mf::Session> const& session));
 
     MOCK_METHOD2(tag_session_with_lightdm_id, void (std::shared_ptr<mf::Session> const& session, int id));
@@ -165,13 +165,13 @@
 
                     Sequence s1, s2;
 
-                    EXPECT_CALL(*mock_shell, open_session(_))
+                    EXPECT_CALL(*mock_shell, open_session(_, _))
                         .InSequence(s1, s2);
 
                     EXPECT_CALL(*mock_shell, create_surface_for(_,_))
                         .InSequence(s1);
 
-                    EXPECT_CALL(*mock_shell, open_session(_))
+                    EXPECT_CALL(*mock_shell, open_session(_, _))
                         .InSequence(s2);
 
                     EXPECT_CALL(*mock_shell, close_session(_))

=== modified file 'tests/acceptance-tests/test_focus_selection.cpp'
--- tests/acceptance-tests/test_focus_selection.cpp	2013-04-18 04:23:56 +0000
+++ tests/acceptance-tests/test_focus_selection.cpp	2013-04-23 12:15:34 +0000
@@ -24,11 +24,11 @@
 #include "mir/shell/organising_surface_factory.h"
 #include "mir/shell/session_manager.h"
 #include "mir/graphics/display.h"
-#include "mir/shell/input_focus_selector.h"
+#include "mir/shell/input_target_listener.h"
 
 #include "mir_test_framework/display_server_test_fixture.h"
 #include "mir_test_doubles/mock_focus_setter.h"
-#include "mir_test_doubles/mock_input_focus_selector.h"
+#include "mir_test_doubles/mock_input_target_listener.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -36,7 +36,8 @@
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 namespace mi = mir::input;
-namespace mtd = mir::test::doubles;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
 namespace mtf = mir_test_framework;
 
 namespace
@@ -46,6 +47,7 @@
 
 namespace
 {
+
 struct ClientConfigCommon : TestingClientConfiguration
 {
     ClientConfigCommon() :
@@ -121,18 +123,10 @@
 {
     return arg != std::shared_ptr<msh::Session>();
 }
-MATCHER(NonNullSessionTarget, "")
-{
-    return arg != std::shared_ptr<mi::SessionTarget>();
-}
 MATCHER(NonNullSurfaceTarget, "")
 {
     return arg != std::shared_ptr<mi::SurfaceTarget>();
 }
-MATCHER(NullSurfaceTarget, "")
-{
-    return arg == std::shared_ptr<mi::SurfaceTarget>();
-}
 }
 
 TEST_F(BespokeDisplayServerTestFixture, sessions_creating_surface_receive_focus)
@@ -148,7 +142,6 @@
                 using namespace ::testing;
 
                 auto focus_setter = std::make_shared<mtd::MockFocusSetter>();
-
                 {
                     InSequence seq;
                     // Once on application registration and once on surface creation
@@ -174,30 +167,37 @@
 {
     struct ServerConfig : TestingServerConfiguration
     {
-        std::shared_ptr<mtd::MockInputFocusSelector> focus_selector;
+        std::shared_ptr<mtd::MockInputTargetListener> target_listener;
         bool expected;
 
         ServerConfig()
-          : focus_selector(std::make_shared<mtd::MockInputFocusSelector>()),
+          : target_listener(std::make_shared<mtd::MockInputTargetListener>()),
             expected(false)
         {
         }
 
-        std::shared_ptr<msh::InputFocusSelector>
-        the_input_focus_selector() override
+        std::shared_ptr<msh::InputTargetListener>
+        the_input_target_listener() override
         {
             using namespace ::testing;
 
             if (!expected)
             {
-                InSequence seq;
+                
+                EXPECT_CALL(*target_listener, input_application_opened(_)).Times(AtLeast(0));
+                EXPECT_CALL(*target_listener, input_application_closed(_)).Times(AtLeast(0));
+                EXPECT_CALL(*target_listener, input_surface_opened(_,_)).Times(AtLeast(0));
+                EXPECT_CALL(*target_listener, input_surface_closed(_)).Times(AtLeast(0));
+                EXPECT_CALL(*target_listener, focus_cleared()).Times(AtLeast(0));
 
-                EXPECT_CALL(*focus_selector, set_input_focus_to(NonNullSessionTarget(), NullSurfaceTarget())).Times(1);
-                EXPECT_CALL(*focus_selector, set_input_focus_to(NonNullSessionTarget(), NonNullSurfaceTarget())).Times(1);
-                expected = true;
+                {
+                    InSequence seq;
+                    EXPECT_CALL(*target_listener, focus_changed(NonNullSurfaceTarget())).Times(1);
+                    expected = true;
+                }
             }
 
-            return focus_selector;
+            return target_listener;
         }
     } server_config;
 

=== modified file 'tests/behavior-tests/session_management_context.cpp'
--- tests/behavior-tests/session_management_context.cpp	2013-04-22 03:24:56 +0000
+++ tests/behavior-tests/session_management_context.cpp	2013-04-23 12:15:34 +0000
@@ -66,12 +66,16 @@
     {
     }
 
-    std::shared_ptr<msh::Surface> create_surface(const mf::SurfaceCreationParameters& params)
+    std::shared_ptr<msh::Surface> create_surface(const mf::SurfaceCreationParameters& params,
+        frontend::SurfaceId id,
+        std::shared_ptr<events::EventSink> const& sink) override
     {
         return std::make_shared<msh::Surface>(
             mt::fake_shared(surface_builder),
             params,
-            std::shared_ptr<mir::input::InputChannel>());
+            std::shared_ptr<mir::input::InputChannel>(),
+            id,
+            sink);
     }
 
     mtd::StubSurfaceBuilder surface_builder;
@@ -152,7 +156,7 @@
 bool mtc::SessionManagementContext::open_window_consuming(std::string const& window_name)
 {
     auto const params = mf::a_surface().of_name(window_name);
-    auto session = shell->open_session(window_name);
+    auto session = shell->open_session(window_name, std::shared_ptr<mir::events::EventSink>());
     auto const surface_id = session->create_surface(params);
 
     open_windows[window_name] = std::make_tuple(session, surface_id);
@@ -164,7 +168,7 @@
                                                           geom::Size const& size)
 {
     auto const params = mf::a_surface().of_name(window_name).of_size(size);
-    auto session = shell->open_session(window_name);
+    auto session = shell->open_session(window_name, std::shared_ptr<mir::events::EventSink>());
     auto const surface_id = session->create_surface(params);
 
     open_windows[window_name] = std::make_tuple(session, surface_id);

=== modified file 'tests/death-tests/test_application_manager_death.cpp'
--- tests/death-tests/test_application_manager_death.cpp	2013-03-21 03:32:59 +0000
+++ tests/death-tests/test_application_manager_death.cpp	2013-04-23 12:15:34 +0000
@@ -30,11 +30,12 @@
 //  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 // leads to the test failing under valgrind
     EXPECT_EXIT(
-                std::shared_ptr<msh::SurfaceFactory> factory;
-                mir::shell::SessionManager app(factory,
+                std::shared_ptr<msh::SurfaceFactory> surface_factory;
+                mir::shell::SessionManager app(surface_factory,
                                                std::shared_ptr<msh::SessionContainer>(),
                                                std::shared_ptr<msh::FocusSequence>(),
-                                               std::shared_ptr<msh::FocusSetter>()),
+                                               std::shared_ptr<msh::FocusSetter>(),
+                                               std::shared_ptr<msh::InputTargetListener>()),
                 ::testing::KilledBySignal(SIGABRT),
                 ".*");
 }

=== modified file 'tests/integration-tests/cucumber/test_session_management_context.cpp'
--- tests/integration-tests/cucumber/test_session_management_context.cpp	2013-04-22 03:24:56 +0000
+++ tests/integration-tests/cucumber/test_session_management_context.cpp	2013-04-23 12:15:34 +0000
@@ -106,7 +106,7 @@
 
     mtd::MockSession session;
 
-    EXPECT_CALL(shell, open_session(test_window_name)).Times(1)
+    EXPECT_CALL(shell, open_session(test_window_name, _)).Times(1)
         .WillOnce(Return(mt::fake_shared<mf::Session>(session)));
 
     // As consuming mode is the default, omiting geometry is sufficient to request it.
@@ -122,7 +122,7 @@
 
     mtd::MockSession session;
 
-    EXPECT_CALL(shell, open_session(test_window_name)).Times(1)
+    EXPECT_CALL(shell, open_session(test_window_name, _)).Times(1)
         .WillOnce(Return(mt::fake_shared<mf::Session>(session)));
 
     EXPECT_CALL(session, create_surface(NamedWindowWithGeometry(test_window_name, test_window_size))).Times(1)
@@ -138,7 +138,7 @@
     mtd::MockSession session;
     mtd::MockSurface surface(std::make_shared<mtd::StubSurfaceBuilder>());
 
-    EXPECT_CALL(shell, open_session(test_window_name)).Times(1)
+    EXPECT_CALL(shell, open_session(test_window_name, _)).Times(1)
         .WillOnce(Return(mt::fake_shared<mf::Session>(session)));
 
     EXPECT_CALL(session, create_surface(NamedWindowWithGeometry(test_window_name, test_window_size))).Times(1)

=== modified file 'tests/integration-tests/input/android/test_android_input_manager.cpp'
--- tests/integration-tests/input/android/test_android_input_manager.cpp	2013-04-16 04:56:53 +0000
+++ tests/integration-tests/input/android/test_android_input_manager.cpp	2013-04-23 12:15:34 +0000
@@ -171,7 +171,7 @@
 struct MockDispatcherPolicy : public mia::EventFilterDispatcherPolicy
 {
     MockDispatcherPolicy(std::shared_ptr<mi::EventFilter> const& filter)
-      : EventFilterDispatcherPolicy(filter)
+      : EventFilterDispatcherPolicy(filter, false)
     {
     }
     MOCK_METHOD3(interceptKeyBeforeDispatching, nsecs_t(droidinput::sp<droidinput::InputWindowHandle> const&,
@@ -211,24 +211,31 @@
         ON_CALL(viewable_area, view_area())
             .WillByDefault(Return(default_view_area));
         input_manager = std::make_shared<mia::InputManager>(configuration);
-        input_focus_selector = std::make_shared<mia::DispatcherController>(configuration);
+        input_target_listener = std::make_shared<mia::DispatcherController>(configuration);
 
         dispatcher_policy = configuration->the_mock_dispatcher_policy();
 
     }
 
+    ~AndroidInputManagerDispatcherInterceptSetup()
+    {
+        input_manager->stop();
+    }
+
     // TODO: It would be nice if it were possible to mock the interface between
     // droidinput::InputChannel and droidinput::InputDispatcher rather than use
     // valid fds to allow non-throwing construction of a real input channel.
     void SetUp()
     {
-        test_input_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
         input_manager->start();
     }
-    void TearDown()
+    
+    int test_fd()
     {
-        input_manager->stop();
-        close(test_input_fd);
+        int fds[2];
+        // Closed by droidinput InputChannel on shutdown
+        socketpair(AF_UNIX, SOCK_SEQPACKET, 0, fds);
+        return fds[0];
     }
 
     MockEventFilter event_filter;
@@ -238,9 +245,7 @@
     droidinput::sp<MockDispatcherPolicy> dispatcher_policy;
 
     std::shared_ptr<mia::InputManager> input_manager;
-    std::shared_ptr<msh::InputFocusSelector> input_focus_selector;
-
-    int test_input_fd;
+    std::shared_ptr<msh::InputTargetListener> input_target_listener;
 };
 
 MATCHER_P(WindowHandleWithInputFd, input_fd, "")
@@ -259,14 +264,18 @@
     mt::WaitCondition wait_condition;
 
     mtd::StubSessionTarget session;
-    mtd::StubSurfaceTarget surface(test_input_fd);
+    
+    auto input_fd = test_fd();
+    mtd::StubSurfaceTarget surface(input_fd);
 
     EXPECT_CALL(event_filter, handles(_)).Times(1).WillOnce(Return(false));
     // We return -1 here to skip publishing of the event (to an unconnected test socket!).
-    EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(test_input_fd), _, _))
+    EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(input_fd), _, _))
         .Times(1).WillOnce(DoAll(mt::WakeUp(&wait_condition), Return(-1)));
 
-    input_focus_selector->set_input_focus_to(mt::fake_shared(session), mt::fake_shared(surface));
+    input_target_listener->input_application_opened(mt::fake_shared(session));
+    input_target_listener->input_surface_opened(mt::fake_shared(session), mt::fake_shared(surface));
+    input_target_listener->focus_changed(mt::fake_shared(surface));
 
     fake_event_hub->synthesize_builtin_keyboard_added();
     fake_event_hub->synthesize_device_scan_complete();
@@ -275,3 +284,52 @@
 
     wait_condition.wait_for_at_most_seconds(1);
 }
+
+TEST_F(AndroidInputManagerDispatcherInterceptSetup, changing_focus_changes_event_recipient)
+{
+    using namespace ::testing;
+
+    mt::WaitCondition wait1, wait2, wait3;
+
+    mtd::StubSessionTarget session;
+    
+    auto input_fd_1 = test_fd();
+    mtd::StubSurfaceTarget surface1(input_fd_1);
+    auto input_fd_2 = test_fd();
+    mtd::StubSurfaceTarget surface2(input_fd_2);
+
+    input_target_listener->input_application_opened(mt::fake_shared(session));
+    input_target_listener->input_surface_opened(mt::fake_shared(session), mt::fake_shared(surface1));
+    input_target_listener->input_surface_opened(mt::fake_shared(session), mt::fake_shared(surface2));
+
+    EXPECT_CALL(event_filter, handles(_)).Times(3).WillRepeatedly(Return(false));
+
+    {
+        InSequence seq;
+
+        EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(input_fd_1), _, _))
+            .Times(1).WillOnce(DoAll(mt::WakeUp(&wait1), Return(-1)));
+        EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(input_fd_2), _, _))
+            .Times(1).WillOnce(DoAll(mt::WakeUp(&wait2), Return(-1)));
+        EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(input_fd_1), _, _))
+            .Times(1).WillOnce(DoAll(mt::WakeUp(&wait3), Return(-1)));
+    }
+
+    fake_event_hub->synthesize_builtin_keyboard_added();
+    fake_event_hub->synthesize_device_scan_complete();
+
+    input_target_listener->focus_changed(mt::fake_shared(surface1));
+    fake_event_hub->synthesize_event(mis::a_key_down_event()
+                                .of_scancode(KEY_1));
+    wait1.wait_for_at_most_seconds(1);
+
+    input_target_listener->focus_changed(mt::fake_shared(surface2));
+    fake_event_hub->synthesize_event(mis::a_key_down_event()
+                                .of_scancode(KEY_2));
+    wait2.wait_for_at_most_seconds(1);
+
+    input_target_listener->focus_changed(mt::fake_shared(surface1));
+    fake_event_hub->synthesize_event(mis::a_key_down_event()
+                                .of_scancode(KEY_3));
+    wait3.wait_for_at_most_seconds(5);
+} 

=== modified file 'tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp'
--- tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp	2013-04-05 07:12:27 +0000
+++ tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp	2013-04-23 12:15:34 +0000
@@ -56,7 +56,7 @@
     void SetUp()
     {
         event_hub = new mia::FakeEventHub();
-        dispatcher_policy = new mia::EventFilterDispatcherPolicy(mt::fake_shared(event_filter));
+        dispatcher_policy = new mia::EventFilterDispatcherPolicy(mt::fake_shared(event_filter), false);
         reader_policy = new mia::RudimentaryInputReaderPolicy();
         dispatcher = new droidinput::InputDispatcher(dispatcher_policy);
         reader = new droidinput::InputReader(event_hub, reader_policy, dispatcher);

=== modified file 'tests/integration-tests/shell/test_session_manager.cpp'
--- tests/integration-tests/shell/test_session_manager.cpp	2013-04-19 03:20:05 +0000
+++ tests/integration-tests/shell/test_session_manager.cpp	2013-04-23 12:15:34 +0000
@@ -33,8 +33,10 @@
 #include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_surface_factory.h"
 #include "mir_test_doubles/mock_focus_setter.h"
+#include "mir_test_doubles/stub_input_target_listener.h"
 
 namespace mc = mir::compositor;
+namespace me = mir::events;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 namespace ms = mir::surfaces;
@@ -44,29 +46,32 @@
 TEST(TestSessionManagerAndFocusSelectionStrategy, cycle_focus)
 {
     using namespace ::testing;
+
     mtd::MockSurfaceFactory surface_factory;
     std::shared_ptr<msh::DefaultSessionContainer> container(new msh::DefaultSessionContainer());
     msh::RegistrationOrderFocusSequence sequence(container);
-    mtd::MockFocusSetter focus_changer;
+    mtd::MockFocusSetter focus_setter;
     std::shared_ptr<mf::Session> new_session;
+    mtd::StubInputTargetListener input_target_listener;
 
     msh::SessionManager session_manager(
             mt::fake_shared(surface_factory),
             container,
             mt::fake_shared(sequence),
-            mt::fake_shared(focus_changer));
-
-    EXPECT_CALL(focus_changer, set_focus_to(_)).Times(3);
-
-    auto session1 = session_manager.open_session("Visual Basic Studio");
-    auto session2 = session_manager.open_session("Microsoft Access");
-    auto session3 = session_manager.open_session("WordPerfect");
+            mt::fake_shared(focus_setter),
+            mt::fake_shared(input_target_listener));
+
+    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>());
 
     {
       InSequence seq;
-      EXPECT_CALL(focus_changer, set_focus_to(Eq(session1))).Times(1);
-      EXPECT_CALL(focus_changer, set_focus_to(Eq(session2))).Times(1);
-      EXPECT_CALL(focus_changer, set_focus_to(Eq(session3))).Times(1);
+      EXPECT_CALL(focus_setter, set_focus_to(Eq(session1))).Times(1);
+      EXPECT_CALL(focus_setter, set_focus_to(Eq(session2))).Times(1);
+      EXPECT_CALL(focus_setter, set_focus_to(Eq(session3))).Times(1);
     }
 
     session_manager.focus_next();
@@ -77,28 +82,31 @@
 TEST(TestSessionManagerAndFocusSelectionStrategy, closing_applications_transfers_focus)
 {
     using namespace ::testing;
+
     mtd::MockSurfaceFactory surface_factory;
-    std::shared_ptr<msh::DefaultSessionContainer> model(new msh::DefaultSessionContainer());
-    msh::RegistrationOrderFocusSequence sequence(model);
-    mtd::MockFocusSetter focus_changer;
+    std::shared_ptr<msh::DefaultSessionContainer> container(new msh::DefaultSessionContainer());
+    msh::RegistrationOrderFocusSequence sequence(container);
+    mtd::MockFocusSetter focus_setter;
     std::shared_ptr<mf::Session> new_session;
+    mtd::StubInputTargetListener input_target_listener;
 
     msh::SessionManager session_manager(
-        mt::fake_shared(surface_factory),
-        model,
-        mt::fake_shared(sequence),
-        mt::fake_shared(focus_changer));
-
-    EXPECT_CALL(focus_changer, set_focus_to(_)).Times(3);
-
-    auto session1 = session_manager.open_session("Visual Basic Studio");
-    auto session2 = session_manager.open_session("Microsoft Access");
-    auto session3 = session_manager.open_session("WordPerfect");
+            mt::fake_shared(surface_factory),
+            container,
+            mt::fake_shared(sequence),
+            mt::fake_shared(focus_setter),
+            mt::fake_shared(input_target_listener));
+
+    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>());
 
     {
       InSequence seq;
-      EXPECT_CALL(focus_changer, set_focus_to(Eq(session2))).Times(1);
-      EXPECT_CALL(focus_changer, set_focus_to(Eq(session1))).Times(1);
+      EXPECT_CALL(focus_setter, set_focus_to(Eq(session2))).Times(1);
+      EXPECT_CALL(focus_setter, set_focus_to(Eq(session1))).Times(1);
     }
 
     session_manager.close_session(session3);

=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2013-04-22 03:24:56 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2013-04-23 12:15:34 +0000
@@ -29,7 +29,7 @@
 #include "mir/compositor/graphic_buffer_allocator.h"
 #include "mir/input/input_channel.h"
 #include "mir/input/input_manager.h"
-#include "mir/shell/input_focus_selector.h"
+#include "mir/input/null_input_target_listener.h"
 #include "src/server/input/android/android_input_manager.h"
 #include "src/server/input/android/android_dispatcher_controller.h"
 
@@ -159,14 +159,6 @@
     }
 };
 
-class StubInputFocusSelector : public msh::InputFocusSelector
-{
-public:
-    void set_input_focus_to(std::shared_ptr<mi::SessionTarget> const& /* session */, std::shared_ptr<mi::SurfaceTarget> const& /* surface */)
-    {
-    }
-};
-
 }
 
 mtf::TestingServerConfiguration::TestingServerConfiguration() :
@@ -184,14 +176,14 @@
         return std::make_shared<StubInputManager>();
 }
 
-std::shared_ptr<msh::InputFocusSelector> mtf::TestingServerConfiguration::the_input_focus_selector()
+std::shared_ptr<msh::InputTargetListener> mtf::TestingServerConfiguration::the_input_target_listener()
 {
     auto options = the_options();
  
    if (options->get("tests-use-real-input", false))
         return std::make_shared<mia::DispatcherController>(the_input_configuration());
     else
-        return std::make_shared<StubInputFocusSelector>();
+        return std::make_shared<mi::NullInputTargetListener>();
 }
 
 std::shared_ptr<mg::Platform> mtf::TestingServerConfiguration::the_graphics_platform()

=== modified file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	2013-04-10 02:48:51 +0000
+++ tests/unit-tests/CMakeLists.txt	2013-04-23 12:15:34 +0000
@@ -20,8 +20,12 @@
 add_subdirectory(android_input/)
 add_subdirectory(surfaces/)
 add_subdirectory(draw/)
+<<<<<<< TREE
 add_subdirectory(event/)
 
+=======
+
+>>>>>>> MERGE-SOURCE
 add_executable(unit-tests ${UNIT_TEST_SOURCES})
 uses_android_input(unit-tests)
 

=== modified file 'tests/unit-tests/frontend/CMakeLists.txt'
--- tests/unit-tests/frontend/CMakeLists.txt	2013-04-11 03:54:01 +0000
+++ tests/unit-tests/frontend/CMakeLists.txt	2013-04-23 12:15:34 +0000
@@ -6,6 +6,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_protobuf_reports_errors.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
 )
 
 # TODO this test is a mess - something better is needed.

=== renamed file 'tests/unit-tests/event/test_event_queue.cpp' => 'tests/unit-tests/frontend/test_event_pipe.cpp'
--- tests/unit-tests/event/test_event_queue.cpp	2013-04-22 03:37:28 +0000
+++ tests/unit-tests/frontend/test_event_pipe.cpp	2013-04-23 12:15:34 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 /*
  * Copyright © 2013 Canonical Ltd.
  *
@@ -111,3 +112,121 @@
     EXPECT_EQ(mir_event_type_key, b->last_event_handled().type);
     EXPECT_EQ(mir_event_type_motion, a->last_event_handled().type);
 }
+=======
+/*
+ * 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);
+}
+>>>>>>> MERGE-SOURCE

=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2013-04-19 08:03:57 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2013-04-23 12:15:34 +0000
@@ -34,7 +34,11 @@
 #include "mir_test_doubles/stub_session.h"
 #include "mir_test_doubles/stub_surface_builder.h"
 #include "mir_test/fake_shared.h"
+<<<<<<< TREE
 #include "mir/event_queue.h"
+=======
+#include "mir/events/event_sink.h"
+>>>>>>> MERGE-SOURCE
 #include "mir/shell/surface.h"
 
 #include <gtest/gtest.h>
@@ -129,7 +133,11 @@
     }
 };
 
-}
+class NullEventSink : public mir::events::EventSink
+{
+public:
+    void handle_event(MirEvent const& ) override {}
+};
 
 struct SessionMediatorTest : public ::testing::Test
 {
@@ -141,15 +149,21 @@
           report{std::make_shared<mf::NullSessionMediatorReport>()},
           resource_cache{std::make_shared<mf::ResourceCache>()},
           mediator{shell, graphics_platform, graphics_display,
+<<<<<<< TREE
                    buffer_allocator, report, 
                    std::make_shared<mir::EventQueue>(),
                    resource_cache},
+=======
+                   buffer_allocator, report, 
+                   std::make_shared<NullEventSink>(),
+                   resource_cache},
+>>>>>>> MERGE-SOURCE
           stubbed_session{std::make_shared<StubbedSession>()},
           null_callback{google::protobuf::NewPermanentCallback(google::protobuf::DoNothing)}
     {
         using namespace ::testing;
 
-        ON_CALL(*shell, open_session(_)).WillByDefault(Return(stubbed_session));
+        ON_CALL(*shell, open_session(_, _)).WillByDefault(Return(stubbed_session));
         ON_CALL(*shell, create_surface_for(_, _)).WillByDefault(Return(mf::SurfaceId{1}));
     }
 
@@ -164,7 +178,7 @@
 
     std::unique_ptr<google::protobuf::Closure> null_callback;
 };
-
+}
 
 TEST_F(SessionMediatorTest, disconnect_releases_session)
 {

=== modified file 'tests/unit-tests/frontend/test_session_mediator_android.cpp'
--- tests/unit-tests/frontend/test_session_mediator_android.cpp	2013-04-22 03:35:08 +0000
+++ tests/unit-tests/frontend/test_session_mediator_android.cpp	2013-04-23 12:15:34 +0000
@@ -31,8 +31,13 @@
 #include "mir_test_doubles/mock_session.h"
 #include "mir_test_doubles/stub_shell.h"
 
+<<<<<<< TREE
 #include "mir/event_queue.h"
 
+=======
+#include "mir/event_sink.h"
+
+>>>>>>> MERGE-SOURCE
 #include <gtest/gtest.h>
 
 #include <stdexcept>
@@ -87,7 +92,11 @@
     }
 };
 
-}
+class NullEventSink : public mir::EventSink
+{
+public:
+    void handle_event(MirEvent const& ) override {}
+};
 
 struct SessionMediatorAndroidTest : public ::testing::Test
 {
@@ -99,9 +108,15 @@
           report{std::make_shared<mf::NullSessionMediatorReport>()},
           resource_cache{std::make_shared<mf::ResourceCache>()},
           mediator{shell, graphics_platform, graphics_display,
+<<<<<<< TREE
                    buffer_allocator, report,
                    std::make_shared<mir::EventQueue>(),
                    resource_cache},
+=======
+                   buffer_allocator, report,
+                   std::make_shared<NullEventSink>(),
+                   resource_cache},
+>>>>>>> MERGE-SOURCE
           null_callback{google::protobuf::NewPermanentCallback(google::protobuf::DoNothing)}
     {
     }
@@ -117,6 +132,8 @@
     std::unique_ptr<google::protobuf::Closure> null_callback;
 };
 
+}
+
 TEST_F(SessionMediatorAndroidTest, drm_auth_magic_throws)
 {
     mp::ConnectParameters connect_parameters;

=== modified file 'tests/unit-tests/frontend/test_session_mediator_gbm.cpp'
--- tests/unit-tests/frontend/test_session_mediator_gbm.cpp	2013-04-19 08:03:57 +0000
+++ tests/unit-tests/frontend/test_session_mediator_gbm.cpp	2013-04-23 12:15:34 +0000
@@ -27,7 +27,11 @@
 #include "mir/graphics/drm_authenticator.h"
 #include "mir/graphics/platform.h"
 #include "mir/graphics/platform_ipc_package.h"
+<<<<<<< TREE
 #include "mir/event_queue.h"
+=======
+#include "mir/events/event_sink.h"
+>>>>>>> MERGE-SOURCE
 
 #include <boost/exception/errinfo_errno.hpp>
 #include <boost/throw_exception.hpp>
@@ -91,7 +95,11 @@
     MOCK_METHOD1(drm_auth_magic, void(drm_magic_t));
 };
 
-}
+class NullEventSink : public mir::events::EventSink
+{
+public:
+    void handle_event(MirEvent const& ) override {}
+};
 
 struct SessionMediatorGBMTest : public ::testing::Test
 {
@@ -103,9 +111,15 @@
           report{std::make_shared<mf::NullSessionMediatorReport>()},
           resource_cache{std::make_shared<mf::ResourceCache>()},
           mediator{shell, mock_platform, graphics_display,
+<<<<<<< TREE
                    buffer_allocator, report,
                    std::make_shared<mir::EventQueue>(),
                    resource_cache},
+=======
+                   buffer_allocator, report,
+                   std::make_shared<NullEventSink>(),
+                   resource_cache},
+>>>>>>> MERGE-SOURCE
           null_callback{google::protobuf::NewPermanentCallback(google::protobuf::DoNothing)}
     {
     }
@@ -121,6 +135,8 @@
     std::unique_ptr<google::protobuf::Closure> null_callback;
 };
 
+}
+
 TEST_F(SessionMediatorGBMTest, drm_auth_magic_uses_drm_authenticator)
 {
     mp::ConnectParameters connect_parameters;

=== modified file 'tests/unit-tests/input/android/test_android_dispatcher_controller.cpp'
--- tests/unit-tests/input/android/test_android_dispatcher_controller.cpp	2013-04-15 14:39:18 +0000
+++ tests/unit-tests/input/android/test_android_dispatcher_controller.cpp	2013-04-23 12:15:34 +0000
@@ -2,15 +2,15 @@
  * 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,
+ * 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: Robert Carr <[e-mail]>
@@ -31,6 +31,8 @@
 #include <sys/types.h>
 #include <sys/socket.h>
 
+#include <stdexcept>
+
 namespace mi = mir::input;
 namespace mia = mi::android;
 namespace mt = mir::test;
@@ -47,12 +49,16 @@
     void SetUp() override
     {
         test_input_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
+        
+        dispatcher = new mtd::MockInputDispatcher();
     }
     void TearDown() override
     {
         close(test_input_fd);
     }
     int test_input_fd;
+    droidinput::sp<mtd::MockInputDispatcher> dispatcher;
+    mtd::MockInputConfiguration config;
 };
 
 static bool
@@ -104,30 +110,151 @@
 
 }
 
-TEST_F(AndroidDispatcherControllerFdSetup, set_input_focus)
-{
-    using namespace ::testing;
-
-    auto dispatcher = new mtd::MockInputDispatcher(); // We need droidinput::sp
-    mtd::MockInputConfiguration config;
-    EXPECT_CALL(config, the_dispatcher()).Times(1)
-        .WillOnce(Return(dispatcher));
-
-    auto session = std::make_shared<mtd::StubSessionTarget>();
-    auto surface = std::make_shared<mtd::StubSurfaceTarget>(test_input_fd);
+TEST_F(AndroidDispatcherControllerFdSetup, input_application_opened_behavior)
+{    
+    using namespace ::testing;
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+    mia::DispatcherController controller(mt::fake_shared(config));
+    
+    auto session = std::make_shared<mtd::StubSessionTarget>();
+    controller.input_application_opened(session);
+    EXPECT_THROW({
+            // An application can not be opened twice!
+            controller.input_application_opened(session);
+    }, std::logic_error);
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, input_application_closed_behavior)
+{    
+    using namespace ::testing;
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+    mia::DispatcherController controller(mt::fake_shared(config));
+    
+    auto session = std::make_shared<mtd::StubSessionTarget>();
+    EXPECT_THROW({
+            // We can't close an application which is not open
+            controller.input_application_closed(session);
+    }, std::logic_error);
+    controller.input_application_opened(session);
+    controller.input_application_closed(session);
+    EXPECT_THROW({
+            // Nor can we close an application twice
+            controller.input_application_closed(session);
+    }, std::logic_error);
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, input_surface_opened_behavior)
+{    
+    using namespace ::testing;
+
+    auto session = std::make_shared<mtd::StubSessionTarget>();
+    auto surface = std::make_shared<mtd::StubSurfaceTarget>(test_input_fd);
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+    EXPECT_CALL(*dispatcher, registerInputChannel(_, WindowHandleFor(session, surface), false)).Times(1)
+        .WillOnce(Return(droidinput::OK));
+
+    mia::DispatcherController controller(mt::fake_shared(config));
+    
+    EXPECT_THROW({
+            // We can't open a surface with an unopened session!
+            controller.input_surface_opened(session, surface);
+     }, std::logic_error);
+     controller.input_application_opened(session);
+     controller.input_surface_opened(session, surface);
+     EXPECT_THROW({
+             // We can't open a surface twice
+             controller.input_surface_opened(session, surface);
+     }, std::logic_error);
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, input_surface_closed_behavior)
+{
+    using namespace ::testing;
+
+    auto session = std::make_shared<mtd::StubSessionTarget>();
+    auto surface = std::make_shared<mtd::StubSurfaceTarget>(test_input_fd);
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+    EXPECT_CALL(*dispatcher, registerInputChannel(_, WindowHandleFor(session, surface), false)).Times(1)
+        .WillOnce(Return(droidinput::OK));
+    EXPECT_CALL(*dispatcher, unregisterInputChannel(_)).Times(1);
+    mia::DispatcherController controller(mt::fake_shared(config));
+    
+    controller.input_application_opened(session);
+
+    EXPECT_THROW({
+            // We can't close a surface which hasn't been opened
+            controller.input_surface_closed(surface);
+    }, std::logic_error);
+    controller.input_surface_opened(session, surface);
+    controller.input_surface_closed(surface);
+    EXPECT_THROW({
+            // Nor can we close a surface twice
+            controller.input_surface_closed(surface);
+    }, std::logic_error);
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, on_focus_cleared)
+{
+    using namespace ::testing;
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+
+    EXPECT_CALL(*dispatcher, setFocusedApplication(droidinput::sp<droidinput::InputApplicationHandle>(0))).Times(1);
+    EXPECT_CALL(*dispatcher, setInputWindows(EmptyVector())).Times(1);
+
+    mia::DispatcherController controller(mt::fake_shared(config));
+    
+    controller.focus_cleared();
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, on_focus_changed)
+{
+    using namespace ::testing;
+
+    auto session = std::make_shared<mtd::StubSessionTarget>();
+    auto surface = std::make_shared<mtd::StubSurfaceTarget>(test_input_fd);
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+    EXPECT_CALL(*dispatcher, registerInputChannel(_, WindowHandleFor(session, surface), false)).Times(1)
+        .WillOnce(Return(droidinput::OK));
 
     {
         InSequence seq;
         EXPECT_CALL(*dispatcher, setFocusedApplication(ApplicationHandleFor(session))).Times(1);
-        EXPECT_CALL(*dispatcher, registerInputChannel(_, WindowHandleFor(session, surface), false)).Times(1)
-            .WillOnce(Return(droidinput::OK));
         EXPECT_CALL(*dispatcher, setInputWindows(VectorContainingWindowHandleFor(session, surface))).Times(1);
-        EXPECT_CALL(*dispatcher, unregisterInputChannel(_)).Times(1);
-        EXPECT_CALL(*dispatcher, setInputWindows(EmptyVector())).Times(1);
     }
 
     mia::DispatcherController controller(mt::fake_shared(config));
-
-    controller.set_input_focus_to(session, surface);
-    controller.set_input_focus_to(session, std::shared_ptr<mi::SurfaceTarget>());
+    
+    controller.input_application_opened(session);
+    controller.input_surface_opened(session, surface);
+
+    controller.focus_changed(surface);
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, on_focus_changed_throw_behavior)
+{
+    using namespace ::testing;
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+
+    auto surface = std::make_shared<mtd::StubSurfaceTarget>(test_input_fd);
+
+    mia::DispatcherController controller(mt::fake_shared(config));
+
+    EXPECT_THROW({
+            // We can't focus surfaces which never opened
+            controller.focus_changed(surface);
+    }, std::logic_error);
 }

=== modified file 'tests/unit-tests/input/android/test_event_filter_input_dispatcher_policy.cpp'
--- tests/unit-tests/input/android/test_event_filter_input_dispatcher_policy.cpp	2013-03-26 05:28:14 +0000
+++ tests/unit-tests/input/android/test_event_filter_input_dispatcher_policy.cpp	2013-04-23 12:15:34 +0000
@@ -37,7 +37,7 @@
     using namespace ::testing;
     droidinput::KeyEvent ev;
     mtd::MockEventFilter filter;
-    mia::EventFilterDispatcherPolicy policy(mt::fake_shared(filter));
+    mia::EventFilterDispatcherPolicy policy(mt::fake_shared(filter), true);
     uint32_t policy_flags;
 
     EXPECT_CALL(filter, handles(_)).Times(1).WillOnce(Return(false));

=== modified file 'tests/unit-tests/shell/test_application_session.cpp'
--- tests/unit-tests/shell/test_application_session.cpp	2013-04-22 03:24:56 +0000
+++ tests/unit-tests/shell/test_application_session.cpp	2013-04-23 12:15:34 +0000
@@ -22,6 +22,7 @@
 #include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_surface_factory.h"
 #include "mir_test_doubles/mock_surface.h"
+#include "mir_test_doubles/stub_input_target_listener.h"
 #include "mir_test_doubles/stub_surface_builder.h"
 #include "mir_test_doubles/stub_surface.h"
 
@@ -31,6 +32,7 @@
 #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,12 +48,13 @@
     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(surface_factory, create_surface(_, _, _));
     EXPECT_CALL(*mock_surface, destroy());
 
-    msh::ApplicationSession session(mt::fake_shared(surface_factory), "Foo");
+    mtd::StubInputTargetListener input_listener;
+    msh::ApplicationSession session(mt::fake_shared(surface_factory), mt::fake_shared(input_listener), "Foo", std::shared_ptr<me::EventSink>());
 
     mf::SurfaceCreationParameters params;
     auto surf = session.create_surface(params);
@@ -67,15 +70,16 @@
     mtd::StubSurfaceBuilder surface_builder;
     {
         InSequence seq;
-        EXPECT_CALL(surface_factory, create_surface(_)).Times(1)
-            .WillOnce(Return(std::make_shared<NiceMock<mtd::MockSurface>>(mt::fake_shared(surface_builder))));
-        EXPECT_CALL(surface_factory, create_surface(_)).Times(1)
-            .WillOnce(Return(std::make_shared<NiceMock<mtd::MockSurface>>(mt::fake_shared(surface_builder))));
-        EXPECT_CALL(surface_factory, create_surface(_)).Times(1)
+        EXPECT_CALL(surface_factory, create_surface(_, _, _)).Times(1)
+            .WillOnce(Return(std::make_shared<NiceMock<mtd::MockSurface>>(mt::fake_shared(surface_builder))));
+        EXPECT_CALL(surface_factory, create_surface(_, _, _)).Times(1)
+            .WillOnce(Return(std::make_shared<NiceMock<mtd::MockSurface>>(mt::fake_shared(surface_builder))));
+        EXPECT_CALL(surface_factory, create_surface(_, _, _)).Times(1)
             .WillOnce(Return(std::make_shared<NiceMock<mtd::MockSurface>>(mt::fake_shared(surface_builder))));
     }
 
-    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo");
+    mtd::StubInputTargetListener input_listener;
+    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), mt::fake_shared(input_listener), "Foo", std::shared_ptr<me::EventSink>());
 
     mf::SurfaceCreationParameters params;
     auto id1 = app_session.create_surface(params);
@@ -103,11 +107,12 @@
     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));
-
-    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo");
-
-    EXPECT_CALL(surface_factory, create_surface(_));
+    ON_CALL(surface_factory, create_surface(_, _, _)).WillByDefault(Return(mock_surface));
+
+    mtd::StubInputTargetListener input_listener;
+    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), mt::fake_shared(input_listener), "Foo", std::shared_ptr<me::EventSink>());
+
+    EXPECT_CALL(surface_factory, create_surface(_, _, _));
 
     {
         InSequence seq;
@@ -130,7 +135,8 @@
     using namespace ::testing;
 
     mtd::MockSurfaceFactory surface_factory;
-    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo");
+    mtd::StubInputTargetListener input_listener;
+    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), mt::fake_shared(input_listener), "Foo", std::shared_ptr<me::EventSink>());
     mf::SurfaceId invalid_surface_id(1);
 
     EXPECT_THROW({
@@ -143,7 +149,8 @@
     using namespace ::testing;
 
     mtd::MockSurfaceFactory surface_factory;
-    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo");
+    mtd::StubInputTargetListener input_listener;
+    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), mt::fake_shared(input_listener), "Foo", std::shared_ptr<me::EventSink>());
     mf::SurfaceId invalid_surface_id(1);
 
     EXPECT_THROW({

=== modified file 'tests/unit-tests/shell/test_organising_surface_factory.cpp'
--- tests/unit-tests/shell/test_organising_surface_factory.cpp	2013-04-02 05:58:55 +0000
+++ tests/unit-tests/shell/test_organising_surface_factory.cpp	2013-04-23 12:15:34 +0000
@@ -25,6 +25,7 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
+namespace me = mir::events;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 namespace geom = mir::geometry;
@@ -45,7 +46,7 @@
         using namespace ::testing;
 
         underlying_surface_factory = std::make_shared<mtd::MockSurfaceFactory>();
-        ON_CALL(*underlying_surface_factory, create_surface(_)).WillByDefault(Return(null_surface));
+        ON_CALL(*underlying_surface_factory, create_surface(_, _, _)).WillByDefault(Return(null_surface));
 
         placement_strategy = std::make_shared<MockPlacementStrategy>();
     }
@@ -62,13 +63,13 @@
 
     msh::OrganisingSurfaceFactory factory(underlying_surface_factory, placement_strategy);
 
-    EXPECT_CALL(*underlying_surface_factory, create_surface(_)).Times(1);
+    EXPECT_CALL(*underlying_surface_factory, create_surface(_, _, _)).Times(1);
 
     auto params = mf::a_surface();
     EXPECT_CALL(*placement_strategy, place(Ref(params))).Times(1)
         .WillOnce(Return(mf::a_surface()));
 
-    factory.create_surface(params);
+    factory.create_surface(params, mf::SurfaceId(), std::shared_ptr<me::EventSink>());
 }
 
 TEST_F(OrganisingSurfaceFactorySetup, forwards_create_surface_parameters_from_placement_strategy_to_underlying_factory)
@@ -83,8 +84,8 @@
 
     EXPECT_CALL(*placement_strategy, place(Ref(params))).Times(1)
         .WillOnce(Return(placed_params));
-    EXPECT_CALL(*underlying_surface_factory, create_surface(placed_params));
+    EXPECT_CALL(*underlying_surface_factory, create_surface(placed_params, mf::SurfaceId(), std::shared_ptr<me::EventSink>()));
 
-    factory.create_surface(params);
+    factory.create_surface(params, mf::SurfaceId(), std::shared_ptr<me::EventSink>());
 }
 

=== modified file 'tests/unit-tests/shell/test_registration_order_focus_sequence.cpp'
--- tests/unit-tests/shell/test_registration_order_focus_sequence.cpp	2013-04-19 03:20:05 +0000
+++ tests/unit-tests/shell/test_registration_order_focus_sequence.cpp	2013-04-23 12:15:34 +0000
@@ -22,17 +22,22 @@
 #include "mir/shell/registration_order_focus_sequence.h"
 #include "mir/frontend/surface_creation_parameters.h"
 #include "mir/surfaces/surface.h"
+
 #include "mir_test_doubles/mock_buffer_bundle.h"
 #include "mir_test_doubles/mock_surface_factory.h"
+#include "mir_test_doubles/stub_input_target_listener.h"
+#include "mir_test/fake_shared.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <string>
 
 namespace mc = mir::compositor;
+namespace me = mir::events;
 namespace msh = mir::shell;
 namespace ms = mir::surfaces;
-namespace mtd = mir::test::doubles;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
 
 namespace
 {
@@ -45,6 +50,7 @@
     }
     std::shared_ptr<mtd::MockSurfaceFactory> factory;
     std::shared_ptr<msh::DefaultSessionContainer> container;
+    mtd::StubInputTargetListener input_listener;
 
     static std::string const testing_app_name1;
     static std::string const testing_app_name2;
@@ -60,9 +66,9 @@
 {
     using namespace ::testing;
 
-    auto app1 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name1);
-    auto app2 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name2);
-    auto app3 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name3);
+    auto app1 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name1, std::shared_ptr<me::EventSink>());
+    auto app2 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name2, std::shared_ptr<me::EventSink>());
+    auto app3 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name3, std::shared_ptr<me::EventSink>());
 
     container->insert_session(app1);
     container->insert_session(app2);
@@ -78,9 +84,9 @@
 {
     using namespace ::testing;
 
-    auto app1 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name1);
-    auto app2 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name2);
-    auto app3 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name3);
+    auto app1 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name1, std::shared_ptr<me::EventSink>());
+    auto app2 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name2, std::shared_ptr<me::EventSink>());
+    auto app3 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name3, std::shared_ptr<me::EventSink>());
     container->insert_session(app1);
     container->insert_session(app2);
     container->insert_session(app3);
@@ -95,7 +101,7 @@
 {
     using namespace ::testing;
 
-    auto app1 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name1);
+    auto app1 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name1, std::shared_ptr<me::EventSink>());
     container->insert_session(app1);
 
     msh::RegistrationOrderFocusSequence focus_sequence(container);
@@ -107,8 +113,8 @@
 {
     using namespace ::testing;
 
-    auto app1 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name1);
-    auto app2 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name2);
+    auto app1 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name1, std::shared_ptr<me::EventSink>());
+    auto app2 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name2, std::shared_ptr<me::EventSink>());
     auto null_session = std::shared_ptr<msh::ApplicationSession>();
 
     msh::RegistrationOrderFocusSequence focus_sequence(container);
@@ -124,7 +130,7 @@
 {
     using namespace ::testing;
 
-    auto invalid_session = std::make_shared<msh::ApplicationSession>(factory, testing_app_name1);
+    auto invalid_session = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name1, std::shared_ptr<me::EventSink>());
     auto null_session = std::shared_ptr<msh::ApplicationSession>();
 
     msh::RegistrationOrderFocusSequence focus_sequence(container);

=== modified file 'tests/unit-tests/shell/test_session_manager.cpp'
--- tests/unit-tests/shell/test_session_manager.cpp	2013-04-19 03:20:05 +0000
+++ tests/unit-tests/shell/test_session_manager.cpp	2013-04-23 12:15:34 +0000
@@ -21,15 +21,19 @@
 #include "mir/shell/session_manager.h"
 #include "mir/shell/default_session_container.h"
 #include "mir/shell/session.h"
+#include "mir/shell/input_target_listener.h"
 #include "mir/frontend/surface_creation_parameters.h"
 #include "mir/surfaces/surface.h"
 #include "mir/input/input_channel.h"
+
+#include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_buffer_bundle.h"
-#include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_surface_factory.h"
 #include "mir_test_doubles/mock_focus_setter.h"
 #include "mir_test_doubles/null_buffer_bundle.h"
 #include "mir_test_doubles/stub_surface_builder.h"
+#include "mir_test_doubles/stub_input_target_listener.h"
+#include "mir_test_doubles/mock_input_target_listener.h"
 
 #include "mir/shell/surface.h"
 
@@ -37,6 +41,7 @@
 #include <gtest/gtest.h>
 
 namespace mc = mir::compositor;
+namespace me = mir::events;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 namespace ms = mir::surfaces;
@@ -56,7 +61,7 @@
     ~MockSessionContainer() noexcept {}
 };
 
-struct MockFocusSequence: public msh::FocusSequence
+struct MockFocusSequence : public msh::FocusSequence
 {
     MOCK_CONST_METHOD1(successor_of, std::shared_ptr<msh::Session>(std::shared_ptr<msh::Session> const&));
     MOCK_CONST_METHOD1(predecessor_of, std::shared_ptr<msh::Session>(std::shared_ptr<msh::Session> const&));
@@ -68,16 +73,18 @@
     SessionManagerSetup()
       : session_manager(mt::fake_shared(surface_factory),
                         mt::fake_shared(container),
-                        mt::fake_shared(sequence),
-                        mt::fake_shared(focus_setter))
+                        mt::fake_shared(focus_sequence),
+                        mt::fake_shared(focus_setter),
+                        mt::fake_shared(input_target_listener))
     {
     }
 
     mtd::StubSurfaceBuilder surface_builder;
     mtd::MockSurfaceFactory surface_factory;
     testing::NiceMock<MockSessionContainer> container;    // Inelegant but some tests need a stub
-    MockFocusSequence sequence;
+    MockFocusSequence focus_sequence;
     testing::NiceMock<mtd::MockFocusSetter> focus_setter; // Inelegant but some tests need a stub
+    mtd::StubInputTargetListener input_target_listener;
 
     msh::SessionManager session_manager;
 };
@@ -93,9 +100,9 @@
     EXPECT_CALL(focus_setter, set_focus_to(_));
     EXPECT_CALL(focus_setter, set_focus_to(std::shared_ptr<msh::Session>())).Times(1);
 
-    EXPECT_CALL(sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
+    EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
 
-    auto session = session_manager.open_session("Visual Basic Studio");
+    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
     session_manager.close_session(session);
 }
 
@@ -103,14 +110,16 @@
 {
     using namespace ::testing;
 
-    EXPECT_CALL(surface_factory, create_surface(_)).Times(1);
+    EXPECT_CALL(surface_factory, create_surface(_, _, _)).Times(1);
 
     std::shared_ptr<mi::InputChannel> null_input_channel;
-    ON_CALL(surface_factory, create_surface(_)).WillByDefault(
+    ON_CALL(surface_factory, create_surface(_, _, _)).WillByDefault(
        Return(std::make_shared<msh::Surface>(
            mt::fake_shared(surface_builder),
            mf::a_surface(),
-           null_input_channel)));
+           null_input_channel,
+           mf::SurfaceId(),
+           std::shared_ptr<me::EventSink>())));
 
     EXPECT_CALL(container, insert_session(_)).Times(1);
     EXPECT_CALL(container, remove_session(_)).Times(1);
@@ -118,9 +127,9 @@
     EXPECT_CALL(focus_setter, set_focus_to(_)).Times(1);
     EXPECT_CALL(focus_setter, set_focus_to(std::shared_ptr<msh::Session>())).Times(1);
 
-    EXPECT_CALL(sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
+    EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
 
-    auto session = session_manager.open_session("Visual Basic Studio");
+    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
     session->create_surface(mf::a_surface().of_size(geom::Size{geom::Width{1024}, geom::Height{768}}));
 
     session_manager.close_session(session);
@@ -134,7 +143,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");
+    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
     EXPECT_EQ(session, new_session);
 }
 
@@ -142,8 +151,8 @@
 {
     using namespace ::testing;
 
-    auto session1 = session_manager.open_session("Visual Basic Studio");
-    auto session2 = session_manager.open_session("IntelliJ IDEA");
+    auto session1 = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
+    auto session2 = session_manager.open_session("IntelliJ IDEA", std::shared_ptr<me::EventSink>());
 
     session_manager.tag_session_with_lightdm_id(session1, 1);
 
@@ -155,8 +164,8 @@
 {
     using namespace ::testing;
 
-    auto session1 = session_manager.open_session("Visual Basic Studio");
-    auto session2 = session_manager.open_session("IntelliJ IDEA");
+    auto session1 = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
+    auto session2 = session_manager.open_session("IntelliJ IDEA", std::shared_ptr<me::EventSink>());
 
     auto shell_session1 = std::dynamic_pointer_cast<msh::Session>(session1);
     auto shell_session2 = std::dynamic_pointer_cast<msh::Session>(session2);
@@ -164,7 +173,7 @@
     session_manager.tag_session_with_lightdm_id(session1, 1);
     session_manager.focus_session_with_lightdm_id(1);
 
-    EXPECT_CALL(sequence, default_focus()).WillOnce(Return(shell_session2));
+    EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return(shell_session2));
     EXPECT_CALL(focus_setter, set_focus_to(Eq(shell_session2)));
 
     session_manager.close_session(session1);
@@ -174,22 +183,85 @@
 {
     using namespace ::testing;
     std::shared_ptr<mi::InputChannel> null_input_channel;
-    ON_CALL(surface_factory, create_surface(_)).WillByDefault(
+    ON_CALL(surface_factory, create_surface(_, _, _)).WillByDefault(
         Return(std::make_shared<msh::Surface>(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel)));
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>())));
 
     // Once for session creation and once for surface creation
     {
         InSequence seq;
 
         EXPECT_CALL(focus_setter, set_focus_to(_)).Times(1); // Session creation
-        EXPECT_CALL(surface_factory, create_surface(_)).Times(1);
+        EXPECT_CALL(surface_factory, create_surface(_, _, _)).Times(1);
         EXPECT_CALL(focus_setter, set_focus_to(_)).Times(1); // Post Surface creation
     }
 
-    auto session1 = session_manager.open_session("Weather Report");
+    auto session1 = session_manager.open_session("Weather Report", std::shared_ptr<me::EventSink>());
     session_manager.create_surface_for(session1, mf::a_surface());
 }
 
+namespace
+{
+
+struct SessionManagerInputTargetListenerSetup : public testing::Test
+{
+    SessionManagerInputTargetListenerSetup()
+      : session_manager(mt::fake_shared(surface_factory),
+                        mt::fake_shared(container),
+                        mt::fake_shared(focus_sequence),
+                        mt::fake_shared(focus_setter),
+                        mt::fake_shared(input_target_listener))
+    {
+    }
+
+    mtd::StubSurfaceBuilder surface_builder;
+    mtd::MockSurfaceFactory surface_factory;
+    testing::NiceMock<MockSessionContainer> container;    // Inelegant but some tests need a stub
+    testing::NiceMock<MockFocusSequence> focus_sequence;
+    testing::NiceMock<mtd::MockFocusSetter> focus_setter; // Inelegant but some tests need a stub
+    mtd::MockInputTargetListener input_target_listener;
+
+    msh::SessionManager session_manager;
+};
+
+}
+
+TEST_F(SessionManagerInputTargetListenerSetup, listener_is_notified_of_session_and_surfacelifecycle)
+{
+    using namespace ::testing;
+
+    std::shared_ptr<mi::InputChannel> null_input_channel;
+    ON_CALL(surface_factory, create_surface(_,_,_)).WillByDefault(
+       Return(std::make_shared<msh::Surface>(
+           mt::fake_shared(surface_builder),
+           mf::a_surface(),
+           null_input_channel,
+           mf::SurfaceId(),
+           std::shared_ptr<me::EventSink>())));
+    EXPECT_CALL(surface_factory, create_surface(_,_,_)).Times(1);
+
+    EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
+    {
+        InSequence seq;
+
+        EXPECT_CALL(input_target_listener, input_application_opened(_))
+            .Times(1);
+        EXPECT_CALL(input_target_listener, input_surface_opened(_, _)).Times(1);
+        EXPECT_CALL(input_target_listener, focus_changed(_)).Times(1);
+        EXPECT_CALL(input_target_listener, input_surface_closed(_)).Times(1);
+        EXPECT_CALL(input_target_listener, input_application_closed(_))
+            .Times(1);
+        EXPECT_CALL(input_target_listener, focus_cleared()).Times(1);
+    }
+
+    {
+        auto session = session_manager.open_session("test", std::shared_ptr<me::EventSink>());
+        auto surf = session_manager.create_surface_for(session, mf::a_surface());
+        session->destroy_surface(surf);
+        session_manager.close_session(session);
+    }
+}

=== modified file 'tests/unit-tests/shell/test_single_visibility_focus_mechanism.cpp'
--- tests/unit-tests/shell/test_single_visibility_focus_mechanism.cpp	2013-04-22 03:24:56 +0000
+++ tests/unit-tests/shell/test_single_visibility_focus_mechanism.cpp	2013-04-23 12:15:34 +0000
@@ -27,7 +27,6 @@
 #include "mir_test_doubles/mock_buffer_bundle.h"
 #include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_surface_factory.h"
-#include "mir_test_doubles/mock_input_focus_selector.h"
 #include "mir_test_doubles/stub_surface.h"
 #include "mir_test_doubles/mock_surface.h"
 #include "mir_test_doubles/stub_surface_builder.h"
@@ -65,8 +64,6 @@
 {
     using namespace ::testing;
 
-    NiceMock<mtd::MockInputFocusSelector> input_focus_selector;
-
     NiceMock<MockShellSession> app1, app2, app3;
     msh::DefaultSessionContainer model;
 
@@ -74,7 +71,7 @@
     ON_CALL(app2, default_surface()).WillByDefault(Return(std::shared_ptr<msh::Surface>()));
     ON_CALL(app3, default_surface()).WillByDefault(Return(std::shared_ptr<msh::Surface>()));
 
-    msh::SingleVisibilityFocusMechanism focus_mechanism(mt::fake_shared(model), mt::fake_shared(input_focus_selector));
+    msh::SingleVisibilityFocusMechanism focus_mechanism(mt::fake_shared(model));
 
     EXPECT_CALL(app1, show()).Times(1);
     EXPECT_CALL(app2, hide()).Times(1);
@@ -90,23 +87,3 @@
 
     focus_mechanism.set_focus_to(mt::fake_shared(app1));
 }
-
-TEST(SingleVisibilityFocusMechanism, mechanism_sets_input_focus_from_default_surface)
-{
-    using namespace ::testing;
-
-    mtd::MockInputFocusSelector input_focus_selector;
-    msh::DefaultSessionContainer model;
-    auto session = std::make_shared<NiceMock<MockShellSession>>();
-    auto surface = std::make_shared<mtd::MockSurface>(std::make_shared<mtd::StubSurfaceBuilder>());
-
-    msh::SingleVisibilityFocusMechanism focus_mechanism(mt::fake_shared(model), mt::fake_shared(input_focus_selector));
-
-    EXPECT_CALL(*session, default_surface()).Times(1).WillOnce(Return(surface));
-
-    EXPECT_CALL(input_focus_selector, set_input_focus_to(Eq(session), Eq(surface))).Times(1);
-
-    model.insert_session(session);
-    focus_mechanism.set_focus_to(session);
-}
-

=== modified file 'tests/unit-tests/shell/test_surface.cpp'
--- tests/unit-tests/shell/test_surface.cpp	2013-04-19 03:20:05 +0000
+++ tests/unit-tests/shell/test_surface.cpp	2013-04-23 12:15:34 +0000
@@ -33,6 +33,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+namespace me = mir::events;
 namespace ms = mir::surfaces;
 namespace msh = mir::shell;
 namespace mf = mir::frontend;
@@ -137,7 +138,9 @@
     msh::Surface test(
         mt::fake_shared(surface_builder),
         params,
-        null_input_channel);
+        null_input_channel,
+        mf::SurfaceId(),
+        std::shared_ptr<me::EventSink>());
 }
 
 TEST_F(ShellSurface, creation_throws_means_no_destroy)
@@ -156,7 +159,9 @@
         msh::Surface test(
             mt::fake_shared(surface_builder),
             params,
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
     }, std::runtime_error);
 }
 
@@ -172,7 +177,9 @@
     msh::Surface test(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     Mock::VerifyAndClearExpectations(&test);
     EXPECT_CALL(surface_builder, destroy_surface(_)).Times(1);
@@ -189,7 +196,9 @@
     msh::Surface test(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     EXPECT_NO_THROW({
         test.client_buffer();
@@ -207,7 +216,9 @@
     msh::Surface test(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     EXPECT_NO_THROW({
         test.size();
@@ -225,7 +236,9 @@
     msh::Surface test(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     EXPECT_NO_THROW({
         test.name();
@@ -243,7 +256,9 @@
     msh::Surface test(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     EXPECT_NO_THROW({
         test.pixel_format();
@@ -261,7 +276,9 @@
     msh::Surface test(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     EXPECT_NO_THROW({
         test.hide();
@@ -279,7 +296,9 @@
     msh::Surface test(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     EXPECT_NO_THROW({
         test.show();
@@ -297,7 +316,9 @@
     msh::Surface test(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     EXPECT_NO_THROW({
         test.destroy();
@@ -315,7 +336,9 @@
     msh::Surface test(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     EXPECT_NO_THROW({
         test.force_requests_to_complete();
@@ -333,7 +356,9 @@
     msh::Surface test(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     EXPECT_NO_THROW({
         test.advance_client_buffer();
@@ -352,8 +377,19 @@
     const int testing_client_fd = 17;
 
     MockInputChannel mock_package;
-    msh::Surface proxy_surface(mt::fake_shared(surface_builder), mf::a_surface(), null_input_channel);
-    msh::Surface input_proxy_surface(mt::fake_shared(surface_builder), mf::a_surface(), mt::fake_shared(mock_package));
+    msh::Surface proxy_surface(
+        mt::fake_shared(surface_builder),
+        mf::a_surface(),
+        null_input_channel,
+        mf::SurfaceId(),
+        std::shared_ptr<me::EventSink>());
+
+    msh::Surface input_proxy_surface(
+        mt::fake_shared(surface_builder),
+        mf::a_surface(),
+        mt::fake_shared(mock_package),
+        mf::SurfaceId(),
+        std::shared_ptr<me::EventSink>());
 
     EXPECT_CALL(mock_package, client_fd()).Times(1).WillOnce(Return(testing_client_fd));
 
@@ -374,7 +410,9 @@
     msh::Surface surf(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     EXPECT_THROW({
         surf.configure(static_cast<MirSurfaceAttrib>(111), 222);
@@ -388,7 +426,9 @@
     msh::Surface surf(
             mt::fake_shared(surface_builder),
             mf::a_surface(),
-            null_input_channel);
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
 
     EXPECT_EQ(mir_surface_type_normal, surf.type());
 
@@ -415,6 +455,7 @@
                              mir_surface_type_freestyle));
     EXPECT_EQ(mir_surface_type_freestyle, surf.type());
 }
+<<<<<<< TREE
 
 TEST_F(ShellSurface, states)
 {
@@ -450,3 +491,43 @@
                              mir_surface_state_fullscreen));
     EXPECT_EQ(mir_surface_state_fullscreen, surf.state());
 }
+=======
+
+TEST_F(ShellSurface, states)
+{
+    using namespace testing;
+
+    msh::Surface surf(
+            mt::fake_shared(surface_builder),
+            mf::a_surface(),
+            null_input_channel,
+            mf::SurfaceId(),
+            std::shared_ptr<me::EventSink>());
+
+    EXPECT_EQ(mir_surface_state_restored, surf.state());
+
+    EXPECT_EQ(mir_surface_state_vertmaximized,
+              surf.configure(mir_surface_attrib_state,
+                             mir_surface_state_vertmaximized));
+    EXPECT_EQ(mir_surface_state_vertmaximized, surf.state());
+
+    EXPECT_THROW({
+        surf.configure(mir_surface_attrib_state, 999);
+    }, std::logic_error);
+    EXPECT_THROW({
+        surf.configure(mir_surface_attrib_state, -1);
+    }, std::logic_error);
+    EXPECT_EQ(mir_surface_state_vertmaximized, surf.state());
+
+    EXPECT_EQ(mir_surface_state_minimized,
+              surf.configure(mir_surface_attrib_state,
+                             mir_surface_state_minimized));
+    EXPECT_EQ(mir_surface_state_minimized, surf.state());
+
+    EXPECT_EQ(mir_surface_state_fullscreen,
+              surf.configure(mir_surface_attrib_state,
+                             mir_surface_state_fullscreen));
+    EXPECT_EQ(mir_surface_state_fullscreen, surf.state());
+}
+
+>>>>>>> MERGE-SOURCE

=== modified file 'tests/unit-tests/shell/test_the_session_container_implementation.cpp'
--- tests/unit-tests/shell/test_the_session_container_implementation.cpp	2013-04-19 03:20:05 +0000
+++ tests/unit-tests/shell/test_the_session_container_implementation.cpp	2013-04-23 12:15:34 +0000
@@ -22,12 +22,14 @@
 #include "mir/frontend/surface_creation_parameters.h"
 #include "mir/surfaces/surface.h"
 #include "mir_test_doubles/mock_buffer_bundle.h"
+#include "mir_test_doubles/stub_input_target_listener.h"
 #include "mir_test_doubles/mock_surface_factory.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;
@@ -38,8 +40,8 @@
     auto factory = std::make_shared<mtd::MockSurfaceFactory>();
     msh::DefaultSessionContainer container;
 
-    container.insert_session(std::make_shared<msh::ApplicationSession>(factory, "Visual Studio 7"));
-    container.insert_session(std::make_shared<msh::ApplicationSession>(factory, "Visual Studio 8"));
+    container.insert_session(std::make_shared<msh::ApplicationSession>(factory, std::make_shared<mtd::StubInputTargetListener>(), "Visual Studio 7", std::shared_ptr<me::EventSink>()));
+    container.insert_session(std::make_shared<msh::ApplicationSession>(factory, std::make_shared<mtd::StubInputTargetListener>(), "Visual Studio 8", std::shared_ptr<me::EventSink>()));
 
     struct local
     {
@@ -64,8 +66,11 @@
     auto factory = std::make_shared<mtd::MockSurfaceFactory>();
     msh::DefaultSessionContainer container;
 
-    auto session = std::make_shared<msh::ApplicationSession>(factory,
-                                                               "Visual Studio 7");
+    auto session = std::make_shared<msh::ApplicationSession>(
+        factory,
+        std::make_shared<mtd::StubInputTargetListener>(),
+        "Visual Studio 7",
+        std::shared_ptr<me::EventSink>());
     EXPECT_THROW({
         container.remove_session(session);
     }, std::logic_error);

=== modified file 'tools/setup-partial-armhf-chroot.sh'
--- tools/setup-partial-armhf-chroot.sh	2013-04-17 02:49:53 +0000
+++ tools/setup-partial-armhf-chroot.sh	2013-04-23 12:15:34 +0000
@@ -7,7 +7,7 @@
     exit
 fi
 
-echo "creating phablet-compatible quantal armhf partial chroot for mir compiles in directory ${1}"
+echo "creating phablet-compatible raring armhf partial chroot for mir compiles in directory ${1}"
 
 if [ ! -d ${1} ]; then
     mkdir -p ${1} 
@@ -37,6 +37,10 @@
         libboost-program-options1.49.0
         libhybris
         libhybris-dev
+        libgflags2
+        libgflags-dev
+        libgoogle-glog-dev
+        libgoogle-glog0
         libicu48
         libprotobuf7
         libprotobuf-dev
@@ -75,29 +79,6 @@
         dpkg -x ${PACKAGE_FILENAME} . 
     done
 
-    #glog is only available in raring for armhf. we download the raring sources and 
-    #install them manually for this quantal script
-    if [ ! -f libgoogle-glog0_0.3.2-4ubuntu1_armhf.deb ]; then
-        wget "https://launchpad.net/ubuntu/+archive/primary/+files/libgoogle-glog0_0.3.2-4ubuntu1_armhf.deb"
-    fi
-
-    if [ ! -f libgflags2_2.0-1_armhf.deb ]; then
-        wget "https://launchpad.net/ubuntu/+archive/primary/+files/libgflags2_2.0-1_armhf.deb"
-    fi
-
-    if [ ! -f libgoogle-glog-dev_0.3.2-4ubuntu1_armhf.deb ]; then
-        wget "http://launchpadlibrarian.net/134086853/libgoogle-glog-dev_0.3.2-4ubuntu1_armhf.deb"
-    fi
-
-    if [ ! -f libgflags-dev_2.0-1_armhf.deb ]; then
-        wget "http://launchpadlibrarian.net/106868249/libgflags-dev_2.0-1_armhf.deb"
-    fi
-
-    dpkg -x libgflags-dev_2.0-1_armhf.deb .
-    dpkg -x libgflags2_2.0-1_armhf.deb .
-    dpkg -x libgoogle-glog0_0.3.2-4ubuntu1_armhf.deb .
-    dpkg -x libgoogle-glog-dev_0.3.2-4ubuntu1_armhf.deb .
-
     #todo: we get egl/gles headers from the mesa packages, but should be pointing at the hybris libraries
     #just rewrite the symlinks for now
     rm ./usr/lib/arm-linux-gnueabihf/libEGL.so