Merge lp:~robertcarr/mir/rebuild-input-targeting into lp:~mir-team/mir/trunk

[Robert Carr]

Rebuild input targeting subsystem to enable multiple surface touch input picking.

This branch is a rework of the interface between the android input stack and Mir.

TestClientInput, multiple_clients_receive_motion_inside_windows, is the acceptance test driving the branch. A scenario where the pointer is dragged across two windows laid out next to one another.

This of course fails in trunk, as the "InputDispatcherController" only supports passing one input window through to the InputDispatcher at a time.

This branch has two major pushes:
1. Enable the droidinput::InputDispatcher to work in terms of an InputEnumerator interface (i.e. the SurfaceStack) rather than through the setInputWindows stack synchronization mechanism.
2. A rebuilding of the Mir/droidinput interface (some bits such as as surface/input registration need to move down to the ms:: layer (from the shell layer).

First, the Mir changes:

InputConfiguration/AndroidInputConfiguration is cleaned up to reduce coupling between the rest of the server and mir::input::android. The interfaces between mir::input:: and the rest of the server are reduced to:

ms::InputRegistrar - Used by the SurfaceStack to register input surfaces and notify the dispatcher of surface destruction.
msh::InputTargeter - Used by the shell to set Keyboard focus.
mi::InputManager - Used by the DisplayServer to start and stop input.
mi::InputTargets/SurfaceTarget - Provided by the surface stack/surface to the InputDispatcher in order to enumerate potential targets for input (i.e. during touch input picking).

The input channel factory is left over, but should be merged with the InputRegistrar in a later branch.

Input channel creation and association is moved from the shell surface to the surface stack itself (at surface creation time).

On the android-input side...

The current design of the droidinput::InputDispatcher interface is based around a setInputWindows interface, which is used to copy the window stack to the InputDispatcher. The InputDispatcher then inspects the window stack to generate events for itself (such as window removed, focus changed, etc). Implementing the stack synchronization for multiple surfaces was looking pretty cumbersome. This interface in general is a little frustrating to work with, and fights against what we want to present to the shell (the ability to arbitrarily target input events).

droidinput::InputDispatcher is reworked to accept an InputEnumerator (provided by the mi::InputTargets through an adapter class..mia::InputTargetEnumerator) and modified to remove it's internal copy of the stack. In some cases the copying of the window stack was used as notification for events (i.e. window removed, key focus changed), these events are split in to new methods.

[Robert Carr (robertcarr)]

Some old test code from before we had a full stack of input tests was deemed as not worth updating to new interfaces, i.e. the dispatcher-check tool and test_fake_event_hub_to_event_filter.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:748
http://jenkins.qa.ubuntu.com/job/mir-ci/627/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/757/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/640
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/112
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/112/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=precise,flavor=amd64/340/console

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

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Overall, this looks like a nice simplification but there's a lot too it and I've not processed it all yet. Meanwhile...

include/server/mir/input/null_input_configuration.h
include/server/mir/input/null_input_registrar.h
include/server/mir/input/null_input_targeter.h

Too much implementation in a header files

~~~~

1317 + virtual ~NullInputConfiguration() {}

no reason not to be noexcept

~~~~

1777 + friend class SessionManager;

I've yet worked out what really motivates this, but it is probably not the right solution.

~~~~

1923 +

Whitespace

review: Needs Fixing

[Robert Carr (robertcarr)]

- Reorganized NullInputConfiguration (remove public headers for null registrar/targeter/manager, and placed in new null_input_manager.cpp implementation. + default destructor (r750)
- Whitespace fix (r751)
- Removed session manager friend class and internal_surface method through addition of shell::surface::take_input_focus as we discussed on irc

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:751
http://jenkins.qa.ubuntu.com/job/mir-ci/629/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/760
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/642
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/114
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/114/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=precise,flavor=amd64/342

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:758
http://jenkins.qa.ubuntu.com/job/mir-ci/633/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/765
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/647
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/118
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/118/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

There seems to be a lot of "for_each" use that replaces a loop that can exit early. Is this an efficiency concern? Would a for_each_while(std::function<bool(sp<InputWindowHandle> const&)> const& callback) option be useful?

[Alan Griffiths (alan-griffiths)]

Overall, this looks like a nice simplification but there's a lot to it and (due to the poor test coverage of the 3rd_party input code) I don't feel confident that nothing breaks as a result.

It isn't easy to get the code under test (especially without reworking it - which is what this MP does), so I can't insist on "more tests".

Anyway, there's a bit of tidy up needed...

226 + synthesizeCancelationEventsForInputChannelLocked(
227 + focusedInputChannel, options);

Strange indentation

~~~~

2845 + virtual ~InputRegistrar() noexcept(true) {}

2978 + virtual ~InputTargetEnumerator() noexcept(true) {}

These don't gain by being inline

~~~~

2853 +protected:
2854 + InputRegistrar(const InputRegistrar&) = delete;
2855 + InputRegistrar& operator=(const InputRegistrar&) = delete;

2982 +protected:
2983 + InputTargetEnumerator(const InputTargetEnumerator&) = delete;
2984 + InputTargetEnumerator& operator=(const InputTargetEnumerator&) = delete;

No need for a protected section for these - and aren't they deleted in the base anyway?

~~~~~

2858 + droidinput::sp<droidinput::InputDispatcherInterface> input_dispatcher;

should be const

review: Needs Fixing

[Robert Carr (robertcarr)]

Some cleanup!

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:760
http://jenkins.qa.ubuntu.com/job/mir-ci/641/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/776
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/658
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/126
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/126/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:761
http://jenkins.qa.ubuntu.com/job/mir-ci/642/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/777
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/659
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/127
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/127/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Overall, this looks like a nice simplification.

But there's a lot to it and (due to the poor test coverage of the 3rd_party input code) I don't feel confident that nothing breaks as a result: I'd prefer some more eyes on this before it lands. **HINT**

review: Approve

[Robert Ancell (robert-ancell)]

I'll lend you some eyes... It's a huge patch and hard to see all the implications but I can't see anything wrong with it.

review: Approve

[Alexandros Frantzis (afrantzis)]

Looks good overall (in a "it's so complicated that there are no obvious deficiencies" way :))

Non-blocking nits (taking into account the size of this MP...):

1334 + NullInputConfiguration(const NullInputConfiguration&) = delete;
1335 + NullInputConfiguration& operator=(const NullInputConfiguration&) = delete;

3175 + InputTargeter(const InputTargeter&) = delete;
3176 + InputTargeter& operator=(const InputTargeter&) = delete;

Not needed.

2759 + std::unique_lock<std::mutex> lock(handles_mutex);

std::lock_guard is supposed to be slightly more lightweight than std::unique_lock, and there is no reason not to prefer lock_guard when condition variables and lock transfers are not involved

4407 + PositionList surface_positions_by_name;
4457 + int screen_width, screen_height;
4458 + PositionList positions;
4492 + MirSurfaceParameters params;

Could be const.

In tests/unit-tests/surfaces/test_surface_stack.cpp:

+ ms::SurfaceStack stack{std::make_shared<StubBufferBundleFactory>(),
+ std::make_shared<StubInputChannelFactory>(),
+ mt::fake_shared(registrar)};

Strange indentation (at various points where the stack is constructed).

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/mir-autolanding/296/
Executed test runs:
    FAILURE: http://s-jenkins:8080/job/generic-cleanup-mbs/67/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/794/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/676/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-autolanding/86/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-autolanding-build/./distribution=quantal,flavor=amd64/183

review: Needs Fixing (continuous-integration)

[Robert Carr (robertcarr)]

The trunk its merged!

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
Unapproved changes made after approval.
http://jenkins.qa.ubuntu.com/job/mir-autolanding/297/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/795
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/677
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-autolanding/87
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-autolanding/87/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-autolanding-build/./distribution=quantal,flavor=amd64/184

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:764
http://jenkins.qa.ubuntu.com/job/mir-ci/650/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/796
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/678
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/135
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/135/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2013-05-28 17:52:18 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2013-05-30 19:33:26 +0000
@@ -186,6 +186,12 @@
     policy->getDispatcherConfiguration(&mConfig);
 }
 
+void InputDispatcher::setInputEnumerator(sp<InputEnumerator> const& enumerator)
+{
+    AutoMutex _l(mLock);
+    mEnumerator = enumerator;
+}
+
 InputDispatcher::~InputDispatcher() {
     { // acquire lock
         AutoMutex _l(mLock);
@@ -424,10 +430,8 @@
 }
 
 sp<InputWindowHandle> InputDispatcher::findTouchedWindowAtLocked(int32_t x, int32_t y) {
-    // Traverse windows from front to back to find touched window.
-    size_t numWindows = mWindowHandles.size();
-    for (size_t i = 0; i < numWindows; i++) {
-        sp<InputWindowHandle> windowHandle = mWindowHandles.itemAt(i);
+    sp<InputWindowHandle> foundHandle = NULL;
+    mEnumerator->for_each([&](sp<InputWindowHandle> windowHandle) {
         const InputWindowInfo* windowInfo = windowHandle->getInfo();
         int32_t flags = windowInfo->layoutParamsFlags;
 
@@ -437,17 +441,17 @@
                         | InputWindowInfo::FLAG_NOT_TOUCH_MODAL)) == 0;
                 if (isTouchModal || windowInfo->touchableRegionContainsPoint(x, y)) {
                     // Found window.
-                    return windowHandle;
+                    foundHandle = windowHandle;
                 }
             }
         }
 
         if (flags & InputWindowInfo::FLAG_SYSTEM_ERROR) {
-            // Error window is on top but not visible, so touch is dropped.
-            return NULL;
+            foundHandle = NULL;
         }
-    }
-    return NULL;
+    });
+
+    return foundHandle;
 }
 
 void InputDispatcher::dropInboundEventLocked(EventEntry* entry, DropReason dropReason) {
@@ -1141,14 +1145,14 @@
                 getAxisValue(AMOTION_EVENT_AXIS_X));
         int32_t y = int32_t(entry->pointerCoords[pointerIndex].
                 getAxisValue(AMOTION_EVENT_AXIS_Y));
-        sp<InputWindowHandle> newTouchedWindowHandle;
+        sp<InputWindowHandle> newTouchedWindowHandle = NULL;
         sp<InputWindowHandle> topErrorWindowHandle;
         bool isTouchModal = false;
 
         // Traverse windows from front to back to find touched window and outside targets.
-        size_t numWindows = mWindowHandles.size();
-        for (size_t i = 0; i < numWindows; i++) {
-            sp<InputWindowHandle> windowHandle = mWindowHandles.itemAt(i);
+        mEnumerator->for_each([&](sp<InputWindowHandle> const& windowHandle){
+            if (newTouchedWindowHandle != NULL)
+                return;
             const InputWindowInfo* windowInfo = windowHandle->getInfo();
             int32_t flags = windowInfo->layoutParamsFlags;
 
@@ -1167,7 +1171,7 @@
                                 || (flags & InputWindowInfo::FLAG_TOUCHABLE_WHEN_WAKING)) {
                             newTouchedWindowHandle = windowHandle;
                         }
-                        break; // found touched window, exit window loop
+                        return; // found touched window, exit window loop
                     }
                 }
 
@@ -1182,7 +1186,7 @@
                             windowHandle, outsideTargetFlags, BitSet32(0));
                 }
             }
-        }
+        });
 
         // If there is an error window but it is not taking focus (typically because
         // it is invisible) then wait for it.  Any other focused window may in
@@ -1408,12 +1412,12 @@
     // We do not collect wallpapers during HOVER_MOVE or SCROLL because the wallpaper
     // engine only supports touch events.  We would need to add a mechanism similar
     // to View.onGenericMotionEvent to enable wallpapers to handle these events.
+    // TODO: What does any of this mean? ~racarr
     if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
         sp<InputWindowHandle> foregroundWindowHandle =
                 mTempTouchState.getFirstForegroundWindowHandle();
         if (foregroundWindowHandle->getInfo()->hasWallpaper) {
-            for (size_t i = 0; i < mWindowHandles.size(); i++) {
-                sp<InputWindowHandle> windowHandle = mWindowHandles.itemAt(i);
+            mEnumerator->for_each([&](sp<InputWindowHandle> const& windowHandle){
                 if (windowHandle->getInfo()->layoutParamsType
                         == InputWindowInfo::TYPE_WALLPAPER) {
                     mTempTouchState.addOrUpdateWindow(windowHandle,
@@ -1421,7 +1425,7 @@
                                     | InputTarget::FLAG_DISPATCH_AS_IS,
                             BitSet32(0));
                 }
-            }
+            });
         }
     }
 
@@ -1586,20 +1590,23 @@
 
 bool InputDispatcher::isWindowObscuredAtPointLocked(
         const sp<InputWindowHandle>& windowHandle, int32_t x, int32_t y) const {
-    size_t numWindows = mWindowHandles.size();
-    for (size_t i = 0; i < numWindows; i++) {
-        sp<InputWindowHandle> otherHandle = mWindowHandles.itemAt(i);
+    bool obscured = false;
+    bool seen_handle = false;
+    
+    mEnumerator->for_each([&](sp<InputWindowHandle> const& otherHandle){
         if (otherHandle == windowHandle) {
-            break;
+            seen_handle = true;
+            return;
         }
-
-        const InputWindowInfo* otherInfo = otherHandle->getInfo();
-        if (otherInfo->visible && ! otherInfo->isTrustedOverlay()
+        if (seen_handle) {
+            const InputWindowInfo* otherInfo = otherHandle->getInfo();
+            if (otherInfo->visible && ! otherInfo->isTrustedOverlay()
                 && otherInfo->frameContainsPoint(x, y)) {
-            return true;
+                obscured = true;
+            }
         }
-    }
-    return false;
+    });
+    return obscured;
 }
 
 bool InputDispatcher::isWindowReadyForMoreInputLocked(nsecs_t currentTime,
@@ -2665,79 +2672,74 @@
 
 sp<InputWindowHandle> InputDispatcher::getWindowHandleLocked(
         const sp<InputChannel>& inputChannel) const {
-    size_t numWindows = mWindowHandles.size();
-    for (size_t i = 0; i < numWindows; i++) {
-        const sp<InputWindowHandle>& windowHandle = mWindowHandles.itemAt(i);
+    sp<InputWindowHandle> foundHandle = NULL;
+    mEnumerator->for_each([&](sp<InputWindowHandle> const& windowHandle){
         if (windowHandle->getInputChannel() == inputChannel) {
-            return windowHandle;
+            foundHandle = windowHandle;
         }
-    }
-    return NULL;
+    });
+    return foundHandle;
 }
 
 bool InputDispatcher::hasWindowHandleLocked(
         const sp<InputWindowHandle>& windowHandle) const {
-    size_t numWindows = mWindowHandles.size();
-    for (size_t i = 0; i < numWindows; i++) {
-        if (mWindowHandles.itemAt(i) == windowHandle) {
-            return true;
-        }
-    }
-    return false;
-}
-
-void InputDispatcher::setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles) {
-#if DEBUG_FOCUS
-    ALOGD("setInputWindows");
+    bool found_handle = false;
+    mEnumerator->for_each([&](sp<InputWindowHandle> const& otherHandle){
+        if (otherHandle == windowHandle) {
+            found_handle = true;
+        }
+    });
+    return found_handle;
+}
+
+void InputDispatcher::setKeyboardFocus(const sp<InputWindowHandle>& newFocusedWindowHandle)
+{
+#if DEBUG_FOCUS
+    ALOGD("setKeyboardFocus");
+#endif
+    {
+        AutoMutex _l(mLock);
+        setKeyboardFocusLocked(newFocusedWindowHandle);
+    }
+    mLooper->wake();
+}
+
+void InputDispatcher::setKeyboardFocusLocked(const sp<InputWindowHandle>& newFocusedWindowHandle)
+{
+    if (mFocusedWindowHandle != newFocusedWindowHandle) {
+        if (mFocusedWindowHandle != NULL) {
+#if DEBUG_FOCUS
+            ALOGD("Focus left window: %s",
+                  c_str(mFocusedWindowHandle->getName()));
+#endif
+            sp<InputChannel> focusedInputChannel = mFocusedWindowHandle->getInputChannel();
+            if (focusedInputChannel != NULL) {
+                CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS,
+                                           "focus left window");
+                synthesizeCancelationEventsForInputChannelLocked(
+                    focusedInputChannel, options);
+            }
+        }
+        if (newFocusedWindowHandle != NULL) {
+#if DEBUG_FOCUS
+            ALOGD("Focus entered window: %s",
+                  c_str(newFocusedWindowHandle->getName()));
+#endif
+        }
+        mFocusedWindowHandle = newFocusedWindowHandle;
+    }
+}
+
+void InputDispatcher::notifyWindowRemoved(const sp<InputWindowHandle>& windowHandle)
+{
+#if DEBUG_FOCUS
+    ALOGD("notifyWindowRemoved");
 #endif
     { // acquire lock
         AutoMutex _l(mLock);
 
-        Vector<sp<InputWindowHandle> > oldWindowHandles = mWindowHandles;
-        mWindowHandles = inputWindowHandles;
-
-        sp<InputWindowHandle> newFocusedWindowHandle;
-        bool foundHoveredWindow = false;
-        for (size_t i = 0; i < mWindowHandles.size(); i++) {
-            const sp<InputWindowHandle>& windowHandle = mWindowHandles.itemAt(i);
-            if (!windowHandle->updateInfo() || windowHandle->getInputChannel() == NULL) {
-                mWindowHandles.removeAt(i--);
-                continue;
-            }
-            if (windowHandle->getInfo()->hasFocus) {
-                newFocusedWindowHandle = windowHandle;
-            }
-            if (windowHandle == mLastHoverWindowHandle) {
-                foundHoveredWindow = true;
-            }
-        }
-
-        if (!foundHoveredWindow) {
+        if (windowHandle == mLastHoverWindowHandle)
             mLastHoverWindowHandle = NULL;
-        }
-
-        if (mFocusedWindowHandle != newFocusedWindowHandle) {
-            if (mFocusedWindowHandle != NULL) {
-#if DEBUG_FOCUS
-                ALOGD("Focus left window: %s",
-                    c_str(mFocusedWindowHandle->getName()));
-#endif
-                sp<InputChannel> focusedInputChannel = mFocusedWindowHandle->getInputChannel();
-                if (focusedInputChannel != NULL) {
-                    CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS,
-                            "focus left window");
-                    synthesizeCancelationEventsForInputChannelLocked(
-                            focusedInputChannel, options);
-                }
-            }
-            if (newFocusedWindowHandle != NULL) {
-#if DEBUG_FOCUS
-                ALOGD("Focus entered window: %s",
-                    c_str(newFocusedWindowHandle->getName()));
-#endif
-            }
-            mFocusedWindowHandle = newFocusedWindowHandle;
-        }
 
         for (size_t i = 0; i < mTouchState.windows.size(); i++) {
             TouchedWindow& touchedWindow = mTouchState.windows.editItemAt(i);
@@ -2750,20 +2752,21 @@
                         touchedWindow.windowHandle->getInputChannel();
                 if (touchedInputChannel != NULL) {
                     CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,
-                            "touched window was removed");
+                        "touched window was removed");
                     synthesizeCancelationEventsForInputChannelLocked(
-                            touchedInputChannel, options);
+                        touchedInputChannel, options);
                 }
                 mTouchState.windows.removeAt(i--);
             }
         }
 
+        if (windowHandle == mFocusedWindowHandle)
+            setKeyboardFocusLocked(NULL);
+
     } // release lock
-
-    // Wake up poll loop since it may need to make new input dispatching choices.
     mLooper->wake();
 }
-
+    
 void InputDispatcher::setFocusedApplication(
         const sp<InputApplicationHandle>& inputApplicationHandle) {
 #if DEBUG_FOCUS
@@ -2800,6 +2803,9 @@
     ALOGD("setInputDispatchMode: enabled=%d, frozen=%d", enabled, frozen);
 #endif
 
+    if (enabled)
+        assert(mEnumerator != NULL);
+
     bool changed;
     { // acquire lock
         AutoMutex _l(mLock);
@@ -2988,37 +2994,33 @@
         dump.append(INDENT "TouchedWindows: <none>\n");
     }
 
-    if (!mWindowHandles.isEmpty()) {
-        dump.append(INDENT "Windows:\n");
-        for (size_t i = 0; i < mWindowHandles.size(); i++) {
-            const sp<InputWindowHandle>& windowHandle = mWindowHandles.itemAt(i);
-            const InputWindowInfo* windowInfo = windowHandle->getInfo();
-
-            appendFormat(dump, INDENT2 "%d: name='%s', paused=%s, hasFocus=%s, hasWallpaper=%s, "
-                    "visible=%s, canReceiveKeys=%s, flags=0x%08x, type=0x%08x, layer=%d, "
-                    "frame=[%d,%d][%d,%d], scale=%f, "
-                    "touchableRegion=[%d,%d][%d,%d]",
-                    i, c_str(windowInfo->name),
-                    toString(windowInfo->paused),
-                    toString(windowInfo->hasFocus),
-                    toString(windowInfo->hasWallpaper),
-                    toString(windowInfo->visible),
-                    toString(windowInfo->canReceiveKeys),
-                    windowInfo->layoutParamsFlags, windowInfo->layoutParamsType,
-                    windowInfo->layer,
-                    windowInfo->frameLeft, windowInfo->frameTop,
-                    windowInfo->frameRight, windowInfo->frameBottom,
-                    windowInfo->scaleFactor,
-                    windowInfo->touchableRegionLeft, windowInfo->touchableRegionTop,
-                    windowInfo->touchableRegionRight, windowInfo->touchableRegionBottom);
-            appendFormat(dump, ", inputFeatures=0x%08x", windowInfo->inputFeatures);
-            appendFormat(dump, ", ownerPid=%d, ownerUid=%d, dispatchingTimeout=%0.3fms\n",
-                    windowInfo->ownerPid, windowInfo->ownerUid,
-                    windowInfo->dispatchingTimeout / 1000000.0);
-        }
-    } else {
-        dump.append(INDENT "Windows: <none>\n");
-    }
+    dump.append(INDENT "Windows:\n");
+
+    mEnumerator->for_each([&](sp<InputWindowHandle> const& windowHandle){
+        const InputWindowInfo* windowInfo = windowHandle->getInfo();
+
+        appendFormat(dump, INDENT2 "name='%s', paused=%s, hasFocus=%s, hasWallpaper=%s, "
+                "visible=%s, canReceiveKeys=%s, flags=0x%08x, type=0x%08x, layer=%d, "
+                "frame=[%d,%d][%d,%d], scale=%f, "
+                "touchableRegion=[%d,%d][%d,%d]",
+                c_str(windowInfo->name),
+                toString(windowInfo->paused),
+                toString(windowInfo->hasFocus),
+                toString(windowInfo->hasWallpaper),
+                toString(windowInfo->visible),
+                toString(windowInfo->canReceiveKeys),
+                windowInfo->layoutParamsFlags, windowInfo->layoutParamsType,
+                windowInfo->layer,
+                windowInfo->frameLeft, windowInfo->frameTop,
+                windowInfo->frameRight, windowInfo->frameBottom,
+                windowInfo->scaleFactor,
+                windowInfo->touchableRegionLeft, windowInfo->touchableRegionTop,
+                windowInfo->touchableRegionRight, windowInfo->touchableRegionBottom);
+        appendFormat(dump, ", inputFeatures=0x%08x", windowInfo->inputFeatures);
+        appendFormat(dump, ", ownerPid=%d, ownerUid=%d, dispatchingTimeout=%0.3fms\n",
+            windowInfo->ownerPid, windowInfo->ownerUid,
+                windowInfo->dispatchingTimeout / 1000000.0);
+        });
 
     if (!mMonitoringChannels.isEmpty()) {
         dump.append(INDENT "MonitoringChannels:\n");

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h	2013-05-28 17:47:03 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h	2013-05-30 19:33:26 +0000
@@ -38,6 +38,7 @@
 #include "InputWindow.h"
 #include "InputApplication.h"
 #include "InputListener.h"
+#include "InputEnumerator.h"
 
 #include <memory>
 
@@ -283,6 +284,13 @@
     virtual ~InputDispatcherInterface() { }
 
 public:
+    /* 
+     * Sets the enumerator of input targets. This must be called prior to enabling input dispatch.
+     *
+     * This method may be called by any thread.
+     */
+    virtual void setInputEnumerator(sp<InputEnumerator> const& enumerator) = 0;
+
     /* Dumps the state of the input dispatcher.
      *
      * This method may be called on any thread (usually by the input manager). */
@@ -309,11 +317,18 @@
             int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,
             uint32_t policyFlags) = 0;
 
-    /* Sets the list of input windows.
+    /* 
+     * Sets the keyboard focus target.
      *
-     * This method may be called on any thread (usually by the input manager).
-     */
-    virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles) = 0;
+     * This method may be called on any thread.
+     */
+    virtual void setKeyboardFocus(const sp<InputWindowHandle>& windowHandle) = 0;
+    /*
+     * Notify that a window handle is about to vanish
+
+     * This method may be called on any thread.
+     */
+    virtual void notifyWindowRemoved(const sp<InputWindowHandle>& windowHandle) = 0;
 
     /* Sets the focused application.
      *
@@ -378,6 +393,8 @@
 public:
     explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy, std::shared_ptr<mir::input::InputReport> const& input_report);
 
+    virtual void setInputEnumerator(sp<InputEnumerator> const& enumerator);
+
     virtual void dump(String8& dump);
     virtual void monitor();
 
@@ -393,7 +410,9 @@
             int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,
             uint32_t policyFlags);
 
-    virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles);
+    virtual void setKeyboardFocus(const sp<InputWindowHandle>& windowHandle);
+    virtual void notifyWindowRemoved(const sp<InputWindowHandle>& windowHandle);
+
     virtual void setFocusedApplication(const sp<InputApplicationHandle>& inputApplicationHandle);
     virtual void setInputDispatchMode(bool enabled, bool frozen);
     virtual void setInputFilterEnabled(bool enabled);
@@ -922,7 +941,7 @@
     bool mDispatchFrozen;
     bool mInputFilterEnabled;
 
-    Vector<sp<InputWindowHandle> > mWindowHandles;
+    sp<InputEnumerator> mEnumerator;
 
     sp<InputWindowHandle> getWindowHandleLocked(const sp<InputChannel>& inputChannel) const;
     bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const;
@@ -1096,6 +1115,8 @@
     // Statistics gathering.
     void updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry,
             int32_t injectionResult, nsecs_t timeSpentWaitingForApplication);
+
+    void setKeyboardFocusLocked(const sp<InputWindowHandle>& windowHandle);
 };
 
 /* Enqueues and dispatches input events, endlessly. */

=== added file '3rd_party/android-input/android/frameworks/base/services/input/InputEnumerator.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputEnumerator.h	1970-01-01 00:00:00 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputEnumerator.h	2013-05-30 19:33:26 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2013 Canonical LTD
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Robert Carr <[e-mail]>
+ */
+
+// TODO: ~racarr. What license should this file be under?
+
+#ifndef _UI_INPUT_ENUMERATOR_H
+#define _UI_INPUT_ENUMERATOR_H
+
+#include <std/RefBase.h>
+
+#include <functional>
+
+namespace android 
+{
+class InputWindowHandle;
+
+class InputEnumerator : public RefBase {
+public:
+    virtual void for_each(std::function<void(sp<InputWindowHandle> const&)> const& callback) = 0;
+
+protected:
+    InputEnumerator() = default;
+    virtual ~InputEnumerator() = default;
+};
+
+} // namespace android
+
+#endif // _UI_INPUT_ENUMERATOR_H

=== removed file '3rd_party/android-input/android/frameworks/base/services/input/InputManager.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputManager.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputManager.h	1970-01-01 00:00:00 +0000
@@ -1,109 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _UI_INPUT_MANAGER_H
-#define _UI_INPUT_MANAGER_H
-
-/**
- * Native input manager.
- */
-
-#include "EventHub.h"
-#include "InputReader.h"
-#include "InputDispatcher.h"
-
-#include <androidfw/Input.h>
-#include <androidfw/InputTransport.h>
-#include <std/Errors.h>
-#include <std/Vector.h>
-#include <std/Timers.h>
-#include <std/RefBase.h>
-#include <std/String8.h>
-
-namespace android {
-
-/*
- * The input manager is the core of the system event processing.
- *
- * The input manager uses two threads.
- *
- * 1. The InputReaderThread (called "InputReader") reads and preprocesses raw input events,
- *    applies policy, and posts messages to a queue managed by the DispatcherThread.
- * 2. The InputDispatcherThread (called "InputDispatcher") thread waits for new events on the
- *    queue and asynchronously dispatches them to applications.
- *
- * By design, the InputReaderThread class and InputDispatcherThread class do not share any
- * internal state.  Moreover, all communication is done one way from the InputReaderThread
- * into the InputDispatcherThread and never the reverse.  Both classes may interact with the
- * InputDispatchPolicy, however.
- *
- * The InputManager class never makes any calls into Java itself.  Instead, the
- * InputDispatchPolicy is responsible for performing all external interactions with the
- * system, including calling DVM services.
- */
-class InputManagerInterface : public virtual RefBase {
-protected:
-    InputManagerInterface() { }
-    virtual ~InputManagerInterface() { }
-
-public:
-    /* Starts the input manager threads. */
-    virtual status_t start() = 0;
-
-    /* Stops the input manager threads and waits for them to exit. */
-    virtual status_t stop() = 0;
-
-    /* Gets the input reader. */
-    virtual sp<InputReaderInterface> getReader() = 0;
-
-    /* Gets the input dispatcher. */
-    virtual sp<InputDispatcherInterface> getDispatcher() = 0;
-};
-
-class InputManager : public InputManagerInterface {
-protected:
-    virtual ~InputManager();
-
-public:
-    InputManager(
-            const sp<EventHubInterface>& eventHub,
-            const sp<InputReaderPolicyInterface>& readerPolicy,
-            const sp<InputDispatcherPolicyInterface>& dispatcherPolicy);
-
-    // (used for testing purposes)
-    InputManager(
-            const sp<InputReaderInterface>& reader,
-            const sp<InputDispatcherInterface>& dispatcher);
-
-    virtual status_t start();
-    virtual status_t stop();
-
-    virtual sp<InputReaderInterface> getReader();
-    virtual sp<InputDispatcherInterface> getDispatcher();
-
-private:
-    sp<InputReaderInterface> mReader;
-    sp<InputReaderThread> mReaderThread;
-
-    sp<InputDispatcherInterface> mDispatcher;
-    sp<InputDispatcherThread> mDispatcherThread;
-
-    void initialize();
-};
-
-} // namespace android
-
-#endif // _UI_INPUT_MANAGER_H

=== removed directory '3rd_party/android-input/tools'
=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2013-05-21 17:16:43 +0000
+++ examples/render_surfaces.cpp	2013-05-30 19:33:26 +0000
@@ -24,7 +24,6 @@
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/graphics/cursor.h"
 #include "mir/graphics/display.h"
-#include "mir/input/null_input_manager.h"
 #include "mir/shell/surface_builder.h"
 #include "mir/surfaces/surface.h"
 #include "mir/default_server_configuration.h"

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2013-05-28 17:15:21 +0000
+++ include/server/mir/default_server_configuration.h	2013-05-30 19:33:26 +0000
@@ -51,7 +51,7 @@
 {
 class SurfaceFactory;
 class SurfaceBuilder;
-class InputTargetListener;
+class InputTargeter;
 class SessionContainer;
 class FocusSetter;
 class FocusSequence;
@@ -70,6 +70,7 @@
 class SurfaceStackModel;
 class SurfaceStack;
 class SurfaceController;
+class InputRegistrar;
 }
 namespace graphics
 {
@@ -86,11 +87,8 @@
 class InputManager;
 class EventFilter;
 class InputChannelFactory;
-namespace android
-{
 class InputConfiguration;
 }
-}
 
 namespace logging
 {
@@ -185,9 +183,10 @@
     /** @name input configuration
      *  @{ */
     virtual std::shared_ptr<input::InputReport> the_input_report();
-    virtual std::shared_ptr<input::android::InputConfiguration> the_input_configuration();
+    virtual std::shared_ptr<input::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();
+    virtual std::shared_ptr<surfaces::InputRegistrar> the_input_registrar();
+    virtual std::shared_ptr<shell::InputTargeter> the_input_targeter();
     /** @} */
 
     /** @name logging configuration - customization
@@ -213,10 +212,13 @@
     CachedPtr<frontend::Communicator> communicator;
     CachedPtr<shell::SessionManager> session_manager;
 
+
+    std::shared_ptr<input::InputConfiguration> input_configuration;
+
     CachedPtr<input::InputReport> input_report;
-    std::shared_ptr<input::android::InputConfiguration> input_configuration;
     CachedPtr<input::InputManager>    input_manager;
-    CachedPtr<shell::InputTargetListener> input_target_listener;
+    CachedPtr<surfaces::InputRegistrar> input_registrar;
+    CachedPtr<shell::InputTargeter> input_targeter;
     CachedPtr<graphics::Platform>     graphics_platform;
     CachedPtr<graphics::BufferInitializer> buffer_initializer;
     CachedPtr<compositor::GraphicBufferAllocator> buffer_allocator;

=== renamed file 'include/server/mir/input/android/android_input_configuration.h' => 'include/server/mir/input/input_configuration.h'
--- include/server/mir/input/android/android_input_configuration.h	2013-04-24 05:22:20 +0000
+++ include/server/mir/input/input_configuration.h	2013-05-30 19:33:26 +0000
@@ -16,38 +16,36 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_INPUT_ANDROID_INPUT_CONFIGURATION_H_
-#define MIR_INPUT_ANDROID_INPUT_CONFIGURATION_H_
-
-#include <utils/StrongPointer.h>
+#ifndef MIR_INPUT_INPUT_CONFIGURATION_H_
+#define MIR_INPUT_INPUT_CONFIGURATION_H_
 
 #include <memory>
 
-namespace droidinput = android;
-
-namespace android
-{
-class EventHubInterface;
-class InputDispatcherInterface;
-}
-
 namespace mir
 {
+namespace surfaces
+{
+class InputRegistrar;
+}
+namespace shell
+{
+class InputTargeter;
+}
 namespace input
 {
-namespace android
-{
-class InputThread;
+class InputTargets;
+class InputManager;
 
 class InputConfiguration
 {
 public:
     virtual ~InputConfiguration() {}
 
-    virtual droidinput::sp<droidinput::EventHubInterface> the_event_hub() = 0;
-    virtual droidinput::sp<droidinput::InputDispatcherInterface> the_dispatcher() = 0;
-    virtual std::shared_ptr<InputThread> the_dispatcher_thread() = 0;
-    virtual std::shared_ptr<InputThread> the_reader_thread() = 0;
+    virtual std::shared_ptr<surfaces::InputRegistrar> the_input_registrar() = 0;
+    virtual std::shared_ptr<shell::InputTargeter> the_input_targeter() = 0;
+    virtual std::shared_ptr<input::InputManager> the_input_manager() = 0;
+    
+    virtual void set_input_targets(std::shared_ptr<input::InputTargets> const& targets) = 0;
 
 protected:
     InputConfiguration() = default;
@@ -55,7 +53,6 @@
     InputConfiguration& operator=(InputConfiguration const&) = delete;
 };
 }
-}
 } // namespace mir
 
-#endif // MIR_INPUT_ANDROID_INPUT_CONFIGURATION_H_
+#endif // MIR_INPUT_INPUT_CONFIGURATION_H_

=== added file 'include/server/mir/input/input_targets.h'
--- include/server/mir/input/input_targets.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/input/input_targets.h	2013-05-30 19:33:26 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ *              Daniel d'Andradra <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_INPUT_TARGETS_H_
+#define MIR_INPUT_INPUT_TARGETS_H_
+
+#include "mir/input/input_channel_factory.h"
+
+#include <memory>
+
+namespace mir
+{
+namespace input
+{
+class SurfaceTarget;
+
+class InputTargets
+{
+public:
+    virtual ~InputTargets() = default;
+
+    virtual void for_each(std::function<void(std::shared_ptr<input::SurfaceTarget> const&)> const& callback) = 0;
+
+protected:
+    InputTargets() = default;
+    InputTargets(InputTargets const&) = delete;
+    InputTargets& operator=(InputTargets const&) = delete;
+};
+
+}
+}
+
+#endif // MIR_INPUT_INPUT_TARGETS

=== added file 'include/server/mir/input/null_input_configuration.h'
--- include/server/mir/input/null_input_configuration.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/input/null_input_configuration.h	2013-05-30 19:33:26 +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_INPUT_NULL_INPUT_CONFIGURATION_H_
+#define MIR_INPUT_NULL_INPUT_CONFIGURATION_H_
+
+#include "mir/input/input_configuration.h"
+
+namespace mir
+{
+namespace input
+{
+
+class NullInputConfiguration : public InputConfiguration
+{
+public:
+    NullInputConfiguration() = default;
+    virtual ~NullInputConfiguration() = default;
+
+    std::shared_ptr<surfaces::InputRegistrar> the_input_registrar();
+    std::shared_ptr<shell::InputTargeter> the_input_targeter();
+    std::shared_ptr<InputManager> the_input_manager();
+    
+    void set_input_targets(std::shared_ptr<InputTargets> const& /* targets */);
+
+protected:
+    NullInputConfiguration(const NullInputConfiguration&) = delete;
+    NullInputConfiguration& operator=(const NullInputConfiguration&) = delete;
+};
+
+}
+}
+
+#endif // MIR_INPUT_NULL_INPUT_CONFIGURATION

=== removed file 'include/server/mir/input/null_input_manager.h'
--- include/server/mir/input/null_input_manager.h	2013-05-02 00:11:18 +0000
+++ include/server/mir/input/null_input_manager.h	1970-01-01 00:00:00 +0000
@@ -1,51 +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_INPUT_NULL_INPUT_MANAGER_H_
-#define MIR_INPUT_NULL_INPUT_MANAGER_H_
-
-#include "mir/input/input_manager.h"
-
-namespace mir
-{
-namespace input
-{
-
-class NullInputManager : public InputManager
-{
-public:
-    NullInputManager() {};
-    virtual ~NullInputManager() {}
-
-    void start() {}
-    void stop() {}
-
-    std::shared_ptr<InputChannel> make_input_channel()
-    {
-        return std::shared_ptr<InputChannel>();
-    }
-
-protected:
-    NullInputManager(const NullInputManager&) = delete;
-    NullInputManager& operator=(const NullInputManager&) = delete;
-};
-
-}
-}
-
-#endif // MIR_INPUT_NULL_INPUT_MANAGER

=== removed file 'include/server/mir/input/null_input_target_listener.h'
--- include/server/mir/input/null_input_target_listener.h	2013-05-02 00:11:18 +0000
+++ include/server/mir/input/null_input_target_listener.h	1970-01-01 00:00:00 +0000
@@ -1,63 +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_INPUT_NULL_INPUT_TARGET_LISTENER_H_
-#define MIR_INPUT_NULL_INPUT_TARGET_LISTENER_H_
-
-#include "mir/shell/input_target_listener.h"
-
-namespace mir
-{
-namespace input
-{
-
-class NullInputTargetListener : public shell::InputTargetListener
-{
-public:
-    NullInputTargetListener() {};
-    virtual ~NullInputTargetListener() noexcept(true) {}
-    
-    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:
-    NullInputTargetListener(const NullInputTargetListener&) = delete;
-    NullInputTargetListener& operator=(const NullInputTargetListener&) = delete;
-};
-
-}
-}
-
-#endif // MIR_INPUT_NULL_INPUT_TARGET_LISTENER_H_

=== removed file 'include/server/mir/input/session_target.h'
--- include/server/mir/input/session_target.h	2013-04-24 05:22:20 +0000
+++ include/server/mir/input/session_target.h	1970-01-01 00:00:00 +0000
@@ -1,45 +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_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_

=== modified file 'include/server/mir/input/surface_target.h'
--- include/server/mir/input/surface_target.h	2013-04-26 16:12:22 +0000
+++ include/server/mir/input/surface_target.h	2013-05-30 19:33:26 +0000
@@ -36,7 +36,7 @@
 
     virtual geometry::Point top_left() const = 0;
     virtual geometry::Size size() const = 0;
-    virtual std::string name() const = 0;
+    virtual std::string const& name() const = 0;
 
     virtual int server_input_fd() const = 0;
 

=== modified file 'include/server/mir/shell/application_session.h'
--- include/server/mir/shell/application_session.h	2013-05-21 17:16:43 +0000
+++ include/server/mir/shell/application_session.h	2013-05-30 19:33:26 +0000
@@ -33,17 +33,14 @@
 {
 class SurfaceFactory;
 class Surface;
-class InputTargetListener;
 
 class ApplicationSession : public Session
 {
 public:
-    explicit ApplicationSession(std::shared_ptr<SurfaceFactory> const& surface_factory, 
-        std::shared_ptr<InputTargetListener> const& input_target_listener, std::string const& session_name);
+    explicit ApplicationSession(std::shared_ptr<SurfaceFactory> const& surface_factory, std::string const& session_name);
 
     ApplicationSession(
         std::shared_ptr<SurfaceFactory> const& surface_factory,
-        std::shared_ptr<InputTargetListener> const& input_target_listener,
         std::string const& session_name,
         std::shared_ptr<events::EventSink> const& sink);
 
@@ -70,7 +67,6 @@
 
 private:
     std::shared_ptr<SurfaceFactory> const surface_factory;
-    std::shared_ptr<InputTargetListener> const input_target_listener;
     std::string const session_name;
     std::shared_ptr<events::EventSink> const event_sink;
 

=== removed file 'include/server/mir/shell/input_target_listener.h'
--- include/server/mir/shell/input_target_listener.h	2013-04-19 17:44:48 +0000
+++ include/server/mir/shell/input_target_listener.h	1970-01-01 00:00:00 +0000
@@ -1,59 +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_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_

=== added file 'include/server/mir/shell/input_targeter.h'
--- include/server/mir/shell/input_targeter.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/shell/input_targeter.h	2013-05-30 19:33:26 +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 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_TARGETER_H_
+#define MIR_SHELL_INPUT_TARGETER_H_
+
+#include <memory>
+
+namespace mir
+{
+namespace input
+{
+class SurfaceTarget;
+}
+
+namespace shell
+{
+
+/// An interface used to control the selection of keyboard input focus.
+class InputTargeter
+{
+public:
+    virtual ~InputTargeter() = default;
+    
+    virtual void focus_changed(std::shared_ptr<input::SurfaceTarget const> const& focus_surface) = 0;
+    virtual void focus_cleared() = 0;
+
+protected:
+    InputTargeter() = default;
+    InputTargeter(InputTargeter const&) = delete;
+    InputTargeter& operator=(InputTargeter const&) = delete;
+};
+
+}
+} // namespace mir
+
+#endif // MIR_SHELL_INPUT_TARGETER_H_

=== modified file 'include/server/mir/shell/session.h'
--- include/server/mir/shell/session.h	2013-04-25 09:48:54 +0000
+++ include/server/mir/shell/session.h	2013-05-30 19:33:26 +0000
@@ -20,7 +20,6 @@
 #define MIR_SHELL_SESSION_H_
 
 #include "mir/frontend/session.h"
-#include "mir/input/session_target.h"
 
 namespace mir
 {
@@ -29,7 +28,7 @@
 {
 class Surface;
 
-class Session : public frontend::Session, public input::SessionTarget
+class Session : public frontend::Session
 {
 public:
     virtual std::string name() const = 0;

=== modified file 'include/server/mir/shell/session_manager.h'
--- include/server/mir/shell/session_manager.h	2013-05-21 17:16:43 +0000
+++ include/server/mir/shell/session_manager.h	2013-05-30 19:33:26 +0000
@@ -38,7 +38,7 @@
 class FocusSequence;
 class FocusSetter;
 class Session;
-class InputTargetListener;
+class InputRegistrar;
 class SessionListener;
 struct SurfaceCreationParameters;
 
@@ -49,7 +49,6 @@
                             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::shared_ptr<SessionListener> const& session_listener);
     virtual ~SessionManager();
 
@@ -70,7 +69,6 @@
     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::shared_ptr<SessionListener> const session_listener;
 
     std::mutex mutex;

=== modified file 'include/server/mir/shell/single_visibility_focus_mechanism.h'
--- include/server/mir/shell/single_visibility_focus_mechanism.h	2013-05-02 00:11:18 +0000
+++ include/server/mir/shell/single_visibility_focus_mechanism.h	2013-05-30 19:33:26 +0000
@@ -28,11 +28,13 @@
 namespace shell
 {
 class SessionContainer;
+class InputTargeter;
 
 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<InputTargeter> const& input_targeter);
     virtual ~SingleVisibilityFocusMechanism() {}
 
     void set_focus_to(std::shared_ptr<shell::Session> const& new_focus);
@@ -40,8 +42,10 @@
 protected:
     SingleVisibilityFocusMechanism(const SingleVisibilityFocusMechanism&) = delete;
     SingleVisibilityFocusMechanism& operator=(const SingleVisibilityFocusMechanism&) = delete;
+
 private:
     std::shared_ptr<SessionContainer> const app_container;
+    std::shared_ptr<InputTargeter> const input_targeter;
 };
 
 }

=== modified file 'include/server/mir/shell/surface.h'
--- include/server/mir/shell/surface.h	2013-05-22 17:11:51 +0000
+++ include/server/mir/shell/surface.h	2013-05-30 19:33:26 +0000
@@ -23,7 +23,6 @@
 #include "mir/frontend/surface.h"
 #include "mir/frontend/surface_id.h"
 #include "mir/surfaces/surface.h"
-#include "mir/input/surface_target.h"
 
 #include "mir_toolkit/common.h"
 
@@ -35,28 +34,23 @@
 {
 class EventSink;
 }
-namespace input
-{
-class InputChannel;
-}
 
 namespace shell
 {
+class InputTargeter;
 class SurfaceBuilder;
 struct SurfaceCreationParameters;
 
-class Surface : public frontend::Surface, public input::SurfaceTarget
+class Surface : public frontend::Surface
 {
 public:
     Surface(
         std::shared_ptr<SurfaceBuilder> const& builder,
-        SurfaceCreationParameters const& params,
-        std::shared_ptr<input::InputChannel> const& input_channel);
+        SurfaceCreationParameters const& params);
 
     Surface(
         std::shared_ptr<SurfaceBuilder> const& builder,
         SurfaceCreationParameters const& params,
-        std::shared_ptr<input::InputChannel> const& input_channel,
         frontend::SurfaceId id,
         std::shared_ptr<events::EventSink> const& sink);
 
@@ -89,13 +83,14 @@
     virtual MirSurfaceType type() const;
     virtual MirSurfaceState state() const;
 
+    virtual void take_input_focus(std::shared_ptr<InputTargeter> const& targeter);
+
 private:
     bool set_type(MirSurfaceType t);  // Use configure() to make public changes
     bool set_state(MirSurfaceState s);
     void notify_change(MirSurfaceAttrib attrib, int value);
 
     std::shared_ptr<SurfaceBuilder> const builder;
-    std::shared_ptr<mir::input::InputChannel> const input_channel;
     std::weak_ptr<mir::surfaces::Surface> const surface;
 
     frontend::SurfaceId const id;

=== modified file 'include/server/mir/shell/surface_source.h'
--- include/server/mir/shell/surface_source.h	2013-05-21 17:16:43 +0000
+++ include/server/mir/shell/surface_source.h	2013-05-30 19:33:26 +0000
@@ -25,10 +25,6 @@
 
 namespace mir
 {
-namespace input
-{
-class InputChannelFactory;
-}
 
 namespace shell
 {
@@ -37,7 +33,7 @@
 class SurfaceSource : public SurfaceFactory
 {
 public:
-    explicit SurfaceSource(std::shared_ptr<SurfaceBuilder> const& surface_builder, std::shared_ptr<input::InputChannelFactory> const& input_factory);
+    explicit SurfaceSource(std::shared_ptr<SurfaceBuilder> const& surface_builder);
     virtual ~SurfaceSource() {}
 
     std::shared_ptr<Surface> create_surface(
@@ -51,7 +47,6 @@
 
 private:
     std::shared_ptr<SurfaceBuilder> const surface_builder;
-    std::shared_ptr<input::InputChannelFactory> const input_factory;
 };
 
 }

=== added file 'include/server/mir/surfaces/input_registrar.h'
--- include/server/mir/surfaces/input_registrar.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/surfaces/input_registrar.h	2013-05-30 19:33:26 +0000
@@ -0,0 +1,54 @@
+/*
+ * 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_SURFACES_INPUT_REGISTRAR_H_
+#define MIR_SURFACES_INPUT_REGISTRAR_H_
+
+#include <memory>
+
+namespace mir
+{
+namespace input
+{
+class SessionTarget;
+class SurfaceTarget;
+}
+
+namespace surfaces
+{
+
+/// An interface used to register input targets and take care of input assosciation (i.e.
+/// create input channels).
+class InputRegistrar
+{
+public:
+    virtual ~InputRegistrar() = default;
+    
+    virtual void input_surface_opened(std::shared_ptr<input::SurfaceTarget> const& opened_surface) = 0;
+    virtual void input_surface_closed(std::shared_ptr<input::SurfaceTarget> const& closed_surface) = 0;
+
+protected:
+    InputRegistrar() = default;
+    InputRegistrar(InputRegistrar const&) = delete;
+    InputRegistrar& operator=(InputRegistrar const&) = delete;
+};
+
+}
+} // namespace mir
+
+#endif // MIR_SURFACES_INPUT_REGISTRAR_H_

=== modified file 'include/server/mir/surfaces/surface.h'
--- include/server/mir/surfaces/surface.h	2013-05-20 22:55:43 +0000
+++ include/server/mir/surfaces/surface.h	2013-05-30 19:33:26 +0000
@@ -22,6 +22,7 @@
 #include "mir/geometry/pixel_format.h"
 #include "mir/graphics/renderable.h"
 #include "mir/compositor/buffer_properties.h"
+#include "mir/input/surface_target.h"
 
 #include <memory>
 #include <string>
@@ -35,6 +36,10 @@
 struct BufferIPCPackage;
 class BufferID;
 }
+namespace input
+{
+class InputChannel;
+}
 
 namespace surfaces
 {
@@ -42,11 +47,12 @@
 
 // TODO this is ideally an implementation class. It is only in a public header
 // TODO because it is used in some example code (which probably needs rethinking).
-class Surface : public graphics::Renderable
+class Surface : public graphics::Renderable, public input::SurfaceTarget
 {
 public:
     Surface(const std::string& name, geometry::Point const& top_left,
             std::shared_ptr<BufferBundle> buffer_bundle,
+            std::shared_ptr<input::InputChannel> const& input_channel,
             std::function<void()> const& change_callback);
 
     ~Surface();
@@ -74,12 +80,17 @@
     void force_requests_to_complete();
     void flag_for_render();
 
+    bool supports_input() const;
+    int client_input_fd() const;
+    int server_input_fd() const;
 private:
     std::string surface_name;
     geometry::Point top_left_point;
 
     std::shared_ptr<BufferBundle> buffer_bundle;
 
+    std::shared_ptr<input::InputChannel> const input_channel;
+
     std::shared_ptr<compositor::Buffer> client_buffer_resource;
     glm::mat4 rotation_matrix;
     float alpha_value;

=== modified file 'include/server/mir/surfaces/surface_stack.h'
--- include/server/mir/surfaces/surface_stack.h	2013-05-21 17:16:43 +0000
+++ include/server/mir/surfaces/surface_stack.h	2013-05-30 19:33:26 +0000
@@ -21,6 +21,7 @@
 
 #include "surface_stack_model.h"
 #include "mir/compositor/renderables.h"
+#include "mir/input/input_targets.h"
 
 #include <memory>
 #include <vector>
@@ -40,22 +41,34 @@
 struct SurfaceCreationParameters;
 }
 
+namespace input
+{
+class InputChannelFactory;
+class SurfaceTarget;
+}
+
 /// Management of Surface objects. Includes the model (SurfaceStack and Surface
 /// classes) and controller (SurfaceController) elements of an MVC design.
 namespace surfaces
 {
 class BufferBundleFactory;
+class InputRegistrar;
 class Surface;
 
-class SurfaceStack : public compositor::Renderables, public SurfaceStackModel
+class SurfaceStack : public compositor::Renderables, public input::InputTargets, public SurfaceStackModel
 {
 public:
-    explicit SurfaceStack(std::shared_ptr<BufferBundleFactory> const& bb_factory);
-    virtual ~SurfaceStack() = default;
+    explicit SurfaceStack(std::shared_ptr<BufferBundleFactory> const& bb_factory,
+                          std::shared_ptr<input::InputChannelFactory> const& input_factory,
+                          std::shared_ptr<InputRegistrar> const& input_registrar);
+    virtual ~SurfaceStack() noexcept(true) {}
 
     // From Renderables
     virtual void for_each_if(compositor::FilterForRenderables &filter, compositor::OperatorForRenderables &renderable_operator);
     virtual void set_change_callback(std::function<void()> const& f);
+    
+    // From InputTargets
+    void for_each(std::function<void(std::shared_ptr<input::SurfaceTarget> const&)> const& callback);
 
     // From SurfaceStackModel
     virtual std::weak_ptr<Surface> create_surface(const shell::SurfaceCreationParameters& params);
@@ -70,6 +83,8 @@
 
     std::mutex guard;
     std::shared_ptr<BufferBundleFactory> const buffer_bundle_factory;
+    std::shared_ptr<input::InputChannelFactory> const input_factory;
+    std::shared_ptr<InputRegistrar> const input_registrar;
     std::vector<std::shared_ptr<Surface>> surfaces;
     std::mutex notify_change_mutex;
     std::function<void()> notify_change;

=== modified file 'include/test/mir_test_doubles/mock_input_configuration.h'
--- include/test/mir_test_doubles/mock_input_configuration.h	2013-04-24 05:22:20 +0000
+++ include/test/mir_test_doubles/mock_input_configuration.h	2013-05-30 19:33:26 +0000
@@ -40,6 +40,11 @@
     MOCK_METHOD0(the_dispatcher, droidinput::sp<droidinput::InputDispatcherInterface>());
     MOCK_METHOD0(the_dispatcher_thread, std::shared_ptr<input::android::InputThread>());
     MOCK_METHOD0(the_reader_thread, std::shared_ptr<input::android::InputThread>());
+    
+    MOCK_METHOD0(the_input_registrar, std::shared_ptr<surfaces::InputRegistrar>());
+    MOCK_METHOD0(the_input_targeter, std::shared_ptr<shell::InputTargeter>());
+
+    MOCK_METHOD1(set_input_targets, void(std::shared_ptr<input::InputTargets> const&));
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_input_dispatcher.h'
--- include/test/mir_test_doubles/mock_input_dispatcher.h	2013-04-24 05:22:20 +0000
+++ include/test/mir_test_doubles/mock_input_dispatcher.h	2013-05-30 19:33:26 +0000
@@ -34,17 +34,20 @@
 struct MockInputDispatcher : public droidinput::InputDispatcherInterface
 {
     // droidinput::InputDispatcher interface
+    MOCK_METHOD1(setInputEnumerator, void(droidinput::sp<droidinput::InputEnumerator> const&));
     MOCK_METHOD1(dump, void(droidinput::String8&));
     MOCK_METHOD0(monitor, void());
     MOCK_METHOD0(dispatchOnce, void());
     MOCK_METHOD6(injectInputEvent, int32_t(droidinput::InputEvent const*, int32_t, int32_t, int32_t, int32_t, uint32_t));
-    MOCK_METHOD1(setInputWindows, void(droidinput::Vector<droidinput::sp<droidinput::InputWindowHandle>> const&));
     MOCK_METHOD1(setFocusedApplication, void(droidinput::sp<droidinput::InputApplicationHandle> const&));
     MOCK_METHOD2(setInputDispatchMode, void(bool, bool));
     MOCK_METHOD1(setInputFilterEnabled, void(bool));
     MOCK_METHOD2(transferTouchFocus, bool(droidinput::sp<droidinput::InputChannel> const&, droidinput::sp<droidinput::InputChannel> const&));
     MOCK_METHOD3(registerInputChannel, droidinput::status_t(droidinput::sp<droidinput::InputChannel> const&, droidinput::sp<droidinput::InputWindowHandle> const&, bool));
     MOCK_METHOD1(unregisterInputChannel, droidinput::status_t(droidinput::sp<droidinput::InputChannel> const&));
+    
+    MOCK_METHOD1(setKeyboardFocus, void(droidinput::sp<droidinput::InputWindowHandle> const&));
+    MOCK_METHOD1(notifyWindowRemoved, void(droidinput::sp<droidinput::InputWindowHandle> const&));
 
     // droidinput::InputListener interface
     MOCK_METHOD1(notifyConfigurationChanged, void(droidinput::NotifyConfigurationChangedArgs const*));

=== renamed file 'include/test/mir_test_doubles/mock_input_target_listener.h' => 'include/test/mir_test_doubles/mock_input_registrar.h'
--- include/test/mir_test_doubles/mock_input_target_listener.h	2013-04-16 20:08:57 +0000
+++ include/test/mir_test_doubles/mock_input_registrar.h	2013-05-30 19:33:26 +0000
@@ -16,10 +16,10 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_TEST_DOUBLES_MOCK_INPUT_TARGET_LISTENER_H_
-#define MIR_TEST_DOUBLES_MOCK_INPUT_TARGET_LISTENER_H_
+#ifndef MIR_TEST_DOUBLES_MOCK_INPUT_REGISTRAR_H_
+#define MIR_TEST_DOUBLES_MOCK_INPUT_REGISTRAR_H_
 
-#include "mir/shell/input_target_listener.h"
+#include "mir/surfaces/input_registrar.h"
 
 #include <gmock/gmock.h>
 
@@ -30,20 +30,15 @@
 namespace doubles
 {
 
-struct MockInputTargetListener : public shell::InputTargetListener
+struct MockInputRegistrar : public surfaces::InputRegistrar
 {
-    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));
+    virtual ~MockInputRegistrar() noexcept(true) {}
+    MOCK_METHOD1(input_surface_opened, void(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_
+#endif // MIR_TEST_DOUBLES_MOCK_INPUT_REGISTRAR_H_

=== added file 'include/test/mir_test_doubles/mock_input_targeter.h'
--- include/test/mir_test_doubles/mock_input_targeter.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_input_targeter.h	2013-05-30 19:33:26 +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 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_TARGETER_H_
+#define MIR_TEST_DOUBLES_MOCK_INPUT_TARGETER_H_
+
+#include "mir/shell/input_targeter.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct MockInputTargeter : public shell::InputTargeter
+{
+    virtual ~MockInputTargeter() noexcept(true) {}
+    MOCK_METHOD1(focus_changed, void(std::shared_ptr<input::SurfaceTarget const> const& focus_surface));
+    MOCK_METHOD0(focus_cleared, void());
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_TEST_DOUBLES_MOCK_INPUT_TARGETER_H_

=== modified file 'include/test/mir_test_doubles/mock_surface.h'
--- include/test/mir_test_doubles/mock_surface.h	2013-05-21 17:16:43 +0000
+++ include/test/mir_test_doubles/mock_surface.h	2013-05-30 19:33:26 +0000
@@ -37,7 +37,7 @@
 struct MockSurface : public shell::Surface
 {
     MockSurface(std::shared_ptr<shell::SurfaceBuilder> const& builder) :
-        shell::Surface(builder, shell::a_surface(), std::shared_ptr<input::InputChannel>())
+        shell::Surface(builder, shell::a_surface())
     {
     }
 
@@ -57,6 +57,7 @@
     MOCK_CONST_METHOD0(server_input_fd, int());
 
     MOCK_METHOD2(configure, int(MirSurfaceAttrib, int));
+    MOCK_METHOD1(take_input_focus, void(std::shared_ptr<shell::InputTargeter> const&));
 };
 
 }

=== renamed file 'include/test/mir_test_doubles/stub_input_target_listener.h' => 'include/test/mir_test_doubles/stub_input_registrar.h'
--- include/test/mir_test_doubles/stub_input_target_listener.h	2013-04-18 17:22:34 +0000
+++ include/test/mir_test_doubles/stub_input_registrar.h	2013-05-30 19:33:26 +0000
@@ -16,10 +16,10 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_TEST_DOUBLES_STUB_INPUT_LISTENER_H_
-#define MIR_TEST_DOUBLES_STUB_INPUT_LISTENER_H_
+#ifndef MIR_TEST_DOUBLES_STUB_INPUT_REGISTRAR_H_
+#define MIR_TEST_DOUBLES_STUB_INPUT_REGISTRAR_H_
 
-#include "mir/shell/input_target_listener.h"
+#include "mir/surfaces/input_registrar.h"
 
 namespace mir
 {
@@ -28,32 +28,18 @@
 namespace doubles
 {
 
-struct StubInputTargetListener : public shell::InputTargetListener
+struct StubInputRegistrar : public surfaces::InputRegistrar
 {
-    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_opened(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_
+#endif // MIR_TEST_DOUBLES_STUB_INPUT_REGISTRAR_H_

=== added file 'include/test/mir_test_doubles/stub_input_targeter.h'
--- include/test/mir_test_doubles/stub_input_targeter.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_input_targeter.h	2013-05-30 19:33:26 +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 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_TARGETER_H_
+#define MIR_TEST_DOUBLES_STUB_INPUT_TARGETER_H_
+
+#include "mir/shell/input_targeter.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubInputTargeter : public shell::InputTargeter
+{
+    void focus_changed(std::shared_ptr<input::SurfaceTarget const> const&)
+    {
+    }
+    void focus_cleared()
+    {
+    }
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_TEST_DOUBLES_STUB_INPUT_TARGETER_H_

=== removed file 'include/test/mir_test_doubles/stub_session_target.h'
--- include/test/mir_test_doubles/stub_session_target.h	2013-04-24 05:22:20 +0000
+++ include/test/mir_test_doubles/stub_session_target.h	1970-01-01 00:00:00 +0000
@@ -1,44 +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_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_
-

=== modified file 'include/test/mir_test_doubles/stub_surface_builder.h'
--- include/test/mir_test_doubles/stub_surface_builder.h	2013-05-21 17:16:43 +0000
+++ include/test/mir_test_doubles/stub_surface_builder.h	2013-05-30 19:33:26 +0000
@@ -44,7 +44,8 @@
 
     std::weak_ptr<surfaces::Surface> create_surface(shell::SurfaceCreationParameters const& param)
     {
-        dummy_surface = std::make_shared<surfaces::Surface>(param.name, param.top_left, buffer_bundle, []{});
+        dummy_surface = std::make_shared<surfaces::Surface>(param.name, param.top_left, buffer_bundle, 
+            std::shared_ptr<input::InputChannel>(), []{});
         return dummy_surface;
     }
 

=== modified file 'include/test/mir_test_doubles/stub_surface_target.h'
--- include/test/mir_test_doubles/stub_surface_target.h	2013-04-26 16:12:22 +0000
+++ include/test/mir_test_doubles/stub_surface_target.h	2013-05-30 19:33:26 +0000
@@ -47,9 +47,10 @@
     {
         return geometry::Point();
     }
-    std::string name() const override
+    std::string const& name() const override
     {
-        return std::string();
+        static std::string empty_name;
+        return empty_name;
     }
 
     int input_fd;

=== modified file 'include/test/mir_test_framework/testing_server_configuration.h'
--- include/test/mir_test_framework/testing_server_configuration.h	2013-05-02 00:11:18 +0000
+++ include/test/mir_test_framework/testing_server_configuration.h	2013-05-30 19:33:26 +0000
@@ -48,8 +48,7 @@
     // We override the_input_manager in the default server configuration
     // 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::InputTargetListener> the_input_target_listener();
+    std::shared_ptr<input::InputConfiguration> the_input_configuration();
 
     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-05-28 18:24:07 +0000
+++ src/server/default_server_configuration.cpp	2013-05-30 19:33:26 +0000
@@ -48,12 +48,11 @@
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/graphics/null_display_report.h"
 #include "mir/input/cursor_listener.h"
-#include "mir/input/null_input_manager.h"
-#include "mir/input/null_input_target_listener.h"
+#include "mir/input/null_input_configuration.h"
 #include "mir/input/null_input_report.h"
 #include "input/android/default_android_input_configuration.h"
 #include "input/android/android_input_manager.h"
-#include "input/android/android_dispatcher_controller.h"
+#include "input/android/android_input_targeter.h"
 #include "mir/logging/logger.h"
 #include "mir/logging/input_report.h"
 #include "mir/logging/dumb_console_logger.h"
@@ -347,7 +346,7 @@
         [this]
         {
             return std::make_shared<msh::SingleVisibilityFocusMechanism>(
-                the_shell_session_container());
+                the_shell_session_container(), the_input_targeter());
         });
 }
 
@@ -393,7 +392,6 @@
                 the_shell_session_container(),
                 the_shell_focus_sequence(),
                 the_shell_focus_setter(),
-                the_input_target_listener(),
                 the_shell_session_listener());
         });
 }
@@ -440,7 +438,7 @@
         });
 }
 
-std::shared_ptr<mia::InputConfiguration>
+std::shared_ptr<mi::InputConfiguration>
 mir::DefaultServerConfiguration::the_input_configuration()
 {
     if (!input_configuration)
@@ -463,11 +461,18 @@
             std::weak_ptr<mg::Cursor> const cursor;
         };
 
-        input_configuration = std::make_shared<mia::DefaultInputConfiguration>(
-            the_event_filters(),
-            the_display(),
-            std::make_shared<DefaultCursorListener>(the_display()->the_cursor()),
-            the_input_report());
+        if (the_options()->get("enable-input", enable_input_default))
+        {
+            input_configuration = std::make_shared<mia::DefaultInputConfiguration>(
+                the_event_filters(),
+                the_display(),
+                std::make_shared<DefaultCursorListener>(the_display()->the_cursor()),
+                the_input_report());
+        }
+        else
+        {
+            input_configuration = std::make_shared<mi::NullInputConfiguration>();
+        }
     }
     return input_configuration;
 }
@@ -478,14 +483,9 @@
     return input_manager(
         [&, this]() -> std::shared_ptr<mi::InputManager>
         {
-            if (the_options()->get("enable-input", enable_input_default))
-            {
-                if (the_options()->get(legacy_input_report_opt, off_opt_value) == log_opt_value)
+            if (the_options()->get(legacy_input_report_opt, off_opt_value) == log_opt_value)
                     ml::legacy_input_report::initialize(the_logger());
-                return std::make_shared<mia::InputManager>(the_input_configuration());
-            }
-            else 
-                return std::make_shared<mi::NullInputManager>();
+            return the_input_configuration()->the_input_manager();
         });
 }
 
@@ -518,9 +518,11 @@
 mir::DefaultServerConfiguration::the_surface_stack_model()
 {
     return surface_stack(
-        [this]()
+        [this]() -> std::shared_ptr<ms::SurfaceStack>
         {
-            return std::make_shared<ms::SurfaceStack>(the_buffer_bundle_factory());
+            auto ss = std::make_shared<ms::SurfaceStack>(the_buffer_bundle_factory(), the_input_channel_factory(), the_input_registrar());
+            the_input_configuration()->set_input_targets(ss);
+            return ss;
         });
 }
 
@@ -528,9 +530,11 @@
 mir::DefaultServerConfiguration::the_renderables()
 {
     return surface_stack(
-        [this]()
+        [this]() -> std::shared_ptr<ms::SurfaceStack>
         {
-            return std::make_shared<ms::SurfaceStack>(the_buffer_bundle_factory());
+            auto ss = std::make_shared<ms::SurfaceStack>(the_buffer_bundle_factory(), the_input_channel_factory(), the_input_registrar());
+            the_input_configuration()->set_input_targets(ss);
+            return ss;
         });
 }
 
@@ -541,8 +545,7 @@
         [this]()
         {
             auto surface_source = std::make_shared<msh::SurfaceSource>(
-                the_surface_builder(),
-                the_input_channel_factory());
+                the_surface_builder());
 
             return std::make_shared<msh::OrganisingSurfaceFactory>(
                 surface_source,
@@ -691,15 +694,21 @@
     return the_input_manager();
 }
 
-std::shared_ptr<msh::InputTargetListener> mir::DefaultServerConfiguration::the_input_target_listener()
-{
-    return input_target_listener(
-        [&]() -> std::shared_ptr<msh::InputTargetListener>
-        {
-            if (the_options()->get("enable-input", enable_input_default))
-                return std::make_shared<mia::DispatcherController>(the_input_configuration());
-            else
-                return std::make_shared<mi::NullInputTargetListener>();
+std::shared_ptr<msh::InputTargeter> mir::DefaultServerConfiguration::the_input_targeter()
+{
+    return input_targeter(
+        [&]() -> std::shared_ptr<msh::InputTargeter>
+        {
+            return the_input_configuration()->the_input_targeter();
+        });
+}
+
+std::shared_ptr<ms::InputRegistrar> mir::DefaultServerConfiguration::the_input_registrar()
+{
+    return input_registrar(
+        [&]() -> std::shared_ptr<ms::InputRegistrar>
+        {
+            return the_input_configuration()->the_input_registrar();
         });
 }
 

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2013-05-22 00:44:25 +0000
+++ src/server/frontend/session_mediator.cpp	2013-05-30 19:33:26 +0000
@@ -40,7 +40,7 @@
 
 namespace msh = mir::shell;
 namespace mf = mir::frontend;
-namespace mfd=mir::frontend::detail;
+namespace mfd = mir::frontend::detail;
 
 mf::SessionMediator::SessionMediator(
     std::shared_ptr<frontend::Shell> const& shell,

=== modified file 'src/server/input/CMakeLists.txt'
--- src/server/input/CMakeLists.txt	2013-05-28 17:15:21 +0000
+++ src/server/input/CMakeLists.txt	2013-05-30 19:33:26 +0000
@@ -2,6 +2,8 @@
   INPUT_SOURCES
 
   event_filter_chain.cpp
+
+  null_input_configuration.cpp
   null_input_report.cpp
 )
 

=== modified file 'src/server/input/android/CMakeLists.txt'
--- src/server/input/android/CMakeLists.txt	2013-04-24 05:22:20 +0000
+++ src/server/input/android/CMakeLists.txt	2013-05-30 19:33:26 +0000
@@ -9,7 +9,9 @@
   ${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
-  ${CMAKE_CURRENT_SOURCE_DIR}/android_dispatcher_controller.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_registrar.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_targeter.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_target_enumerator.cpp
 )
 
 set(

=== modified file 'src/server/input/android/android_input_application_handle.cpp'
--- src/server/input/android/android_input_application_handle.cpp	2013-04-24 05:22:20 +0000
+++ src/server/input/android/android_input_application_handle.cpp	2013-05-30 19:33:26 +0000
@@ -18,15 +18,15 @@
 
 #include "android_input_application_handle.h"
 
-#include "mir/input/session_target.h"
+#include "mir/input/surface_target.h"
 
 #include <limits.h>
 
 namespace mi = mir::input;
 namespace mia = mi::android;
 
-mia::InputApplicationHandle::InputApplicationHandle(std::shared_ptr<mi::SessionTarget> const& session)
-  : weak_session(session)
+mia::InputApplicationHandle::InputApplicationHandle(std::shared_ptr<mi::SurfaceTarget> const& surface)
+  : weak_surface(surface)
 {
     updateInfo();
 }
@@ -36,12 +36,12 @@
     if (mInfo == NULL)
         mInfo = new droidinput::InputApplicationInfo;
     
-    auto session = weak_session.lock();
-    if (!session)
+    auto surface = weak_surface.lock();
+    if (!surface)
         return false;
 
     mInfo->dispatchingTimeout = INT_MAX;
-    mInfo->name = droidinput::String8(session->name().c_str());
+    mInfo->name = droidinput::String8(surface->name().c_str());
 
     return true;
 }

=== modified file 'src/server/input/android/android_input_application_handle.h'
--- src/server/input/android/android_input_application_handle.h	2013-04-24 05:22:20 +0000
+++ src/server/input/android/android_input_application_handle.h	2013-05-30 19:33:26 +0000
@@ -30,7 +30,7 @@
 
 namespace input
 {
-class SessionTarget;
+class SurfaceTarget;
 
 namespace android
 {
@@ -38,7 +38,7 @@
 class InputApplicationHandle : public droidinput::InputApplicationHandle
 {
 public:
-    InputApplicationHandle(std::shared_ptr<input::SessionTarget> const& surface);
+    InputApplicationHandle(std::shared_ptr<input::SurfaceTarget> const& surface);
     ~InputApplicationHandle() {}
 
     bool updateInfo();
@@ -48,7 +48,7 @@
     InputApplicationHandle& operator=(InputApplicationHandle const&) = delete;
 
 private:
-    std::weak_ptr<input::SessionTarget> weak_session;
+    std::weak_ptr<input::SurfaceTarget> weak_surface;
 };
 
 }

=== modified file 'src/server/input/android/android_input_manager.cpp'
--- src/server/input/android/android_input_manager.cpp	2013-05-13 09:35:44 +0000
+++ src/server/input/android/android_input_manager.cpp	2013-05-30 19:33:26 +0000
@@ -18,7 +18,6 @@
  */
 
 #include "mir/graphics/viewable_area.h"
-#include "mir/input/session_target.h"
 #include "mir/input/surface_target.h"
 
 #include "android_input_manager.h"
@@ -37,11 +36,14 @@
 namespace mi = mir::input;
 namespace mia = mi::android;
 
-mia::InputManager::InputManager(std::shared_ptr<mia::InputConfiguration> const& config)
-  : event_hub(config->the_event_hub()),
-    dispatcher(config->the_dispatcher()),
-    reader_thread(config->the_reader_thread()),
-    dispatcher_thread(config->the_dispatcher_thread())
+mia::InputManager::InputManager(droidinput::sp<droidinput::EventHubInterface> const& event_hub,
+    droidinput::sp<droidinput::InputDispatcherInterface> const& dispatcher,
+    std::shared_ptr<InputThread> const& reader_thread,
+    std::shared_ptr<InputThread> const& dispatcher_thread)
+  : event_hub(event_hub),
+    dispatcher(dispatcher),
+    reader_thread(reader_thread),
+    dispatcher_thread(dispatcher_thread)
 {
 }
 

=== modified file 'src/server/input/android/android_input_manager.h'
--- src/server/input/android/android_input_manager.h	2013-04-24 05:22:20 +0000
+++ src/server/input/android/android_input_manager.h	2013-05-30 19:33:26 +0000
@@ -37,10 +37,6 @@
 
 namespace mir
 {
-namespace graphics
-{
-class ViewableArea;
-}
 
 namespace input
 {
@@ -49,7 +45,6 @@
 namespace android
 {
 class InputThread;
-class InputConfiguration;
 
 /// Encapsulates an instance of the Android input stack, that is to say an EventHub tied
 /// to an InputReader tied to an InputDispatcher. Provides interfaces for controlling input
@@ -57,8 +52,10 @@
 class InputManager : public mir::input::InputManager
 {
 public:
-    explicit InputManager(
-        std::shared_ptr<InputConfiguration> const& input_configuration);
+    explicit InputManager(droidinput::sp<droidinput::EventHubInterface> const& event_hub,
+                          droidinput::sp<droidinput::InputDispatcherInterface> const& dispatcher,
+                          std::shared_ptr<InputThread> const& reader_thread,
+                          std::shared_ptr<InputThread> const& dispatcher_thread);
     virtual ~InputManager();
 
     void start();

=== added file 'src/server/input/android/android_input_registrar.cpp'
--- src/server/input/android/android_input_registrar.cpp	1970-01-01 00:00:00 +0000
+++ src/server/input/android/android_input_registrar.cpp	2013-05-30 19:33:26 +0000
@@ -0,0 +1,78 @@
+/*
+ * 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_registrar.h"
+
+#include "android_input_window_handle.h"
+#include "android_input_application_handle.h"
+
+#include <InputDispatcher.h>
+
+#include <boost/throw_exception.hpp>
+
+#include <stdexcept>
+#include <mutex>
+
+namespace mi = mir::input;
+namespace mia = mi::android;
+
+mia::InputRegistrar::InputRegistrar(droidinput::sp<droidinput::InputDispatcherInterface> const& input_dispatcher)
+    : input_dispatcher(input_dispatcher)
+{
+}
+
+mia::InputRegistrar::~InputRegistrar() noexcept(true)
+{
+}
+
+void mia::InputRegistrar::input_surface_opened(std::shared_ptr<input::SurfaceTarget> const& opened_surface)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+
+    // TODO: We don't have much use for InputApplicationHandle so we simply use one per surface.
+    // it is only used in droidinput for logging and determining application not responding (ANR),
+    // we determine ANR on a per surface basis. When we have time we should factor InputApplicationHandle out
+    // of the input stack (merging it's state with WindowHandle). ~racarr
+    if (window_handles.find(opened_surface) != window_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("A surface was opened twice"));
+
+    auto application_handle = new mia::InputApplicationHandle(opened_surface);
+    droidinput::sp<droidinput::InputWindowHandle> window_handle = new mia::InputWindowHandle(application_handle, opened_surface);
+    input_dispatcher->registerInputChannel(window_handle->getInfo()->inputChannel, window_handle, false);
+    
+    window_handles[opened_surface] = window_handle;
+}
+
+void mia::InputRegistrar::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);
+}
+
+droidinput::sp<droidinput::InputWindowHandle> mia::InputRegistrar::handle_for_surface(std::shared_ptr<input::SurfaceTarget const> const& surface)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+    if (window_handles.find(surface) == window_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("Requesting handle for an unregistered surface"));
+    return window_handles[surface];
+}

=== added file 'src/server/input/android/android_input_registrar.h'
--- src/server/input/android/android_input_registrar.h	1970-01-01 00:00:00 +0000
+++ src/server/input/android/android_input_registrar.h	2013-05-30 19:33:26 +0000
@@ -0,0 +1,72 @@
+/*
+ * 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_REGISTRAR_H_
+#define MIR_INPUT_ANDROID_REGISTRAR_H_
+
+#include "android_window_handle_repository.h"
+
+#include "mir/surfaces/input_registrar.h"
+
+#include <utils/StrongPointer.h>
+
+#include <map>
+#include <mutex>
+
+namespace android
+{
+class InputDispatcherInterface;
+class InputWindowHandle;
+}
+
+namespace droidinput = android;
+
+namespace mir
+{
+namespace input
+{
+namespace android
+{
+class InputConfiguration;
+class InputTargeter;
+
+class InputRegistrar : public surfaces::InputRegistrar, public WindowHandleRepository
+{
+public:
+    explicit InputRegistrar(droidinput::sp<droidinput::InputDispatcherInterface> const& input_dispatcher);
+    virtual ~InputRegistrar() noexcept(true);
+
+    void input_surface_opened(std::shared_ptr<input::SurfaceTarget> const& opened_surface);
+    void input_surface_closed(std::shared_ptr<input::SurfaceTarget> const& closed_surface);
+
+
+    virtual droidinput::sp<droidinput::InputWindowHandle> handle_for_surface(std::shared_ptr<input::SurfaceTarget const> const& surface);
+
+private:
+    droidinput::sp<droidinput::InputDispatcherInterface> const input_dispatcher;
+
+    std::map<std::shared_ptr<input::SurfaceTarget const>, droidinput::sp<droidinput::InputWindowHandle>> window_handles;
+
+    std::mutex handles_mutex;
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_INPUT_ANDROID_REGISTRAR_H_

=== added file 'src/server/input/android/android_input_target_enumerator.cpp'
--- src/server/input/android/android_input_target_enumerator.cpp	1970-01-01 00:00:00 +0000
+++ src/server/input/android/android_input_target_enumerator.cpp	2013-05-30 19:33:26 +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]>
+ */
+
+#include "android_input_target_enumerator.h"
+
+#include "android_window_handle_repository.h"
+
+#include "mir/input/input_targets.h"
+
+#include <InputWindow.h>
+
+namespace mi = mir::input;
+namespace mia = mi::android;
+
+mia::InputTargetEnumerator::InputTargetEnumerator(std::shared_ptr<mi::InputTargets> const& targets,
+                                                  std::shared_ptr<mia::WindowHandleRepository> const& repository)
+    : targets(targets),
+      repository(repository)
+{
+}
+
+mia::InputTargetEnumerator::~InputTargetEnumerator() noexcept(true)
+{
+}
+
+void mia::InputTargetEnumerator::for_each(std::function<void(droidinput::sp<droidinput::InputWindowHandle> const&)> const& callback)
+{
+    auto t = targets.lock();
+    auto r = repository.lock();
+    t->for_each([&callback, &r, this](std::shared_ptr<mi::SurfaceTarget> const& target){
+            auto handle = r->handle_for_surface(target);
+            callback(handle);
+    });
+}

=== added file 'src/server/input/android/android_input_target_enumerator.h'
--- src/server/input/android/android_input_target_enumerator.h	1970-01-01 00:00:00 +0000
+++ src/server/input/android/android_input_target_enumerator.h	2013-05-30 19:33:26 +0000
@@ -0,0 +1,67 @@
+/*
+ * 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_TARGET_ENUMERATOR_H_
+#define MIR_INPUT_ANDROID_TARGET_ENUMERATOR_H_
+
+#include <InputEnumerator.h>
+
+#include <utils/StrongPointer.h>
+
+#include <memory>
+#include <functional>
+
+namespace android
+{
+class InputWindowHandle;
+}
+
+namespace droidinput = android;
+
+namespace mir
+{
+namespace surfaces
+{
+class InputRegitrar;
+}
+namespace input
+{
+class InputTargets;
+namespace android
+{
+class WindowHandleRepository;
+
+class InputTargetEnumerator : public droidinput::InputEnumerator
+{
+public:
+    explicit InputTargetEnumerator(std::shared_ptr<input::InputTargets> const& targets,
+                                   std::shared_ptr<WindowHandleRepository> const& repository);
+    virtual ~InputTargetEnumerator() noexcept(true);
+    
+    void for_each(std::function<void(droidinput::sp<droidinput::InputWindowHandle> const&)> const& callback);
+    
+private:
+    std::weak_ptr<input::InputTargets> const targets;
+    std::weak_ptr<input::android::WindowHandleRepository> const repository;
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_INPUT_ANDROID_TARGET_ENUMERATOR_H_

=== renamed file 'src/server/input/android/android_dispatcher_controller.cpp' => 'src/server/input/android/android_input_targeter.cpp'
--- src/server/input/android/android_dispatcher_controller.cpp	2013-05-02 00:11:18 +0000
+++ src/server/input/android/android_input_targeter.cpp	2013-05-30 19:33:26 +0000
@@ -16,13 +16,12 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#include "android_dispatcher_controller.h"
+#include "android_input_targeter.h"
+#include "android_input_registrar.h"
 
 #include "android_input_window_handle.h"
 #include "android_input_application_handle.h"
 
-#include "mir/input/android/android_input_configuration.h"
-
 #include <InputDispatcher.h>
 
 #include <boost/throw_exception.hpp>
@@ -32,78 +31,28 @@
 
 namespace mi = mir::input;
 namespace mia = mi::android;
-
-mia::DispatcherController::DispatcherController(std::shared_ptr<mia::InputConfiguration> const& config) :
-    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;
-    windows.push_back(window_handle);
-
-    input_dispatcher->setInputWindows(windows);
+namespace ms = mir::surfaces;
+
+mia::InputTargeter::InputTargeter(droidinput::sp<droidinput::InputDispatcherInterface> const& input_dispatcher,
+                                  std::shared_ptr<mia::WindowHandleRepository> const& repository) :
+    input_dispatcher(input_dispatcher),
+    repository(repository)
+{
+}
+
+void mia::InputTargeter::focus_cleared()
+{
+    droidinput::sp<droidinput::InputWindowHandle> null_window = nullptr;
+    
+    input_dispatcher->setKeyboardFocus(null_window);
+}
+
+void mia::InputTargeter::focus_changed(std::shared_ptr<mi::SurfaceTarget const> const& surface)
+{
+    auto window_handle = repository->handle_for_surface(surface);
+    
+    if (window_handle == NULL)
+        BOOST_THROW_EXCEPTION(std::logic_error("Attempt to set keyboard focus to an unregistered surface"));
+    
+    input_dispatcher->setKeyboardFocus(window_handle);
 }

=== renamed file 'src/server/input/android/android_dispatcher_controller.h' => 'src/server/input/android/android_input_targeter.h'
--- src/server/input/android/android_dispatcher_controller.h	2013-05-02 00:11:18 +0000
+++ src/server/input/android/android_input_targeter.h	2013-05-30 19:33:26 +0000
@@ -16,10 +16,10 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_INPUT_ANDROID_DISPATCHER_CONTROLLER_H_
-#define MIR_INPUT_ANDROID_DISPATCHER_CONTROLLER_H_
+#ifndef MIR_INPUT_ANDROID_TARGET_H_
+#define MIR_INPUT_ANDROID_TARGET_H_
 
-#include "mir/shell/input_target_listener.h"
+#include "mir/shell/input_targeter.h"
 
 #include <utils/StrongPointer.h>
 
@@ -30,7 +30,6 @@
 {
 class InputDispatcherInterface;
 class InputWindowHandle;
-class InputApplicationHandle;
 }
 
 namespace droidinput = android;
@@ -42,38 +41,30 @@
 namespace android
 {
 class InputConfiguration;
+class WindowHandleRepository;
 
-class DispatcherController : public shell::InputTargetListener
+class InputTargeter : public shell::InputTargeter
 {
 public:
-    explicit DispatcherController(std::shared_ptr<InputConfiguration> const& input_configuration);
-    virtual ~DispatcherController() noexcept(true) {}
+    explicit InputTargeter(droidinput::sp<droidinput::InputDispatcherInterface> const& input_dispatcher,
+                           std::shared_ptr<WindowHandleRepository> const& repository);
+    virtual ~InputTargeter() noexcept(true) {}
     
-    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_changed(std::shared_ptr<input::SurfaceTarget const> const& focus_surface);
     void focus_cleared();
 
 protected:
-    DispatcherController(const DispatcherController&) = delete;
-    DispatcherController& operator=(const DispatcherController&) = delete;
+    InputTargeter(const InputTargeter&) = delete;
+    InputTargeter& operator=(const InputTargeter&) = delete;
 
 private:
     droidinput::sp<droidinput::InputDispatcherInterface> input_dispatcher;
 
-    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;
+    std::shared_ptr<WindowHandleRepository> const repository;
 };
 
 }
 }
 } // namespace mir
 
-#endif // MIR_INPUT_ANDROID_DISPATCHER_CONTROLLER_H_
+#endif // MIR_INPUT_ANDROID_TARGET_H_

=== added file 'src/server/input/android/android_window_handle_repository.h'
--- src/server/input/android/android_window_handle_repository.h	1970-01-01 00:00:00 +0000
+++ src/server/input/android/android_window_handle_repository.h	2013-05-30 19:33:26 +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_WINDOW_HANDLE_REPOSITORY_H_
+#define MIR_INPUT_ANDROID_WINDOW_HANDLE_REPOSITORY_H_
+
+#include <utils/StrongPointer.h>
+
+#include <memory>
+
+namespace android
+{
+class InputWindowHandle;
+}
+
+namespace droidinput = android;
+
+namespace mir
+{
+namespace input
+{
+class SurfaceTarget;
+namespace android
+{
+
+/// Interface internal to mir::input::android used for tracking the assosciation between droidinput::InputWindowHandle
+/// and mir::input::SurfaceTarget
+class WindowHandleRepository
+{
+public:
+    virtual ~WindowHandleRepository() = default;
+    
+    virtual droidinput::sp<droidinput::InputWindowHandle> handle_for_surface(std::shared_ptr<input::SurfaceTarget const> const& surface) = 0;
+protected:
+    WindowHandleRepository() = default;
+    WindowHandleRepository(const WindowHandleRepository&) = delete;
+    WindowHandleRepository& operator=(const WindowHandleRepository&) = delete;
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_INPUT_ANDROID_WINDOW_HANDLE_REPOSITORY_H_

=== modified file 'src/server/input/android/default_android_input_configuration.cpp'
--- src/server/input/android/default_android_input_configuration.cpp	2013-05-28 17:47:03 +0000
+++ src/server/input/android/default_android_input_configuration.cpp	2013-05-30 19:33:26 +0000
@@ -20,6 +20,10 @@
 #include "event_filter_dispatcher_policy.h"
 #include "android_input_reader_policy.h"
 #include "android_input_thread.h"
+#include "android_input_registrar.h"
+#include "android_input_targeter.h"
+#include "android_input_target_enumerator.h"
+#include "android_input_manager.h"
 #include "../event_filter_chain.h"
 
 #include <EventHub.h>
@@ -33,6 +37,8 @@
 namespace mi = mir::input;
 namespace mia = mi::android;
 namespace mg = mir::graphics;
+namespace ms = mir::surfaces;
+namespace msh = mir::shell;
 
 namespace
 {
@@ -107,7 +113,7 @@
 droidinput::sp<droidinput::InputDispatcherInterface> mia::DefaultInputConfiguration::the_dispatcher()
 {
     return dispatcher(
-        [this]()
+        [this]() -> droidinput::sp<droidinput::InputDispatcherInterface>
         {
             return new droidinput::InputDispatcher(the_dispatcher_policy(), input_report);
         });
@@ -152,7 +158,49 @@
         });
 }
 
+std::shared_ptr<ms::InputRegistrar> mia::DefaultInputConfiguration::the_input_registrar()
+{
+    return input_registrar(
+        [this]()
+        {
+            return std::make_shared<mia::InputRegistrar>(the_dispatcher());
+        });
+}
+
+std::shared_ptr<mia::WindowHandleRepository> mia::DefaultInputConfiguration::the_window_handle_repository()
+{
+    return input_registrar(
+        [this]()
+        {
+            return std::make_shared<mia::InputRegistrar>(the_dispatcher());
+        });
+}
+
+std::shared_ptr<msh::InputTargeter> mia::DefaultInputConfiguration::the_input_targeter()
+{
+    return input_targeter(
+        [this]()
+        {
+            return std::make_shared<mia::InputTargeter>(the_dispatcher(), the_window_handle_repository());
+        });
+}
+
+std::shared_ptr<mi::InputManager> mia::DefaultInputConfiguration::the_input_manager()
+{
+    return input_manager(
+        [this]()
+        {
+            return std::make_shared<mia::InputManager>(the_event_hub(), the_dispatcher(),
+                                                       the_reader_thread(), the_dispatcher_thread());
+        });
+}
+
 bool mia::DefaultInputConfiguration::is_key_repeat_enabled()
 {
     return true;
 }
+
+void mia::DefaultInputConfiguration::set_input_targets(std::shared_ptr<mi::InputTargets> const& targets)
+{
+    the_dispatcher()->setInputEnumerator(new mia::InputTargetEnumerator(targets, the_window_handle_repository()));
+}

=== modified file 'src/server/input/android/default_android_input_configuration.h'
--- src/server/input/android/default_android_input_configuration.h	2013-05-28 17:15:21 +0000
+++ src/server/input/android/default_android_input_configuration.h	2013-05-30 19:33:26 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_INPUT_ANDROID_DEFAULT_ANDROID_INPUT_CONFIGURATION_H_
 #define MIR_INPUT_ANDROID_DEFAULT_ANDROID_INPUT_CONFIGURATION_H_
 
-#include "mir/input/android/android_input_configuration.h"
+#include "mir/input/input_configuration.h"
 
 #include "mir/cached_ptr.h"
 
@@ -35,6 +35,8 @@
 class InputReaderInterface;
 class InputReaderPolicyInterface;
 class InputDispatcherPolicyInterface;
+class InputDispatcherInterface;
+class EventHubInterface;
 }
 
 namespace mir
@@ -43,6 +45,10 @@
 {
 class ViewableArea;
 }
+namespace shell
+{
+class InputTargeter;
+}
 namespace input
 {
 class EventFilter;
@@ -52,8 +58,11 @@
 
 namespace android
 {
+class InputRegistrar;
+class WindowHandleRepository;
+class InputThread;
 
-class DefaultInputConfiguration : public InputConfiguration
+class DefaultInputConfiguration : public input::InputConfiguration
 {
 public:
     DefaultInputConfiguration(std::initializer_list<std::shared_ptr<EventFilter> const> const& filters,
@@ -62,22 +71,29 @@
                               std::shared_ptr<input::InputReport> const& input_report);
     virtual ~DefaultInputConfiguration();
 
-    droidinput::sp<droidinput::EventHubInterface> the_event_hub();
-    droidinput::sp<droidinput::InputDispatcherInterface> the_dispatcher();
-    droidinput::sp<droidinput::InputReaderInterface> the_reader();
-
-    std::shared_ptr<InputThread> the_dispatcher_thread();
-    std::shared_ptr<InputThread> the_reader_thread();
+    std::shared_ptr<surfaces::InputRegistrar> the_input_registrar();
+    std::shared_ptr<shell::InputTargeter> the_input_targeter();
+    std::shared_ptr<input::InputManager> the_input_manager();
+    
+    void set_input_targets(std::shared_ptr<input::InputTargets> const& targets);
+
+    virtual bool is_key_repeat_enabled();
+    
+protected:
+    virtual droidinput::sp<droidinput::EventHubInterface> the_event_hub();
+    virtual droidinput::sp<droidinput::InputDispatcherInterface> the_dispatcher();
+    virtual droidinput::sp<droidinput::InputReaderInterface> the_reader();
+
+    virtual std::shared_ptr<InputThread> the_dispatcher_thread();
+    virtual std::shared_ptr<InputThread> the_reader_thread();
 
     virtual droidinput::sp<droidinput::InputDispatcherPolicyInterface> the_dispatcher_policy();
     virtual droidinput::sp<droidinput::InputReaderPolicyInterface> the_reader_policy();
-    
-    virtual bool is_key_repeat_enabled();
-
-protected:
+
+    std::shared_ptr<WindowHandleRepository> the_window_handle_repository();
+
     DefaultInputConfiguration(DefaultInputConfiguration const&) = delete;
     DefaultInputConfiguration& operator=(DefaultInputConfiguration const&) = delete;
-
 private:
     template <typename Type>
     class CachedAndroidPtr
@@ -104,10 +120,16 @@
     std::shared_ptr<EventFilterChain> const filter_chain;
     std::shared_ptr<graphics::ViewableArea> const view_area;
     std::shared_ptr<CursorListener> const cursor_listener;
+    
     std::shared_ptr<input::InputReport> const input_report;
 
     CachedPtr<InputThread> dispatcher_thread;
     CachedPtr<InputThread> reader_thread;
+    CachedPtr<InputRegistrar> input_registrar;
+
+    CachedPtr<shell::InputTargeter> input_targeter;
+    CachedPtr<input::InputManager> input_manager;
+
     CachedAndroidPtr<droidinput::EventHubInterface> event_hub;
     CachedAndroidPtr<droidinput::InputDispatcherPolicyInterface> dispatcher_policy;
     CachedAndroidPtr<droidinput::InputReaderPolicyInterface> reader_policy;

=== added file 'src/server/input/null_input_configuration.cpp'
--- src/server/input/null_input_configuration.cpp	1970-01-01 00:00:00 +0000
+++ src/server/input/null_input_configuration.cpp	2013-05-30 19:33:26 +0000
@@ -0,0 +1,93 @@
+/*
+ * 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 "mir/input/null_input_configuration.h"
+
+#include "mir/surfaces/input_registrar.h"
+#include "mir/shell/input_targeter.h"
+#include "mir/input/input_manager.h"
+
+namespace mi = mir::input;
+namespace ms = mir::surfaces;
+namespace msh = mir::shell;
+
+namespace
+{
+
+struct NullInputRegistrar : public ms::InputRegistrar
+{
+    NullInputRegistrar() = default;
+    virtual ~NullInputRegistrar() noexcept(true) = default;
+    
+    void input_surface_opened(std::shared_ptr<mi::SurfaceTarget> const&)
+    {
+    }
+
+    void input_surface_closed(std::shared_ptr<mi::SurfaceTarget> const&)
+    {
+    }
+};
+
+struct NullInputTargeter : public msh::InputTargeter
+{
+    NullInputTargeter() = default;
+    virtual ~NullInputTargeter() noexcept(true) = default;
+
+    void focus_changed(std::shared_ptr<mi::SurfaceTarget const> const&)
+    {
+    }
+
+    void focus_cleared()
+    {
+    }
+};
+
+struct NullInputManager : public mi::InputManager
+{
+    void start()
+    {
+    }
+    void stop()
+    {
+    }
+    std::shared_ptr<mi::InputChannel> make_input_channel()
+    {
+        return std::shared_ptr<mi::InputChannel>();
+    }
+};
+
+}
+
+std::shared_ptr<ms::InputRegistrar> mi::NullInputConfiguration::the_input_registrar()
+{
+    return std::make_shared<NullInputRegistrar>();
+}
+
+std::shared_ptr<msh::InputTargeter> mi::NullInputConfiguration::the_input_targeter()
+{
+    return std::make_shared<NullInputTargeter>();
+}
+
+std::shared_ptr<mi::InputManager> mi::NullInputConfiguration::the_input_manager()
+{
+    return std::make_shared<NullInputManager>();
+}
+
+void mi::NullInputConfiguration::set_input_targets(std::shared_ptr<mi::InputTargets> const&)
+{
+}

=== modified file 'src/server/shell/application_session.cpp'
--- src/server/shell/application_session.cpp	2013-05-21 17:16:43 +0000
+++ src/server/shell/application_session.cpp	2013-05-30 19:33:26 +0000
@@ -19,7 +19,6 @@
 #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>
 
@@ -34,11 +33,9 @@
 
 msh::ApplicationSession::ApplicationSession(
     std::shared_ptr<SurfaceFactory> const& surface_factory,
-    std::shared_ptr<msh::InputTargetListener> const& input_target_listener,
     std::string const& session_name,
     std::shared_ptr<me::EventSink> const& sink) :
     surface_factory(surface_factory),
-    input_target_listener(input_target_listener),
     session_name(session_name),
     event_sink(sink),
     next_surface_id(0)
@@ -48,9 +45,8 @@
 
 msh::ApplicationSession::ApplicationSession(
     std::shared_ptr<SurfaceFactory> const& surface_factory,
-    std::shared_ptr<msh::InputTargetListener> const& input_target_listener,
     std::string const& session_name) :
-    ApplicationSession(surface_factory, input_target_listener, session_name, std::shared_ptr<me::EventSink>())
+    ApplicationSession(surface_factory, session_name, std::shared_ptr<me::EventSink>())
 {
 }
 
@@ -59,7 +55,6 @@
     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();
     }
 }
@@ -109,7 +104,6 @@
     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-05-21 17:16:43 +0000
+++ src/server/shell/session_manager.cpp	2013-05-30 19:33:26 +0000
@@ -24,7 +24,6 @@
 #include "mir/shell/focus_setter.h"
 #include "mir/shell/session.h"
 #include "mir/shell/surface.h"
-#include "mir/shell/input_target_listener.h"
 #include "mir/shell/session_listener.h"
 
 #include <memory>
@@ -38,20 +37,17 @@
     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::InputTargetListener> const& input_target_listener,
     std::shared_ptr<msh::SessionListener> const& session_listener) :
     surface_factory(surface_factory),
     app_container(container),
     focus_sequence(sequence),
     focus_setter(focus_setter),
-    input_target_listener(input_target_listener),
     session_listener(session_listener)
 {
     assert(surface_factory);
     assert(sequence);
     assert(container);
     assert(focus_setter);
-    assert(input_target_listener);
     assert(session_listener);
 }
 
@@ -60,7 +56,7 @@
     /*
      * Close all open sessions. We need to do this manually here
      * to break the cyclic dependency between msh::Session
-     * and msh::InputTargetListener, since our implementations
+     * and mi::*, since our implementations
      * of these interfaces keep strong references to each other.
      * TODO: Investigate other solutions (e.g. weak_ptr)
      */
@@ -79,11 +75,10 @@
     std::string const& name,
     std::shared_ptr<events::EventSink> const& sink)
 {
-    std::shared_ptr<msh::Session> new_session = std::make_shared<msh::ApplicationSession>(surface_factory, input_target_listener, name, sink);
+    std::shared_ptr<msh::Session> new_session = std::make_shared<msh::ApplicationSession>(surface_factory, name, sink);
 
     app_container->insert_session(new_session);
     
-    input_target_listener->input_application_opened(new_session);
     session_listener->starting(new_session);
 
     set_focus_to_locked(std::unique_lock<std::mutex>(mutex), new_session);
@@ -97,18 +92,12 @@
 
     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);
     session_listener->stopping(shell_session);
 
     app_container->remove_session(shell_session);
@@ -145,8 +134,6 @@
     auto shell_session = std::dynamic_pointer_cast<Session>(session);
     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-05-02 00:11:18 +0000
+++ src/server/shell/single_visibility_focus_mechanism.cpp	2013-05-30 19:33:26 +0000
@@ -16,27 +16,36 @@
  * Authored By: Robert Carr <[e-mail]>
  */
 
+#include "mir/frontend/session.h"
 #include "mir/shell/session_container.h"
-#include "mir/frontend/session.h"
 #include "mir/shell/single_visibility_focus_mechanism.h"
-
+#include "mir/shell/input_targeter.h"
 #include "mir/shell/session.h"
 #include "mir/shell/surface.h"
 
 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::InputTargeter> const& input_targeter)
+  : app_container(app_container),
+    input_targeter(input_targeter)
 {
 }
 
 void msh::SingleVisibilityFocusMechanism::set_focus_to(std::shared_ptr<Session> const& focus_session)
 {
+    bool set_input_focus = false;
     app_container->for_each(
         [&](std::shared_ptr<mf::Session> const& session) {
         if (session == focus_session)
         {
+            auto surface = focus_session->default_surface();
+            if (surface)
+            {
+                surface->take_input_focus(input_targeter);
+                set_input_focus = true;
+            }
             session->show();
         }
         else
@@ -44,4 +53,7 @@
             session->hide();
         }
     });
+
+    if (set_input_focus == false)
+        input_targeter->focus_cleared();
 }

=== modified file 'src/server/shell/surface.cpp'
--- src/server/shell/surface.cpp	2013-05-21 17:16:43 +0000
+++ src/server/shell/surface.cpp	2013-05-30 19:33:26 +0000
@@ -18,9 +18,11 @@
 
 #include "mir/shell/surface.h"
 #include "mir/shell/surface_builder.h"
+#include "mir/shell/input_targeter.h"
 #include "mir/input/input_channel.h"
+#include "mir/events/event_sink.h"
+
 #include "mir_toolkit/event.h"
-#include "mir/events/event_sink.h"
 
 #include <boost/throw_exception.hpp>
 
@@ -30,15 +32,14 @@
 namespace msh = mir::shell;
 namespace mc = mir::compositor;
 namespace mi = mir::input;
+namespace ms = mir::surfaces;
 
 msh::Surface::Surface(
     std::shared_ptr<SurfaceBuilder> const& builder,
     shell::SurfaceCreationParameters const& params,
-    std::shared_ptr<input::InputChannel> const& input_channel,
     frontend::SurfaceId id,
     std::shared_ptr<events::EventSink> const& sink)
   : builder(builder),
-    input_channel(input_channel),
     surface(builder->create_surface(params)),
     id(id),
     event_sink(sink),
@@ -49,10 +50,8 @@
 
 msh::Surface::Surface(
     std::shared_ptr<SurfaceBuilder> const& builder,
-    shell::SurfaceCreationParameters const& params,
-    std::shared_ptr<input::InputChannel> const& input_channel)
+    shell::SurfaceCreationParameters const& params)
   : builder(builder),
-    input_channel(input_channel),
     surface(builder->create_surface(params)),
     id(),
     event_sink(),
@@ -168,23 +167,38 @@
 
 bool msh::Surface::supports_input() const
 {
-    if (input_channel)
-        return true;
-    return false;
+    if (auto const& s = surface.lock())
+    {
+        return s->supports_input();
+    }
+    else
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface"));
+    }
 }
 
 int msh::Surface::client_input_fd() const
 {
-    if (!supports_input())
-        BOOST_THROW_EXCEPTION(std::logic_error("Surface does not support input"));
-    return input_channel->client_fd();
+    if (auto const& s = surface.lock())
+    {
+        return s->client_input_fd();
+    }
+    else
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface"));
+    }
 }
 
 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();
+    if (auto const& s = surface.lock())
+    {
+        return s->server_input_fd();
+    }
+    else
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface"));
+    }
 }
 
 int msh::Surface::configure(MirSurfaceAttrib attrib, int value)
@@ -276,3 +290,12 @@
         event_sink->handle_event(e);
     }
 }
+
+void msh::Surface::take_input_focus(std::shared_ptr<msh::InputTargeter> const& targeter)
+{
+    auto s = surface.lock();
+    if (s)
+        targeter->focus_changed(s);
+    else
+        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface"));
+}

=== modified file 'src/server/shell/surface_source.cpp'
--- src/server/shell/surface_source.cpp	2013-05-21 17:16:43 +0000
+++ src/server/shell/surface_source.cpp	2013-05-30 19:33:26 +0000
@@ -30,11 +30,8 @@
 namespace mf = mir::frontend;
 
 
-msh::SurfaceSource::SurfaceSource(
-    std::shared_ptr<SurfaceBuilder> const& surface_builder,
-    std::shared_ptr<mi::InputChannelFactory> const& input_factory) :
-    surface_builder(surface_builder),
-    input_factory(input_factory)
+msh::SurfaceSource::SurfaceSource(std::shared_ptr<SurfaceBuilder> const& surface_builder)
+    : surface_builder(surface_builder)
 {
     assert(surface_builder);
 }
@@ -47,7 +44,6 @@
     return std::make_shared<Surface>(
         surface_builder,
         params,
-        input_factory->make_input_channel(),
         id,
         sink);
 }

=== modified file 'src/server/surfaces/surface.cpp'
--- src/server/surfaces/surface.cpp	2013-05-22 00:44:25 +0000
+++ src/server/surfaces/surface.cpp	2013-05-30 19:33:26 +0000
@@ -20,23 +20,31 @@
 
 #include "mir/surfaces/surface.h"
 #include "mir/surfaces/buffer_bundle.h"
-
+#include "mir/input/input_channel.h"
+
+#include <boost/throw_exception.hpp>
+
+#include <stdexcept>
 #include <cassert>
+
 #include <glm/gtc/matrix_transform.hpp>
 
 namespace mc = mir::compositor;
 namespace ms = mir::surfaces;
 namespace mg = mir::graphics;
+namespace mi = mir::input;
 namespace geom = mir::geometry;
 
 ms::Surface::Surface(
     std::string const& name,
     geom::Point const& top_left,
     std::shared_ptr<BufferBundle> buffer_bundle,
+    std::shared_ptr<input::InputChannel> const& input_channel,
     std::function<void()> const& change_callback) :
     surface_name(name),
     top_left_point(top_left),
     buffer_bundle(buffer_bundle),
+    input_channel(input_channel),
     client_buffer_resource(buffer_bundle->secure_client_buffer()),
     alpha_value(1.0f),
     is_hidden(false),
@@ -173,3 +181,24 @@
 {
     buffer_is_valid = true;
 }
+
+bool ms::Surface::supports_input() const
+{
+    if (input_channel)
+        return true;
+    return false;
+}
+
+int ms::Surface::client_input_fd() const
+{
+    if (!supports_input())
+        BOOST_THROW_EXCEPTION(std::logic_error("Surface does not support input"));
+    return input_channel->client_fd();
+}
+
+int ms::Surface::server_input_fd() const
+{
+    if (!supports_input())
+        BOOST_THROW_EXCEPTION(std::logic_error("Surface does not support input"));
+    return input_channel->server_fd();
+}

=== modified file 'src/server/surfaces/surface_stack.cpp'
--- src/server/surfaces/surface_stack.cpp	2013-05-21 17:16:43 +0000
+++ src/server/surfaces/surface_stack.cpp	2013-05-30 19:33:26 +0000
@@ -24,6 +24,8 @@
 #include "mir/shell/surface_creation_parameters.h"
 #include "mir/surfaces/surface.h"
 #include "mir/surfaces/surface_stack.h"
+#include "mir/surfaces/input_registrar.h"
+#include "mir/input/input_channel_factory.h"
 
 #include <algorithm>
 #include <cassert>
@@ -33,10 +35,15 @@
 namespace ms = mir::surfaces;
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
+namespace mi = mir::input;
 namespace geom = mir::geometry;
 
-ms::SurfaceStack::SurfaceStack(std::shared_ptr<BufferBundleFactory> const& bb_factory)
+ms::SurfaceStack::SurfaceStack(std::shared_ptr<BufferBundleFactory> const& bb_factory,
+                               std::shared_ptr<mi::InputChannelFactory> const& input_factory,
+                               std::shared_ptr<ms::InputRegistrar> const& input_registrar)
     : buffer_bundle_factory{bb_factory},
+      input_factory{input_factory},
+      input_registrar{input_registrar},
       notify_change{[]{}}
 {
     assert(buffer_bundle_factory);
@@ -70,6 +77,7 @@
         new ms::Surface(
             params.name, params.top_left,
             buffer_bundle_factory->create_buffer_bundle(buffer_properties),
+            input_factory->make_input_channel(),
             [this]() { emit_change_notification(); }));
     
     {
@@ -77,6 +85,10 @@
         surfaces.push_back(surface);
     }
 
+    // TODO: It might be a nice refactoring to combine this with input channel creation
+    // i.e. client_fd = registrar->register_for_input(surface). ~racarr
+    input_registrar->input_surface_opened(surface);
+
     emit_change_notification();
 
     return surface;
@@ -88,8 +100,12 @@
         std::lock_guard<std::mutex> lg(guard);
 
         auto const p = std::find(surfaces.begin(), surfaces.end(), surface.lock());
-
-        if (p != surfaces.end()) surfaces.erase(p);
+        
+        if (p != surfaces.end())
+        {
+            input_registrar->input_surface_closed(*p);
+            surfaces.erase(p);
+        }
         // else; TODO error logging
     }
 
@@ -101,3 +117,9 @@
     std::lock_guard<std::mutex> lock{notify_change_mutex};
     notify_change();
 }
+
+void ms::SurfaceStack::for_each(std::function<void(std::shared_ptr<mi::SurfaceTarget> const&)> const& callback)
+{
+    for (auto it = surfaces.rbegin(); it != surfaces.rend(); ++it)
+        callback(*it);
+}

=== modified file 'src/shared/input/android/android_input_receiver.cpp'
--- src/shared/input/android/android_input_receiver.cpp	2013-05-17 19:42:09 +0000
+++ src/shared/input/android/android_input_receiver.cpp	2013-05-30 19:33:26 +0000
@@ -71,14 +71,29 @@
 
 }
 
+bool mircva::InputReceiver::try_next_event(MirEvent &ev)
+{
+    droidinput::InputEvent *android_event;
+    uint32_t event_sequence_id;
+
+   if(input_consumer->consume(&event_factory, true,
+        -1, &event_sequence_id, &android_event) != droidinput::WOULD_BLOCK)
+    {
+        mia::Lexicon::translate(android_event, ev);
+
+        map_key_event(xkb_mapper, ev);
+
+        input_consumer->sendFinishedSignal(event_sequence_id, true);
+
+        return true;
+    }
+   return false;
+}
+
 // TODO: We use a droidinput::Looper here for polling functionality but it might be nice to integrate
 // with the existing client io_service ~racarr ~tvoss
 bool mircva::InputReceiver::next_event(std::chrono::milliseconds const& timeout, MirEvent &ev)
 {
-    droidinput::InputEvent *android_event;
-    uint32_t event_sequence_id;
-    bool handled_event = false;
-
     if (!fd_added)
     {
         // TODO: Why will this fail from the constructor? ~racarr
@@ -86,27 +101,16 @@
         fd_added = true;
     }
     
+    if(try_next_event(ev))
+        return true;
+
     auto result = looper->pollOnce(timeout.count());
     if (result == ALOOPER_POLL_WAKE)
         return false;
-    else if (result == ALOOPER_POLL_ERROR) // TODO: Exception?
-        return false;
-
-    if(input_consumer->consume(&event_factory, true,
-        -1, &event_sequence_id, &android_event) != droidinput::WOULD_BLOCK)
-    {
-        mia::Lexicon::translate(android_event, ev);
-
-        map_key_event(xkb_mapper, ev);
-
-        input_consumer->sendFinishedSignal(event_sequence_id, true);
-        handled_event = true;
-    }
-
-    // So far once we have sent an event to the client there is no chance for redispatch
-    // so the client handles all events.
-    
-    return handled_event;
+    if (result == ALOOPER_POLL_ERROR) // TODO: Exception?
+       return false;
+
+    return try_next_event(ev);
 }
 
 void mircva::InputReceiver::wake()

=== modified file 'src/shared/input/android/android_input_receiver.h'
--- src/shared/input/android/android_input_receiver.h	2013-05-13 23:20:52 +0000
+++ src/shared/input/android/android_input_receiver.h	2013-05-30 19:33:26 +0000
@@ -78,6 +78,8 @@
     bool fd_added;
 
     std::shared_ptr<XKBMapper> xkb_mapper;
+    
+    bool try_next_event(MirEvent &ev);
 };
 
 }

=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2013-05-28 17:15:21 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2013-05-30 19:33:26 +0000
@@ -17,9 +17,12 @@
  */
 
 #include "mir/graphics/display.h"
+#include "mir/graphics/viewable_area.h"
+#include "mir/shell/surface_creation_parameters.h"
+#include "mir/shell/placement_strategy.h"
 
 #include "src/server/input/android/android_input_manager.h"
-#include "src/server/input/android/android_dispatcher_controller.h"
+#include "src/server/input/android/android_input_targeter.h"
 
 #include "mir_toolkit/mir_client_library.h"
 
@@ -38,11 +41,16 @@
 
 #include <thread>
 #include <functional>
+#include <map>
 
 namespace mi = mir::input;
 namespace mia = mi::android;
 namespace mis = mi::synthesis;
+namespace mf = mir::frontend;
 namespace msh = mir::shell;
+namespace ms = mir::surfaces;
+namespace mg = mir::graphics;
+namespace geom = mir::geometry;
 namespace mt = mir::test;
 namespace mtd = mt::doubles;
 namespace mtf = mir_test_framework;
@@ -52,30 +60,36 @@
     char const* const mir_test_socket = mtf::test_socket_file().c_str();
 }
 
+#include "mir/input/surface_target.h"
+
 namespace
 {
-
-struct FocusNotifyingDispatcherController : public mia::DispatcherController
+struct FocusNotifyingInputTargeter : public msh::InputTargeter
 {
-    FocusNotifyingDispatcherController(std::shared_ptr<mia::InputConfiguration> const& configuration,
-                                       mt::WaitCondition &wait_condition)
-      : DispatcherController(configuration),
-        on_focus_set(wait_condition)
+    FocusNotifyingInputTargeter(std::shared_ptr<msh::InputTargeter> const& real_targeter,
+                                std::function<void(void)> const& focus_set)
+      : real_targeter(real_targeter),
+        focus_set(focus_set)
     {
 
     }
+    virtual ~FocusNotifyingInputTargeter() noexcept(true) {}
     
-    void focus_changed(std::shared_ptr<mi::SurfaceTarget> const& surface) override
+    void focus_changed(std::shared_ptr<mi::SurfaceTarget const> const& surface) override
     {
-        DispatcherController::focus_changed(surface);
-        
+        real_targeter->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).
-        if (surface)
-            on_focus_set.wake_up_everyone();
+        focus_set();
+    }
+    void focus_cleared()
+    {
+        real_targeter->focus_cleared();
     }
 
-    mt::WaitCondition &on_focus_set;
+    std::shared_ptr<msh::InputTargeter> const real_targeter;
+    std::function<void(void)> focus_set;
 };
 
 struct FakeInputServerConfiguration : public mir_test_framework::TestingServerConfiguration
@@ -85,57 +99,41 @@
     {
     }
 
-    virtual void inject_input()
-    {
-    }
-    
-    void exec() override
-    {
-        input_injection_thread = std::thread([this]() -> void
-        {
-            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();
-        });
-    }
-    
-    void on_exit() override
-    {
-        input_injection_thread.join();
-    }
-    
-    std::shared_ptr<mia::InputConfiguration> the_input_configuration() override
+    virtual void inject_input_after_focus()
+    {
+    }
+    
+    std::shared_ptr<mi::InputConfiguration> the_input_configuration() override
     {
         fake_event_hub = input_config.the_fake_event_hub();
+        fake_event_hub->synthesize_builtin_keyboard_added();
+        fake_event_hub->synthesize_builtin_cursor_added();
+        fake_event_hub->synthesize_device_scan_complete();
+
         return mt::fake_shared(input_config);
     }
     
     std::shared_ptr<mi::InputManager> the_input_manager() override
     {
-        return input_manager(
-            [&]()
-            {
-                // Force usage of real input even in case of tests-use-real-input = false.
-                return std::make_shared<mia::InputManager>(the_input_configuration());
-            });
+        return DefaultServerConfiguration::the_input_manager();
+    }
+    std::shared_ptr<ms::InputRegistrar> the_input_registrar() override
+    {        
+        return DefaultServerConfiguration::the_input_registrar();
     }
 
-    std::shared_ptr<msh::InputTargetListener>
-    the_input_target_listener() override
+    std::shared_ptr<msh::InputTargeter>
+    the_input_targeter() override
     {
-        return input_target_listener(
+        return input_targeter(
             [this]()
             {
-                return std::make_shared<FocusNotifyingDispatcherController>(mt::fake_shared(input_config), on_focus_set);
+                return std::make_shared<FocusNotifyingInputTargeter>(DefaultServerConfiguration::the_input_targeter(), std::bind(std::mem_fn(&FakeInputServerConfiguration::inject_input_after_focus), this));
             });
     }
 
     mtd::FakeEventHubInputConfiguration input_config;
     mia::FakeEventHub* fake_event_hub;
-    mt::WaitCondition on_focus_set;
-    std::thread input_injection_thread;
 };
 
 
@@ -201,6 +199,7 @@
     static void handle_input(MirSurface* /* surface */, MirEvent const* ev, void* context)
     {
         auto client = static_cast<InputReceivingClient *>(context);
+
         if (client->handler->handle_input(ev))
         {
             client->event_received[client->events_received].wake_up_everyone();
@@ -210,6 +209,18 @@
     virtual void expect_input()
     {
     }
+    
+    virtual MirSurfaceParameters parameters()
+    {
+        MirSurfaceParameters const request_params =
+         {
+             __PRETTY_FUNCTION__,
+             surface_width, surface_height,
+             mir_pixel_format_abgr_8888,
+             mir_buffer_usage_hardware
+         };
+        return request_params;
+    }
 
     void exec()
     {
@@ -223,18 +234,13 @@
             connection_callback,
             this));
          ASSERT_TRUE(connection != NULL);
-         MirSurfaceParameters const request_params =
-         {
-             __PRETTY_FUNCTION__,
-             surface_width, surface_height,
-             mir_pixel_format_abgr_8888,
-             mir_buffer_usage_hardware
-         };
+    
          MirEventDelegate const event_delegate =
          {
              handle_input,
              this
          };
+         auto request_params = parameters();
          mir_wait_for(mir_connection_create_surface(connection, &request_params, create_surface_callback, this));
 
          mir_surface_set_event_handler(surface, &event_delegate);
@@ -253,7 +259,7 @@
     }
     
     std::shared_ptr<MockInputHandler> handler;
-    static int const max_events_to_receive = 3;
+    static int const max_events_to_receive = 4;
     mt::WaitCondition event_received[max_events_to_receive];
     
     int events_to_receive;
@@ -288,6 +294,15 @@
 
     return true;
 }
+MATCHER(HoverExitEvent, "")
+{
+    if (arg->type != mir_event_type_motion)
+        return false;
+    if (arg->motion.action != mir_motion_action_hover_exit)
+        return false;
+
+    return true;
+}
 
 MATCHER_P2(ButtonDownEvent, x, y, "")
 {
@@ -308,6 +323,9 @@
 {
     if (arg->type != mir_event_type_motion)
         return false;
+    if (arg->motion.action != mir_motion_action_move &&
+        arg->motion.action != mir_motion_action_hover_move)
+        return false;
     if (arg->motion.pointer_coordinates[0].x != x)
         return false;
     if (arg->motion.pointer_coordinates[0].y != y)
@@ -328,7 +346,7 @@
 
     struct InputProducingServerConfiguration : FakeInputServerConfiguration
     {
-        void inject_input()
+        void inject_input_after_focus()
         {
             // We send multiple events in order to verify the client is handling them
             // and server dispatch does not become backed up.
@@ -358,7 +376,7 @@
     
     struct InputProducingServerConfiguration : FakeInputServerConfiguration
     {
-        void inject_input()
+        void inject_input_after_focus()
         {
             fake_event_hub->synthesize_event(mis::a_key_down_event()
                                              .of_scancode(KEY_LEFTSHIFT));
@@ -394,7 +412,7 @@
     
     struct InputProducingServerConfiguration : FakeInputServerConfiguration
     {
-        void inject_input()
+        void inject_input_after_focus()
         {
             fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(InputReceivingClient::surface_width,
                                                                                  InputReceivingClient::surface_height));
@@ -430,7 +448,7 @@
     
     struct InputProducingServerConfiguration : FakeInputServerConfiguration
     {
-        void inject_input()
+        void inject_input_after_focus()
         {
             fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
         }
@@ -453,3 +471,165 @@
     } client_config;
     launch_client_process(client_config);
 }
+
+namespace
+{
+struct StubViewableArea : public mg::ViewableArea
+{
+    StubViewableArea(int width, int height) :
+        width(width),
+        height(height),
+        x(0),
+        y(0)
+    {
+    }
+    
+    geom::Rectangle view_area() const
+    {
+        return geom::Rectangle{geom::Point{x, y},
+            geom::Size{width, height}};
+    }
+    
+    geom::Width const width;
+    geom::Height const height;
+    geom::X const x;
+    geom::Y const y;
+};
+
+typedef std::map<std::string, geom::Point> PositionList;
+
+struct StaticPlacementStrategy : public msh::PlacementStrategy
+{
+    StaticPlacementStrategy(PositionList positions)
+        : surface_positions_by_name(positions)
+    {
+    }
+
+    msh::SurfaceCreationParameters place(msh::SurfaceCreationParameters const& request_parameters)
+    {
+        auto placed = request_parameters;
+        placed.top_left = surface_positions_by_name[request_parameters.name];
+        return placed;
+    }
+    PositionList surface_positions_by_name;
+};
+
+}
+
+TEST_F(TestClientInput, multiple_clients_receive_motion_inside_windows)
+{
+    using namespace ::testing;
+    
+    int const screen_width = 1000;
+    int const screen_height = 800;
+    int const client_width = screen_width/2;
+    int const client_height = screen_height;
+    std::string const surface1_name = "1";
+    std::string const surface2_name = "2";
+    
+    PositionList positions;
+    positions[surface1_name] = geom::Point{geom::X{0}, geom::Y{0}};
+    positions[surface2_name] = geom::Point{geom::X{screen_width/2}, geom::Y{0}};
+
+    struct TestServerConfiguration : FakeInputServerConfiguration
+    {
+        TestServerConfiguration(int screen_width, int screen_height, PositionList positions)
+            : screen_width(screen_width),
+              screen_height(screen_height),
+              positions(positions),
+              clients_ready(0)
+        {
+        }
+
+        std::shared_ptr<mg::ViewableArea> the_viewable_area() override
+        {
+            return std::make_shared<StubViewableArea>(screen_width, screen_height);
+        }
+        std::shared_ptr<msh::PlacementStrategy> the_shell_placement_strategy() override
+        {
+            return std::make_shared<StaticPlacementStrategy>(positions);
+        }
+
+        void inject_input_after_focus() override
+        {
+            clients_ready++;
+            if (clients_ready != 2) // We wait until both clients have connected and registered with the input stack.
+                return;
+            
+            // In the bounds of the first surface
+            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(screen_width/2-1, 0));
+            // In the bounds of the second surface
+            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(screen_width/2, 0));
+        }
+        int screen_width, screen_height;
+        PositionList positions;
+
+        int clients_ready;
+    } server_config(screen_width, screen_height, positions);
+    
+    launch_server_process(server_config);
+    
+    MirSurfaceParameters const surface1_params =
+        {
+            surface1_name.c_str(),
+            client_width, client_height,
+            mir_pixel_format_abgr_8888,
+            mir_buffer_usage_hardware
+        };    
+    MirSurfaceParameters const surface2_params =
+        {
+            surface2_name.c_str(),
+            client_width, client_height,
+            mir_pixel_format_abgr_8888,
+            mir_buffer_usage_hardware
+        };
+    struct ParameterizedClient : InputReceivingClient
+    {
+        ParameterizedClient(MirSurfaceParameters params, int events_to_expect) : 
+            InputReceivingClient(events_to_expect),
+            params(params)
+        {
+        }
+        
+        MirSurfaceParameters parameters() override
+        {
+            return params;
+        }
+
+        MirSurfaceParameters params;
+    };
+    struct InputClientOne : ParameterizedClient
+    {
+        InputClientOne(MirSurfaceParameters params) :
+            ParameterizedClient(params, 3)
+        {
+        }
+        
+        void expect_input() override
+        {
+            InSequence seq;
+            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(1).WillOnce(Return(true));
+            EXPECT_CALL(*handler, handle_input(
+                MotionEventWithPosition(params.width - 1, 0))).Times(1).WillOnce(Return(true));
+            EXPECT_CALL(*handler, handle_input(HoverExitEvent())).Times(1).WillOnce(Return(true));
+        }
+    } client_1(surface1_params);
+    struct InputClientTwo : ParameterizedClient
+    {
+        InputClientTwo(MirSurfaceParameters params) :
+            ParameterizedClient(params, 2)
+        {
+        }
+        
+        void expect_input() override
+        {
+            InSequence seq;
+            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(1).WillOnce(Return(true));
+            EXPECT_CALL(*handler, handle_input(
+                MotionEventWithPosition(params.width - 1, 0))).Times(1).WillOnce(Return(true));
+        }
+    } client_2(surface2_params);
+
+    launch_client_process(client_1);
+    launch_client_process(client_2);
+}

=== modified file 'tests/acceptance-tests/test_focus_selection.cpp'
--- tests/acceptance-tests/test_focus_selection.cpp	2013-05-02 00:11:18 +0000
+++ tests/acceptance-tests/test_focus_selection.cpp	2013-05-30 19:33:26 +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_target_listener.h"
+#include "mir/shell/input_targeter.h"
 
 #include "mir_test_framework/display_server_test_fixture.h"
 #include "mir_test_doubles/mock_focus_setter.h"
-#include "mir_test_doubles/mock_input_target_listener.h"
+#include "mir_test_doubles/mock_input_targeter.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -167,37 +167,33 @@
 {
     struct ServerConfig : TestingServerConfiguration
     {
-        std::shared_ptr<mtd::MockInputTargetListener> target_listener;
+        std::shared_ptr<mtd::MockInputTargeter> targeter;
         bool expected;
 
         ServerConfig()
-          : target_listener(std::make_shared<mtd::MockInputTargetListener>()),
+          : targeter(std::make_shared<mtd::MockInputTargeter>()),
             expected(false)
         {
         }
 
-        std::shared_ptr<msh::InputTargetListener>
-        the_input_target_listener() override
+        std::shared_ptr<msh::InputTargeter>
+        the_input_targeter() override
         {
             using namespace ::testing;
 
             if (!expected)
             {
                 
-                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(*targeter, focus_cleared()).Times(AtLeast(0));
 
                 {
                     InSequence seq;
-                    EXPECT_CALL(*target_listener, focus_changed(NonNullSurfaceTarget())).Times(1);
+                    EXPECT_CALL(*targeter, focus_changed(NonNullSurfaceTarget())).Times(1);
                     expected = true;
                 }
             }
 
-            return target_listener;
+            return targeter;
         }
     } server_config;
 

=== modified file 'tests/acceptance-tests/test_server_shutdown.cpp'
--- tests/acceptance-tests/test_server_shutdown.cpp	2013-05-28 17:15:21 +0000
+++ tests/acceptance-tests/test_server_shutdown.cpp	2013-05-30 19:33:26 +0000
@@ -197,7 +197,7 @@
     /* Use the real input manager, but with a fake event hub */
     struct ServerConfig : TestingServerConfiguration
     {
-        std::shared_ptr<mia::InputConfiguration> the_input_configuration() override
+        std::shared_ptr<mi::InputConfiguration> the_input_configuration() override
         {
             if (!input_configuration)
             {
@@ -217,12 +217,16 @@
             return DefaultServerConfiguration::the_input_manager();
         }
 
-        std::shared_ptr<mir::shell::InputTargetListener> the_input_target_listener() override
-        {
-            return DefaultServerConfiguration::the_input_target_listener();
+        std::shared_ptr<mir::shell::InputTargeter> the_input_targeter() override
+        {
+            return DefaultServerConfiguration::the_input_targeter();
+        }
+        std::shared_ptr<mir::surfaces::InputRegistrar> the_input_registrar() override
+        {
+            return DefaultServerConfiguration::the_input_registrar();
         }
 
-        std::shared_ptr<mia::InputConfiguration> input_configuration;
+        std::shared_ptr<mi::InputConfiguration> input_configuration;
     };
 
     auto server_config = std::make_shared<ServerConfig>();

=== modified file 'tests/behavior-tests/session_management_context.cpp'
--- tests/behavior-tests/session_management_context.cpp	2013-05-21 17:16:43 +0000
+++ tests/behavior-tests/session_management_context.cpp	2013-05-30 19:33:26 +0000
@@ -25,7 +25,6 @@
 #include "mir/shell/single_visibility_focus_mechanism.h"
 #include "mir/shell/session_container.h"
 #include "mir/frontend/shell.h"
-#include "mir/input/input_channel.h"
 #include "mir/shell/surface_factory.h"
 #include "mir/graphics/display.h"
 #include "mir/default_server_configuration.h"
@@ -39,7 +38,6 @@
 namespace msh = mir::shell;
 namespace mg = mir::graphics;
 namespace mc = mir::compositor;
-namespace mi = mir::input;
 namespace geom = mir::geometry;
 namespace mt = mir::test;
 namespace mtc = mir::test::cucumber;
@@ -73,7 +71,6 @@
         return std::make_shared<msh::Surface>(
             mt::fake_shared(surface_builder),
             params,
-            std::shared_ptr<mir::input::InputChannel>(),
             id,
             sink);
     }

=== modified file 'tests/death-tests/test_application_manager_death.cpp'
--- tests/death-tests/test_application_manager_death.cpp	2013-05-02 00:11:18 +0000
+++ tests/death-tests/test_application_manager_death.cpp	2013-05-30 19:33:26 +0000
@@ -35,7 +35,6 @@
                                                std::shared_ptr<msh::SessionContainer>(),
                                                std::shared_ptr<msh::FocusSequence>(),
                                                std::shared_ptr<msh::FocusSetter>(),
-                                               std::shared_ptr<msh::InputTargetListener>(),
                                                std::shared_ptr<msh::SessionListener>()),
                 ::testing::KilledBySignal(SIGABRT),
                 ".*");

=== modified file 'tests/integration-tests/graphics/android/test_internal_client.cpp'
--- tests/integration-tests/graphics/android/test_internal_client.cpp	2013-05-21 17:16:43 +0000
+++ tests/integration-tests/graphics/android/test_internal_client.cpp	2013-05-30 19:33:26 +0000
@@ -35,6 +35,8 @@
 #include "mir/frontend/surface_id.h"
 #include "mir/input/input_channel_factory.h"
 
+#include "mir_test_doubles/stub_input_registrar.h"
+
 #include <EGL/egl.h>
 #include <gtest/gtest.h>
 
@@ -49,6 +51,7 @@
 namespace msh=mir::shell;
 namespace mf=mir::frontend;
 namespace mi=mir::input;
+namespace mtd=mir::test::doubles;
 
 namespace
 {
@@ -82,13 +85,14 @@
     auto id = mf::SurfaceId{4458};
 
     auto stub_input_factory = std::make_shared<StubInputFactory>();
+    auto stub_input_registrar = std::make_shared<mtd::StubInputRegistrar>();
     auto null_buffer_initializer = std::make_shared<mg::NullBufferInitializer>();
     auto allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(null_buffer_initializer);
     auto strategy = std::make_shared<mc::SwapperFactory>(allocator);
     auto buffer_bundle_factory = std::make_shared<mc::BufferBundleManager>(strategy);
-    auto ss = std::make_shared<ms::SurfaceStack>(buffer_bundle_factory);
+    auto ss = std::make_shared<ms::SurfaceStack>(buffer_bundle_factory, stub_input_factory, stub_input_registrar);
     auto surface_controller = std::make_shared<ms::SurfaceController>(ss);
-    auto surface_source = std::make_shared<msh::SurfaceSource>(surface_controller, stub_input_factory);
+    auto surface_source = std::make_shared<msh::SurfaceSource>(surface_controller);
     auto mir_surface = surface_source->create_surface(params, id, std::shared_ptr<mir::events::EventSink>());
 
     auto report = std::shared_ptr<mg::NullDisplayReport>(); 

=== modified file 'tests/integration-tests/input/android/CMakeLists.txt'
--- tests/integration-tests/input/android/CMakeLists.txt	2013-04-24 05:22:20 +0000
+++ tests/integration-tests/input/android/CMakeLists.txt	2013-05-30 19:33:26 +0000
@@ -1,6 +1,5 @@
 list(
   APPEND INTEGRATION_TESTS_SRCS
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_fake_event_hub_to_event_filter.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_manager.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_cursor_listener.cpp
 )

=== modified file 'tests/integration-tests/input/android/test_android_cursor_listener.cpp'
--- tests/integration-tests/input/android/test_android_cursor_listener.cpp	2013-05-28 17:15:21 +0000
+++ tests/integration-tests/input/android/test_android_cursor_listener.cpp	2013-05-30 19:33:26 +0000
@@ -17,10 +17,11 @@
  *              Daniel d'Andrada <[e-mail]>
  */
 
-#include "mir/input/event_filter.h"
 #include "src/server/input/android/android_input_manager.h"
 #include "src/server/input/android/default_android_input_configuration.h"
+#include "mir/input/event_filter.h"
 #include "mir/input/cursor_listener.h"
+#include "mir/input/input_targets.h"
 #include "mir/input/null_input_report.h"
 
 #include "mir_test/fake_shared.h"
@@ -50,6 +51,13 @@
 {
 using namespace ::testing;
 
+struct StubInputTargets : public mi::InputTargets
+{
+    void for_each(std::function<void(std::shared_ptr<mi::SurfaceTarget> const&)> const&)
+    {
+    }
+};
+
 struct MockCursorListener : public mi::CursorListener
 {
     MOCK_METHOD2(cursor_moved_to, void(float, float));
@@ -79,7 +87,10 @@
 
         fake_event_hub = configuration->the_fake_event_hub();
 
-        input_manager = std::make_shared<mia::InputManager>(configuration);
+        input_manager = configuration->the_input_manager();
+
+        stub_targets = std::make_shared<StubInputTargets>();
+        configuration->set_input_targets(stub_targets);
 
         input_manager->start();
     }
@@ -93,8 +104,9 @@
     mia::FakeEventHub* fake_event_hub;
     std::shared_ptr<MockEventFilter> event_filter;
     NiceMock<mtd::MockViewableArea> viewable_area;
-    std::shared_ptr<mia::InputManager> input_manager;
+    std::shared_ptr<mi::InputManager> input_manager;
     MockCursorListener cursor_listener;
+    std::shared_ptr<StubInputTargets> stub_targets;
 };
 
 }

=== modified file 'tests/integration-tests/input/android/test_android_input_manager.cpp'
--- tests/integration-tests/input/android/test_android_input_manager.cpp	2013-05-28 17:15:21 +0000
+++ tests/integration-tests/input/android/test_android_input_manager.cpp	2013-05-30 19:33:26 +0000
@@ -18,13 +18,13 @@
  */
 
 #include "mir/input/event_filter.h"
+#include "mir/input/input_targets.h"
 #include "mir/shell/surface_creation_parameters.h"
-#include "mir/input/android/android_input_configuration.h"
 #include "mir/input/null_input_report.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/android_dispatcher_controller.h"
+#include "src/server/input/android/android_input_targeter.h"
+#include "src/server/input/android/android_input_registrar.h"
 #include "src/server/input/android/event_filter_dispatcher_policy.h"
 
 #include "mir_test/fake_shared.h"
@@ -32,7 +32,6 @@
 #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"
@@ -40,6 +39,7 @@
 
 #include <EventHub.h>
 #include <InputDispatcher.h>
+#include <InputEnumerator.h>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -51,6 +51,7 @@
 namespace mia = mir::input::android;
 namespace mis = mir::input::synthesis;
 namespace mg = mir::graphics;
+namespace ms = mir::surfaces;
 namespace msh = mir::shell;
 namespace geom = mir::geometry;
 namespace mt = mir::test;
@@ -68,6 +69,13 @@
 
 static const std::shared_ptr<mi::CursorListener> null_cursor_listener{};
 
+struct StubInputTargets : public mi::InputTargets
+{
+    void for_each(std::function<void(std::shared_ptr<mi::SurfaceTarget> const&)> const&)
+    {
+    }
+};
+
 class AndroidInputManagerAndEventFilterDispatcherSetup : public testing::Test
 {
 public:
@@ -79,8 +87,11 @@
             .WillByDefault(Return(default_view_area));
 
         fake_event_hub = configuration->the_fake_event_hub();
+        
+        input_manager = configuration->the_input_manager();
 
-        input_manager = std::make_shared<mia::InputManager>(configuration);
+        stub_targets = std::make_shared<StubInputTargets>();
+        configuration->set_input_targets(stub_targets);
 
         input_manager->start();
     }
@@ -93,9 +104,10 @@
   protected:
     std::shared_ptr<mtd::FakeEventHubInputConfiguration> configuration;
     mia::FakeEventHub* fake_event_hub;
-    std::shared_ptr<mia::InputManager> input_manager;
+    std::shared_ptr<mi::InputManager> input_manager;
     std::shared_ptr<MockEventFilter> event_filter;
     NiceMock<mtd::MockViewableArea> viewable_area;
+    std::shared_ptr<StubInputTargets> stub_targets;
 };
 
 }
@@ -249,11 +261,15 @@
 
         ON_CALL(viewable_area, view_area())
             .WillByDefault(Return(default_view_area));
-        input_manager = std::make_shared<mia::InputManager>(configuration);
-        input_target_listener = std::make_shared<mia::DispatcherController>(configuration);
+        input_manager = configuration->the_input_manager();
+        
+        input_registrar = configuration->the_input_registrar();
+        input_targeter = configuration->the_input_targeter();
 
         dispatcher_policy = configuration->the_mock_dispatcher_policy();
 
+        stub_targets = std::make_shared<StubInputTargets>();
+        configuration->set_input_targets(stub_targets);
     }
 
     ~AndroidInputManagerDispatcherInterceptSetup()
@@ -283,8 +299,11 @@
     mia::FakeEventHub* fake_event_hub;
     droidinput::sp<MockDispatcherPolicy> dispatcher_policy;
 
-    std::shared_ptr<mia::InputManager> input_manager;
-    std::shared_ptr<msh::InputTargetListener> input_target_listener;
+    std::shared_ptr<StubInputTargets> stub_targets;
+
+    std::shared_ptr<mi::InputManager> input_manager;
+    std::shared_ptr<ms::InputRegistrar> input_registrar;
+    std::shared_ptr<msh::InputTargeter> input_targeter;
 };
 
 MATCHER_P(WindowHandleWithInputFd, input_fd, "")
@@ -302,8 +321,6 @@
 
     mt::WaitCondition wait_condition;
 
-    mtd::StubSessionTarget session;
-    
     auto input_fd = test_fd();
     mtd::StubSurfaceTarget surface(input_fd);
 
@@ -312,9 +329,8 @@
     EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(input_fd), _, _))
         .Times(1).WillOnce(DoAll(mt::WakeUp(&wait_condition), Return(-1)));
 
-    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));
+    input_registrar->input_surface_opened(mt::fake_shared(surface));
+    input_targeter->focus_changed(mt::fake_shared(surface));
 
     fake_event_hub->synthesize_builtin_keyboard_added();
     fake_event_hub->synthesize_device_scan_complete();
@@ -330,16 +346,13 @@
 
     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));
+    input_registrar->input_surface_opened(mt::fake_shared(surface1));
+    input_registrar->input_surface_opened(mt::fake_shared(surface2));
 
     EXPECT_CALL(*event_filter, handles(_)).Times(3).WillRepeatedly(Return(false));
 
@@ -357,17 +370,17 @@
     fake_event_hub->synthesize_builtin_keyboard_added();
     fake_event_hub->synthesize_device_scan_complete();
 
-    input_target_listener->focus_changed(mt::fake_shared(surface1));
+    input_targeter->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));
+    input_targeter->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));
+    input_targeter->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);

=== removed 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-05-28 17:47:03 +0000
+++ tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp	1970-01-01 00:00:00 +0000
@@ -1,118 +0,0 @@
-/*
- * Copyright © 2012 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Robert Carr <[e-mail]>
- *              Daniel d'Andrada <[e-mail]>
- */
-#include "src/server/input/android/event_filter_dispatcher_policy.h"
-#include "src/server/input/android/rudimentary_input_reader_policy.h"
-#include "src/server/input/android/android_input_constants.h"
-
-#include "mir/input/event_filter.h"
-#include "mir/input/null_input_report.h"
-
-#include "mir_test/fake_shared.h"
-#include "mir_test/fake_event_hub.h"
-#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>
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-namespace mi = mir::input;
-namespace mia = mi::android;
-namespace mis = mir::input::synthesis;
-namespace mt = mir::test;
-namespace mtd = mir::test::doubles;
-
-namespace mir
-{
-
-class FakeEventHubSetup : public testing::Test
-{
-  public:
-    FakeEventHubSetup()
-    {
-    }
-
-    ~FakeEventHubSetup()
-    {
-    }
-
-    void SetUp()
-    {
-        event_hub = new mia::FakeEventHub();
-        dispatcher_policy = new mia::EventFilterDispatcherPolicy(mt::fake_shared(event_filter), false);
-        reader_policy = new mia::RudimentaryInputReaderPolicy();
-        dispatcher = new droidinput::InputDispatcher(dispatcher_policy, std::make_shared<mi::NullInputReport>());
-        reader = new droidinput::InputReader(event_hub, reader_policy, dispatcher);
-        reader_thread = new droidinput::InputReaderThread(reader);
-        dispatcher_thread = new droidinput::InputDispatcherThread(dispatcher);
-
-        dispatcher->setInputDispatchMode(mia::DispatchEnabled, mia::DispatchUnfrozen);
-        dispatcher->setInputFilterEnabled(true);
-
-        dispatcher_thread->run("InputDispatcher", droidinput::PRIORITY_URGENT_DISPLAY);
-        reader_thread->run("InputReader", droidinput::PRIORITY_URGENT_DISPLAY);
-    }
-
-    void TearDown()
-    {
-        dispatcher_thread->requestExit();
-        dispatcher->setInputDispatchMode(mia::DispatchDisabled, mia::DispatchFrozen);
-        dispatcher_thread->join();
-
-        reader_thread->requestExit();
-        event_hub->wake();
-        reader_thread->join();
-    }
-
-  protected:
-    mtd::MockEventFilter event_filter;
-    droidinput::sp<mia::FakeEventHub> event_hub;
-    droidinput::sp<droidinput::InputDispatcherPolicyInterface> dispatcher_policy;
-    droidinput::sp<droidinput::InputReaderPolicyInterface> reader_policy;
-    droidinput::sp<droidinput::InputDispatcher> dispatcher;
-    droidinput::sp<droidinput::InputReader> reader;
-    droidinput::sp<droidinput::InputReaderThread> reader_thread;
-    droidinput::sp<droidinput::InputDispatcherThread> dispatcher_thread;
-};
-
-}
-
-using mir::FakeEventHubSetup;
-
-TEST_F(FakeEventHubSetup, fake_event_hub_dispatches_to_filter)
-{
-    using namespace ::testing;
-
-    mt::WaitCondition wait_condition;
-
-    EXPECT_CALL(event_filter, handles(mt::KeyDownEvent())).Times(1)
-        .WillOnce(mt::ReturnFalseAndWakeUp(&wait_condition));
-
-    event_hub->synthesize_builtin_keyboard_added();
-    event_hub->synthesize_device_scan_complete();
-
-    event_hub->synthesize_event(mis::a_key_down_event()
-                                .of_scancode(KEY_ENTER));
-
-    wait_condition.wait_for_at_most_seconds(1);
-}

=== modified file 'tests/integration-tests/shell/test_session_manager.cpp'
--- tests/integration-tests/shell/test_session_manager.cpp	2013-05-21 17:16:43 +0000
+++ tests/integration-tests/shell/test_session_manager.cpp	2013-05-30 19:33:26 +0000
@@ -28,13 +28,13 @@
 #include "mir/compositor/buffer_swapper.h"
 #include "mir/shell/surface_creation_parameters.h"
 
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
 #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"
-#include "mir_test_doubles/stub_input_target_listener.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
 
 namespace mc = mir::compositor;
 namespace me = mir::events;
@@ -53,7 +53,6 @@
     msh::RegistrationOrderFocusSequence sequence(container);
     mtd::MockFocusSetter focus_setter;
     std::shared_ptr<mf::Session> new_session;
-    mtd::StubInputTargetListener input_target_listener;
     msh::NullSessionListener session_listener;
 
     msh::SessionManager session_manager(
@@ -61,7 +60,6 @@
             container,
             mt::fake_shared(sequence),
             mt::fake_shared(focus_setter),
-            mt::fake_shared(input_target_listener),
             mt::fake_shared(session_listener));
 
     EXPECT_CALL(focus_setter, set_focus_to(_)).Times(3);
@@ -98,7 +96,6 @@
     msh::RegistrationOrderFocusSequence sequence(container);
     mtd::MockFocusSetter focus_setter;
     std::shared_ptr<mf::Session> new_session;
-    mtd::StubInputTargetListener input_target_listener;
     msh::NullSessionListener session_listener;
 
     msh::SessionManager session_manager(
@@ -106,7 +103,6 @@
             container,
             mt::fake_shared(sequence),
             mt::fake_shared(focus_setter),
-            mt::fake_shared(input_target_listener),
             mt::fake_shared(session_listener));
 
     EXPECT_CALL(focus_setter, set_focus_to(_)).Times(3);

=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2013-05-21 15:11:41 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2013-05-30 19:33:26 +0000
@@ -28,9 +28,7 @@
 #include "mir/compositor/graphic_buffer_allocator.h"
 #include "mir/input/input_channel.h"
 #include "mir/input/input_manager.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"
+#include "mir/input/null_input_configuration.h"
 
 #include "mir_test_doubles/stub_buffer.h"
 #include "mir_test_doubles/stub_surface_builder.h"
@@ -43,7 +41,7 @@
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
 namespace mi = mir::input;
-namespace mia = mir::input::android;
+namespace ms = mir::surfaces;
 namespace mf = mir::frontend;
 namespace mtf = mir_test_framework;
 namespace mtd = mir::test::doubles;
@@ -182,24 +180,14 @@
         ("tests-use-real-input", po::value<bool>(), "Use real input in tests. [bool:default=false]");
 }
 
-
-std::shared_ptr<mi::InputManager> mtf::TestingServerConfiguration::the_input_manager()
+std::shared_ptr<mi::InputConfiguration> mtf::TestingServerConfiguration::the_input_configuration()
 {
     auto options = the_options();
+
     if (options->get("tests-use-real-input", false))
-        return std::make_shared<mia::InputManager>(the_input_configuration());
-    else
-        return std::make_shared<StubInputManager>();
-}
-
-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<mi::NullInputTargetListener>();
+        return DefaultServerConfiguration::the_input_configuration();
+    else
+        return std::make_shared<mi::NullInputConfiguration>();
 }
 
 std::shared_ptr<mg::Platform> mtf::TestingServerConfiguration::the_graphics_platform()

=== modified file 'tests/unit-tests/input/android/CMakeLists.txt'
--- tests/unit-tests/input/android/CMakeLists.txt	2013-04-24 21:54:41 +0000
+++ tests/unit-tests/input/android/CMakeLists.txt	2013-05-30 19:33:26 +0000
@@ -7,7 +7,8 @@
   ${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
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_dispatcher_controller.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_targeter.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_target_enumerator.cpp
 )
 
 set(

=== modified file 'tests/unit-tests/input/android/test_android_input_application_handle.cpp'
--- tests/unit-tests/input/android/test_android_input_application_handle.cpp	2013-04-24 05:22:20 +0000
+++ tests/unit-tests/input/android/test_android_input_application_handle.cpp	2013-05-30 19:33:26 +0000
@@ -18,7 +18,7 @@
 
 #include "src/server/input/android/android_input_application_handle.h"
 
-#include "mir/input/session_target.h"
+#include "mir/input/surface_target.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -27,43 +27,47 @@
 
 namespace mi = mir::input;
 namespace mia = mi::android;
+namespace geom = mir::geometry;
 
 namespace
 {
-struct MockSessionHandle : public mi::SessionTarget
+struct MockSurfaceHandle : public mi::SurfaceTarget
 {
-    MOCK_CONST_METHOD0(name, std::string());
+    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 const&());
 };
 }
 
 
-TEST(AndroidInputApplicationHandle, takes_name_from_session_and_specifies_max_timeout)
+TEST(AndroidInputApplicationHandle, takes_name_from_surface_and_specifies_max_timeout)
 {
     using namespace ::testing;
-    std::string const testing_session_name = "Cats";
-    auto session = std::make_shared<MockSessionHandle>();
+    std::string testing_surface_name = "Cats";
+    auto surface = std::make_shared<MockSurfaceHandle>();
 
-    EXPECT_CALL(*session, name()).Times(AtLeast(1))
-        .WillRepeatedly(Return(testing_session_name));
-    mia::InputApplicationHandle application_handle(session);
+    EXPECT_CALL(*surface, name()).Times(AtLeast(1))
+        .WillRepeatedly(ReturnRef(testing_surface_name));
+    mia::InputApplicationHandle application_handle(surface);
     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);
+    EXPECT_EQ(droidinput::String8(testing_surface_name.c_str()), info->name);
 }
 
-TEST(AndroidInputApplicationHandle, does_not_own_session)
+TEST(AndroidInputApplicationHandle, does_not_own_surface)
 {
     using namespace ::testing;
-    std::string const testing_session_name = "Let it Grow";
-    
-    auto session = std::make_shared<MockSessionHandle>();
-    EXPECT_CALL(*session, name()).Times(AtLeast(1))
-        .WillRepeatedly(Return(testing_session_name));
-    
-    mia::InputApplicationHandle application_handle(session);
+    std::string const testing_surface_name = "Let it Grow";
+    
+    auto surface = std::make_shared<MockSurfaceHandle>();
+    EXPECT_CALL(*surface, name()).Times(AtLeast(1))
+        .WillRepeatedly(ReturnRef(testing_surface_name));
+    
+    mia::InputApplicationHandle application_handle(surface);
     EXPECT_TRUE(application_handle.updateInfo());
-    session.reset();
+    surface.reset();
     EXPECT_FALSE(application_handle.updateInfo());
 
 }

=== modified file 'tests/unit-tests/input/android/test_android_input_manager.cpp'
--- tests/unit-tests/input/android/test_android_input_manager.cpp	2013-05-13 09:35:44 +0000
+++ tests/unit-tests/input/android/test_android_input_manager.cpp	2013-05-30 19:33:26 +0000
@@ -21,15 +21,11 @@
 #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/input/android/android_input_configuration.h"
 
 #include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_viewable_area.h"
 #include "mir_test_doubles/mock_input_dispatcher.h"
-#include "mir_test_doubles/mock_input_configuration.h"
-#include "mir_test_doubles/stub_session_target.h"
 #include "mir_test_doubles/stub_surface_target.h"
 
 #include <EventHub.h>
@@ -116,15 +112,9 @@
         dispatcher = new mtd::MockInputDispatcher();
         dispatcher_thread = std::make_shared<MockInputThread>();
         reader_thread = std::make_shared<MockInputThread>();
-
-        ON_CALL(config, the_event_hub()).WillByDefault(Return(event_hub));
-        ON_CALL(config, the_dispatcher()).WillByDefault(Return(dispatcher));
-        ON_CALL(config, the_reader_thread()).WillByDefault(Return(reader_thread));
-        ON_CALL(config, the_dispatcher_thread()).WillByDefault(Return(dispatcher_thread));
     }
     mtd::MockViewableArea view_area;
 
-    testing::NiceMock<mtd::MockInputConfiguration> config;
     droidinput::sp<MockEventHub> event_hub;
     droidinput::sp<mtd::MockInputDispatcher> dispatcher;
     std::shared_ptr<MockInputThread> dispatcher_thread;
@@ -133,19 +123,6 @@
 
 }
 
-TEST_F(AndroidInputManagerSetup, takes_input_setup_from_configuration)
-{
-    using namespace ::testing;
-
-    EXPECT_CALL(config, the_event_hub()).Times(1);
-    EXPECT_CALL(config, the_dispatcher()).Times(1);
-    EXPECT_CALL(config, the_reader_thread()).Times(1);
-    EXPECT_CALL(config, the_dispatcher_thread()).Times(1);
-
-    mia::InputManager manager(mt::fake_shared(config));
-
-}
-
 TEST_F(AndroidInputManagerSetup, start_and_stop)
 {
     using namespace ::testing;
@@ -180,7 +157,7 @@
         EXPECT_CALL(*reader_thread, join());
     }
 
-    mia::InputManager manager(mt::fake_shared(config));
+    mia::InputManager manager(event_hub, dispatcher, reader_thread, dispatcher_thread);
 
     manager.start();
     manager.stop();
@@ -188,7 +165,7 @@
 
 TEST_F(AndroidInputManagerSetup, manager_returns_input_channel_with_fds)
 {
-    mia::InputManager manager(mt::fake_shared(config));
+    mia::InputManager manager(event_hub, dispatcher, reader_thread, dispatcher_thread);
 
     auto package = manager.make_input_channel();
     EXPECT_GT(package->client_fd(), 0);

=== renamed file 'tests/unit-tests/input/android/test_android_dispatcher_controller.cpp' => 'tests/unit-tests/input/android/test_android_input_registrar.cpp'
--- tests/unit-tests/input/android/test_android_dispatcher_controller.cpp	2013-05-02 00:11:18 +0000
+++ tests/unit-tests/input/android/test_android_input_registrar.cpp	2013-05-30 19:33:26 +0000
@@ -16,11 +16,10 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#include "src/server/input/android/android_dispatcher_controller.h"
+#include "src/server/input/android/android_input_registrar.h"
 
 #include "mir_test_doubles/mock_input_configuration.h"
 #include "mir_test_doubles/mock_input_dispatcher.h"
-#include "mir_test_doubles/stub_session_target.h"
 #include "mir_test_doubles/stub_surface_target.h"
 
 #include "mir_test/fake_shared.h"
@@ -44,7 +43,7 @@
 // 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 AndroidDispatcherControllerFdSetup : public testing::Test
+struct AndroidInputRegistrarFdSetup : public testing::Test
 {
     void SetUp() override
     {
@@ -61,200 +60,57 @@
     mtd::MockInputConfiguration config;
 };
 
-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())
+MATCHER_P(WindowHandleFor, surface, "")
+{
+    if (arg->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;
-}
-
-}
-
-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({