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

[Robert Carr]

Enable motion and touch/button events

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).

Depends on:
~robertcarr/mir/reflow-input-focus-selection

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:605
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~robertcarr/mir/enable-pointer-touch-input/+merge/160153/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/mir-ci/468/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/498
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/381
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/473/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:606
http://jenkins.qa.ubuntu.com/job/mir-ci/469/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/499
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/382
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/474/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:607
http://jenkins.qa.ubuntu.com/job/mir-ci/470/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/500
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/383
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/475
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/475/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

1744 +TEST_F(AndroidInputManagerDispatcherInterceptSetup, changing_focus_changes_event_recipient)

It's not the test that needs fixing, but the fundamental assumption behind it. Touch and pointer events are never affected by focus. Focus only relates to key events, because key events lack an (x,y).

Because touch and pointer events already have (x,y) they do not relate to focus. Please remove this assumption if it has been made... ?

review: Needs Information

[Alan Griffiths (alan-griffiths)]

Looks mostly sensible. I'm not convinced by the name "InputTargetListener" as what it "listens" to are session and surface lifecycle messages, not input target messages.

I'll comment further after a closer look.

=== 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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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_reader_policy.cpp'
--- src/server/input/android/android_input_reader_policy.cpp	2013-04-16 09:08:29 +0000
+++ src/server/input/android/android_input_reader_policy.cpp	2013-04-22 21:32:25 +0000
@@ -47,7 +47,10 @@
         width,
         height,
         default_display_orientation);
+    
+    out_config->pointerVelocityControlParameters.acceleration = 1.0;
 }
+
 droidinput::sp<droidinput::PointerControllerInterface> mia::InputReaderPolicy::obtainPointerController(int32_t /*device_id*/)
 {
     return pointer_controller;

=== 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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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 21:32:25 +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);