Merge lp:~robertcarr/mir/enable-pointer-touch-input into lp:~mir-team/mir/trunk

[Robert Carr]

Enable motion events! (Pointer and touch input)

Enable motion events in the DispatcherPolicy and Window Handle. This branch is largely new acceptance tests! (small changes to event_filter_dispatcher_policy and android_input_window_handle)

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2013-04-19 15:59:41 +0000
+++ include/server/mir/default_server_configuration.h	2013-04-22 16:32:37 +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/input/input_manager.h'
--- include/server/mir/input/input_manager.h	2013-04-16 09:08:29 +0000
+++ include/server/mir/input/input_manager.h	2013-04-22 16:32:37 +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:08:29 +0000
+++ include/server/mir/input/null_input_manager.h	2013-04-22 16:32:37 +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-22 16:32:37 +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/input/surface_target.h'
--- include/server/mir/input/surface_target.h	2013-04-16 09:08:29 +0000
+++ include/server/mir/input/surface_target.h	2013-04-22 16:32:37 +0000
@@ -20,6 +20,7 @@
 #define MIR_INPUT_SURFACE_TARGET_H_
 
 #include "mir/geometry/size.h"
+#include "mir/geometry/point.h"
 
 #include <string>
 
@@ -33,6 +34,7 @@
 public:
     virtual ~SurfaceTarget() {}
 
+    virtual geometry::Point top_left() const = 0;
     virtual geometry::Size size() const = 0;
     virtual std::string name() const = 0;
 
 
=== modified file 'include/server/mir/shell/application_session.h'
--- include/server/mir/shell/application_session.h	2013-04-16 17:42:26 +0000
+++ include/server/mir/shell/application_session.h	2013-04-22 16:32:37 +0000
@@ -30,11 +30,13 @@
 {
 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);
     ~ApplicationSession();
 
     frontend::SurfaceId create_surface(frontend::SurfaceCreationParameters const& params);
@@ -58,6 +60,7 @@
 
 private:
     std::shared_ptr<SurfaceFactory> const surface_factory;
+    std::shared_ptr<InputTargetListener> const input_target_listener;
     std::string const session_name;
 
     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:08:29 +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-22 16:32:37 +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/session_manager.h'
--- include/server/mir/shell/session_manager.h	2013-04-19 09:15:31 +0000
+++ include/server/mir/shell/session_manager.h	2013-04-22 16:32:37 +0000
@@ -40,15 +40,17 @@
 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);
@@ -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:08:29 +0000
+++ include/server/mir/shell/single_visibility_focus_mechanism.h	2013-04-22 16:32:37 +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-16 17:42:26 +0000
+++ include/server/mir/shell/surface.h	2013-04-22 16:32:37 +0000
@@ -63,6 +63,7 @@
     virtual std::string name() const;
 
     virtual geometry::Size size() const;
+    virtual geometry::Point top_left() const;
 
     virtual geometry::PixelFormat pixel_format() const;
 
 
=== added file 'include/test/mir_test/event_matchers.h'
--- include/test/mir_test/event_matchers.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test/event_matchers.h	2013-04-22 16:32:37 +0000
@@ -0,0 +1,64 @@
+/*
+ * 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_EVENT_MATCHERS_H_
+#define MIR_TEST_EVENT_MATCHERS_H_
+
+#include <androidfw/Input.h>
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+
+MATCHER_P(IsKeyEventWithKey, key, "")
+{
+    if (arg.type != mir_event_type_key)
+        return false;
+
+    return arg.key.key_code == key;
+}
+MATCHER(KeyDownEvent, "")
+{
+    if (arg.type != mir_event_type_key)
+        return false;
+
+    return arg.key.action == AKEY_EVENT_ACTION_DOWN;
+}
+MATCHER(ButtonDownEvent, "")
+{
+    if (arg.type != mir_event_type_motion)
+        return false;
+    if (arg.motion.button_state == 0)
+        return false;
+    return arg.motion.action == AMOTION_EVENT_ACTION_DOWN;
+}
+MATCHER_P2(MotionEvent, dx, dy, "")
+{
+    if (arg.type != mir_event_type_motion)
+        return false;
+    auto coords = &arg.motion.pointer_coordinates[0];
+    return (coords->x == dx) && (coords->y == dy);
+}
+
+}
+} // namespace mir
+
+#endif // MIR_TEST_EVENT_MATCHERS_H_
 
=== modified file 'include/test/mir_test/fake_event_hub_input_configuration.h'
--- include/test/mir_test/fake_event_hub_input_configuration.h	2013-04-16 09:08:29 +0000
+++ include/test/mir_test/fake_event_hub_input_configuration.h	2013-04-22 16:32:37 +0000
@@ -63,6 +63,8 @@
 
     droidinput::sp<droidinput::EventHubInterface> the_event_hub();
     input::android::FakeEventHub* the_fake_event_hub();
+    
+    bool is_key_repeat_enabled() override { return false; }
 
 
 protected:
 
=== modified file 'include/test/mir_test_doubles/mock_event_filter.h'
--- include/test/mir_test_doubles/mock_event_filter.h	2013-04-16 09:08:29 +0000
+++ include/test/mir_test_doubles/mock_event_filter.h	2013-04-22 16:32:37 +0000
@@ -21,8 +21,6 @@
 
 #include "mir/input/event_filter.h"
 
-#include <androidfw/Input.h>
-
 #include <gmock/gmock.h>
 
 namespace mir
@@ -36,36 +34,6 @@
     MOCK_METHOD1(handles, bool(const MirEvent&));
 };
 }
-
-MATCHER_P(IsKeyEventWithKey, key, "")
-{
-    if (arg.type != mir_event_type_key)
-        return false;
-
-    return arg.key.key_code == key;
-}
-MATCHER(KeyDownEvent, "")
-{
-    if (arg.type != mir_event_type_key)
-        return false;
-
-    return arg.key.action == AKEY_EVENT_ACTION_DOWN;
-}
-MATCHER(ButtonDownEvent, "")
-{
-    if (arg.type != mir_event_type_motion)
-        return false;
-    if (arg.motion.button_state == 0)
-        return false;
-    return arg.motion.action == AKEY_EVENT_ACTION_DOWN;
-}
-MATCHER_P2(MotionEvent, dx, dy, "")
-{
-    if (arg.type != mir_event_type_motion)
-        return false;
-    auto coords = &arg.motion.pointer_coordinates[0];
-    return (coords->x == dx) && (coords->y == dy);
-}
 }
 }
 
 
=== 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:08:29 +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-22 16:32:37 +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_
 
=== 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-22 16:32:37 +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_surface_target.h'
--- include/test/mir_test_doubles/stub_surface_target.h	2013-04-16 09:08:29 +0000
+++ include/test/mir_test_doubles/stub_surface_target.h	2013-04-22 16:32:37 +0000
@@ -43,6 +43,10 @@
     {
         return geometry::Size();
     }
+    geometry::Point top_left() const override
+    {
+        return geometry::Point();
+    }
     std::string name() const override
     {
         return std::string();
 
=== modified file 'include/test/mir_test_framework/testing_server_configuration.h'
--- include/test/mir_test_framework/testing_server_configuration.h	2013-04-16 09:08:29 +0000
+++ include/test/mir_test_framework/testing_server_configuration.h	2013-04-22 16:32:37 +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/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2013-04-19 12:49:42 +0000
+++ src/server/default_server_configuration.cpp	2013-04-22 16:32:37 +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"
@@ -310,8 +310,7 @@
         [this]
         {
             return std::make_shared<msh::SingleVisibilityFocusMechanism>(
-                the_shell_session_container(),
-                the_input_focus_selector());
+                the_shell_session_container());
         });
 }
 
@@ -347,7 +346,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());
         });
 }
 
@@ -562,15 +562,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-19 14:52:23 +0000
+++ src/server/display_server.cpp	2013-04-22 16:32:37 +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/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-22 16:32:37 +0000
@@ -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-22 16:32:37 +0000
@@ -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/android_input_window_handle.cpp'
--- src/server/input/android/android_input_window_handle.cpp	2013-03-29 16:51:35 +0000
+++ src/server/input/android/android_input_window_handle.cpp	2013-04-22 16:32:37 +0000
@@ -48,11 +48,17 @@
                                                            surface->server_input_fd());
     }
 
-    mInfo->frameLeft = 0;
-    mInfo->frameTop = 0;
+    auto surface_position = surface->top_left();
+    mInfo->frameLeft = surface_position.x.as_uint32_t();
+    mInfo->frameTop = surface_position.y.as_uint32_t();
     auto surface_size = surface->size();
     mInfo->frameRight = mInfo->frameLeft + surface_size.width.as_uint32_t();
     mInfo->frameBottom = mInfo->frameTop + surface_size.height.as_uint32_t();
+    
+    mInfo->touchableRegionLeft = mInfo->frameLeft;
+    mInfo->touchableRegionTop = mInfo->frameTop;
+    mInfo->touchableRegionRight = mInfo->frameRight;
+    mInfo->touchableRegionBottom = mInfo->frameBottom;
 
     mInfo->name = droidinput::String8(surface->name().c_str());
     mInfo->layoutParamsFlags = droidinput::InputWindowInfo::FLAG_NOT_TOUCH_MODAL;
 
=== modified file 'src/server/input/android/default_android_input_configuration.cpp'
--- src/server/input/android/default_android_input_configuration.cpp	2013-04-16 09:08:29 +0000
+++ src/server/input/android/default_android_input_configuration.cpp	2013-04-22 16:32:37 +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:08:29 +0000
+++ src/server/input/android/default_android_input_configuration.h	2013-04-22 16:32:37 +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-16 09:27:00 +0000
+++ src/server/input/android/event_filter_dispatcher_policy.cpp	2013-04-22 16:32:37 +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*/)
@@ -67,9 +68,9 @@
     policy_flags |= droidinput::POLICY_FLAG_PASS_TO_USER;
 }
 
-void mia::EventFilterDispatcherPolicy::interceptMotionBeforeQueueing(nsecs_t /* when */, uint32_t& /* policyFlags */)
+void mia::EventFilterDispatcherPolicy::interceptMotionBeforeQueueing(nsecs_t /* when */, uint32_t& policy_flags)
 {
-    // TODO: Implement for motion events to client.
+    policy_flags |= droidinput::POLICY_FLAG_PASS_TO_USER;
 }
 
 nsecs_t mia::EventFilterDispatcherPolicy::interceptKeyBeforeDispatching(
 
=== modified file 'src/server/input/android/event_filter_dispatcher_policy.h'
--- src/server/input/android/event_filter_dispatcher_policy.h	2013-04-16 09:08:29 +0000
+++ src/server/input/android/event_filter_dispatcher_policy.h	2013-04-22 16:32:37 +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-16 17:42:26 +0000
+++ src/server/shell/application_session.cpp	2013-04-22 16:32:37 +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>
 
@@ -32,9 +32,11 @@
 namespace msh = mir::shell;
 
 msh::ApplicationSession::ApplicationSession(
-    std::shared_ptr<SurfaceFactory> const& surface_factory,
+    std::shared_ptr<msh::SurfaceFactory> const& surface_factory,
+    std::shared_ptr<msh::InputTargetListener> const& input_target_listener,
     std::string const& session_name) :
     surface_factory(surface_factory),
+    input_target_listener(input_target_listener),
     session_name(session_name),
     next_surface_id(0)
 {
@@ -46,6 +48,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();
     }
 }
@@ -95,6 +98,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/session_manager.cpp'
--- src/server/shell/session_manager.cpp	2013-04-19 09:15:31 +0000
+++ src/server/shell/session_manager.cpp	2013-04-22 16:32:37 +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,20 +33,22 @@
 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()
@@ -53,25 +57,36 @@
 
 std::shared_ptr<mf::Session> msh::SessionManager::open_session(std::string const& name)
 {
-    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);
 
     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 +148,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-18 22:57:01 +0000
+++ src/server/shell/single_visibility_focus_mechanism.cpp	2013-04-22 16:32:37 +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-16 17:42:26 +0000
+++ src/server/shell/surface.cpp	2013-04-22 16:32:37 +0000
@@ -88,6 +88,18 @@
     }
 }
 
+mir::geometry::Point msh::Surface::top_left() const
+{
+    if (auto const& s = surface.lock())
+    {
+        return s->top_left();
+    }
+    else
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface"));
+    }
+}
+
 std::string msh::Surface::name() const
 {
     if (auto const& s = surface.lock())
 
=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2013-04-17 07:31:40 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2013-04-22 16:32:37 +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).
@@ -96,6 +95,7 @@
         {
             on_focus_set.wait_for_at_most_seconds(10);
             fake_event_hub->synthesize_builtin_keyboard_added();
+            fake_event_hub->synthesize_builtin_cursor_added();
             fake_event_hub->synthesize_device_scan_complete();
             inject_input();
         });
@@ -122,10 +122,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);
@@ -186,7 +186,7 @@
 
 struct MockInputHandler
 {
-    MOCK_METHOD1(handle_key_down, void(MirEvent const*));
+    MOCK_METHOD1(handle_input, bool(MirEvent const*));
 };
 
 struct InputReceivingClient : ClientConfigCommon
@@ -201,9 +201,9 @@
     static void handle_input(MirSurface* /* surface */, MirEvent const* ev, void* context)
     {
         auto client = static_cast<InputReceivingClient *>(context);
-        if (ev->key.action == 0)
+
+        if(client->handler->handle_input(ev))
         {
-            client->handler->handle_key_down(ev);
             client->event_received[client->events_received].wake_up_everyone();
             client->events_received++;
         }
@@ -227,7 +227,7 @@
          MirSurfaceParameters const request_params =
          {
              __PRETTY_FUNCTION__,
-             640, 480,
+             surface_width, surface_height,
              mir_pixel_format_abgr_8888,
              mir_buffer_usage_hardware
          };
@@ -259,9 +259,66 @@
     
     int events_to_receive;
     int events_received;
+
+    static int const surface_width = 100;
+    static int const surface_height = 100;
 };
 
-}
+MATCHER(KeyDownEvent, "")
+{
+    if (arg->type != mir_event_type_key)
+        return false;
+    if (arg->key.action != 0) // Key down
+        return false;
+    
+    return true;
+}
+MATCHER_P(KeyOfSymbol, keysym, "")
+{
+    if (static_cast<xkb_keysym_t>(arg->key.key_code) == (uint)keysym)
+        return true;
+    return false;
+}
+
+MATCHER(HoverEnterEvent, "")
+{
+    if (arg->type != mir_event_type_motion)
+        return false;
+    if (arg->motion.action != AMOTION_EVENT_ACTION_HOVER_ENTER)
+        return false;
+
+    return true;
+}
+
+MATCHER_P2(ButtonDownEvent, x, y, "")
+{
+    if (arg->type != mir_event_type_motion)
+        return false;
+    if (arg->motion.action != AMOTION_EVENT_ACTION_DOWN)
+        return false;
+    printf("action: %d \n", arg->motion.action);
+    if (arg->motion.button_state == 0)
+        return false;
+    if (arg->motion.pointer_coordinates[0].x != x)
+        return false;
+    if (arg->motion.pointer_coordinates[0].y != y)
+        return false;
+    return true;
+}
+
+MATCHER_P2(MotionEventWithPosition, x, y, "")
+{
+    if (arg->type != mir_event_type_motion)
+        return false;
+    if (arg->motion.pointer_coordinates[0].x != x)
+        return false;
+    if (arg->motion.pointer_coordinates[0].y != y)
+        return false;
+    return true;
+}
+
+}
+
 
 using TestClientInput = BespokeDisplayServerTestFixture;
 
@@ -290,22 +347,13 @@
         void expect_input()
         {
             using namespace ::testing;
-            EXPECT_CALL(*handler, handle_key_down(_)).Times(num_events_produced);
+            EXPECT_CALL(*handler, handle_input(KeyDownEvent())).Times(num_events_produced)
+                .WillRepeatedly(Return(true));
         }
     } client_config;
     launch_client_process(client_config);
 }
 
-namespace
-{
-MATCHER_P(KeyOfSymbol, keysym, "")
-{
-    if (static_cast<xkb_keysym_t>(arg->key.key_code) == (uint)keysym)
-        return true;
-    return false;
-}
-}
-
 TEST_F(TestClientInput, clients_receive_us_english_mapped_keys)
 {
     using namespace ::testing;
@@ -319,12 +367,6 @@
             fake_event_hub->synthesize_event(mis::a_key_down_event()
                                              .of_scancode(KEY_4));
 
-            // Release the keys so we don't get repeat events.
-            fake_event_hub->synthesize_event(mis::a_key_up_event()
-                                             .of_scancode(KEY_4));
-            fake_event_hub->synthesize_event(mis::a_key_up_event()
-                                             .of_scancode(KEY_LEFTSHIFT));
-
         }
     } server_config;
     launch_server_process(server_config);
@@ -338,10 +380,78 @@
             using namespace ::testing;
 
             InSequence seq;
-            EXPECT_CALL(*handler, handle_key_down(KeyOfSymbol(XKB_KEY_Shift_L))).Times(1);
-            EXPECT_CALL(*handler, handle_key_down(KeyOfSymbol(XKB_KEY_dollar))).Times(1);
-        }
-    } client_config;
-    launch_client_process(client_config);
-}
-
+            EXPECT_CALL(*handler, handle_input(AllOf(KeyDownEvent(), KeyOfSymbol(XKB_KEY_Shift_L)))).Times(1)
+                .WillOnce(Return(true));
+            EXPECT_CALL(*handler, handle_input(AllOf(KeyDownEvent(), KeyOfSymbol(XKB_KEY_dollar)))).Times(1)
+                .WillOnce(Return(true));
+        }
+    } client_config;
+    launch_client_process(client_config);
+}
+
+// TODO: This assumes that clients are placed by shell at 0,0. Which probably isn't quite safe!
+TEST_F(TestClientInput, clients_receive_motion_inside_window)
+{
+    using namespace ::testing;
+    
+    struct InputProducingServerConfiguration : FakeInputServerConfiguration
+    {
+        void inject_input()
+        {
+            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(InputReceivingClient::surface_width,
+                                                                                 InputReceivingClient::surface_height));
+            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(2,2));
+        }
+    } server_config;
+    launch_server_process(server_config);
+    
+    struct MotionReceivingClient : InputReceivingClient
+    {
+        MotionReceivingClient() : InputReceivingClient(2) {}
+
+        void expect_input()
+        {
+            using namespace ::testing;
+            
+            InSequence seq;
+
+            // We should see the cursor enter
+            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(1).WillOnce(Return(true));
+            EXPECT_CALL(*handler, handle_input(
+                MotionEventWithPosition(InputReceivingClient::surface_width, 
+                                        InputReceivingClient::surface_height))).Times(1).WillOnce(Return(true));
+            // But we should not receive an event for the second movement outside of our surface!
+        }
+    } client_config;
+    launch_client_process(client_config);
+}
+
+TEST_F(TestClientInput, clients_receive_button_events_inside_window)
+{
+    using namespace ::testing;
+    
+    struct InputProducingServerConfiguration : FakeInputServerConfiguration
+    {
+        void inject_input()
+        {
+            fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
+        }
+    } server_config;
+    launch_server_process(server_config);
+    
+    struct ButtonReceivingClient : InputReceivingClient
+    {
+        ButtonReceivingClient() : InputReceivingClient(1) {}
+
+        void expect_input()
+        {
+            using namespace ::testing;
+            
+            InSequence seq;
+
+            // The cursor starts at (0, 0).
+            EXPECT_CALL(*handler, handle_input(ButtonDownEvent(0, 0))).Times(1).WillOnce(Return(true));
+        }
+    } client_config;
+    launch_client_process(client_config);
+}
 
=== modified file 'tests/acceptance-tests/test_focus_selection.cpp'
--- tests/acceptance-tests/test_focus_selection.cpp	2013-04-18 02:52:30 +0000
+++ tests/acceptance-tests/test_focus_selection.cpp	2013-04-22 16:32:37 +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/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-22 16:32:37 +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/input/android/test_android_input_manager.cpp'
--- tests/integration-tests/input/android/test_android_input_manager.cpp	2013-04-10 23:48:23 +0000
+++ tests/integration-tests/input/android/test_android_input_manager.cpp	2013-04-22 16:32:37 +0000
@@ -35,6 +35,7 @@
 #include "mir_test_doubles/stub_surface_target.h"
 #include "mir_test/wait_condition.h"
 #include "mir_test/event_factory.h"
+#include "mir_test/event_matchers.h"
 
 #include <EventHub.h>
 #include <InputDispatcher.h>
@@ -171,7 +172,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 +212,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 +246,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 +265,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 +285,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-02 18:26:40 +0000
+++ tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp	2013-04-22 16:32:37 +0000
@@ -26,6 +26,7 @@
 #include "mir_test_doubles/mock_event_filter.h"
 #include "mir_test/wait_condition.h"
 #include "mir_test/event_factory.h"
+#include "mir_test/event_matchers.h"
 
 #include <InputDispatcher.h>
 #include <InputReader.h>
@@ -56,7 +57,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-18 00:00:55 +0000
+++ tests/integration-tests/shell/test_session_manager.cpp	2013-04-22 16:32:37 +0000
@@ -33,6 +33,7 @@
 #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 mf = mir::frontend;
@@ -44,19 +45,22 @@
 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);
+            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");
     auto session2 = session_manager.open_session("Microsoft Access");
@@ -64,9 +68,9 @@
 
     {
       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,19 +81,22 @@
 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));
+            mt::fake_shared(surface_factory),
+            container,
+            mt::fake_shared(sequence),
+            mt::fake_shared(focus_setter),
+            mt::fake_shared(input_target_listener));
 
-    EXPECT_CALL(focus_changer, set_focus_to(_)).Times(3);
+    EXPECT_CALL(focus_setter, set_focus_to(_)).Times(3);
 
     auto session1 = session_manager.open_session("Visual Basic Studio");
     auto session2 = session_manager.open_session("Microsoft Access");
@@ -97,8 +104,8 @@
 
     {
       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_doubles/fake_event_hub.cpp'
--- tests/mir_test_doubles/fake_event_hub.cpp	2013-03-29 16:51:35 +0000
+++ tests/mir_test_doubles/fake_event_hub.cpp	2013-04-22 16:32:37 +0000
@@ -322,7 +322,7 @@
 void mia::FakeEventHub::synthesize_event(const mis::ButtonParameters &parameters)
 {
     RawEvent event;
-    event.when = 0; // TODO: This may need a timestamp to go over the wire ~racarr
+    event.when = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
     event.type = EV_KEY;
     event.code = parameters.button;
 
@@ -348,7 +348,7 @@
 void mia::FakeEventHub::synthesize_event(const mis::MotionParameters &parameters)
 {
     RawEvent event;
-    event.when = 0;
+    event.when = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
     event.type = EV_REL;
     if (parameters.device_id)
         event.deviceId = parameters.device_id;
 
=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2013-04-18 15:20:45 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2013-04-22 16:32:37 +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/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-22 16:32:37 +0000
@@ -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,12 +110,116 @@
 
 }
 
-TEST_F(AndroidDispatcherControllerFdSetup, set_input_focus)
-{
-    using namespace ::testing;
-
-    auto dispatcher = new mtd::MockInputDispatcher(); // We need droidinput::sp
-    mtd::MockInputConfiguration config;
+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;
+
     EXPECT_CALL(config, the_dispatcher()).Times(1)
         .WillOnce(Return(dispatcher));
 
@@ -119,15 +229,30 @@
     {
         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_android_input_window_handle.cpp'
--- tests/unit-tests/input/android/test_android_input_window_handle.cpp	2013-04-04 11:26:58 +0000
+++ tests/unit-tests/input/android/test_android_input_window_handle.cpp	2013-04-22 16:32:37 +0000
@@ -52,6 +52,7 @@
 struct MockSurfaceTarget : public mi::SurfaceTarget
 {
     MOCK_CONST_METHOD0(server_input_fd, int());
+    MOCK_CONST_METHOD0(top_left, geom::Point());
     MOCK_CONST_METHOD0(size, geom::Size());
     MOCK_CONST_METHOD0(name, std::string());
 };
@@ -64,6 +65,7 @@
 
     geom::Size const default_surface_size = geom::Size{geom::Width{256},
                                                       geom::Height{256}};
+    geom::Point const default_surface_top_left = geom::Point{geom::X{10}, geom::Y{10}};
     std::string const testing_surface_name = "Test";
 
     // We need a real open fd, as InputWindowHandle's constructor will fcntl() it, and
@@ -81,6 +83,8 @@
     // for touch/pointer events we will need a position
     EXPECT_CALL(surface, size()).Times(1)
         .WillOnce(Return(default_surface_size));
+    EXPECT_CALL(surface, top_left()).Times(1)
+        .WillOnce(Return(default_surface_top_left));
     EXPECT_CALL(surface, name()).Times(1)
         .WillOnce(Return(testing_surface_name));
 
@@ -93,8 +97,15 @@
 
     EXPECT_EQ(testing_server_fd, info->inputChannel->getFd());
 
+    EXPECT_EQ(default_surface_top_left.x.as_uint32_t(), (uint32_t)(info->frameLeft));
+    EXPECT_EQ(default_surface_top_left.y.as_uint32_t(), (uint32_t)(info->frameTop));
     EXPECT_EQ(default_surface_size.height.as_uint32_t(), (uint32_t)(info->frameRight - info->frameLeft));
     EXPECT_EQ(default_surface_size.height.as_uint32_t(), (uint32_t)(info->frameBottom - info->frameTop));
 
+    EXPECT_EQ(info->frameLeft, info->touchableRegionLeft);
+    EXPECT_EQ(info->frameTop, info->touchableRegionTop);
+    EXPECT_EQ(info->frameRight, info->touchableRegionRight);
+    EXPECT_EQ(info->frameBottom, info->touchableRegionBottom);
+
     free(filename);
 }
 
=== 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-22 16:41:59 +0000
+++ tests/unit-tests/input/android/test_event_filter_input_dispatcher_policy.cpp	2013-04-22 16:32:37 +0000
@@ -32,12 +32,12 @@
 namespace mt = mir::test;
 namespace mtd = mir::test::doubles;
 
-TEST(EventFilterDispatcherPolicy, offers_events_to_filter)
+TEST(EventFilterDispatcherPolicy, offers_key_events_to_filter)
 {
     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));
@@ -53,3 +53,16 @@
     EXPECT_TRUE(policy.filterInputEvent(&ev, 0));
 }
 
+TEST(EventFilterDispatcherPolicy, motion_events_are_allowed_to_pass_to_clients)
+{
+    using namespace ::testing;
+
+    mtd::MockEventFilter filter;
+    mia::EventFilterDispatcherPolicy policy(mt::fake_shared(filter), true);
+
+    uint32_t policy_flags;
+    policy.interceptMotionBeforeQueueing(0, policy_flags);
+
+    // All motion events are allowed. Of course they could later be removed by the input filter.
+    EXPECT_TRUE(policy_flags & droidinput::POLICY_FLAG_PASS_TO_USER);
+}
 
=== modified file 'tests/unit-tests/shell/test_application_session.cpp'
--- tests/unit-tests/shell/test_application_session.cpp	2013-04-17 18:18:31 +0000
+++ tests/unit-tests/shell/test_application_session.cpp	2013-04-22 16:32:37 +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"
 
@@ -51,7 +52,8 @@
     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");
 
     mf::SurfaceCreationParameters params;
     auto surf = session.create_surface(params);
@@ -75,7 +77,8 @@
             .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");
 
     mf::SurfaceCreationParameters params;
     auto id1 = app_session.create_surface(params);
@@ -105,7 +108,8 @@
     mtd::MockSurfaceFactory surface_factory;
     ON_CALL(surface_factory, create_surface(_)).WillByDefault(Return(mock_surface));
 
-    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");
 
     EXPECT_CALL(surface_factory, create_surface(_));
 
@@ -130,7 +134,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");
     mf::SurfaceId invalid_surface_id(1);
 
     EXPECT_THROW({
@@ -143,7 +148,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");
     mf::SurfaceId invalid_surface_id(1);
 
     EXPECT_THROW({
 
=== modified file 'tests/unit-tests/shell/test_registration_order_focus_sequence.cpp'
--- tests/unit-tests/shell/test_registration_order_focus_sequence.cpp	2013-04-18 00:00:55 +0000
+++ tests/unit-tests/shell/test_registration_order_focus_sequence.cpp	2013-04-22 16:32:37 +0000
@@ -22,8 +22,11 @@
 #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>
@@ -32,7 +35,8 @@
 namespace mc = mir::compositor;
 namespace msh = mir::shell;
 namespace ms = mir::surfaces;
-namespace mtd = mir::test::doubles;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
 
 namespace
 {
@@ -45,6 +49,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 +65,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);
+    auto app2 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name2);
+    auto app3 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name3);
 
     container->insert_session(app1);
     container->insert_session(app2);
@@ -78,9 +83,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);
+    auto app2 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name2);
+    auto app3 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name3);
     container->insert_session(app1);
     container->insert_session(app2);
     container->insert_session(app3);
@@ -95,7 +100,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);
     container->insert_session(app1);
 
     msh::RegistrationOrderFocusSequence focus_sequence(container);
@@ -107,8 +112,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);
+    auto app2 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name2);
     auto null_session = std::shared_ptr<msh::ApplicationSession>();
 
     msh::RegistrationOrderFocusSequence focus_sequence(container);
@@ -124,7 +129,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);
     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-18 22:29:24 +0000
+++ tests/unit-tests/shell/test_session_manager.cpp	2013-04-22 16:32:37 +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"
 
@@ -56,7 +60,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 +72,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,7 +99,7 @@
     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");
     session_manager.close_session(session);
@@ -118,7 +124,7 @@
     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");
     session->create_surface(mf::a_surface().of_size(geom::Size{geom::Width{1024}, geom::Height{768}}));
@@ -164,7 +170,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);
@@ -193,3 +199,61 @@
     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)));
+
+    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");
+        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-19 15:33:04 +0000
+++ tests/unit-tests/shell/test_single_visibility_focus_mechanism.cpp	2013-04-22 16:32:37 +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"
@@ -64,8 +63,6 @@
 {
     using namespace ::testing;
 
-    NiceMock<mtd::MockInputFocusSelector> input_focus_selector;
-
     NiceMock<MockShellSession> app1, app2, app3;
     msh::DefaultSessionContainer model;
 
@@ -73,7 +70,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);
@@ -89,23 +86,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-16 17:42:26 +0000
+++ tests/unit-tests/shell/test_surface.cpp	2013-04-22 16:32:37 +0000
@@ -220,6 +220,24 @@
     }, std::runtime_error);
 }
 
+TEST_F(ShellSurface, top_left_throw_behavior)
+{
+    msh::Surface test(
+            mt::fake_shared(surface_builder),
+            mf::a_surface(),
+            null_input_channel);
+
+    EXPECT_NO_THROW({
+        test.top_left();
+    });
+
+    surface_builder.reset_surface();
+
+    EXPECT_THROW({
+        test.top_left();
+    }, std::runtime_error);
+}
+
 TEST_F(ShellSurface, name_throw_behavior)
 {
     msh::Surface test(
 
=== modified file 'tests/unit-tests/shell/test_the_session_container_implementation.cpp'
--- tests/unit-tests/shell/test_the_session_container_implementation.cpp	2013-04-18 00:00:55 +0000
+++ tests/unit-tests/shell/test_the_session_container_implementation.cpp	2013-04-22 16:32:37 +0000
@@ -22,6 +22,7 @@
 #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>
@@ -38,8 +39,10 @@
     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"));
+    container.insert_session(std::make_shared<msh::ApplicationSession>(factory, std::make_shared<mtd::StubInputTargetListener>(), 
+        "Visual Studio 8"));
 
     struct local
     {
@@ -64,8 +67,8 @@
     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");
     EXPECT_THROW({
         container.remove_session(session);
     }, std::logic_error);