Merge lp:~robertcarr/mir/send-input-to-clients into lp:~mir-team/mir/trunk

[Robert Carr]

Send input to clients through interfacing the InputManager and SessionManager

Send input to clients through interfacing the InputManager and SessionManager.

Two driving tests:
(acceptance )BespokeDisplayServerTestFixture.sessions_creating_surface_receive_focus

This test ensures the shell passes off focused surfaces to input by selecting the input focus. This is done through passing the InputFocusSelector (InputManager) to the SingleVisibilityFocusMechanism.

(integration) AndroidInputManagerDispatcherInterceptSetup.server_input_fd_of_focused_surface_is_sent_unfiltered_key_events

This test tests at the integration level that the reader policy, dispatcher, and dispatcher policy properly dispatch input to clients.

(unit) AndroidInputManagerFdSetup.set_input_focus is also a good entry point.

This tests that the focus is set correctly on the dispatcher.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:539
http://jenkins.qa.ubuntu.com/job/mir-ci/138/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/49/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/139/console
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/139/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/138/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

50 + virtual std::string name() const = 0;
51 +
...
59 + virtual int server_input_fd() const = 0;

These are not used by frontend. Therefore they don't belong on the frontend::Surface interface.

In principle, input should be defining interfaces that describe its own requirements. It should not injecting requirements into another part of the system nor relying on accidental similarity to what is needed elsewhere.

review: Needs Fixing

[Alexandros Frantzis (afrantzis)]

Also, FocusSelector should be defined in shell::, not in input::, since it's only used by shell::SingleVisibilityFocusMechanism

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:541
http://jenkins.qa.ubuntu.com/job/mir-ci/145/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/59
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/146
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/146/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

1. Moved focus selector
2. Defined mi::SurfaceTarget and mi::SessionTarget and use them for the interface. It's a little tricky as the focus mechanism, session container, etc...want to work in terms of msh::Session but create/close session, etc want to deal in terms of mf::Session...I couldn't find a clear structuring to make this work besides the dynamic_cast in SessionManager::set_focus_to...looking for improvements but I think some of it may be beyond the scope of this branch. At least these interfaces protect the input from continued session/shell changes.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:554
http://jenkins.qa.ubuntu.com/job/mir-ci/146/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/60/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/147
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/147/artifact/work/output/*zip*/output.zip

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:555
http://jenkins.qa.ubuntu.com/job/mir-ci/147/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/61/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/148
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/148/artifact/work/output/*zip*/output.zip

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:556
http://jenkins.qa.ubuntu.com/job/mir-ci/153/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/68/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/154
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/154/artifact/work/output/*zip*/output.zip

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

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

79 + virtual void set_input_focus_to(std::shared_ptr<input::SessionTarget> const& session,
80 + std::shared_ptr<input::SurfaceTarget> const& surface) = 0;

A signature like this makes me wonder what should happen if session and surface are not associated. (Or if there is a requirement that surface belongs to session why both need to be supplied.)

[Alan Griffiths (alan-griffiths)]

122 +
123 + virtual std::string name() = 0;

surely this can be const?

~~~~

529 +#include <gtest/gtest.h>

Not needed

~~~~

922 -
923 +

Adding pointless whitespace.

~~~~

1531 === modified file 'tests/integration-tests/frontend/test_session_manager.cpp'

This really ought to be

tests/integration-tests/*shell*/test_session_manager.cpp

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

This might cause a cascade of fixes - if so, it belongs to another cleanup MP...

121 + virtual ~SessionTarget() {}

Shouldn't that be virtual "~SessionTarget() = default" (there is a semantic difference - the latter is noexcept).

[Robert Carr (robertcarr)]

>> surely this can be const?
r557

>>529 +#include <gtest/gtest.h>
>>
>>Not needed
r558!

>> 922 -
>> 923 +

r559

>>This really ought to be

>>tests/integration-tests/*shell*/test_session_manager.cpp
r560

>> This might cause a cascade of fixes - if so, it belongs to another cleanup MP...

It does cause a cascade so lets fix it next.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:561
http://jenkins.qa.ubuntu.com/job/mir-ci/161/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/78/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/162/console

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

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Concerns addressed - but has merge conflicts.

Abstaining so to avoid blocking

review: Abstain

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:562
http://jenkins.qa.ubuntu.com/job/mir-ci/163/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/80
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/164
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/164/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

LGTM

review: Approve

[Alexandros Frantzis (afrantzis)]

Looks good.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/mir-autolanding/76/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/93/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-autolanding/77/console

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Dammit. My copy of trunk needed updating

[Robert Carr (robertcarr)]

Merged trunk.

[Alan Griffiths (alan-griffiths)]

We should not be using the system clock - our own timesource can be mocked to facilitate testing of time dependent scenarios.

But that can be fixed later. Let's land the rest.

review: Approve

[Alan Griffiths (alan-griffiths)]

> We should not be using the system clock - our own timesource can be mocked to
> facilitate testing of time dependent scenarios.
>

And

991 +// mInfo->touchableRegion = touchable_region;
...
998 +// mInfo->layer = props.layer;

Comments shouldn't contain code

[Robert Carr (robertcarr)]

Fixed the comments

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:563
http://jenkins.qa.ubuntu.com/job/mir-ci/182/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/108
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/183
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/183/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:564
http://jenkins.qa.ubuntu.com/job/mir-ci/185/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/112
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/186/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2013-03-21 03:32:59 +0000
+++ examples/render_surfaces.cpp	2013-03-22 17:46:22 +0000
@@ -47,9 +47,9 @@
 namespace mc = mir::compositor;
 namespace ms = mir::surfaces;
 namespace mf = mir::frontend;
+namespace mi = mir::input;
 namespace geom = mir::geometry;
 namespace mt = mir::tools;
-namespace mi = mir::input;
 
 namespace
 {
@@ -194,6 +194,10 @@
     {
         return std::shared_ptr<mi::InputChannel>();
     }
+    void set_input_focus_to(std::shared_ptr<mi::SessionTarget> const& /* session */, 
+                            std::shared_ptr<mi::SurfaceTarget> const& /* surface */)
+    {
+    }
 };
 
 class RenderSurfacesCompositingStrategy : public mc::DefaultCompositingStrategy
 
=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2013-03-22 03:33:00 +0000
+++ include/server/mir/default_server_configuration.h	2013-03-22 17:46:22 +0000
@@ -52,6 +52,7 @@
 class SurfaceFactory;
 class SurfaceSource;
 class SurfaceBuilder;
+class InputFocusSelector;
 }
 namespace surfaces
 {
@@ -113,6 +114,7 @@
 
     virtual std::initializer_list<std::shared_ptr<input::EventFilter> const> the_event_filters();
     virtual std::shared_ptr<input::InputManager> the_input_manager();
+    virtual std::shared_ptr<shell::InputFocusSelector> the_input_focus_selector();
 
     virtual std::shared_ptr<shell::SurfaceBuilder> the_surface_builder();
 
 
=== modified file 'include/server/mir/input/input_manager.h'
--- include/server/mir/input/input_manager.h	2013-03-21 03:32:59 +0000
+++ include/server/mir/input/input_manager.h	2013-03-22 17:46:22 +0000
@@ -21,6 +21,7 @@
 #define MIR_INPUT_INPUT_MANAGER_H_
 
 #include "mir/input/input_channel_factory.h"
+#include "mir/shell/input_focus_selector.h"
 
 #include <memory>
 
@@ -30,12 +31,15 @@
 {
 class ViewableArea;
 }
+
 namespace input
 {
 class EventFilter;
 class InputChannel;
+class SessionTarget;
+class SurfaceTarget;
 
-class InputManager : public InputChannelFactory
+class InputManager : public InputChannelFactory, public shell::InputFocusSelector
 {
 public:
     virtual void start() = 0;
@@ -43,6 +47,9 @@
     
     virtual std::shared_ptr<InputChannel> make_input_channel() = 0;
 
+    virtual void set_input_focus_to(std::shared_ptr<input::SessionTarget> const& session,
+                                    std::shared_ptr<input::SurfaceTarget> const& surface) = 0;
+
 protected:
     InputManager() {};
     virtual ~InputManager() {}
 
=== added file 'include/server/mir/input/session_target.h'
--- include/server/mir/input/session_target.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/input/session_target.h	2013-03-22 17:46:22 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_SESSION_TARGET_H_
+#define MIR_INPUT_SESSION_TARGET_H_
+
+#include <string>
+
+namespace mir
+{
+namespace input
+{
+
+class SessionTarget
+{
+public:
+    virtual ~SessionTarget() {}
+  
+    virtual std::string name() const = 0;
+
+protected:
+    SessionTarget() = default;
+    SessionTarget(SessionTarget const&) = delete;
+    SessionTarget& operator=(SessionTarget const&) = delete;
+};
+
+}
+} // namespace mir
+
+#endif // MIR_INPUT_SESSION_TARGET_H_
 
=== added file 'include/server/mir/input/surface_target.h'
--- include/server/mir/input/surface_target.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/input/surface_target.h	2013-03-22 17:46:22 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_SURFACE_TARGET_H_
+#define MIR_INPUT_SURFACE_TARGET_H_
+
+#include "mir/geometry/size.h"
+
+#include <string>
+
+namespace mir
+{
+namespace input
+{
+
+class SurfaceTarget
+{
+public:
+    virtual ~SurfaceTarget() {}
+    
+    virtual geometry::Size size() const = 0;
+    virtual std::string name() const = 0;
+    
+    virtual int server_input_fd() const = 0;    
+
+protected:
+    SurfaceTarget() = default;
+    SurfaceTarget(SurfaceTarget const&) = delete;
+    SurfaceTarget& operator=(SurfaceTarget const&) = delete;
+};
+
+}
+} // namespace mir
+
+#endif // MIR_INPUT_SURFACE_TARGET_H_
 
=== modified file 'include/server/mir/shell/application_session.h'
--- include/server/mir/shell/application_session.h	2013-03-22 03:33:00 +0000
+++ include/server/mir/shell/application_session.h	2013-03-22 17:46:22 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_SHELL_APPLICATION_SESSION_H_
 #define MIR_SHELL_APPLICATION_SESSION_H_
 
-#include "mir/frontend/session.h"
+#include "mir/shell/session.h"
 
 #include <map>
 
@@ -31,7 +31,7 @@
 class SurfaceFactory;
 class Surface;
 
-class ApplicationSession : public frontend::Session
+class ApplicationSession : public Session
 {
 public:
     explicit ApplicationSession(std::shared_ptr<SurfaceFactory> const& surface_factory, std::string const& session_name);
@@ -41,6 +41,8 @@
     void destroy_surface(frontend::SurfaceId surface);
     std::shared_ptr<frontend::Surface> get_surface(frontend::SurfaceId surface) const;
 
+    std::shared_ptr<Surface> default_surface() const;
+
     std::string name() const;
 
     void shutdown();
 
=== modified file 'include/server/mir/shell/focus_setter.h'
--- include/server/mir/shell/focus_setter.h	2013-03-21 03:32:59 +0000
+++ include/server/mir/shell/focus_setter.h	2013-03-22 17:46:22 +0000
@@ -23,20 +23,17 @@
 
 namespace mir
 {
-namespace frontend
+
+namespace shell
 {
 class Session;
-}
-
-namespace shell
-{
 
 class FocusSetter
 {
 public:
     virtual ~FocusSetter() {}
 
-    virtual void set_focus_to(std::shared_ptr<frontend::Session> const& new_focus) = 0;
+    virtual void set_focus_to(std::shared_ptr<shell::Session> const& new_focus) = 0;
 
 protected:
     FocusSetter() = default;
 
=== added file 'include/server/mir/shell/input_focus_selector.h'
--- include/server/mir/shell/input_focus_selector.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/shell/input_focus_selector.h	2013-03-22 17:46:22 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: 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/session.h'
--- include/server/mir/shell/session.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/shell/session.h	2013-03-22 17:46:22 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored By: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_SHELL_SESSION_H_
+#define MIR_SHELL_SESSION_H_
+
+#include "mir/frontend/session.h"
+#include "mir/input/session_target.h"
+
+#include <mutex>
+#include <atomic>
+#include <memory>
+#include <string>
+
+namespace mir
+{
+
+namespace shell
+{
+class Surface;
+
+class Session : public frontend::Session, public input::SessionTarget
+{
+public:
+    virtual ~Session() {}
+
+    virtual frontend::SurfaceId create_surface(frontend::SurfaceCreationParameters const& params) = 0;
+    virtual void destroy_surface(frontend::SurfaceId surface) = 0;
+    virtual std::shared_ptr<frontend::Surface> get_surface(frontend::SurfaceId surface) const = 0;
+
+    virtual std::string name() const = 0; 
+    virtual void shutdown() = 0;
+
+    virtual void hide() = 0;
+    virtual void show() = 0;
+
+    virtual std::shared_ptr<Surface> default_surface() const = 0;
+
+protected:
+    Session() = default;
+    Session(Session const&) = delete;
+    Session& operator=(Session const&) = delete;
+};
+
+}
+}
+
+#endif // MIR_SHELL_SESSION_H_
 
=== renamed file 'include/server/mir/frontend/session_container.h' => 'include/server/mir/shell/session_container.h'
--- include/server/mir/frontend/session_container.h	2013-03-21 03:32:59 +0000
+++ include/server/mir/shell/session_container.h	2013-03-22 17:46:22 +0000
@@ -16,8 +16,8 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef FRONTEND_SESSION_CONTAINER_H_
-#define FRONTEND_SESSION_CONTAINER_H_
+#ifndef MIR_SHELL_SESSION_CONTAINER_H_
+#define MIR_SHELL_SESSION_CONTAINER_H_
 
 #include <vector>
 #include <memory>
@@ -56,4 +56,4 @@
 }
 
 
-#endif // FRONTEND_SESSION_CONTAINER_H_
+#endif // MIR_SHELL_SESSION_CONTAINER_H_
 
=== modified file 'include/server/mir/shell/single_visibility_focus_mechanism.h'
--- include/server/mir/shell/single_visibility_focus_mechanism.h	2013-03-21 03:32:59 +0000
+++ include/server/mir/shell/single_visibility_focus_mechanism.h	2013-03-22 17:46:22 +0000
@@ -24,28 +24,27 @@
 
 namespace mir
 {
-namespace frontend
-{
-class Session;
-}
 
 namespace shell
 {
 class SessionContainer;
+class InputFocusSelector;
 
 class SingleVisibilityFocusMechanism : public FocusSetter
 {
 public:
-    explicit SingleVisibilityFocusMechanism(std::shared_ptr<SessionContainer> const& app_container);
+    explicit SingleVisibilityFocusMechanism(std::shared_ptr<SessionContainer> const& app_container,
+                                            std::shared_ptr<shell::InputFocusSelector> const& input_selector);
     virtual ~SingleVisibilityFocusMechanism() {}
 
-    void set_focus_to(std::shared_ptr<frontend::Session> const& new_focus);
+    void set_focus_to(std::shared_ptr<shell::Session> const& new_focus);
 
 protected:
     SingleVisibilityFocusMechanism(const SingleVisibilityFocusMechanism&) = delete;
     SingleVisibilityFocusMechanism& operator=(const SingleVisibilityFocusMechanism&) = delete;
 private:
-    std::shared_ptr<SessionContainer> app_container;
+    std::shared_ptr<SessionContainer> const app_container;
+    std::shared_ptr<shell::InputFocusSelector> const input_selector;
 };
 
 }
 
=== modified file 'include/test/mir_test/wait_condition.h'
--- include/test/mir_test/wait_condition.h	2013-03-13 04:54:15 +0000
+++ include/test/mir_test/wait_condition.h	2013-03-22 17:46:22 +0000
@@ -55,6 +55,10 @@
     wait_condition->wake_up_everyone();
     return false;
 }
+ACTION_P(WakeUp, wait_condition)
+{
+    wait_condition->wake_up_everyone();
+}
 }
 
 #endif // MIR_TEST_WAIT_CONDITION_H_
 
=== modified file 'include/test/mir_test_doubles/mock_focus_setter.h'
--- include/test/mir_test_doubles/mock_focus_setter.h	2013-03-15 23:15:45 +0000
+++ include/test/mir_test_doubles/mock_focus_setter.h	2013-03-22 17:46:22 +0000
@@ -32,7 +32,7 @@
 
 struct MockFocusSetter : public shell::FocusSetter
 {
-    MOCK_METHOD1(set_focus_to, void(std::shared_ptr<frontend::Session> const&));
+    MOCK_METHOD1(set_focus_to, void(std::shared_ptr<shell::Session> const&));
 };
 
 }
 
=== added file 'include/test/mir_test_doubles/mock_input_focus_selector.h'
--- include/test/mir_test_doubles/mock_input_focus_selector.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_input_focus_selector.h	2013-03-22 17:46:22 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: 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_
 
=== modified file 'include/test/mir_test_doubles/mock_input_manager.h'
--- include/test/mir_test_doubles/mock_input_manager.h	2013-03-21 03:32:59 +0000
+++ include/test/mir_test_doubles/mock_input_manager.h	2013-03-22 17:46:22 +0000
@@ -37,6 +37,7 @@
     MOCK_METHOD0(stop, void());
     
     MOCK_METHOD0(make_input_channel, std::shared_ptr<input::InputChannel>());
+    MOCK_METHOD2(set_input_focus_to, void(std::shared_ptr<input::SessionTarget> const& session, std::shared_ptr<input::SurfaceTarget> const& surface));
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/mock_surface.h'
--- include/test/mir_test_doubles/mock_surface.h	2013-03-21 03:32:59 +0000
+++ include/test/mir_test_doubles/mock_surface.h	2013-03-22 17:46:22 +0000
@@ -21,6 +21,10 @@
 
 #include "src/server/shell/surface.h"
 
+#include "mir/frontend/surface_creation_parameters.h"
+
+#include <gmock/gmock.h>
+
 #include <memory>
 
 namespace mir
@@ -43,12 +47,14 @@
     MOCK_METHOD0(shutdown, void());
     MOCK_METHOD0(advance_client_buffer, void());
 
+    MOCK_CONST_METHOD0(name, std::string ());
     MOCK_CONST_METHOD0(size, geometry::Size ());
     MOCK_CONST_METHOD0(pixel_format, geometry::PixelFormat ());
     MOCK_CONST_METHOD0(client_buffer, std::shared_ptr<compositor::Buffer> ());
     
     MOCK_CONST_METHOD0(supports_input, bool());
     MOCK_CONST_METHOD0(client_input_fd, int());
+    MOCK_CONST_METHOD0(server_input_fd, int());
 
     MOCK_METHOD2(configure, int(MirSurfaceAttrib, int));
 };
 
=== added file 'include/test/mir_test_doubles/stub_session_target.h'
--- include/test/mir_test_doubles/stub_session_target.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_session_target.h	2013-03-22 17:46:22 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_SESSION_TARGET_H_
+#define MIR_TEST_DOUBLES_STUB_SESSION_TARGET_H_
+
+#include "mir/input/session_target.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubSessionTarget : public input::SessionTarget
+{
+    std::string name() const override
+    {
+        return std::string();
+    }
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_TEST_DOUBLES_STUB_SESSION_TARGET_H_
+
 
=== added file 'include/test/mir_test_doubles/stub_surface_target.h'
--- include/test/mir_test_doubles/stub_surface_target.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_surface_target.h	2013-03-22 17:46:22 +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 Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_SURFACE_TARGET_H_
+#define MIR_TEST_DOUBLES_STUB_SURFACE_TARGET_H_
+
+#include "mir/input/surface_target.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubSurfaceTarget : public input::SurfaceTarget
+{
+    StubSurfaceTarget(int fd)
+      : input_fd(fd)
+    {
+    }
+    
+    int server_input_fd() const override
+    {
+        return input_fd;
+    }
+    geometry::Size size() const override
+    {
+        return geometry::Size();
+    }
+    std::string name() const override
+    {
+        return std::string();
+    }
+    
+    int input_fd;
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_TEST_DOUBLES_STUB_SURFACE_TARGET_H_
+
 
=== modified file 'include/test/mir_test_framework/testing_server_configuration.h'
--- include/test/mir_test_framework/testing_server_configuration.h	2013-03-13 04:54:15 +0000
+++ include/test/mir_test_framework/testing_server_configuration.h	2013-03-22 17:46:22 +0000
@@ -53,6 +53,7 @@
     virtual std::string the_socket_file() const;
     using DefaultServerConfiguration::the_options;
 
+
 private:
     std::shared_ptr<graphics::Platform> graphics_platform;
 };
 
=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2013-03-22 17:08:01 +0000
+++ src/server/default_server_configuration.cpp	2013-03-22 17:46:22 +0000
@@ -33,7 +33,7 @@
 #include "mir/shell/session_manager.h"
 #include "mir/shell/registration_order_focus_sequence.h"
 #include "mir/shell/single_visibility_focus_mechanism.h"
-#include "mir/frontend/session_container.h"
+#include "mir/shell/session_container.h"
 #include "mir/shell/consuming_placement_strategy.h"
 #include "mir/shell/organising_surface_factory.h"
 #include "mir/graphics/display.h"
@@ -266,7 +266,7 @@
         [this]() -> std::shared_ptr<msh::SessionManager>
         {
             auto session_container = std::make_shared<msh::SessionContainer>();
-            auto focus_mechanism = std::make_shared<msh::SingleVisibilityFocusMechanism>(session_container);
+            auto focus_mechanism = std::make_shared<msh::SingleVisibilityFocusMechanism>(session_container, the_input_focus_selector());
             auto focus_selection_strategy = std::make_shared<msh::RegistrationOrderFocusSequence>(session_container);
 
             auto placement_strategy = std::make_shared<msh::ConsumingPlacementStrategy>(the_display());
@@ -455,3 +455,8 @@
 {
     return the_input_manager();
 }
+
+std::shared_ptr<msh::InputFocusSelector> mir::DefaultServerConfiguration::the_input_focus_selector()
+{
+    return the_input_manager();
+}
 
=== modified file 'src/server/input/android/CMakeLists.txt'
--- src/server/input/android/CMakeLists.txt	2013-03-21 03:32:59 +0000
+++ src/server/input/android/CMakeLists.txt	2013-03-22 17:46:22 +0000
@@ -8,6 +8,8 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/rudimentary_input_reader_policy.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/event_filter_dispatcher_policy.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/default_android_input_configuration.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_application_handle.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_window_handle.cpp
 )
 
 set(
 
=== added file 'src/server/input/android/android_input_application_handle.cpp'
--- src/server/input/android/android_input_application_handle.cpp	1970-01-01 00:00:00 +0000
+++ src/server/input/android/android_input_application_handle.cpp	2013-03-22 17:46:22 +0000
@@ -0,0 +1,42 @@
+/*
+ * 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]>
+ */
+
+#include "android_input_application_handle.h"
+
+#include "mir/input/session_target.h"
+
+#include <limits.h>
+
+namespace mi = mir::input;
+namespace mia = mi::android;
+
+mia::InputApplicationHandle::InputApplicationHandle(std::shared_ptr<mi::SessionTarget> const& session)
+  : session(session)
+{
+    updateInfo();
+}
+
+bool mia::InputApplicationHandle::updateInfo()
+{
+    if (mInfo == NULL)
+        mInfo = new droidinput::InputApplicationInfo;
+    mInfo->dispatchingTimeout = INT_MAX;
+    mInfo->name = droidinput::String8(session->name().c_str());
+
+    return true;
+}
 
=== added file 'src/server/input/android/android_input_application_handle.h'
--- src/server/input/android/android_input_application_handle.h	1970-01-01 00:00:00 +0000
+++ src/server/input/android/android_input_application_handle.h	2013-03-22 17:46:22 +0000
@@ -0,0 +1,58 @@
+/*
+ * 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_INPUT_ANDROID_INPUT_APPLICATION_HANDLE_H_
+#define MIR_INPUT_ANDROID_INPUT_APPLICATION_HANDLE_H_
+
+#include <InputApplication.h>
+
+#include <memory>
+
+namespace droidinput = android;
+
+namespace mir
+{
+
+namespace input
+{
+class SessionTarget;
+
+namespace android
+{
+
+class InputApplicationHandle : public droidinput::InputApplicationHandle
+{
+public:
+    InputApplicationHandle(std::shared_ptr<input::SessionTarget> const& surface);
+    ~InputApplicationHandle() {}
+
+    bool updateInfo();
+
+protected:
+    InputApplicationHandle(InputApplicationHandle const&) = delete;
+    InputApplicationHandle& operator=(InputApplicationHandle const&) = delete;
+
+private:
+    std::shared_ptr<input::SessionTarget> session;
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_INPUT_ANDROID_INPUT_APPLICATION_HANDLE_H_
 
=== modified file 'src/server/input/android/android_input_manager.cpp'
--- src/server/input/android/android_input_manager.cpp	2013-03-21 03:32:59 +0000
+++ src/server/input/android/android_input_manager.cpp	2013-03-22 17:46:22 +0000
@@ -18,12 +18,16 @@
  */
 
 #include "mir/graphics/viewable_area.h"
+#include "mir/input/session_target.h"
+#include "mir/input/surface_target.h"
 
 #include "android_input_manager.h"
 #include "android_input_constants.h"
 #include "android_input_configuration.h"
 #include "android_input_thread.h"
 #include "android_input_channel.h"
+#include "android_input_window_handle.h"
+#include "android_input_application_handle.h"
 #include "default_android_input_configuration.h"
 
 #include <EventHub.h>
@@ -40,7 +44,8 @@
   : event_hub(config->the_event_hub()),
     dispatcher(config->the_dispatcher()),
     reader_thread(config->the_reader_thread()),
-    dispatcher_thread(config->the_dispatcher_thread())
+    dispatcher_thread(config->the_dispatcher_thread()),
+    focused_window_handle(0)
 {
 }
 
@@ -73,6 +78,28 @@
     return std::make_shared<mia::AndroidInputChannel>();
 }
 
+void mia::InputManager::set_input_focus_to(std::shared_ptr<mi::SessionTarget> const& session, std::shared_ptr<mi::SurfaceTarget> const& surface)
+{
+    if (focused_window_handle.get())
+    {
+        dispatcher->unregisterInputChannel(focused_window_handle->getInfo()->inputChannel);
+        focused_window_handle.clear();
+        focused_application_handle.clear();
+    }
+
+    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);
+        dispatcher->setFocusedApplication(focused_application_handle);
+
+        dispatcher->registerInputChannel(focused_window_handle->getInfo()->inputChannel, focused_window_handle, false);
+        windows.push_back(focused_window_handle);
+    }
+    dispatcher->setInputWindows(windows);
+}
+
 std::shared_ptr<mi::InputManager> mi::create_input_manager(
     const std::initializer_list<std::shared_ptr<mi::EventFilter> const>& event_filters,
     std::shared_ptr<mg::ViewableArea> const& view_area)
 
=== modified file 'src/server/input/android/android_input_manager.h'
--- src/server/input/android/android_input_manager.h	2013-03-21 03:32:59 +0000
+++ src/server/input/android/android_input_manager.h	2013-03-22 17:46:22 +0000
@@ -30,6 +30,8 @@
 {
 class EventHubInterface;
 class InputDispatcherInterface;
+class InputWindowHandle;
+class InputApplicationHandle;
 }
 
 namespace droidinput = android;
@@ -40,6 +42,7 @@
 {
 class ViewableArea;
 }
+
 namespace input
 {
 class CursorListener;
@@ -61,6 +64,7 @@
     
     std::shared_ptr<InputChannel> make_input_channel();
     
+    void set_input_focus_to(std::shared_ptr<input::SessionTarget> const& session, std::shared_ptr<input::SurfaceTarget> const& surface);
 
 protected:
     InputManager(const InputManager&) = delete;
@@ -72,6 +76,9 @@
 
     std::shared_ptr<InputThread> reader_thread;
     std::shared_ptr<InputThread> dispatcher_thread;
+    
+    droidinput::sp<droidinput::InputWindowHandle> focused_window_handle;
+    droidinput::sp<droidinput::InputApplicationHandle> focused_application_handle;
 };
 
 }
 
=== added file 'src/server/input/android/android_input_window_handle.cpp'
--- src/server/input/android/android_input_window_handle.cpp	1970-01-01 00:00:00 +0000
+++ src/server/input/android/android_input_window_handle.cpp	2013-03-22 17:46:22 +0000
@@ -0,0 +1,74 @@
+/*
+ * 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]>
+ */
+
+#include "android_input_window_handle.h"
+#include "android_input_application_handle.h"
+
+#include "mir/input/input_channel.h"
+#include "mir/input/surface_target.h"
+
+#include <androidfw/InputTransport.h>
+
+#include <limits.h>
+
+namespace mi = mir::input;
+namespace mia = mi::android;
+
+mia::InputWindowHandle::InputWindowHandle(droidinput::sp<droidinput::InputApplicationHandle> const& input_app_handle,
+                                          std::shared_ptr<mi::SurfaceTarget> const& surface)
+  : droidinput::InputWindowHandle(input_app_handle),
+    surface(surface)
+{
+    updateInfo();
+}
+
+bool mia::InputWindowHandle::updateInfo()
+{
+    if (!mInfo)
+    {
+        mInfo = new droidinput::InputWindowInfo();
+
+        // TODO: How can we avoid recreating the InputChannel which the InputChannelFactory has already created?
+        mInfo->inputChannel = new droidinput::InputChannel(droidinput::String8("TODO: Name"),
+                                                           surface->server_input_fd());
+    }
+    
+    mInfo->frameLeft = 0;
+    mInfo->frameTop = 0;
+    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->name = droidinput::String8(surface->name().c_str());
+    mInfo->layoutParamsFlags = droidinput::InputWindowInfo::FLAG_NOT_TOUCH_MODAL;
+    mInfo->layoutParamsType = droidinput::InputWindowInfo::TYPE_APPLICATION;
+    mInfo->scaleFactor = 1.f;
+    mInfo->visible = true;
+    mInfo->canReceiveKeys = true;
+    mInfo->hasFocus = true;
+    mInfo->hasWallpaper = false;
+    mInfo->paused = false;
+    mInfo->dispatchingTimeout = INT_MAX;
+    mInfo->ownerPid = 0;
+    mInfo->ownerUid = 0;
+    mInfo->inputFeatures = 0;
+
+    // TODO: Set touchableRegion and layer for touch events.
+    
+    return true;
+}
 
=== added file 'src/server/input/android/android_input_window_handle.h'
--- src/server/input/android/android_input_window_handle.h	1970-01-01 00:00:00 +0000
+++ src/server/input/android/android_input_window_handle.h	2013-03-22 17:46:22 +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_INPUT_ANDROID_INPUT_WINDOW_HANDLE_H_
+#define MIR_INPUT_ANDROID_INPUT_WINDOW_HANDLE_H_
+
+#include <InputWindow.h>
+
+#include <memory>
+
+namespace droidinput = android;
+
+namespace mir
+{
+
+namespace input
+{
+class SurfaceTarget;
+
+namespace android
+{
+
+class InputWindowHandle : public droidinput::InputWindowHandle
+{
+public:
+    InputWindowHandle(droidinput::sp<droidinput::InputApplicationHandle> const& input_app_handle,
+                      std::shared_ptr<input::SurfaceTarget> const& surface);
+    ~InputWindowHandle() {}
+
+    bool updateInfo();
+
+protected:
+    InputWindowHandle(InputWindowHandle const&) = delete;
+    InputWindowHandle& operator=(InputWindowHandle const&) = delete;
+
+private:
+    std::shared_ptr<input::SurfaceTarget> surface;
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_INPUT_ANDROID_INPUT_WINDOW_HANDLE_H_
 
=== modified file 'src/server/input/android/default_android_input_configuration.cpp'
--- src/server/input/android/default_android_input_configuration.cpp	2013-03-06 17:01:51 +0000
+++ src/server/input/android/default_android_input_configuration.cpp	2013-03-22 17:46:22 +0000
@@ -26,6 +26,8 @@
 #include <InputDispatcher.h>
 #include <InputReader.h>
 
+#include <string>
+
 namespace droidinput = android;
 
 namespace mi = mir::input;
 
=== modified file 'src/server/input/android/event_filter_dispatcher_policy.cpp'
--- src/server/input/android/event_filter_dispatcher_policy.cpp	2013-03-13 04:54:15 +0000
+++ src/server/input/android/event_filter_dispatcher_policy.cpp	2013-03-22 17:46:22 +0000
@@ -39,5 +39,5 @@
 
 void mia::EventFilterDispatcherPolicy::interceptKeyBeforeQueueing(const droidinput::KeyEvent* /*key_event*/, uint32_t& policy_flags)
 {
-    policy_flags = droidinput::POLICY_FLAG_FILTERED;
+    policy_flags |= droidinput::POLICY_FLAG_PASS_TO_USER;
 }
 
=== modified file 'src/server/input/dummy_input_manager.cpp'
--- src/server/input/dummy_input_manager.cpp	2013-03-21 03:32:59 +0000
+++ src/server/input/dummy_input_manager.cpp	2013-03-22 17:46:22 +0000
@@ -28,6 +28,9 @@
     void stop() {}
     void start() {}
     virtual std::shared_ptr<mi::InputChannel> make_input_channel() { return std::shared_ptr<mi::InputChannel>(); }
+    void set_input_focus_to(std::shared_ptr<mi::SessionTarget> const& /* session */, std::shared_ptr<mi::SurfaceTarget> const& /* surface */)
+    {
+    }
 }; 
 }
 
 
=== modified file 'src/server/shell/application_session.cpp'
--- src/server/shell/application_session.cpp	2013-03-22 03:33:00 +0000
+++ src/server/shell/application_session.cpp	2013-03-22 17:46:22 +0000
@@ -82,6 +82,14 @@
     return checked_find(id)->second;
 }
 
+std::shared_ptr<msh::Surface> msh::ApplicationSession::default_surface() const
+{
+    if (surfaces.size())
+        return surfaces.begin()->second;
+    else
+        return std::shared_ptr<msh::Surface>();
+}
+
 void msh::ApplicationSession::destroy_surface(mf::SurfaceId id)
 {
     std::unique_lock<std::mutex> lock(surfaces_mutex);
 
=== modified file 'src/server/shell/registration_order_focus_sequence.cpp'
--- src/server/shell/registration_order_focus_sequence.cpp	2013-03-21 03:32:59 +0000
+++ src/server/shell/registration_order_focus_sequence.cpp	2013-03-22 17:46:22 +0000
@@ -18,7 +18,7 @@
 
 #include "mir/shell/registration_order_focus_sequence.h"
 #include "mir/frontend/session.h"
-#include "mir/frontend/session_container.h"
+#include "mir/shell/session_container.h"
 
 #include <boost/throw_exception.hpp>
 
 
=== modified file 'src/server/shell/session_container.cpp'
--- src/server/shell/session_container.cpp	2013-03-21 03:32:59 +0000
+++ src/server/shell/session_container.cpp	2013-03-22 17:46:22 +0000
@@ -16,7 +16,7 @@
  * Authored By: Robert Carr <[e-mail]>
  */
 
-#include "mir/frontend/session_container.h"
+#include "mir/shell/session_container.h"
 #include "mir/frontend/session.h"
 
 #include <boost/throw_exception.hpp>
@@ -42,7 +42,6 @@
 void msh::SessionContainer::insert_session(std::shared_ptr<mf::Session> const& session)
 {
     std::unique_lock<std::mutex> lk(guard);
-    auto name = session->name();
 
     apps.push_back(session);
 }
 
=== modified file 'src/server/shell/session_manager.cpp'
--- src/server/shell/session_manager.cpp	2013-03-21 03:32:59 +0000
+++ src/server/shell/session_manager.cpp	2013-03-22 17:46:22 +0000
@@ -18,10 +18,11 @@
 
 #include "mir/shell/session_manager.h"
 #include "mir/shell/application_session.h"
-#include "mir/frontend/session_container.h"
+#include "mir/shell/session_container.h"
 #include "mir/shell/surface_factory.h"
 #include "mir/shell/focus_sequence.h"
 #include "mir/shell/focus_setter.h"
+#include "mir/shell/session.h"
 
 #include <memory>
 #include <cassert>
@@ -67,8 +68,9 @@
 
 inline void msh::SessionManager::set_focus_to(std::shared_ptr<mf::Session> const& next_focus)
 {
-    focus_application = next_focus;
-    focus_setter->set_focus_to(next_focus);
+    auto shell_session = std::dynamic_pointer_cast<msh::Session>(next_focus);
+    focus_application = shell_session;
+    focus_setter->set_focus_to(shell_session);
 }
 
 void msh::SessionManager::close_session(std::shared_ptr<mf::Session> const& session)
 
=== modified file 'src/server/shell/single_visibility_focus_mechanism.cpp'
--- src/server/shell/single_visibility_focus_mechanism.cpp	2013-03-21 03:32:59 +0000
+++ src/server/shell/single_visibility_focus_mechanism.cpp	2013-03-22 17:46:22 +0000
@@ -16,25 +16,33 @@
  * Authored By: Robert Carr <[e-mail]>
  */
 
-#include "mir/frontend/session_container.h"
+#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 "surface.h" // TODO: Cleanup headers ~racarr
 
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 
-msh::SingleVisibilityFocusMechanism::SingleVisibilityFocusMechanism(std::shared_ptr<msh::SessionContainer> const& app_container) :
-  app_container(app_container)
+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)
 {
 }
 
-void msh::SingleVisibilityFocusMechanism::set_focus_to(std::shared_ptr<mf::Session> const& focus_session)
+void msh::SingleVisibilityFocusMechanism::set_focus_to(std::shared_ptr<msh::Session> const& focus_session)
 {
     app_container->for_each(
         [&](std::shared_ptr<mf::Session> const& session) {
         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-03-21 04:03:36 +0000
+++ src/server/shell/surface.cpp	2013-03-22 17:46:22 +0000
@@ -89,6 +89,18 @@
     }
 }
 
+std::string msh::Surface::name() const
+{
+    if (auto const& s = surface.lock())
+    {
+        return s->name();
+    }
+    else
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface"));
+    }
+}
+
 mir::geometry::PixelFormat msh::Surface::pixel_format() const
 {
     if (auto const& s = surface.lock())
@@ -135,6 +147,13 @@
     return input_channel->client_fd();
 }
 
+int msh::Surface::server_input_fd() const
+{
+    if (!supports_input())
+        BOOST_THROW_EXCEPTION(std::logic_error("Surface does not support input"));
+    return input_channel->server_fd();
+}
+
 int msh::Surface::configure(MirSurfaceAttrib attrib, int value)
 {
     int result = 0;
 
=== modified file 'src/server/shell/surface.h'
--- src/server/shell/surface.h	2013-03-21 04:03:36 +0000
+++ src/server/shell/surface.h	2013-03-22 17:46:22 +0000
@@ -22,8 +22,12 @@
 
 #include "mir/frontend/surface.h"
 #include "mir/surfaces/surface.h"
+#include "mir/input/surface_target.h"
+
 #include "mir_toolkit/common.h"
 
+#include <string>
+
 namespace mir
 {
 namespace frontend
@@ -39,7 +43,7 @@
 {
 class SurfaceBuilder;
 
-class Surface : public frontend::Surface
+class Surface : public frontend::Surface, public input::SurfaceTarget
 {
 public:
     Surface(
@@ -56,6 +60,8 @@
 
     virtual void shutdown();
 
+    virtual std::string name() const;
+
     virtual geometry::Size size() const;
 
     virtual geometry::PixelFormat pixel_format() const;
@@ -66,6 +72,7 @@
 
     virtual bool supports_input() const;
     virtual int client_input_fd() const;
+    virtual int server_input_fd() const;
 
     virtual int configure(MirSurfaceAttrib attrib, int value);
     virtual MirSurfaceType type() const;
 
=== modified file 'tests/acceptance-tests/CMakeLists.txt'
--- tests/acceptance-tests/CMakeLists.txt	2013-03-21 03:32:59 +0000
+++ tests/acceptance-tests/CMakeLists.txt	2013-03-22 17:46:22 +0000
@@ -9,7 +9,7 @@
   test_surfaceloop.cpp
   test_test_framework.cpp
   test_focus_management_api.cpp
-  test_surface_focus.cpp
+  test_focus_selection.cpp
 )
 
 # TODO Disabled in binder version as this test uses detect_server() and that
 
=== renamed file 'tests/acceptance-tests/test_surface_focus.cpp' => 'tests/acceptance-tests/test_focus_selection.cpp'
--- tests/acceptance-tests/test_surface_focus.cpp	2013-03-15 23:15:45 +0000
+++ tests/acceptance-tests/test_focus_selection.cpp	2013-03-22 17:46:22 +0000
@@ -18,21 +18,24 @@
 
 #include "mir_toolkit/mir_client_library.h"
 
-#include "mir/frontend/session_container.h"
+#include "mir/shell/session_container.h"
 #include "mir/shell/registration_order_focus_sequence.h"
 #include "mir/shell/consuming_placement_strategy.h"
 #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_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 <gtest/gtest.h>
 #include <gmock/gmock.h>
 
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
+namespace mi = mir::input;
 namespace mtd = mir::test::doubles;
 namespace mtf = mir_test_framework;
 
@@ -87,13 +90,48 @@
     MirConnection* connection;
     MirSurface* surface;
 };
+
+struct SurfaceCreatingClient : ClientConfigCommon
+{
+    void exec()
+    {
+        mir_wait_for(mir_connect(
+            mir_test_socket,
+            __PRETTY_FUNCTION__,
+            connection_callback,
+            this));
+         ASSERT_TRUE(connection != NULL);
+         MirSurfaceParameters const request_params =
+        {
+            __PRETTY_FUNCTION__,
+            640, 480,
+            mir_pixel_format_abgr_8888,
+            mir_buffer_usage_hardware
+        };
+         mir_wait_for(mir_surface_create(connection, &request_params, create_surface_callback, this));
+         mir_connection_release(connection);
+    }
+};
+
 }
 
 namespace
 {
 MATCHER(NonNullSession, "")
 {
-    return arg != std::shared_ptr<mf::Session>();
+    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>();
 }
 }
 
@@ -132,31 +170,46 @@
 
     launch_server_process(server_config);
 
-    struct ClientConfig : ClientConfigCommon
+    SurfaceCreatingClient client;
+    
+    launch_client_process(client);
+}
+
+TEST_F(BespokeDisplayServerTestFixture, surfaces_receive_input_focus_when_created)
+{
+    struct ServerConfig : TestingServerConfiguration
     {
-        void exec()
-        {
-            mir_wait_for(mir_connect(
-                mir_test_socket,
-                __PRETTY_FUNCTION__,
-                connection_callback,
-                this));
-
-            ASSERT_TRUE(connection != NULL);
-
-            MirSurfaceParameters const request_params =
+        std::shared_ptr<mtd::MockInputFocusSelector> focus_selector;
+        bool expected;
+        
+        ServerConfig()
+          : focus_selector(std::make_shared<mtd::MockInputFocusSelector>()),
+            expected(false)
+        {
+        }
+            
+        std::shared_ptr<msh::InputFocusSelector>
+        the_input_focus_selector() override
+        {
+            using namespace ::testing;
+
+            if (!expected)
             {
-                __PRETTY_FUNCTION__,
-                640, 480,
-                mir_pixel_format_abgr_8888,
-                mir_buffer_usage_hardware
-            };
-
-            mir_wait_for(mir_surface_create(connection, &request_params, create_surface_callback, this));
-
-            mir_connection_release(connection);
+                InSequence seq;
+
+                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;
+            }
+                
+            return focus_selector;
         }
-    } focus_config;
+    } server_config;
+
+        
+    launch_server_process(server_config);
+
+    SurfaceCreatingClient client;
     
-    launch_client_process(focus_config);
+    launch_client_process(client);
 }
 
=== modified file 'tests/behavior-tests/session_management_context.cpp'
--- tests/behavior-tests/session_management_context.cpp	2013-03-21 03:32:59 +0000
+++ tests/behavior-tests/session_management_context.cpp	2013-03-22 17:46:22 +0000
@@ -23,7 +23,7 @@
 #include "mir/frontend/session.h"
 #include "mir/shell/registration_order_focus_sequence.h"
 #include "mir/shell/single_visibility_focus_mechanism.h"
-#include "mir/frontend/session_container.h"
+#include "mir/shell/session_container.h"
 #include "mir/frontend/shell.h"
 #include "mir/input/input_channel.h"
 #include "mir/shell/surface_factory.h"
 
=== modified file 'tests/integration-tests/CMakeLists.txt'
--- tests/integration-tests/CMakeLists.txt	2013-03-19 09:51:24 +0000
+++ tests/integration-tests/CMakeLists.txt	2013-03-22 17:46:22 +0000
@@ -10,6 +10,7 @@
 add_subdirectory(client/)
 add_subdirectory(compositor/)
 add_subdirectory(frontend/)
+add_subdirectory(shell/)
 add_subdirectory(process/)
 if (NOT MIR_DISABLE_INPUT)
 add_subdirectory(input/)
 
=== modified file 'tests/integration-tests/cucumber/test_session_management_context.cpp'
--- tests/integration-tests/cucumber/test_session_management_context.cpp	2013-03-21 03:32:59 +0000
+++ tests/integration-tests/cucumber/test_session_management_context.cpp	2013-03-22 17:46:22 +0000
@@ -25,6 +25,8 @@
 #include "mir/graphics/viewable_area.h"
 
 #include "mir_test_doubles/mock_session.h"
+#include "mir_test_doubles/stub_surface_builder.h"
+#include "mir_test_doubles/mock_surface.h"
 #include "mir_test_doubles/mock_shell.h"
 #include "mir_test/fake_shared.h"
 
@@ -52,24 +54,6 @@
     MOCK_METHOD0(the_compositor, std::shared_ptr<mc::Compositor>());
 };
 
-struct MockSurface : public mf::Surface
-{
-    MOCK_METHOD0(hide, void());
-    MOCK_METHOD0(show, void());
-    MOCK_METHOD0(destroy, void());
-    MOCK_METHOD0(shutdown, void());
-    MOCK_METHOD0(advance_client_buffer, void());
-
-    MOCK_CONST_METHOD0(size, mir::geometry::Size ());
-    MOCK_CONST_METHOD0(pixel_format, mir::geometry::PixelFormat ());
-    MOCK_CONST_METHOD0(client_buffer, std::shared_ptr<mc::Buffer> ());
-
-    MOCK_METHOD2(configure, int(MirSurfaceAttrib, int));
-
-    MOCK_CONST_METHOD0(supports_input, bool());
-    MOCK_CONST_METHOD0(client_input_fd, int());
-};
-
 MATCHER_P(NamedWindowWithNoGeometry, name, "")
 {
     if (arg.name != name)
@@ -181,7 +165,7 @@
     using namespace ::testing;
 
     mtd::MockSession session;
-    MockSurface surface;
+    mtd::MockSurface surface(std::make_shared<mtd::StubSurfaceBuilder>());
 
     EXPECT_CALL(shell, open_session(test_window_name)).Times(1)
         .WillOnce(Return(mt::fake_shared<mf::Session>(session)));
 
=== modified file 'tests/integration-tests/frontend/CMakeLists.txt'
--- tests/integration-tests/frontend/CMakeLists.txt	2013-03-13 04:54:15 +0000
+++ tests/integration-tests/frontend/CMakeLists.txt	2013-03-22 17:46:22 +0000
@@ -1,7 +1,6 @@
 list(
   APPEND INTEGRATION_TESTS_SRCS
   ${CMAKE_CURRENT_SOURCE_DIR}/test_application_mediator_report.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_session_manager.cpp
 )
 
 set(
 
=== modified file 'tests/integration-tests/input/android/test_android_input_manager.cpp'
--- tests/integration-tests/input/android/test_android_input_manager.cpp	2013-03-21 03:32:59 +0000
+++ tests/integration-tests/input/android/test_android_input_manager.cpp	2013-03-22 17:46:22 +0000
@@ -18,22 +18,32 @@
  */
 
 #include "mir/input/event_filter.h"
+#include "mir/frontend/surface_creation_parameters.h"
+
 #include "src/server/input/android/default_android_input_configuration.h"
 #include "src/server/input/android/android_input_manager.h"
+#include "src/server/input/android/dummy_input_dispatcher_policy.h"
+#include "src/server/input/android/event_filter_dispatcher_policy.h"
 
 #include "mir_test/fake_shared.h"
 #include "mir_test/fake_event_hub.h"
 #include "mir_test/fake_event_hub_input_configuration.h"
 #include "mir_test_doubles/mock_event_filter.h"
 #include "mir_test_doubles/mock_viewable_area.h"
+#include "mir_test_doubles/stub_session_target.h"
+#include "mir_test_doubles/stub_surface_target.h"
 #include "mir_test/wait_condition.h"
 #include "mir_test/event_factory.h"
 
 #include <EventHub.h>
+#include <InputDispatcher.h>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include <sys/types.h>
+#include <sys/socket.h>
+
 namespace mi = mir::input;
 namespace mia = mir::input::android;
 namespace mis = mir::input::synthesis;
@@ -154,3 +164,111 @@
     wait_condition.wait_for_at_most_seconds(1);
 }
 
+namespace
+{
+
+struct MockDispatcherPolicy : public mia::EventFilterDispatcherPolicy
+{
+    MockDispatcherPolicy(std::shared_ptr<mi::EventFilter> const& filter)
+      : EventFilterDispatcherPolicy(filter)
+    {
+    }
+    MOCK_METHOD3(interceptKeyBeforeDispatching, nsecs_t(droidinput::sp<droidinput::InputWindowHandle> const&,
+                                                        droidinput::KeyEvent const*, uint32_t));
+};
+
+struct TestingInputConfiguration : public mtd::FakeEventHubInputConfiguration
+{
+    TestingInputConfiguration(std::shared_ptr<mi::EventFilter> const& filter,
+                              std::shared_ptr<mg::ViewableArea> const& view_area,
+                              std::shared_ptr<mi::CursorListener> const& cursor_listener)
+        : FakeEventHubInputConfiguration({}, view_area, cursor_listener),
+          dispatcher_policy(new MockDispatcherPolicy(filter))
+    {
+    }
+    droidinput::sp<droidinput::InputDispatcherPolicyInterface> the_dispatcher_policy()
+    {
+        return dispatcher_policy;
+    }
+    droidinput::sp<MockDispatcherPolicy> the_mock_dispatcher_policy()
+    {
+        return dispatcher_policy;
+    }
+
+    droidinput::sp<MockDispatcherPolicy> dispatcher_policy;
+};
+
+struct AndroidInputManagerDispatcherInterceptSetup : public testing::Test
+{
+    AndroidInputManagerDispatcherInterceptSetup()
+    {
+        configuration = std::make_shared<TestingInputConfiguration>(
+            mt::fake_shared(event_filter),
+            mt::fake_shared(viewable_area), null_cursor_listener);
+        fake_event_hub = configuration->the_fake_event_hub();
+
+        ON_CALL(viewable_area, view_area())
+            .WillByDefault(Return(default_view_area));
+        input_manager = std::make_shared<mia::InputManager>(configuration);
+        
+        dispatcher_policy = configuration->the_mock_dispatcher_policy();
+
+    }
+
+    // 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()
+    {
+        input_manager->stop();
+        close(test_input_fd);
+    }
+
+    MockEventFilter event_filter;
+    NiceMock<mtd::MockViewableArea> viewable_area;
+    std::shared_ptr<TestingInputConfiguration> configuration;
+    mia::FakeEventHub* fake_event_hub;
+    droidinput::sp<MockDispatcherPolicy> dispatcher_policy;
+
+    std::shared_ptr<mia::InputManager> input_manager;
+    
+    int test_input_fd;
+};
+
+MATCHER_P(WindowHandleWithInputFd, input_fd, "")
+{
+    if (arg->getInputChannel()->getFd() == input_fd)
+        return true;
+    return false;
+}
+
+}
+
+TEST_F(AndroidInputManagerDispatcherInterceptSetup, server_input_fd_of_focused_surface_is_sent_unfiltered_key_events)
+{
+    using namespace ::testing;
+
+    WaitCondition wait_condition;
+
+    mtd::StubSessionTarget session;
+    mtd::StubSurfaceTarget surface(test_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), _, _))
+        .Times(1).WillOnce(DoAll(WakeUp(&wait_condition), Return(-1)));
+    
+    input_manager->set_input_focus_to(mt::fake_shared(session), mt::fake_shared(surface));
+
+    fake_event_hub->synthesize_builtin_keyboard_added();
+    fake_event_hub->synthesize_device_scan_complete();
+    fake_event_hub->synthesize_event(mis::a_key_down_event()
+                                .of_scancode(KEY_ENTER));
+
+    wait_condition.wait_for_at_most_seconds(1);
+}
 
=== added directory 'tests/integration-tests/shell'
=== added file 'tests/integration-tests/shell/CMakeLists.txt'
--- tests/integration-tests/shell/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/shell/CMakeLists.txt	2013-03-22 17:46:22 +0000
@@ -0,0 +1,9 @@
+list(
+  APPEND INTEGRATION_TESTS_SRCS
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_session_manager.cpp
+)
+
+set(
+  INTEGRATION_TESTS_SRCS
+  ${INTEGRATION_TESTS_SRCS}
+  PARENT_SCOPE)
 
=== renamed file 'tests/integration-tests/frontend/test_session_manager.cpp' => 'tests/integration-tests/shell/test_session_manager.cpp'
--- tests/integration-tests/frontend/test_session_manager.cpp	2013-03-21 03:32:59 +0000
+++ tests/integration-tests/shell/test_session_manager.cpp	2013-03-22 17:46:22 +0000
@@ -17,13 +17,14 @@
  */
 
 #include "mir/shell/session_manager.h"
+#include "mir/shell/session.h"
+#include "mir/shell/focus_sequence.h"
+#include "mir/shell/focus_setter.h"
+#include "mir/shell/registration_order_focus_sequence.h"
+#include "mir/shell/session_container.h"
 #include "mir/surfaces/buffer_bundle.h"
 #include "mir/surfaces/surface.h"
 #include "mir/compositor/buffer_swapper.h"
-#include "mir/shell/focus_sequence.h"
-#include "mir/shell/focus_setter.h"
-#include "mir/shell/registration_order_focus_sequence.h"
-#include "mir/frontend/session_container.h"
 #include "mir/frontend/surface_creation_parameters.h"
 
 #include <gmock/gmock.h>
@@ -31,6 +32,7 @@
 #include "mir_test/gmock_fixes.h"
 #include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_surface_factory.h"
+#include "mir_test_doubles/mock_focus_setter.h"
 
 namespace mc = mir::compositor;
 namespace mf = mir::frontend;
@@ -39,23 +41,13 @@
 namespace mt = mir::test;
 namespace mtd = mir::test::doubles;
 
-namespace
-{
-
-struct MockFocusSetter: public msh::FocusSetter
-{
-  MOCK_METHOD1(set_focus_to, void(std::shared_ptr<mf::Session> const&));
-};
-
-}
-
 TEST(TestSessionManagerAndFocusSelectionStrategy, cycle_focus)
 {
     using namespace ::testing;
     mtd::MockSurfaceFactory surface_factory;
     std::shared_ptr<msh::SessionContainer> container(new msh::SessionContainer());
     msh::RegistrationOrderFocusSequence sequence(container);
-    MockFocusSetter focus_changer;
+    mtd::MockFocusSetter focus_changer;
     std::shared_ptr<mf::Session> new_session;
 
     msh::SessionManager session_manager(
@@ -72,9 +64,9 @@
 
     {
       InSequence seq;
-      EXPECT_CALL(focus_changer, set_focus_to(session1)).Times(1);
-      EXPECT_CALL(focus_changer, set_focus_to(session2)).Times(1);
-      EXPECT_CALL(focus_changer, set_focus_to(session3)).Times(1);
+      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);
     }
 
     session_manager.focus_next();
@@ -88,7 +80,7 @@
     mtd::MockSurfaceFactory surface_factory;
     std::shared_ptr<msh::SessionContainer> model(new msh::SessionContainer());
     msh::RegistrationOrderFocusSequence sequence(model);
-    MockFocusSetter focus_changer;
+    mtd::MockFocusSetter focus_changer;
     std::shared_ptr<mf::Session> new_session;
 
     msh::SessionManager session_manager(
@@ -105,8 +97,8 @@
 
     {
       InSequence seq;
-      EXPECT_CALL(focus_changer, set_focus_to(session2)).Times(1);
-      EXPECT_CALL(focus_changer, set_focus_to(session1)).Times(1);
+      EXPECT_CALL(focus_changer, set_focus_to(Eq(session2))).Times(1);
+      EXPECT_CALL(focus_changer, 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-01-11 23:47:40 +0000
+++ tests/mir_test_doubles/fake_event_hub.cpp	2013-03-22 17:46:22 +0000
@@ -2,6 +2,7 @@
 
 #include <androidfw/Keyboard.h>
 #include <thread> 
+#include <chrono>
 
 using droidinput::AxisInfo;
 using droidinput::InputDeviceIdentifier;
@@ -300,7 +301,7 @@
 void mia::FakeEventHub::synthesize_event(const mis::KeyParameters &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_KEY;
     event.code = parameters.scancode;
 
@@ -321,7 +322,7 @@
 void mia::FakeEventHub::synthesize_event(const mis::ButtonParameters &parameters)
 {
     RawEvent event;
-    event.when = 0;
+    event.when = 0; // TODO: This may need a timestamp to go over the wire ~racarr
     event.type = EV_KEY;
     event.code = parameters.button;
 
 
=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2013-03-21 03:32:59 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2013-03-22 17:46:22 +0000
@@ -41,6 +41,7 @@
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
 namespace mi = mir::input;
+namespace mf = mir::frontend;
 namespace mtf = mir_test_framework;
 namespace mtd = mir::test::doubles;
 
@@ -139,6 +140,10 @@
     {
         return std::make_shared<StubInputChannel>();
     }
+
+    void set_input_focus_to(std::shared_ptr<mi::SessionTarget> const& /* session */, std::shared_ptr<mi::SurfaceTarget> const& /* surface */)
+    {
+    }
 };
 }
 
 
=== modified file 'tests/unit-tests/input/android/CMakeLists.txt'
--- tests/unit-tests/input/android/CMakeLists.txt	2013-03-21 03:32:59 +0000
+++ tests/unit-tests/input/android/CMakeLists.txt	2013-03-22 17:46:22 +0000
@@ -6,6 +6,8 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_reader_policy.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_manager.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_communication_package.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_application_handle.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_window_handle.cpp
 )
 
 set(
 
=== added file 'tests/unit-tests/input/android/test_android_input_application_handle.cpp'
--- tests/unit-tests/input/android/test_android_input_application_handle.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/input/android/test_android_input_application_handle.cpp	2013-03-22 17:46:22 +0000
@@ -0,0 +1,58 @@
+/*
+ * 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]>
+ */
+
+#include "src/server/input/android/android_input_application_handle.h"
+
+#include "mir/input/session_target.h"
+
+#include "mir_test/fake_shared.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <limits.h>
+
+namespace mi = mir::input;
+namespace mia = mi::android;
+namespace mt = mir::test;
+
+namespace
+{
+struct MockSessionHandle : public mi::SessionTarget
+{
+    MOCK_CONST_METHOD0(name, std::string());
+};
+}
+
+
+TEST(AndroidInputApplicationHandle, takes_name_from_session_and_specifies_max_timeout)
+{   
+    using namespace ::testing;
+    std::string const testing_session_name = "Cats";
+    MockSessionHandle session;
+
+    EXPECT_CALL(session, name()).Times(AtLeast(1))
+        .WillRepeatedly(Return(testing_session_name));
+    mia::InputApplicationHandle application_handle(mt::fake_shared(session));
+    EXPECT_TRUE(application_handle.updateInfo());
+    auto info = application_handle.getInfo();
+    EXPECT_EQ(INT_MAX, info->dispatchingTimeout);
+    EXPECT_EQ(droidinput::String8(testing_session_name.c_str()), info->name);
+}
+
+
 
=== modified file 'tests/unit-tests/input/android/test_android_input_manager.cpp'
--- tests/unit-tests/input/android/test_android_input_manager.cpp	2013-03-21 03:32:59 +0000
+++ tests/unit-tests/input/android/test_android_input_manager.cpp	2013-03-22 17:46:22 +0000
@@ -22,9 +22,13 @@
 #include "src/server/input/android/android_input_constants.h"
 
 #include "mir/input/input_channel.h"
+#include "mir/input/session_target.h"
+#include "mir/input/surface_target.h"
 
+#include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_viewable_area.h"
-#include "mir_test/fake_shared.h"
+#include "mir_test_doubles/stub_session_target.h"
+#include "mir_test_doubles/stub_surface_target.h"
 
 #include <InputDispatcher.h>
 #include <InputListener.h>
@@ -126,7 +130,7 @@
 
 struct AndroidInputManagerSetup : public testing::Test
 {
-    void SetUp()
+    AndroidInputManagerSetup()
     {
         using namespace ::testing;
 
@@ -207,3 +211,91 @@
     EXPECT_GT(package->client_fd(), 0);
     EXPECT_GT(package->server_fd(), 0);
 }
+
+namespace
+{
+
+static bool
+application_handle_matches_session(droidinput::sp<droidinput::InputApplicationHandle> const& handle,
+                                   std::shared_ptr<mi::SessionTarget> const& session)
+{
+   if (handle->getName() != droidinput::String8(session->name().c_str()))
+        return false;
+   return true;
+}
+
+static bool
+window_handle_matches_session_and_surface(droidinput::sp<droidinput::InputWindowHandle> const& handle,
+                                          std::shared_ptr<mi::SessionTarget> const& session,
+                                          std::shared_ptr<mi::SurfaceTarget> const& surface)
+{
+    if (!application_handle_matches_session(handle->inputApplicationHandle, session))
+        return false;
+    if (handle->getInputChannel()->getFd() != surface->server_input_fd())
+        return false;
+    return true;
+}
+
+MATCHER_P2(WindowHandleFor, session, surface, "")
+{
+    return window_handle_matches_session_and_surface(arg, session, surface);
+}
+
+MATCHER_P(ApplicationHandleFor, session, "")
+{
+    return application_handle_matches_session(arg, session);
+}
+
+MATCHER_P2(VectorContainingWindowHandleFor, session, surface, "")
+{
+    auto i = arg.size();
+    for (i = 0; i < arg.size(); i++)
+    {
+        if (window_handle_matches_session_and_surface(arg[i], session, surface))
+            return true;
+    }
+    return false;
+}
+
+MATCHER(EmptyVector, "")
+{
+    return arg.size() == 0;
+}
+
+// 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.
+struct AndroidInputManagerFdSetup : public AndroidInputManagerSetup
+{
+    void SetUp() override
+    {
+        test_input_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
+    }
+    void TearDown() override
+    {
+        close(test_input_fd);
+    }
+    int test_input_fd;
+};
+
+}
+
+TEST_F(AndroidInputManagerFdSetup, set_input_focus)
+{
+    using namespace ::testing;
+    
+    auto session = std::make_shared<mtd::StubSessionTarget>();
+    auto surface = std::make_shared<mtd::StubSurfaceTarget>(test_input_fd);
+    
+    EXPECT_CALL(*dispatcher, registerInputChannel(_, WindowHandleFor(session, surface), false)).Times(1)
+        .WillOnce(Return(droidinput::OK));
+    EXPECT_CALL(*dispatcher, setFocusedApplication(ApplicationHandleFor(session))).Times(1);
+    EXPECT_CALL(*dispatcher, setInputWindows(VectorContainingWindowHandleFor(session, surface))).Times(1);
+    EXPECT_CALL(*dispatcher, unregisterInputChannel(_)).Times(1);
+    EXPECT_CALL(*dispatcher, setInputWindows(EmptyVector())).Times(1);
+
+    mia::InputManager manager(mt::fake_shared(config));
+
+    manager.set_input_focus_to(session, surface);
+    manager.set_input_focus_to(session, std::shared_ptr<mi::SurfaceTarget>());
+}
 
=== added file 'tests/unit-tests/input/android/test_android_input_window_handle.cpp'
--- tests/unit-tests/input/android/test_android_input_window_handle.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/input/android/test_android_input_window_handle.cpp	2013-03-22 17:46:22 +0000
@@ -0,0 +1,89 @@
+/*
+ * 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]>
+ */
+
+#include "src/server/input/android/android_input_window_handle.h"
+
+#include "mir/frontend/surface.h"
+#include "mir/geometry/size.h"
+#include "mir/input/input_channel.h"
+#include "mir/input/surface_target.h"
+
+#include "mir_test/fake_shared.h"
+#include "mir_test_doubles/mock_surface.h"
+#include "mir_test_doubles/stub_surface_builder.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace mc = mir::compositor;
+namespace mi = mir::input;
+namespace mia = mi::android;
+namespace mf = mir::frontend;
+namespace geom = mir::geometry;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
+
+namespace
+{
+
+struct StubInputApplicationHandle : public droidinput::InputApplicationHandle
+{
+    bool updateInfo() { return true; }
+};
+
+struct MockSurfaceTarget : public mi::SurfaceTarget
+{
+    MOCK_CONST_METHOD0(server_input_fd, int());
+    MOCK_CONST_METHOD0(size, geom::Size());
+    MOCK_CONST_METHOD0(name, std::string());
+};
+
+}
+
+TEST(AndroidInputWindowHandle, update_info_uses_geometry_and_channel_from_surface)
+{
+    using namespace ::testing;
+
+    geom::Size const default_surface_size = geom::Size{geom::Width{256},
+                                                      geom::Height{256}};
+    std::string const testing_surface_name = "Test";
+    int const testing_server_fd = 2;
+    
+    MockSurfaceTarget surface;
+
+    EXPECT_CALL(surface, server_input_fd()).Times(1)
+        .WillOnce(Return(testing_server_fd));
+    // For now since we are just doing keyboard input we only need surface size, 
+    // for touch/pointer events we will need a position
+    EXPECT_CALL(surface, size()).Times(1)
+        .WillOnce(Return(default_surface_size));
+    EXPECT_CALL(surface, name()).Times(1)
+        .WillOnce(Return(testing_surface_name));
+
+    mia::InputWindowHandle handle(new StubInputApplicationHandle(),
+                                  mt::fake_shared(surface));
+    
+    auto info = handle.getInfo();
+
+    EXPECT_EQ(testing_surface_name, info->name);
+
+    EXPECT_EQ(testing_server_fd, info->inputChannel->getFd());
+    
+    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));
+}
 
=== 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-13 08:09:52 +0000
+++ tests/unit-tests/input/android/test_event_filter_input_dispatcher_policy.cpp	2013-03-22 17:46:22 +0000
@@ -44,7 +44,9 @@
 
     // The policy filters ALL key events before queuing
     policy.interceptKeyBeforeQueueing(&ev, policy_flags);
-    EXPECT_EQ(policy_flags, droidinput::POLICY_FLAG_FILTERED);
+
+    // If the event is unfiltered we will allow it to pass to applications
+    EXPECT_TRUE(policy_flags & droidinput::POLICY_FLAG_PASS_TO_USER);
 
     // Android uses alternate notation...the policy returns true if the event was NOT handled (e.g. the EventFilter
     // returns false)
 
=== modified file 'tests/unit-tests/shell/test_application_session.cpp'
--- tests/unit-tests/shell/test_application_session.cpp	2013-03-21 03:32:59 +0000
+++ tests/unit-tests/shell/test_application_session.cpp	2013-03-22 17:46:22 +0000
@@ -23,6 +23,7 @@
 #include "mir_test_doubles/mock_surface_factory.h"
 #include "mir_test_doubles/mock_surface.h"
 #include "mir_test_doubles/stub_surface_builder.h"
+#include "mir_test_doubles/stub_surface.h"
 
 #include "src/server/shell/surface.h"
 
@@ -58,6 +59,41 @@
     session.destroy_surface(surf);
 }
 
+TEST(ApplicationSession, default_surface_is_first_surface)
+{
+    using namespace ::testing;
+
+    mtd::MockSurfaceFactory surface_factory;
+    mtd::StubSurfaceBuilder surface_builder;
+    {
+        InSequence seq;
+        EXPECT_CALL(surface_factory, create_surface(_)).Times(1)
+            .WillOnce(Return(std::make_shared<mtd::MockSurface>(mt::fake_shared(surface_builder))));
+        EXPECT_CALL(surface_factory, create_surface(_)).Times(1)
+            .WillOnce(Return(std::make_shared<mtd::MockSurface>(mt::fake_shared(surface_builder))));
+        EXPECT_CALL(surface_factory, create_surface(_)).Times(1)
+            .WillOnce(Return(std::make_shared<mtd::MockSurface>(mt::fake_shared(surface_builder))));
+    }
+
+    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo");
+
+    mf::SurfaceCreationParameters params;
+    auto id1 = app_session.create_surface(params);
+    auto id2 = app_session.create_surface(params);
+    auto id3 = app_session.create_surface(params);
+    
+    auto default_surf = app_session.default_surface();
+    EXPECT_EQ(app_session.get_surface(id1), default_surf);
+    app_session.destroy_surface(id1);
+
+    default_surf = app_session.default_surface();
+    EXPECT_EQ(app_session.get_surface(id2), default_surf);
+    app_session.destroy_surface(id2);
+
+    default_surf = app_session.default_surface();
+    EXPECT_EQ(app_session.get_surface(id3), default_surf);
+    app_session.destroy_surface(id3);
+}
 
 TEST(ApplicationSession, session_visbility_propagates_to_surfaces)
 {
 
=== modified file 'tests/unit-tests/shell/test_registration_order_focus_sequence.cpp'
--- tests/unit-tests/shell/test_registration_order_focus_sequence.cpp	2013-03-21 03:32:59 +0000
+++ tests/unit-tests/shell/test_registration_order_focus_sequence.cpp	2013-03-22 17:46:22 +0000
@@ -18,7 +18,7 @@
 
 #include "mir/surfaces/buffer_bundle.h"
 #include "mir/shell/application_session.h"
-#include "mir/frontend/session_container.h"
+#include "mir/shell/session_container.h"
 #include "mir/shell/registration_order_focus_sequence.h"
 #include "mir/frontend/surface_creation_parameters.h"
 #include "mir/surfaces/surface.h"
 
=== modified file 'tests/unit-tests/shell/test_session_manager.cpp'
--- tests/unit-tests/shell/test_session_manager.cpp	2013-03-21 03:32:59 +0000
+++ tests/unit-tests/shell/test_session_manager.cpp	2013-03-22 17:46:22 +0000
@@ -17,11 +17,12 @@
  */
 
 #include "mir/surfaces/buffer_bundle.h"
+#include "mir/shell/focus_sequence.h"
 #include "mir/shell/session_manager.h"
-#include "mir/frontend/session_container.h"
+#include "mir/shell/session_container.h"
+#include "mir/shell/session.h"
 #include "mir/frontend/session.h"
 #include "mir/frontend/surface_creation_parameters.h"
-#include "mir/shell/focus_sequence.h"
 #include "mir/surfaces/surface.h"
 #include "mir/input/input_channel.h"
 #include "mir_test_doubles/mock_buffer_bundle.h"
@@ -90,7 +91,7 @@
     EXPECT_CALL(container, insert_session(_)).Times(1);
     EXPECT_CALL(container, remove_session(_)).Times(1);
     EXPECT_CALL(focus_setter, set_focus_to(_));
-    EXPECT_CALL(focus_setter, set_focus_to(std::shared_ptr<mf::Session>())).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<mf::Session>())));
 
@@ -115,7 +116,7 @@
     EXPECT_CALL(container, remove_session(_)).Times(1);
 
     EXPECT_CALL(focus_setter, set_focus_to(_)).Times(1);
-    EXPECT_CALL(focus_setter, set_focus_to(std::shared_ptr<mf::Session>())).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<mf::Session>())));
 
@@ -146,7 +147,7 @@
 
     session_manager.tag_session_with_lightdm_id(session1, 1);
 
-    EXPECT_CALL(focus_setter, set_focus_to(session1));
+    EXPECT_CALL(focus_setter, set_focus_to(Eq(session1)));
     session_manager.focus_session_with_lightdm_id(1);
 }
 
@@ -161,7 +162,7 @@
     session_manager.focus_session_with_lightdm_id(1);
 
     EXPECT_CALL(sequence, default_focus()).WillOnce(Return(session2));
-    EXPECT_CALL(focus_setter, set_focus_to(session2));
+    EXPECT_CALL(focus_setter, set_focus_to(Eq(session2)));
 
     session_manager.close_session(session1);
 }
 
=== modified file 'tests/unit-tests/shell/test_single_visibility_focus_mechanism.cpp'
--- tests/unit-tests/shell/test_single_visibility_focus_mechanism.cpp	2013-03-21 03:32:59 +0000
+++ tests/unit-tests/shell/test_single_visibility_focus_mechanism.cpp	2013-03-22 17:46:22 +0000
@@ -18,15 +18,19 @@
 
 #include "mir/surfaces/buffer_bundle.h"
 #include "mir/shell/application_session.h"
-#include "mir/frontend/session_container.h"
+#include "mir/shell/session_container.h"
 #include "mir/shell/registration_order_focus_sequence.h"
 #include "mir/shell/single_visibility_focus_mechanism.h"
+#include "mir/shell/session.h"
 #include "mir/frontend/surface_creation_parameters.h"
 #include "mir/surfaces/surface.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_session.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"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -35,19 +39,41 @@
 namespace mc = mir::compositor;
 namespace msh = mir::shell;
 namespace ms = mir::surfaces;
+namespace mf = mir::frontend;
 namespace mt = mir::test;
 namespace mtd = mir::test::doubles;
 
+struct MockShellSession : public msh::Session
+{
+    MOCK_METHOD1(create_surface, mf::SurfaceId(mf::SurfaceCreationParameters const&));
+    MOCK_METHOD1(destroy_surface, void(mf::SurfaceId));
+    MOCK_CONST_METHOD1(get_surface, std::shared_ptr<mf::Surface>(mf::SurfaceId));
+    
+    MOCK_CONST_METHOD0(default_surface, std::shared_ptr<msh::Surface>());
+    
+    MOCK_CONST_METHOD0(name, std::string());
+    MOCK_METHOD0(shutdown, void());
+    
+    MOCK_METHOD0(hide, void());
+    MOCK_METHOD0(show, void());
+
+    MOCK_METHOD3(configure_surface, int(mf::SurfaceId, MirSurfaceAttrib, int));
+};
+
 TEST(SingleVisibilityFocusMechanism, mechanism_sets_visibility)
 {
     using namespace ::testing;
 
-    mtd::MockSession app1;
-    mtd::MockSession app2;
-    mtd::MockSession app3;
+    NiceMock<mtd::MockInputFocusSelector> input_focus_selector;
 
+    MockShellSession app1, app2, app3;
     msh::SessionContainer model;
-    msh::SingleVisibilityFocusMechanism focus_mechanism(mt::fake_shared(model));
+    
+    ON_CALL(app1, default_surface()).WillByDefault(Return(std::shared_ptr<msh::Surface>()));
+    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));
 
     EXPECT_CALL(app1, show()).Times(1);
     EXPECT_CALL(app2, hide()).Times(1);
@@ -60,3 +86,22 @@
     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::SessionContainer model;
+    auto session = std::make_shared<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-03-21 03:55:40 +0000
+++ tests/unit-tests/shell/test_surface.cpp	2013-03-22 17:46:22 +0000
@@ -178,6 +178,24 @@
     }, std::runtime_error);
 }
 
+TEST_F(ShellSurface, name_throw_behavior)
+{
+    msh::Surface test(
+            mt::fake_shared(surface_builder),
+            mf::a_surface(),
+            null_input_channel);
+
+    EXPECT_NO_THROW({
+        test.name();
+    });
+
+    surface_builder.reset_surface();
+
+    EXPECT_THROW({
+        test.name();
+    }, std::runtime_error);
+}
+
 TEST_F(ShellSurface, pixel_format_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-03-21 03:32:59 +0000
+++ tests/unit-tests/shell/test_the_session_container_implementation.cpp	2013-03-22 17:46:22 +0000
@@ -18,7 +18,7 @@
 
 #include "mir/surfaces/buffer_bundle.h"
 #include "mir/shell/application_session.h"
-#include "mir/frontend/session_container.h"
+#include "mir/shell/session_container.h"
 #include "mir/frontend/surface_creation_parameters.h"
 #include "mir/surfaces/surface.h"
 #include "mir_test_doubles/mock_buffer_bundle.h"