Mir

Merge lp:~andreas-pokorny/mir/send-input-device-state-event into lp:mir

send-input-device-state-event
Merge into development-branch

Proposed by Andreas Pokorny on 2016-06-10

Status:	Merged
Approved by:	Andreas Pokorny on 2016-07-07
Approved revision:	no longer in the source branch.
Merged at revision:	3579
Proposed branch:	lp:~andreas-pokorny/mir/send-input-device-state-event
Merge into:	lp:mir
Prerequisite:	lp:~andreas-pokorny/mir/filter-keys-in-seat
Diff against target:	1462 lines (+556/-103) 34 files modified include/platform/mir/input/event_builder.h (+3/-0) include/platform/mir/input/input_sink.h (+22/-0) include/test/mir/test/event_matchers.h (+32/-0) src/client/input/android/android_input_lexicon.cpp (+6/-0) src/client/input/android/android_input_receiver.cpp (+0/-3) src/client/input/xkb_mapper.cpp (+8/-1) src/include/common/mir/input/key_mapper.h (+1/-0) src/include/common/mir/input/xkb_mapper.h (+2/-2) src/include/server/mir/input/seat.h (+7/-0) src/server/graphics/nested/display_buffer.cpp (+3/-4) src/server/graphics/nested/input_platform.cpp (+58/-19) src/server/input/android/input_sender.cpp (+28/-19) src/server/input/basic_seat.cpp (+23/-2) src/server/input/basic_seat.h (+10/-1) src/server/input/default_configuration.cpp (+2/-1) src/server/input/default_event_builder.cpp (+11/-2) src/server/input/default_event_builder.h (+6/-1) src/server/input/default_input_device_hub.cpp (+26/-3) src/server/input/default_input_device_hub.h (+5/-1) src/server/input/seat_input_device_tracker.cpp (+54/-15) src/server/input/seat_input_device_tracker.h (+12/-1) src/server/server.cpp (+46/-1) src/server/shell/abstract_shell.cpp (+1/-0) tests/acceptance-tests/test_nested_input.cpp (+79/-11) tests/include/mir/test/doubles/mock_input_seat.h (+6/-1) tests/include/mir/test/doubles/mock_input_sink.h (+2/-0) tests/include/mir/test/doubles/mock_key_mapper.h (+1/-0) tests/integration-tests/input/test_single_seat_setup.cpp (+7/-4) tests/unit-tests/input/android/test_android_input_sender.cpp (+44/-2) tests/unit-tests/input/evdev/test_libinput_device.cpp (+10/-1) tests/unit-tests/input/test_nested_input_platform.cpp (+4/-2) tests/unit-tests/input/test_seat_input_device_tracker.cpp (+10/-5) tests/unit-tests/input/test_x11_platform.cpp (+3/-1) tests/unit-tests/scene/test_abstract_shell.cpp (+24/-0)
To merge this branch:	bzr merge lp:~andreas-pokorny/mir/send-input-device-state-event
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration	2016-06-10	Approve on 2016-07-07
Alan Griffiths			Needs Fixing on 2016-07-07
Kevin DuBois (community)		2016-06-10	Approve on 2016-07-05
Review via email: mp+297062@code.launchpad.net

Commit message

Make use of the input device state event

AbstractShell sends that event on focus change, the XkbMapper receives that information and used it to update its xkb_state. Additionally the nested input platform forwards that event.

Description of the change

This change now makes use of the new input device state event. The event needs to update the xkb pressed state inside the xkb_mapper, before any further key input events are mapped by the keymapper. So the device state event is sent "on" focus change. "on" because focus is a surface attribute change and because user input has its own queue. It is also necessary for toolkits so that they can redraw menues based on the current modifier state after a focus change.

The handling in nested input platform is a bit special - since input platforms usually do not need to emit an input device state event - but a nested session might be occluded/unfocused/paused so might not have seen the input presses happening.

This change also includes the ability to add event filters prior to startup. That combined with the input device state event provides a utility to detect that a nested server is up, running, focused and capable of receiving events.

In upcoming branches I plan to use that to avoid some of the unconditional sleeps in our acceptance tests.

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-06-10:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1150/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-06-10:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1155/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-06-24:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1192/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-07-01:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1225/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-07-01:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1226/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-07-04:

ah there is a shutdown problem shown in one of the nested server tests.

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-07-04:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1228/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-07-04:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1229/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-07-05:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1231/rebuild

review: Approve (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-07-05:

nits, otherwise, lgtm

16: + virtual EventUPtr device_state_event(float cursor_x, float cursor_y) = 0;
Would be nice if Point/X/Y could be stored as a float in those types.

199, 1232,1233:
+ mutable std::mutex guard;
std::mutex mutable guard; is more like other use of mutable or const

150:
extra line

300:
+ [this](MirEvent const& event, mir::geometry::Rectangle const& area)
[this](auto const& event, auto const& area) is a bit shorter

1158:
aligned to tab after commas, should just have one space.

1432:
+TEST_F(AbstractShell, as_focus_controller_emits_input_device_state_event_on_focus_change)
"as_focus_controller_" is a bit redundant, just "emits_input_Device_state_change_on_focus_change" is better.

review: Approve

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-07-06:

CI failure was new and in NestedInput*, probably needs some investigation....

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-07-06:

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-07-06:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1237/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-07-07:

CI Problem while setting up krillin ^
22:10:51 Slave went offline during the build
22:10:51 ERROR: Connection was broken: java.io.EOFException

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-07-07:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1238/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-07-07:

Another problem with the krillin, now while flashing the device:
06:14:39 WARNING:root:Unable to mark device offline automatically
06:14:39 Traceback (most recent call last):
06:14:39 File "./recover", line 124, in <module>
06:14:39 print(recover(name))
06:14:39 File "./recover", line 114, in recover
06:14:39 return _full_recovery(device)
06:14:39 File "./recover", line 24, in _full_recovery
06:14:39 device.reimage_from_fastboot()
06:14:39 File "/var/lib/jenkins/slaves/krillin-01/workspace/device-runtests-mir/device_type/krillin/lifeboat/device_info.py", line 100, in reimage_from_fastboot
06:14:39 subprocess.check_output(udf_command)
06:14:39 File "/usr/lib/python2.7/subprocess.py", line 573, in check_output
06:14:39 raise CalledProcessError(retcode, cmd, output=output)
06:14:39 subprocess.CalledProcessError: Command '['ubuntu-device-flash', '--server', 'https://system-image.ubuntu.com', 'touch', '--serial', 'JB011018', '--channel', 'ubuntu-touch/stable/bq-aquaris.en', '--bootstrap', '--developer-mode', '--password', '0000']' returned non-zero exit status 1
06:14:40 Build step 'Execute shell' marked build as failure
06:14:41 Archiving artifacts
06:14:44 [WS-CLEANUP] Deleting project workspace...[WS-CLEANUP] done
06:14:44 Finished: FAILURE

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-07-07:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1239/rebuild

review: Approve (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2016-07-07:

Nits:

+#include "mir/events/event_builders.h"

this isn't needed by the header (or any of the files that include it).

~~~~

+ /**
+ * Set all pressed scan codes.
+ * \param scan_codes currently pressed
+ */
+ virtual void set_key_state(std::vector<uint32_t> const& scan_codes) = 0;
+ /**
+ * Set button state of a pointing device.
+ * \param buttons mask of the buttons currently pressed
+ */
+ virtual void set_pointer_state(MirPointerButtons buttons) = 0;

These names seem a little odd for an InputSink. (Maybe it is just my experience with C# and Java suggesting "set_" implies these are properties.) Anyway, "key_state()" or "key_state_is()" would be better than "set_key_state()"

~~~~

- std::mutex guard;
+ mutable std::mutex guard;

We put the cv-qualifier after the type:

std::mutex mutable guard;

~~~~

+#include "mir/event_printer.h"

Needed?

review: Needs Fixing

Revision history for this message

Mir CI Bot (mir-ci-bot) on 2016-07-07:

review: Approve (continuous-integration)

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-07-07:

> Nits:
>
> +#include "mir/events/event_builders.h"
>
> this isn't needed by the header (or any of the files that include it).
>
> ~~~~
>
> + /**
> + * Set all pressed scan codes.
> + * \param scan_codes currently pressed
> + */
> + virtual void set_key_state(std::vector<uint32_t> const& scan_codes) = 0;
> + /**
> + * Set button state of a pointing device.
> + * \param buttons mask of the buttons currently pressed
> + */
> + virtual void set_pointer_state(MirPointerButtons buttons) = 0;
>
> These names seem a little odd for an InputSink. (Maybe it is just my
> experience with C# and Java suggesting "set_" implies these are properties.)
> Anyway, "key_state()" or "key_state_is()" would be better than
> "set_key_state()"
>
> ~~~~
>
> - std::mutex guard;
> + mutable std::mutex guard;
>
> We put the cv-qualifier after the type:
>
> std::mutex mutable guard;
>
> ~~~~
>
> +#include "mir/event_printer.h"
>
> Needed?

Nah all of that is valid, also fixed what kdub complained about. If the MP lands, I am going to prepare that in a new MP

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Andreas Pokorny

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'include/platform/mir/input/event_builder.h'
 --- include/platform/mir/input/event_builder.h	2016-01-29 08:18:22 +0000
 +++ include/platform/mir/input/event_builder.h	2016-07-06 21:48:16 +0000
@@ -21,6 +21,7 @@
  #define MIR_INPUT_EVENT_BUILDER_H_
  #include "mir_toolkit/event.h"
++#include "mir/events/event_builders.h"
  #include <memory>
  #include <chrono>
@@ -51,6 +52,8 @@
      virtual EventUPtr configuration_event(Timestamp timestamp, MirInputConfigurationAction action) = 0;
++    virtual EventUPtr device_state_event(float cursor_x, float cursor_y) = 0;
++
  protected:
      EventBuilder(EventBuilder const&) = delete;
      EventBuilder& operator=(EventBuilder const&) = delete;
 === modified file 'include/platform/mir/input/input_sink.h'
 --- include/platform/mir/input/input_sink.h	2016-01-29 08:18:22 +0000
 +++ include/platform/mir/input/input_sink.h	2016-07-06 21:48:16 +0000
@@ -24,6 +24,8 @@
  #include "mir/geometry/rectangle.h"
  #include "mir/geometry/displacement.h"
++#include <vector>
++
  namespace mir
+ {
  namespace input
@@ -39,6 +41,26 @@
       */
      virtual mir::geometry::Rectangle bounding_rectangle() const = 0;
++    /**
++     * \name Device State interface of InputSink
++     *
++     * In scenarios in which the device is not capable of seeing all changes as they occur,
++     * these method should be used to update the input device state as needed
++     * \{
++     */
++    /**
++     * Set all pressed scan codes.
++     * \param scan_codes currently pressed
++     */
++    virtual void set_key_state(std::vector<uint32_t> const& scan_codes) = 0;
++    /**
++     * Set button state of a pointing device.
++     * \param buttons mask of the buttons currently pressed
++     */
++    virtual void set_pointer_state(MirPointerButtons buttons) = 0;
++    /**
++     * \}
++     */
  private:
      InputSink(InputSink const&) = delete;
      InputSink& operator=(InputSink const&) = delete;
 === modified file 'include/test/mir/test/event_matchers.h'
 --- include/test/mir/test/event_matchers.h	2016-05-03 06:55:25 +0000
 +++ include/test/mir/test/event_matchers.h	2016-07-06 21:48:16 +0000
@@ -503,6 +503,38 @@
      return false;
+ }
++MATCHER(InputDeviceStateEvent, "")
++{
++    auto as_address = to_address(arg);
++    if (mir_event_get_type(as_address) == mir_event_type_input_device_state)
++        return true;
++    return false;
++}
++
++MATCHER_P(DeviceStateWithPressedKeys, keys, "")
++{
++    auto as_address = to_address(arg);
++    if (mir_event_get_type(as_address) != mir_event_type_input_device_state)
++        return false;
++    auto device_state = mir_event_get_input_device_state_event(as_address);
++    for (size_t index = 0, count = mir_input_device_state_event_device_count(device_state);
++         index != count; ++index)
++    {
++        auto key_count = mir_input_device_state_event_device_pressed_keys_count(device_state, index);
++        auto it_keys = begin(keys);
++        auto end_keys = end(keys);
++        decltype(key_count) num_required_keys = distance(it_keys, end_keys);
++        if (num_required_keys != key_count)
++            continue;
++
++        auto pressed_keys = mir_input_device_state_event_device_pressed_keys(device_state, index);
++        if (!std::equal(it_keys, end_keys, pressed_keys))
++            continue;
++        return true;
++    }
++    return false;
++}
++
  MATCHER(InputDeviceConfigurationChangedEvent, "")
+ {
      auto as_address = to_address(arg);
 === modified file 'src/client/input/android/android_input_lexicon.cpp'
 --- src/client/input/android/android_input_lexicon.cpp	2016-01-29 08:18:22 +0000
 +++ src/client/input/android/android_input_lexicon.cpp	2016-07-06 21:48:16 +0000
@@ -20,6 +20,7 @@
  #include "mir/input/android/android_input_lexicon.h"
  #include "mir/input/android/event_conversion_helpers.h"
  #include "mir/events/event_builders.h"
++#include "mir/events/event.h"
  #include "mir/cookie/blob.h"
  #include <androidfw/Input.h>
@@ -36,6 +37,11 @@
+ {
      switch(android_event->getType())
+     {
++        case AINPUT_EVENT_TYPE_BUFFER:
++        {
++            auto buf = static_cast<const droidinput::RawBufferEvent*>(android_event);
++            return MirEvent::deserialize(buf->buffer);
++        }
          case AINPUT_EVENT_TYPE_KEY:
+         {
              auto kev = static_cast<const droidinput::KeyEvent*>(android_event);
 === modified file 'src/client/input/android/android_input_receiver.cpp'
 --- src/client/input/android/android_input_receiver.cpp	2016-06-09 18:38:05 +0000
 +++ src/client/input/android/android_input_receiver.cpp	2016-07-06 21:48:16 +0000
@@ -132,9 +132,6 @@
      // of XKBMapper per device id (or modify XKBMapper semantics)
      if (mir_event_get_type(&ev) != mir_event_type_input)
          return;
--    if (mir_input_event_get_type(mir_event_get_input_event(&ev)) !=
--        mir_input_event_type_key)
--        return;
      xkb_mapper->map_event(ev);
+ }
 === modified file 'src/client/input/xkb_mapper.cpp'
 --- src/client/input/xkb_mapper.cpp	2016-06-24 06:43:18 +0000
 +++ src/client/input/xkb_mapper.cpp	2016-07-06 21:48:16 +0000
@@ -76,7 +76,6 @@
      // xkb scancodes are offset by 8 from evdev scancodes for compatibility with X protocol.
      return evdev_scan_code + 8;
+ }
--
+ }
  mi::XKBContextPtr mi::make_unique_context()
@@ -232,6 +231,14 @@
      update_modifier();
+ }
++MirInputEventModifiers mircv::XKBMapper::modifiers() const
++{
++    std::lock_guard<std::mutex> lg(guard);
++    if (modifier_state.is_set())
++        return expand_modifiers(modifier_state.value());
++    return mir_input_event_modifier_none;
++}
++
  mircv::XKBMapper::XkbMappingState::XkbMappingState(std::shared_ptr<xkb_keymap> const& keymap)
      : keymap{keymap}, state{make_unique_state(this->keymap.get())}
+ {
 === modified file 'src/include/common/mir/input/key_mapper.h'
 --- src/include/common/mir/input/key_mapper.h	2016-06-23 15:09:02 +0000
 +++ src/include/common/mir/input/key_mapper.h	2016-07-06 21:48:16 +0000
@@ -88,6 +88,7 @@
       * masks in input events with the modifier mask evaluated by this Keymapper.
       */
      virtual void map_event(MirEvent& event) = 0;
++    virtual MirInputEventModifiers modifiers() const = 0;
  protected:
      KeyMapper(KeyMapper const&) = delete;
 === modified file 'src/include/common/mir/input/xkb_mapper.h'
 --- src/include/common/mir/input/xkb_mapper.h	2016-06-24 06:43:18 +0000
 +++ src/include/common/mir/input/xkb_mapper.h	2016-07-06 21:48:16 +0000
@@ -58,7 +58,7 @@
      void clear_keymap_for_device(MirInputDeviceId id) override;
      void clear_all_keymaps() override;
      void map_event(MirEvent& event) override;
--
++    MirInputEventModifiers modifiers() const override;
  protected:
      XKBMapper(XKBMapper const&) = delete;
@@ -69,7 +69,7 @@
      void set_keymap(XKBKeymapPtr map);
      void update_modifier();
--    std::mutex guard;
++    mutable std::mutex guard;
      struct XkbMappingState
+     {
 === modified file 'src/include/server/mir/input/seat.h'
 --- src/include/server/mir/input/seat.h	2016-06-20 17:10:33 +0000
 +++ src/include/server/mir/input/seat.h	2016-07-06 21:48:16 +0000
@@ -25,9 +25,11 @@
  #include "mir_toolkit/event.h"
  #include <memory>
++#include <vector>
  namespace mir
+ {
++using EventUPtr = std::unique_ptr<MirEvent, void(*)(MirEvent*)>;
  namespace input
+ {
  class Device;
@@ -40,6 +42,11 @@
      virtual void remove_device(Device const& device) = 0;
      virtual void dispatch_event(MirEvent& event) = 0;
      virtual geometry::Rectangle get_rectangle_for(Device const& dev) = 0;
++    virtual EventUPtr create_device_state() = 0;
++
++    virtual void set_key_state(Device const& dev, std::vector<uint32_t> const& scan_codes) = 0;
++    virtual void set_pointer_state(Device const& dev, MirPointerButtons buttons) = 0;
++    virtual void set_cursor_position(float cursor_x, float cursor_y) = 0;
      virtual void set_confinement_regions(geometry::Rectangles const& regions) = 0;
      virtual void reset_confinement_regions() = 0;
  private:
 === modified file 'src/server/graphics/nested/display_buffer.cpp'
 --- src/server/graphics/nested/display_buffer.cpp	2016-06-09 13:15:34 +0000
 +++ src/server/graphics/nested/display_buffer.cpp	2016-07-06 21:48:16 +0000
@@ -110,10 +110,9 @@
  void mgn::detail::DisplayBuffer::mir_event(MirEvent const& event)
+ {
--    if (mir_event_get_type(&event) != mir_event_type_input)
--        return;
--
--    host_connection->emit_input_event(event, area);
++    if (mir_event_get_type(&event) == mir_event_type_input ||
++        mir_event_get_type(&event) == mir_event_type_input_device_state)
++        host_connection->emit_input_event(event, area);
+ }
  mg::NativeDisplayBuffer* mgn::detail::DisplayBuffer::native_display_buffer()
 === modified file 'src/server/graphics/nested/input_platform.cpp'
 --- src/server/graphics/nested/input_platform.cpp	2016-06-07 16:20:53 +0000
 +++ src/server/graphics/nested/input_platform.cpp	2016-07-06 21:48:16 +0000
@@ -31,6 +31,7 @@
  #include "mir/dispatch/action_queue.h"
  #include "mir/events/event_builders.h"
  #include "mir/events/event_private.h"
++#include "mir/event_printer.h"
  #include <chrono>
@@ -107,13 +108,14 @@
          case mir_input_event_type_key:
+             {
                  auto const* key_event = mir_input_event_get_keyboard_event(event);
--                destination->handle_input(*builder->key_event(
++
++                auto new_kev = builder->key_event(
                          event_time,
                          mir_keyboard_event_action(key_event),
                          mir_keyboard_event_key_code(key_event),
                          mir_keyboard_event_scan_code(key_event)
--                        ));
--
++                        );
++                destination->handle_input(*new_kev);
                  break;
+             }
          case mir_input_event_type_pointer:
@@ -209,28 +211,65 @@
              action_queue->enqueue([this]{update_devices();});
          });
--    connection->set_input_event_callback([this](MirEvent const& event, mir::geometry::Rectangle const& area) {
--        auto const* input_ev = mir_event_get_input_event(&event);
--        auto const id = mir_input_event_get_device_id(input_ev);
--        auto it = devices.find(id);
--        if (it != end(devices))
--        {
--            it->second->emit_event(input_ev, area);
--        }
--        else // device was not advertised to us yet.
--        {
--            unknown_device_events[id].emplace_back(
--                std::piecewise_construct,
--                std::forward_as_tuple(event.clone(), [](MirEvent* e){delete e;}),
--                std::forward_as_tuple(area));
--        }
--    });
++    connection->set_input_event_callback(
++        [this](MirEvent const& event, mir::geometry::Rectangle const& area)
++        {
++            auto const event_type = mir_event_get_type(&event);
++
++            if (event_type == mir_event_type_input)
++            {
++                auto const* input_ev = mir_event_get_input_event(&event);
++                auto const id = mir_input_event_get_device_id(input_ev);
++                auto it = devices.find(id);
++                if (it != end(devices))
++                {
++                    it->second->emit_event(input_ev, area);
++                }
++                else // device was not advertised to us yet.
++                {
++                    unknown_device_events[id].emplace_back(
++                        std::piecewise_construct,
++                        std::forward_as_tuple(event.clone(), [](MirEvent* e){delete e;}),
++                        std::forward_as_tuple(area));
++                }
++            }
++            else if (event_type == mir_event_type_input_device_state)
++            {
++                if (!devices.empty())
++                {
++                    auto const* device_state = mir_event_get_input_device_state_event(&event);
++                    for (size_t index = 0, end_index = mir_input_device_state_event_device_count(device_state);
++                         index != end_index; ++index)
++                    {
++                        auto it = devices.find(mir_input_device_state_event_device_id(device_state, index));
++                        if (it != end(devices) && it->second->destination)
++                        {
++                            auto dest = it->second->destination;
++                            auto key_count = mir_input_device_state_event_device_pressed_keys_count(device_state, index);
++                            auto const* scan_codes = mir_input_device_state_event_device_pressed_keys(device_state, index);
++
++                            dest->set_key_state({scan_codes, scan_codes + key_count});
++                            dest->set_pointer_state(
++                                mir_input_device_state_event_device_pointer_buttons(device_state, index));
++                        }
++                    }
++
++                    auto& front = begin(devices)->second;
++                    auto device_state_event = front->builder->device_state_event(
++                        mir_input_device_state_event_pointer_axis(device_state, mir_pointer_axis_x),
++                        mir_input_device_state_event_pointer_axis(device_state, mir_pointer_axis_y));
++                    front->destination->handle_input(*device_state_event);
++                }
++            }
++        });
+ }
  void mgn::InputPlatform::stop()
+ {
      std::function<void(mgn::UniqueInputConfig)> reset;
      connection->set_input_device_change_callback(reset);
++    std::function<void(MirEvent const&, mir::geometry::Rectangle const&)> empty_event_callback;
++    connection->set_input_event_callback(empty_event_callback);
      for(auto const& device : devices)
          input_device_registry->remove_device(device.second);
 === modified file 'src/server/input/android/input_sender.cpp'
 --- src/server/input/android/input_sender.cpp	2016-05-03 06:55:25 +0000
 +++ src/server/input/android/input_sender.cpp	2016-07-06 21:48:16 +0000
@@ -163,29 +163,38 @@
  void mia::InputSender::ActiveTransfer::send(uint32_t sequence_id, MirEvent const& event)
+ {
--    if (mir_event_get_type(&event) != mir_event_type_input)
++    auto const type = mir_event_get_type(&event);
++
++    if (type != mir_event_type_input_device_state && type != mir_event_type_input)
          return;
      droidinput::status_t error_status;
--    auto event_time = mir_input_event_get_event_time(mir_event_get_input_event(&event));
--    auto input_event = mir_event_get_input_event(&event);
--    switch(mir_input_event_get_type(input_event))
--    {
--    case mir_input_event_type_key:
--        error_status = send_key_event(sequence_id, event);
--        state.report->published_key_event(channel->server_fd(), sequence_id, event_time);
--        break;
--    case mir_input_event_type_touch:
--        error_status = send_touch_event(sequence_id, event);
--        state.report->published_motion_event(channel->server_fd(), sequence_id, event_time);
--        break;
--    case mir_input_event_type_pointer:
--        error_status = send_pointer_event(sequence_id, event);
--        state.report->published_motion_event(channel->server_fd(), sequence_id, event_time);
--        break;
--    default:
--        BOOST_THROW_EXCEPTION(std::runtime_error("unknown input event type"));
++    if (type == mir_event_type_input)
++    {
++        auto event_time = mir_input_event_get_event_time(mir_event_get_input_event(&event));
++        auto input_event = mir_event_get_input_event(&event);
++        switch(mir_input_event_get_type(input_event))
++        {
++        case mir_input_event_type_key:
++            error_status = send_key_event(sequence_id, event);
++            state.report->published_key_event(channel->server_fd(), sequence_id, event_time);
++            break;
++        case mir_input_event_type_touch:
++            error_status = send_touch_event(sequence_id, event);
++            state.report->published_motion_event(channel->server_fd(), sequence_id, event_time);
++            break;
++        case mir_input_event_type_pointer:
++            error_status = send_pointer_event(sequence_id, event);
++            state.report->published_motion_event(channel->server_fd(), sequence_id, event_time);
++            break;
++        default:
++            BOOST_THROW_EXCEPTION(std::runtime_error("unknown input event type"));
++        }
++    }
++    else
++    {
++        error_status = publisher.publishEventBuffer(sequence_id, MirEvent::serialize(&event));
+     }
      switch(error_status)
 === modified file 'src/server/input/basic_seat.cpp'
 --- src/server/input/basic_seat.cpp	2016-06-28 13:19:50 +0000
 +++ src/server/input/basic_seat.cpp	2016-07-06 21:48:16 +0000
@@ -30,8 +30,9 @@
                           std::shared_ptr<mi::TouchVisualizer> const& touch_visualizer,
                           std::shared_ptr<mi::CursorListener> const& cursor_listener,
                           std::shared_ptr<mi::InputRegion> const& input_region,
--                         std::shared_ptr<mi::KeyMapper> const& key_mapper)
--    : input_state_tracker{dispatcher, touch_visualizer, cursor_listener, input_region, key_mapper}, input_region{input_region}
++                         std::shared_ptr<mi::KeyMapper> const& key_mapper,
++                         std::shared_ptr<time::Clock> const& clock)
++    : input_state_tracker{dispatcher, touch_visualizer, cursor_listener, input_region, key_mapper, clock}, input_region{input_region}
+ {
+ }
@@ -59,6 +60,26 @@
      return input_region->bounding_rectangle();
+ }
++mir::EventUPtr mi::BasicSeat::create_device_state()
++{
++    return input_state_tracker.create_device_state();
++}
++
++void mi::BasicSeat::set_key_state(Device const& dev, std::vector<uint32_t> const& scan_codes)
++{
++    input_state_tracker.set_key_state(dev.id(), scan_codes);
++}
++
++void mi::BasicSeat::set_pointer_state(Device const& dev, MirPointerButtons buttons)
++{
++    input_state_tracker.set_pointer_state(dev.id(), buttons);
++}
++
++void mi::BasicSeat::set_cursor_position(float cursor_x, float cursor_y)
++{
++    input_state_tracker.set_cursor_position(cursor_x, cursor_y);
++}
++
  void mi::BasicSeat::set_confinement_regions(geometry::Rectangles const& regions)
+ {
      input_state_tracker.set_confinement_regions(regions);
 === modified file 'src/server/input/basic_seat.h'
 --- src/server/input/basic_seat.h	2016-06-28 13:19:50 +0000
 +++ src/server/input/basic_seat.h	2016-07-06 21:48:16 +0000
@@ -28,6 +28,10 @@
  namespace mir
+ {
++namespace time
++{
++class Clock;
++}
  namespace input
+ {
  class TouchVisualizer;
@@ -43,15 +47,20 @@
                std::shared_ptr<TouchVisualizer> const& touch_visualizer,
                std::shared_ptr<CursorListener> const& cursor_listener,
                std::shared_ptr<InputRegion> const& input_region,
--              std::shared_ptr<KeyMapper> const& key_mapper);
++              std::shared_ptr<KeyMapper> const& key_mapper,
++              std::shared_ptr<time::Clock> const& clock);
      // Seat methods:
      void add_device(Device const& device) override;
      void remove_device(Device const& device) override;
      void dispatch_event(MirEvent& event) override;
      geometry::Rectangle get_rectangle_for(Device const& dev) override;
++    virtual EventUPtr create_device_state() override;
      virtual void set_confinement_regions(geometry::Rectangles const& regions) override;
      virtual void reset_confinement_regions() override;
++    void set_key_state(Device const& dev, std::vector<uint32_t> const& scan_codes) override;
++    void set_pointer_state(Device const& dev, MirPointerButtons buttons) override;
++    void set_cursor_position(float cursor_x, float cursor_y) override;
  private:
      SeatInputDeviceTracker input_state_tracker;
      std::shared_ptr<InputRegion> const input_region;
 === modified file 'src/server/input/default_configuration.cpp'
 --- src/server/input/default_configuration.cpp	2016-06-02 08:20:22 +0000
 +++ src/server/input/default_configuration.cpp	2016-07-06 21:48:16 +0000
@@ -332,7 +332,8 @@
                      the_touch_visualizer(),
                      the_cursor_listener(),
                      the_input_region(),
--                    the_key_mapper());
++                    the_key_mapper(),
++                    the_clock());
          });
+ }
 === modified file 'src/server/input/default_event_builder.cpp'
 --- src/server/input/default_event_builder.cpp	2016-05-03 06:55:25 +0000
 +++ src/server/input/default_event_builder.cpp	2016-07-06 21:48:16 +0000
@@ -18,6 +18,7 @@
   */
  #include "default_event_builder.h"
++#include "mir/input/seat.h"
  #include "mir/events/event_builders.h"
  #include "mir/cookie/authority.h"
  #include "mir/events/event_private.h"
@@ -28,9 +29,11 @@
  namespace mi = mir::input;
  mi::DefaultEventBuilder::DefaultEventBuilder(MirInputDeviceId device_id,
--                                             std::shared_ptr<mir::cookie::Authority> const& cookie_authority)
++                                             std::shared_ptr<mir::cookie::Authority> const& cookie_authority,
++                                             std::shared_ptr<mi::Seat> const& seat)
      : device_id(device_id),
--      cookie_authority(cookie_authority)
++      cookie_authority(cookie_authority),
++      seat(seat)
+ {
+ }
@@ -86,3 +89,9 @@
+ {
      return me::make_event(action, device_id, timestamp);
+ }
++
++mir::EventUPtr mi::DefaultEventBuilder::device_state_event(float cursor_x, float cursor_y)
++{
++    seat->set_cursor_position(cursor_x, cursor_y);
++    return seat->create_device_state();
++}
 === modified file 'src/server/input/default_event_builder.h'
 --- src/server/input/default_event_builder.h	2016-01-29 08:18:22 +0000
 +++ src/server/input/default_event_builder.h	2016-07-06 21:48:16 +0000
@@ -31,11 +31,14 @@
+ }
  namespace input
+ {
++class Seat;
++
  class DefaultEventBuilder : public EventBuilder
+ {
  public:
      explicit DefaultEventBuilder(MirInputDeviceId device_id,
--                                 std::shared_ptr<cookie::Authority> const& cookie_authority);
++                                 std::shared_ptr<cookie::Authority> const& cookie_authority,
++                                 std::shared_ptr<Seat> const& seat);
      EventUPtr key_event(Timestamp timestamp, MirKeyboardAction action, xkb_keysym_t key_code, int scan_code) override;
@@ -50,9 +53,11 @@
      EventUPtr configuration_event(Timestamp timestamp, MirInputConfigurationAction action) override;
++    EventUPtr device_state_event(float cursor_x, float cursor_y) override;
  private:
      MirInputDeviceId const device_id;
      std::shared_ptr<cookie::Authority> const cookie_authority;
++    std::shared_ptr<Seat> const seat;
  };
+ }
+ }
 === modified file 'src/server/input/default_input_device_hub.cpp'
 --- src/server/input/default_input_device_hub.cpp	2016-06-02 08:20:22 +0000
 +++ src/server/input/default_input_device_hub.cpp	2016-07-06 21:48:16 +0000
@@ -142,7 +142,11 @@
      std::shared_ptr<dispatch::MultiplexingDispatchable> const& multiplexer,
      std::shared_ptr<mir::cookie::Authority> const& cookie_authority,
      std::shared_ptr<mi::DefaultDevice> const& handle)
--    : handle(handle), device_id(device_id), builder(device_id, cookie_authority), device(dev), multiplexer(multiplexer)
++    : handle(handle),
++      device_id(device_id),
++      cookie_authority(cookie_authority),
++      device(dev),
++      multiplexer(multiplexer)
+ {
+ }
@@ -160,7 +164,8 @@
+ {
      auto type = mir_event_get_type(&event);
--    if (type != mir_event_type_input)
++    if (type != mir_event_type_input &&
++        type != mir_event_type_input_device_state)
          BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid input event received from device"));
      if (!seat)
@@ -177,13 +182,15 @@
  void mi::DefaultInputDeviceHub::RegisteredDevice::start(std::shared_ptr<Seat> const& seat)
+ {
      this->seat = seat;
--    device->start(this, &builder);
++    builder = std::make_unique<DefaultEventBuilder>(device_id, cookie_authority, seat);
++    device->start(this, builder.get());
+ }
  void mi::DefaultInputDeviceHub::RegisteredDevice::stop()
+ {
      device->stop();
      seat = nullptr;
++    builder.reset();
+ }
  mir::geometry::Rectangle mi::DefaultInputDeviceHub::RegisteredDevice::bounding_rectangle() const
@@ -194,6 +201,22 @@
      return seat->get_rectangle_for(*handle);
+ }
++void mi::DefaultInputDeviceHub::RegisteredDevice::set_key_state(std::vector<uint32_t> const& scan_codes)
++{
++    if (!seat)
++        BOOST_THROW_EXCEPTION(std::runtime_error("Device not started and has no seat assigned"));
++
++    seat->set_key_state(*handle, scan_codes);
++}
++
++void mi::DefaultInputDeviceHub::RegisteredDevice::set_pointer_state(MirPointerButtons buttons)
++{
++    if (!seat)
++        BOOST_THROW_EXCEPTION(std::runtime_error("Device not started and has no seat assigned"));
++
++    seat->set_pointer_state(*handle, buttons);
++}
++
  void mi::DefaultInputDeviceHub::add_observer(std::shared_ptr<InputDeviceObserver> const& observer)
+ {
      observer_queue->enqueue(
 === modified file 'src/server/input/default_input_device_hub.h'
 --- src/server/input/default_input_device_hub.h	2016-06-02 08:20:22 +0000
 +++ src/server/input/default_input_device_hub.h	2016-07-06 21:48:16 +0000
@@ -108,9 +108,13 @@
          MirInputDeviceId id();
          std::shared_ptr<Seat> seat;
          const std::shared_ptr<DefaultDevice> handle;
++
++        void set_key_state(std::vector<uint32_t> const& scan_codes) override;
++        void set_pointer_state(MirPointerButtons buttons) override;
      private:
          MirInputDeviceId device_id;
--        DefaultEventBuilder builder;
++        std::unique_ptr<DefaultEventBuilder> builder;
++        std::shared_ptr<cookie::Authority> cookie_authority;
          std::shared_ptr<InputDevice> const device;
          std::shared_ptr<dispatch::MultiplexingDispatchable> const multiplexer;
      };
 === modified file 'src/server/input/seat_input_device_tracker.cpp'
 --- src/server/input/seat_input_device_tracker.cpp	2016-07-01 20:24:26 +0000
 +++ src/server/input/seat_input_device_tracker.cpp	2016-07-06 21:48:16 +0000
@@ -26,6 +26,7 @@
  #include "mir/geometry/displacement.h"
  #include "mir/events/event_builders.h"
  #include "mir/events/event_private.h"
++#include "mir/time/clock.h"
  #include "input_modifier_utils.h"
@@ -44,9 +45,10 @@
                                                     std::shared_ptr<TouchVisualizer> const& touch_visualizer,
                                                     std::shared_ptr<CursorListener> const& cursor_listener,
                                                     std::shared_ptr<InputRegion> const& input_region,
--                                                   std::shared_ptr<KeyMapper> const& key_mapper)
++                                                   std::shared_ptr<KeyMapper> const& key_mapper,
++                                                   std::shared_ptr<time::Clock> const& clock)
      : dispatcher{dispatcher}, touch_visualizer{touch_visualizer}, cursor_listener{cursor_listener},
--      input_region{input_region}, key_mapper{key_mapper}, buttons{0},
++      input_region{input_region}, key_mapper{key_mapper}, clock{clock}, buttons{0},
        confine_function{[input_region](mir::geometry::Point& pos) { input_region->confine(pos); }}
+ {
+ }
@@ -77,20 +79,23 @@
  void mi::SeatInputDeviceTracker::dispatch(MirEvent &event)
+ {
--    auto input_event = mir_event_get_input_event(&event);
--
--    if (filter_input_event(input_event))
--        return;
--
--    update_seat_properties(input_event);
--
--    key_mapper->map_event(event);
--
--    if (mir_input_event_type_pointer == mir_input_event_get_type(input_event))
++    if (mir_event_get_type(&event) == mir_event_type_input)
+     {
--        event.to_input()->to_motion()->set_x(0, cursor_x);
--        event.to_input()->to_motion()->set_y(0, cursor_y);
--        mev::set_button_state(event, button_state());
++        auto input_event = mir_event_get_input_event(&event);
++
++        if (filter_input_event(input_event))
++            return;
++
++        update_seat_properties(input_event);
++
++        key_mapper->map_event(event);
++
++        if (mir_input_event_type_pointer == mir_input_event_get_type(input_event))
++        {
++            event.to_input()->to_motion()->set_x(0, cursor_x);
++            event.to_input()->to_motion()->set_y(0, cursor_y);
++            mev::set_button_state(event, button_state());
++        }
+     }
      dispatcher->dispatch(event);
@@ -227,6 +232,16 @@
      cursor_listener->cursor_moved_to(cursor_x, cursor_y);
+ }
++mir::EventUPtr mi::SeatInputDeviceTracker::create_device_state() const
++{
++    std::vector<mev::InputDeviceState> devices;
++    devices.reserve(device_data.size());
++    for (auto const& item : device_data)
++        devices.push_back({item.first, item.second.scan_codes, item.second.buttons});
++    return mev::make_event(
++        clock->now().time_since_epoch(), buttons, key_mapper->modifiers(), cursor_x, cursor_y, std::move(devices));
++}
++
  void mi::SeatInputDeviceTracker::DeviceData::update_scan_codes(MirKeyboardEvent const* event)
+ {
      auto const action = mir_keyboard_event_action(event);
@@ -237,6 +252,30 @@
          scan_codes.erase(remove(begin(scan_codes), end(scan_codes), scan_code), end(scan_codes));
+ }
++void mi::SeatInputDeviceTracker::set_key_state(MirInputDeviceId id, std::vector<uint32_t> const& scan_codes)
++{
++    key_mapper->set_key_state(id, scan_codes);
++
++    auto device = device_data.find(id);
++
++    if (device != end(device_data))
++        device->second.scan_codes = scan_codes;
++}
++
++void mi::SeatInputDeviceTracker::set_pointer_state(MirInputDeviceId id, MirPointerButtons buttons)
++{
++    auto device = device_data.find(id);
++
++    if (device != end(device_data))
++        device->second.update_button_state(buttons);
++}
++
++void mi::SeatInputDeviceTracker::set_cursor_position(float x, float y)
++{
++    cursor_x = x;
++    cursor_y = y;
++}
++
  bool mi::SeatInputDeviceTracker::DeviceData::allowed_scan_code_action(MirKeyboardEvent const* event) const
+ {
      auto const action = mir_keyboard_event_action(event);
 === modified file 'src/server/input/seat_input_device_tracker.h'
 --- src/server/input/seat_input_device_tracker.h	2016-07-01 20:24:26 +0000
 +++ src/server/input/seat_input_device_tracker.h	2016-07-06 21:48:16 +0000
@@ -29,6 +29,11 @@
  namespace mir
+ {
++using EventUPtr = std::unique_ptr<MirEvent, void(*)(MirEvent*)>;
++namespace time
++{
++class Clock;
++}
  namespace input
+ {
  class CursorListener;
@@ -50,7 +55,8 @@
                             std::shared_ptr<TouchVisualizer> const& touch_visualizer,
                             std::shared_ptr<CursorListener> const& cursor_listener,
                             std::shared_ptr<InputRegion> const& input_region,
--                           std::shared_ptr<KeyMapper> const& key_mapper);
++                           std::shared_ptr<KeyMapper> const& key_mapper,
++                           std::shared_ptr<time::Clock> const& clock);
      void add_device(MirInputDeviceId);
      void remove_device(MirInputDeviceId);
@@ -58,7 +64,11 @@
      MirPointerButtons button_state() const;
      geometry::Point cursor_position() const;
++    EventUPtr create_device_state() const;
++    void set_key_state(MirInputDeviceId id, std::vector<uint32_t> const& scan_codes);
++    void set_pointer_state(MirInputDeviceId id, MirPointerButtons buttons);
++    void set_cursor_position(float cursor_x, float cursor_y);
      void set_confinement_regions(geometry::Rectangles const& region);
      void reset_confinement_regions();
  private:
@@ -74,6 +84,7 @@
      std::shared_ptr<CursorListener> const cursor_listener;
      std::shared_ptr<InputRegion> const input_region;
      std::shared_ptr<KeyMapper> const key_mapper;
++    std::shared_ptr<time::Clock> const clock;
      struct DeviceData
+     {
 === modified file 'src/server/server.cpp'
 --- src/server/server.cpp	2016-06-22 14:43:28 +0000
 +++ src/server/server.cpp	2016-07-06 21:48:16 +0000
@@ -23,6 +23,8 @@
  #include "mir/frontend/connector.h"
  #include "mir/graphics/graphic_buffer_allocator.h"
  #include "mir/graphics/display_buffer.h"
++#include "mir/input/composite_event_filter.h"
++#include "mir/input/event_filter.h"
  #include "mir/options/default_configuration.h"
  #include "mir/renderer/gl/render_target.h"
  #include "mir/default_server_configuration.h"
@@ -41,6 +43,37 @@
  #include <iostream>
  namespace mo = mir::options;
++namespace mi = mir::input;
++
++namespace
++{
++struct TemporaryCompositeEventFilter : public mi::CompositeEventFilter
++{
++    bool handle(MirEvent const&) override { return false; }
++    void append(std::shared_ptr<mi::EventFilter> const& filter) override
++    {
++        append_event_filters.push_back(filter);
++    }
++    void prepend(std::shared_ptr<mi::EventFilter> const& filter) override
++    {
++        prepend_event_filters.push_back(filter);
++    }
++
++    void move_filters(std::shared_ptr<mi::CompositeEventFilter> const& composite_event_filter)
++    {
++        for (auto const& filter : prepend_event_filters)
++            composite_event_filter->prepend(filter);
++
++        for (auto const& filter : append_event_filters)
++            composite_event_filter->append(filter);
++
++        append_event_filters.clear();
++        prepend_event_filters.clear();
++    }
++    std::vector<std::shared_ptr<mi::EventFilter>> prepend_event_filters;
++    std::vector<std::shared_ptr<mi::EventFilter>> append_event_filters;
++};
++}
  #define FOREACH_WRAPPER(MACRO)\
      MACRO(cursor)\
@@ -76,7 +109,6 @@
      MACRO(the_buffer_stream_factory)\
      MACRO(the_compositor)\
      MACRO(the_compositor_report)\
--    MACRO(the_composite_event_filter)\
      MACRO(the_cursor_listener)\
      MACRO(the_cursor)\
      MACRO(the_display)\
@@ -121,6 +153,8 @@
      std::function<void()> exception_handler{};
      Terminator terminator{};
      EmergencyCleanupHandler emergency_cleanup_handler;
++    std::shared_ptr<TemporaryCompositeEventFilter> temporary_event_filter{
++        std::make_shared<TemporaryCompositeEventFilter>()};
      std::function<void(int argc, char const* const* argv)> command_line_hander{};
@@ -386,6 +420,9 @@
          verify_accessing_allowed(self->server_config);
          auto const emergency_cleanup = self->server_config->the_emergency_cleanup();
++        auto const composite_event_filter = self->server_config->the_composite_event_filter();
++
++        self->temporary_event_filter->move_filters(composite_event_filter);
          if (self->emergency_cleanup_handler)
              emergency_cleanup->add(self->emergency_cleanup_handler);
@@ -498,6 +535,14 @@
  #undef MIR_SERVER_WRAP
++auto mir::Server::the_composite_event_filter() const -> decltype(self->server_config->the_composite_event_filter())
++{
++    if (self->server_config)
++        return self->server_config->the_composite_event_filter();
++    else
++        return self->temporary_event_filter;
++}
++
  void mir::Server::add_configuration_option(
      std::string const& option,
      std::string const& description,
 === modified file 'src/server/shell/abstract_shell.cpp'
 --- src/server/shell/abstract_shell.cpp	2016-06-20 17:10:33 +0000
 +++ src/server/shell/abstract_shell.cpp	2016-07-06 21:48:16 +0000
@@ -254,6 +254,7 @@
              // Ensure the surface has really taken the focus before notifying it that it is focused
              input_targeter->set_focus(surface);
++            surface->consume(seat->create_device_state().get());
              surface->configure(mir_surface_attrib_focus, mir_surface_focused);
+         }
          else
 === modified file 'tests/acceptance-tests/test_nested_input.cpp'
 --- tests/acceptance-tests/test_nested_input.cpp	2016-05-03 06:55:25 +0000
 +++ tests/acceptance-tests/test_nested_input.cpp	2016-07-06 21:48:16 +0000
@@ -75,19 +75,24 @@
  struct NestedServerWithMockEventFilter : mtf::HeadlessNestedServerRunner
+ {
--    NestedServerWithMockEventFilter(std:: string const& connection_string)
--        : mtf::HeadlessNestedServerRunner(connection_string)
++    NestedServerWithMockEventFilter(std::string const& connection_string,
++                                    std::shared_ptr<MockEventFilter> const& event_filter)
++        : mtf::HeadlessNestedServerRunner(connection_string), mock_event_filter{event_filter}
+     {
++        server.the_composite_event_filter()->append(mock_event_filter);
          start_server();
--        server.the_composite_event_filter()->append(mock_event_filter);
--
--    }
++    }
++    NestedServerWithMockEventFilter(std::string const& connection_string)
++        : NestedServerWithMockEventFilter(connection_string, std::make_shared<MockEventFilter>())
++    {
++    }
++
      ~NestedServerWithMockEventFilter()
+     {
          stop_server();
+     }
--    std::shared_ptr<MockEventFilter> const mock_event_filter = std::make_shared<MockEventFilter>();
++    std::shared_ptr<MockEventFilter> const mock_event_filter;
  };
  struct NestedInput : public mtf::HeadlessInProcessServer
@@ -121,14 +126,52 @@
          // Ensure the nested server posts a frame
          connection = mir_connect_sync(connect_string.c_str(), __PRETTY_FUNCTION__);
          surface = mtf::make_any_surface(connection);
++        mir_surface_set_event_handler(surface, handle_event, this);
          mir_buffer_stream_swap_buffers_sync(mir_surface_get_buffer_stream(surface));
+     }
++    MOCK_METHOD1(handle_input, void(MirEvent const*));
++
++    void handle_surface_event(MirSurfaceEvent const* event)
++    {
++        auto const attrib = mir_surface_event_get_attribute(event);
++        auto const value = mir_surface_event_get_attribute_value(event);
++
++        if (mir_surface_attrib_visibility == attrib &&
++            mir_surface_visibility_exposed == value)
++            exposed = true;
++
++        if (mir_surface_attrib_focus == attrib &&
++            mir_surface_focused == value)
++            focused = true;
++
++        if (exposed && focused)
++            ready_to_accept_events.raise();
++    }
++
++    static void handle_event(MirSurface*, MirEvent const* ev, void* context)
++    {
++        auto const client = static_cast<ExposedSurface*>(context);
++        auto type = mir_event_get_type(ev);
++        if (type == mir_event_type_surface)
++        {
++            auto surface_event = mir_event_get_surface_event(ev);
++            client->handle_surface_event(surface_event);
++
++        }
++        if (type == mir_event_type_input)
++            client->handle_input(ev);
++    }
++
++    static void null_event_handler(MirSurface*, MirEvent const*, void*) {};
      ~ExposedSurface()
+     {
++        mir_surface_set_event_handler(surface, null_event_handler, nullptr);
          mir_surface_release_sync(surface);
          mir_connection_release(connection);
+     }
++    mir::test::Signal ready_to_accept_events;
++
  protected:
      ExposedSurface(ExposedSurface const&) = delete;
      ExposedSurface& operator=(ExposedSurface const&) = delete;
@@ -136,28 +179,32 @@
  private:
      MirConnection *connection;
      MirSurface *surface;
++    bool exposed{false};
++    bool focused{false};
  };
+ }
  TEST_F(NestedInput, nested_event_filter_receives_keyboard_from_host)
+ {
--    NestedServerWithMockEventFilter nested_mir{new_connection()};
--    ExposedSurface client(nested_mir.new_connection());
++    MockEventFilter nested_event_filter;
      std::atomic<int> num_key_a_events{0};
--
      auto const increase_key_a_events = [&num_key_a_events] { ++num_key_a_events; };
      InSequence seq;
--    EXPECT_CALL(*nested_mir.mock_event_filter, handle(mt::KeyOfScanCode(KEY_A))).
++    EXPECT_CALL(nested_event_filter, handle(mt::InputDeviceStateEvent()));
++    EXPECT_CALL(nested_event_filter, handle(mt::KeyOfScanCode(KEY_A))).
          Times(AtLeast(1)).
          WillRepeatedly(DoAll(InvokeWithoutArgs(increase_key_a_events), Return(true)));
--    EXPECT_CALL(*nested_mir.mock_event_filter, handle(mt::KeyOfScanCode(KEY_RIGHTSHIFT))).
++    EXPECT_CALL(nested_event_filter, handle(mt::KeyOfScanCode(KEY_RIGHTSHIFT))).
          Times(2).
          WillOnce(Return(true)).
          WillOnce(DoAll(mt::WakeUp(&all_events_received), Return(true)));
++    NestedServerWithMockEventFilter nested_mir{new_connection(), mt::fake_shared(nested_event_filter)};
++    ExposedSurface client(nested_mir.new_connection());
++
      // Because we are testing a nested setup, it's difficult to guarantee
      // that the nested framebuffer surface (and consenquently the client surface
      // contained in it) is going to be ready (i.e., exposed and focused) to receive
@@ -229,3 +276,24 @@
      input_device_changes_complete.wait_for(10s);
+ }
++
++TEST_F(NestedInput, on_input_device_state_nested_server_emits_input_device_state)
++{
++    MockEventFilter nested_event_filter;
++    NestedServerWithMockEventFilter nested_mir{new_connection(), mt::fake_shared(nested_event_filter)};
++    ExposedSurface client_to_nested_mir(nested_mir.new_connection());
++
++    client_to_nested_mir.ready_to_accept_events.wait_for(1s);
++    ExposedSurface client_to_host(new_connection());
++    client_to_host.ready_to_accept_events.wait_for(1s);
++
++    EXPECT_CALL(client_to_host, handle_input(mt::KeyOfScanCode(KEY_LEFTALT)));
++    EXPECT_CALL(nested_event_filter,
++                handle(mt::DeviceStateWithPressedKeys(std::vector<uint32_t>({KEY_LEFTALT, KEY_TAB}))))
++        .WillOnce(DoAll(mt::WakeUp(&all_events_received), Return(true)));
++
++    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_LEFTALT));
++    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_TAB));
++
++    all_events_received.wait_for(2s);
++}
 === modified file 'tests/include/mir/test/doubles/mock_input_seat.h'
 --- tests/include/mir/test/doubles/mock_input_seat.h	2016-06-27 20:44:49 +0000
 +++ tests/include/mir/test/doubles/mock_input_seat.h	2016-07-06 21:48:16 +0000
@@ -20,9 +20,10 @@
  #define MIR_TEST_DOUBLES_MOCK_INPUT_SEAT_H_
  #include "mir/input/seat.h"
++#include "mir/input/device.h"
++#include "mir/test/gmock_fixes.h"
  #include <gmock/gmock.h>
--#include "mir/input/device.h"
  namespace mir
+ {
@@ -36,6 +37,10 @@
      MOCK_METHOD1(remove_device, void(input::Device const& device));
      MOCK_METHOD1(dispatch_event, void(MirEvent& event));
      MOCK_METHOD1(get_rectangle_for, geometry::Rectangle(input::Device const& dev));
++    MOCK_METHOD0(create_device_state, mir::EventUPtr());
++    MOCK_METHOD2(set_key_state, void(input::Device const&, std::vector<uint32_t> const&));
++    MOCK_METHOD2(set_pointer_state, void (input::Device const&, MirPointerButtons));
++    MOCK_METHOD2(set_cursor_position, void (float, float));
      MOCK_METHOD1(set_confinement_regions, void(geometry::Rectangles const&));
      MOCK_METHOD0(reset_confinement_regions, void());
  };
 === modified file 'tests/include/mir/test/doubles/mock_input_sink.h'
 --- tests/include/mir/test/doubles/mock_input_sink.h	2015-07-21 17:57:15 +0000
 +++ tests/include/mir/test/doubles/mock_input_sink.h	2016-07-06 21:48:16 +0000
@@ -35,6 +35,8 @@
      MOCK_METHOD1(handle_input, void(MirEvent&));
      MOCK_METHOD1(confine_pointer, void(mir::geometry::Point&));
      MOCK_CONST_METHOD0(bounding_rectangle, mir::geometry::Rectangle());
++    MOCK_METHOD1(set_key_state, void(std::vector<uint32_t> const&));
++    MOCK_METHOD1(set_pointer_state, void(MirPointerButtons));
  };
+ }
 === modified file 'tests/include/mir/test/doubles/mock_key_mapper.h'
 --- tests/include/mir/test/doubles/mock_key_mapper.h	2016-06-24 06:43:18 +0000
 +++ tests/include/mir/test/doubles/mock_key_mapper.h	2016-07-06 21:48:16 +0000
@@ -40,6 +40,7 @@
      MOCK_METHOD1(clear_keymap_for_device, void(MirInputDeviceId id));
      MOCK_METHOD0(clear_all_keymaps, void());
      MOCK_METHOD1(map_event, void(MirEvent& event));
++    MOCK_CONST_METHOD0(modifiers, MirInputEventModifiers());
  };
 === modified file 'tests/integration-tests/input/test_single_seat_setup.cpp'
 --- tests/integration-tests/input/test_single_seat_setup.cpp	2016-06-02 08:20:22 +0000
 +++ tests/integration-tests/input/test_single_seat_setup.cpp	2016-07-06 21:48:16 +0000
@@ -28,6 +28,7 @@
  #include "mir/test/doubles/mock_event_sink.h"
  #include "mir/test/doubles/triggered_main_loop.h"
  #include "mir/test/event_matchers.h"
++#include "mir/test/doubles/advanceable_clock.h"
  #include "mir/test/fake_shared.h"
  #include "mir/dispatch/multiplexing_dispatchable.h"
@@ -81,10 +82,12 @@
      NiceMock<mtd::MockTouchVisualizer> mock_visualizer;
      mi::receiver::XKBMapper key_mapper;
      mir::dispatch::MultiplexingDispatchable multiplexer;
--    mi::BasicSeat seat{mt::fake_shared(mock_dispatcher), mt::fake_shared(mock_visualizer),
--                       mt::fake_shared(mock_cursor_listener), mt::fake_shared(mock_region), mt::fake_shared(key_mapper)};
--    mi::DefaultInputDeviceHub hub{mt::fake_shared(mock_sink), mt::fake_shared(seat), mt::fake_shared(multiplexer), mt::fake_shared(observer_loop),
--                                  cookie_authority, mt::fake_shared(key_mapper)};
++    mtd::AdvanceableClock clock;
++    mi::BasicSeat seat{mt::fake_shared(mock_dispatcher),      mt::fake_shared(mock_visualizer),
++                       mt::fake_shared(mock_cursor_listener), mt::fake_shared(mock_region),
++                       mt::fake_shared(key_mapper),           mt::fake_shared(clock)};
++    mi::DefaultInputDeviceHub hub{mt::fake_shared(mock_sink),     mt::fake_shared(seat), mt::fake_shared(multiplexer),
++                                  mt::fake_shared(observer_loop), cookie_authority,      mt::fake_shared(key_mapper)};
      NiceMock<mtd::MockInputDeviceObserver> mock_observer;
      mi::DeviceCapabilities const keyboard_caps = mi::DeviceCapability::keyboard | mi::DeviceCapability::alpha_numeric;
 === modified file 'tests/unit-tests/input/android/test_android_input_sender.cpp'
 --- tests/unit-tests/input/android/test_android_input_sender.cpp	2016-06-07 17:00:15 +0000
 +++ tests/unit-tests/input/android/test_android_input_sender.cpp	2016-07-06 21:48:16 +0000
@@ -17,6 +17,7 @@
   */
  #include "mir/events/event_private.h"
++#include "mir/events/event_builders.h"
  #include "src/server/input/channel.h"
  #include "src/server/input/android/input_sender.h"
@@ -25,6 +26,7 @@
  #include "mir/test/doubles/stub_scene_surface.h"
  #include "mir/test/doubles/mock_input_surface.h"
++#include "mir/test/doubles/mock_input_seat.h"
  #include "mir/test/doubles/stub_scene.h"
  #include "mir/test/doubles/mock_scene.h"
  #include "mir/test/doubles/triggered_main_loop.h"
@@ -54,7 +56,7 @@
  namespace mtd = mt::doubles;
  namespace droidinput = android;
--using testing::_;
++using namespace testing;
  namespace
+ {
@@ -108,10 +110,11 @@
      mir::geometry::Displacement const movement{10, -10};
      std::shared_ptr<mir::cookie::Authority> const cookie_authority;
      mi::DefaultEventBuilder builder;
++    mtd::MockInputSeat seat;
      AndroidInputSender()
          : cookie_authority(mir::cookie::Authority::create_from({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})),
--          builder(MirInputDeviceId(), cookie_authority),
++          builder(MirInputDeviceId(), cookie_authority, mt::fake_shared(seat)),
            key_event(builder.key_event(std::chrono::nanoseconds(1), mir_keyboard_action_down, 7, test_scan_code)),
            motion_event(builder.touch_event(std::chrono::nanoseconds(-1))),
            pointer_event(builder.pointer_event(std::chrono::nanoseconds(123), mir_pointer_action_motion,
@@ -128,6 +131,7 @@
          ON_CALL(event_factory, createKeyEvent()).WillByDefault(Return(&client_key_event));
          ON_CALL(event_factory, createMotionEvent()).WillByDefault(Return(&client_motion_event));
++        ON_CALL(event_factory, createRawBufferEvent()).WillByDefault(Return(&client_raw_event));
+     }
      void register_surface()
@@ -154,6 +158,7 @@
      droidinput::MotionEvent client_motion_event;
      droidinput::KeyEvent client_key_event;
++    droidinput::RawBufferEvent client_raw_event;
      testing::NiceMock<MockInputEventFactory> event_factory;
@@ -490,3 +495,40 @@
      EXPECT_EQ(4, client_motion_event.getPointerId(2));
      EXPECT_EQ(3, client_motion_event.getPointerCount());
+ }
++
++TEST_F(AndroidInputSender, encodes_input_device_state_event_as_raw_buffer_event)
++{
++    const float cursor_x = 50.0f;
++    const float cursor_y = 60.0f;
++    const auto timestamp = std::chrono::nanoseconds(10);
++    register_surface();
++    std::vector<mir::events::InputDeviceState> states;
++    states.push_back({MirInputDeviceId{23}, {50, 60, 80}, 0});
++    states.push_back({MirInputDeviceId{21}, {}, mir_pointer_button_primary});
++
++    auto device_state = mir::events::make_event(timestamp, mir_pointer_button_primary, mir_input_event_modifier_caps_lock,
++                                                cursor_x, cursor_y, std::move(states));
++
++    sender.send_event(*device_state, channel);
++    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
++    EXPECT_EQ(&client_raw_event, event);
++
++    auto dest_event = MirEvent::deserialize(client_raw_event.buffer);
++    ASSERT_THAT(mir_event_get_type(dest_event.get()), mir_event_type_input_device_state);
++
++    auto input_device_state = mir_event_get_input_device_state_event(dest_event.get());
++    EXPECT_THAT(mir_input_device_state_event_time(input_device_state), Eq(timestamp.count()));
++    EXPECT_THAT(mir_input_device_state_event_modifiers(input_device_state), Eq(mir_input_event_modifier_caps_lock));
++    EXPECT_THAT(mir_input_device_state_event_device_count(input_device_state), Eq(2));
++
++    EXPECT_THAT(mir_input_device_state_event_device_id(input_device_state, 0), Eq(MirInputDeviceId{23}));
++    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys_count(input_device_state, 0), Eq(3));
++    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys(input_device_state, 0)[0], Eq(50));
++    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys(input_device_state, 0)[1], Eq(60));
++    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys(input_device_state, 0)[2], Eq(80));
++    EXPECT_THAT(mir_input_device_state_event_device_pointer_buttons(input_device_state, 0), 0);
++
++    EXPECT_THAT(mir_input_device_state_event_device_id(input_device_state, 1), Eq(MirInputDeviceId{21}));
++    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys_count(input_device_state, 1), Eq(0));
++    EXPECT_THAT(mir_input_device_state_event_device_pointer_buttons(input_device_state, 1), mir_pointer_button_primary);
++}
 === modified file 'tests/unit-tests/input/evdev/test_libinput_device.cpp'
 --- tests/unit-tests/input/evdev/test_libinput_device.cpp	2016-05-03 06:55:25 +0000
 +++ tests/unit-tests/input/evdev/test_libinput_device.cpp	2016-07-06 21:48:16 +0000
@@ -30,7 +30,9 @@
  #include "mir/geometry/rectangle.h"
  #include "mir/test/event_matchers.h"
  #include "mir/test/doubles/mock_libinput.h"
++#include "mir/test/doubles/mock_input_seat.h"
  #include "mir/test/gmock_fixes.h"
++#include "mir/test/fake_shared.h"
  #include "mir/udev/wrapper.h"
  #include "mir/cookie/authority.h"
  #include "mir_test_framework/libinput_environment.h"
@@ -71,12 +73,15 @@
      MOCK_METHOD1(handle_input,void(MirEvent &));
      MOCK_METHOD1(confine_pointer, void(geom::Point&));
      MOCK_CONST_METHOD0(bounding_rectangle, geom::Rectangle());
++    MOCK_METHOD1(set_key_state, void(std::vector<uint32_t> const&));
++    MOCK_METHOD1(set_pointer_state, void(MirPointerButtons));
  };
  struct MockEventBuilder : mi::EventBuilder
+ {
      std::shared_ptr<mir::cookie::Authority> const cookie_authority = mir::cookie::Authority::create();
--    mi::DefaultEventBuilder builder{MirInputDeviceId{3}, cookie_authority};
++    mtd::MockInputSeat seat;
++    mi::DefaultEventBuilder builder{MirInputDeviceId{3}, cookie_authority, mt::fake_shared(seat)};
      MockEventBuilder()
+     {
          ON_CALL(*this, key_event(_,_,_,_))
@@ -119,6 +124,10 @@
      MOCK_METHOD7(pointer_event,
                   mir::EventUPtr(Timestamp, MirPointerAction, MirPointerButtons, float, float, float, float));
      MOCK_METHOD2(configuration_event, mir::EventUPtr(Timestamp, MirInputConfigurationAction));
++    mir::EventUPtr device_state_event(float, float) override
++    {
++        return {nullptr,[](MirEvent*){}};
++    }
  };
  struct LibInputDevice : public ::testing::Test
 === modified file 'tests/unit-tests/input/test_nested_input_platform.cpp'
 --- tests/unit-tests/input/test_nested_input_platform.cpp	2016-06-09 13:15:34 +0000
 +++ tests/unit-tests/input/test_nested_input_platform.cpp	2016-07-06 21:48:16 +0000
@@ -31,6 +31,7 @@
  #include "mir/test/doubles/mock_input_device_registry.h"
  #include "mir/test/doubles/mock_input_sink.h"
++#include "mir/test/doubles/mock_input_seat.h"
  #include "mir/test/doubles/stub_host_connection.h"
  #include "mir/test/fake_shared.h"
  #include "mir/test/event_matchers.h"
@@ -72,6 +73,7 @@
+ {
      NiceMock<mtd::MockInputDeviceRegistry> mock_input_device_registry;
      NiceMock<MockHostConnection> mock_host_connection;
++    NiceMock<mtd::MockInputSeat> mock_seat;
      mgn::InputPlatform platform{mt::fake_shared(mock_host_connection), mt::fake_shared(mock_input_device_registry),
                                  mr::null_input_report()};
      mi::DeviceData a_keyboard{1, mir_input_device_capability_keyboard, "keys" , "keys-evdev2"};
@@ -141,7 +143,7 @@
+ {
      auto nested_input_device = capture_input_device(a_mouse);
      NiceMock<mtd::MockInputSink> event_sink;
--    mi::DefaultEventBuilder builder(MirInputDeviceId{12}, mir::cookie::Authority::create());
++    mi::DefaultEventBuilder builder(MirInputDeviceId{12}, mir::cookie::Authority::create(), mt::fake_shared(mock_seat));
      ASSERT_THAT(nested_input_device, Ne(nullptr));
      nested_input_device->start(&event_sink, &builder);
@@ -165,7 +167,7 @@
      auto nested_input_device = capture_input_device(a_keyboard);
      auto const scan_code = 45;
      NiceMock<mtd::MockInputSink> event_sink;
--    mi::DefaultEventBuilder builder(MirInputDeviceId{18}, mir::cookie::Authority::create());
++    mi::DefaultEventBuilder builder(MirInputDeviceId{18}, mir::cookie::Authority::create(), mt::fake_shared(mock_seat));
      ASSERT_THAT(nested_input_device, Ne(nullptr));
      nested_input_device->start(&event_sink, &builder);
 === modified file 'tests/unit-tests/input/test_seat_input_device_tracker.cpp'
 --- tests/unit-tests/input/test_seat_input_device_tracker.cpp	2016-07-01 20:24:26 +0000
 +++ tests/unit-tests/input/test_seat_input_device_tracker.cpp	2016-07-06 21:48:16 +0000
@@ -25,6 +25,8 @@
  #include "mir/test/doubles/mock_input_region.h"
  #include "mir/test/doubles/mock_cursor_listener.h"
  #include "mir/test/doubles/mock_touch_visualizer.h"
++#include "mir/test/doubles/mock_input_seat.h"
++#include "mir/test/doubles/advanceable_clock.h"
  #include "mir/test/event_matchers.h"
  #include "mir/test/fake_shared.h"
@@ -53,17 +55,20 @@
      Nice<mtd::MockInputRegion> mock_region;
      Nice<mtd::MockCursorListener> mock_cursor_listener;
      Nice<mtd::MockTouchVisualizer> mock_visualizer;
++    Nice<mtd::MockInputSeat> mock_seat;
      MirInputDeviceId some_device{8712};
      MirInputDeviceId another_device{1246};
      MirInputDeviceId third_device{86};
      std::shared_ptr<mir::cookie::Authority> cookie_factory = mir::cookie::Authority::create();
++    mtd::AdvanceableClock clock;
--    mi::DefaultEventBuilder some_device_builder{some_device, cookie_factory};
--    mi::DefaultEventBuilder another_device_builder{another_device, cookie_factory};
--    mi::DefaultEventBuilder third_device_builder{third_device, cookie_factory};
++    mi::DefaultEventBuilder some_device_builder{some_device, cookie_factory, mt::fake_shared(mock_seat)};
++    mi::DefaultEventBuilder another_device_builder{another_device, cookie_factory, mt::fake_shared(mock_seat)};
++    mi::DefaultEventBuilder third_device_builder{third_device, cookie_factory, mt::fake_shared(mock_seat)};
      mi::receiver::XKBMapper mapper;
--    mi::SeatInputDeviceTracker tracker{mt::fake_shared(mock_dispatcher), mt::fake_shared(mock_visualizer),
--                       mt::fake_shared(mock_cursor_listener), mt::fake_shared(mock_region), mt::fake_shared(mapper)};
++    mi::SeatInputDeviceTracker tracker{
++        mt::fake_shared(mock_dispatcher), mt::fake_shared(mock_visualizer), mt::fake_shared(mock_cursor_listener),
++        mt::fake_shared(mock_region),     mt::fake_shared(mapper),          mt::fake_shared(clock)};
      std::chrono::nanoseconds arbitrary_timestamp;
  };
 === modified file 'tests/unit-tests/input/test_x11_platform.cpp'
 --- tests/unit-tests/input/test_x11_platform.cpp	2016-05-03 06:55:25 +0000
 +++ tests/unit-tests/input/test_x11_platform.cpp	2016-07-06 21:48:16 +0000
@@ -28,6 +28,7 @@
  #include "mir_toolkit/event.h"
  #include "mir_toolkit/events/input/input_event.h"
  #include "mir/test/doubles/mock_input_sink.h"
++#include "mir/test/doubles/mock_input_seat.h"
  #include "mir/test/doubles/mock_input_device_registry.h"
  #include "mir/test/doubles/mock_x11.h"
  #include "mir/test/fake_shared.h"
@@ -48,9 +49,10 @@
+ {
      NiceMock<mtd::MockInputSink> mock_pointer_sink;
      NiceMock<mtd::MockInputSink> mock_keyboard_sink;
++    NiceMock<mtd::MockInputSeat> mock_seat;
      NiceMock<mtd::MockX11> mock_x11;
      NiceMock<mtd::MockInputDeviceRegistry> mock_registry;
--    mir::input::DefaultEventBuilder builder{0, mir::cookie::Authority::create()};
++    mir::input::DefaultEventBuilder builder{0, mir::cookie::Authority::create(), mt::fake_shared(mock_seat)};
      mir::input::X::XInputPlatform x11_platform{
          mt::fake_shared(mock_registry),
 === modified file 'tests/unit-tests/scene/test_abstract_shell.cpp'
 --- tests/unit-tests/scene/test_abstract_shell.cpp	2016-06-20 17:10:33 +0000
 +++ tests/unit-tests/scene/test_abstract_shell.cpp	2016-07-06 21:48:16 +0000
@@ -44,6 +44,7 @@
  #include "mir/test/doubles/mock_input_seat.h"
  #include "mir/test/fake_shared.h"
++#include "mir/test/event_matchers.h"
  #include <gmock/gmock.h>
  #include <gtest/gtest.h>
@@ -54,10 +55,12 @@
  namespace msh = mir::shell;
  namespace geom = mir::geometry;
  namespace mg = mir::graphics;
++namespace mev = mir::events;
  namespace mt = mir::test;
  namespace mtd = mir::test::doubles;
  using namespace ::testing;
++using namespace std::chrono_literals;
  namespace
+ {
@@ -145,6 +148,13 @@
              .WillByDefault(Return(geom::Size{}));
          ON_CALL(surface_factory, create_surface(_,_))
              .WillByDefault(Return(mt::fake_shared(mock_surface)));
++        ON_CALL(seat, create_device_state())
++            .WillByDefault(Invoke(
++                    []()
++                    {
++                        return mev::make_event(0ns, 0, mir_input_event_modifier_none, 0.0f, 0.0f,
++                                               std::vector<mev::InputDeviceState>());
++                    }));
+     }
      std::chrono::nanoseconds const event_timestamp = std::chrono::nanoseconds(0);
@@ -603,3 +613,17 @@
      focus_controller.raise(surfaces);
+ }
++
++TEST_F(AbstractShell, as_focus_controller_emits_input_device_state_event_on_focus_change)
++{
++    EXPECT_CALL(mock_surface, consume(mt::InputDeviceStateEvent())).Times(1);
++
++    auto session = shell.open_session(__LINE__, "some", std::shared_ptr<mf::EventSink>());
++    auto creation_params = ms::a_surface()
++        .with_buffer_stream(session->create_buffer_stream(properties));
++    auto surface_id = shell.create_surface(session, creation_params, nullptr);
++    auto surface = session->surface(surface_id);
++
++    msh::FocusController& focus_controller = shell;
++    focus_controller.set_focus_to(session, surface);
++}