Merge lp:~andreas-pokorny/mir/combine-modifier-state-accross-devices into lp:mir

[Andreas Pokorny]

Rework Modifier tracking to combine modifiers within

The platform is no longer in charge of the modifier. Instead the new input stack tracks it when the events are received. To reduce the complexity of InputDeviceHub this behavior and similar parts are moved to mir::input::Seat which represents a group of input devices that belong to a user session. (Currently all of them).

Collateral changes:
- allow changing the modifier of MirEvent after creation -> additional symbols to 'hidden' C++ client API
- reduction of EventBuilder interface
- moving of modifier utils to server

This fixes the problem that caused the revert of the input platform probing mp..

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3018
http://jenkins.qa.ubuntu.com/job/mir-ci/5248/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/4424
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/3331/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/4366
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-wily-touch/324/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1402
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1402/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-i386-ci/324
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-i386-ci/324/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/4367
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/4367/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-touch/7011
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/24181
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-wily-armhf/325/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3019
http://jenkins.qa.ubuntu.com/job/mir-ci/5250/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/4426
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/3333
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/4368
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-wily-touch/326/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1404
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1404/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-i386-ci/326
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-i386-ci/326/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/4369
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/4369/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-touch/7013
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/24185
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-wily-armhf/327/console

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

review: Approve (continuous-integration)

=== modified file 'include/client/mir/events/event_builders.h'
--- include/client/mir/events/event_builders.h	2015-10-02 04:27:33 +0000
+++ include/client/mir/events/event_builders.h	2015-10-14 12:41:48 +0000
@@ -58,6 +58,8 @@
     uint64_t mac, MirKeyboardAction action, xkb_keysym_t key_code,
     int scan_code, MirInputEventModifiers modifiers);
 
+void set_modifier(MirEvent& event, MirInputEventModifiers modifiers);
+
 // Deprecated version without mac
 EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
     MirKeyboardAction action, xkb_keysym_t key_code,

=== modified file 'include/platform/mir/input/event_builder.h'
--- include/platform/mir/input/event_builder.h	2015-08-24 23:25:00 +0000
+++ include/platform/mir/input/event_builder.h	2015-10-14 12:41:48 +0000
@@ -38,18 +38,16 @@
     virtual ~EventBuilder() = default;
     using Timestamp = std::chrono::nanoseconds;
 
-    virtual EventUPtr key_event(Timestamp timestamp, MirKeyboardAction action, xkb_keysym_t key_code, int scan_code,
-                                MirInputEventModifiers modifiers) = 0;
+    virtual EventUPtr key_event(Timestamp timestamp, MirKeyboardAction action, xkb_keysym_t key_code, int scan_code) = 0;
 
-    virtual EventUPtr touch_event(Timestamp timestamp, MirInputEventModifiers modifiers) = 0;
+    virtual EventUPtr touch_event(Timestamp timestamp) = 0;
     virtual void add_touch(MirEvent& event, MirTouchId touch_id, MirTouchAction action, MirTouchTooltype tooltype,
                            float x_axis_value, float y_axis_value, float pressure_value, float touch_major_value,
                            float touch_minor_value, float size_value) = 0;
 
-    virtual EventUPtr pointer_event(Timestamp timestamp, MirInputEventModifiers modifiers, MirPointerAction action,
-                                    MirPointerButtons buttons_pressed, float x_axis_value, float y_axis_value,
-                                    float hscroll_value, float vscroll_value, float relative_x_value,
-                                    float relative_y_value) = 0;
+    virtual EventUPtr pointer_event(Timestamp timestamp, MirPointerAction action, MirPointerButtons buttons_pressed,
+                                    float x_axis_value, float y_axis_value, float hscroll_value, float vscroll_value,
+                                    float relative_x_value, float relative_y_value) = 0;
 
     virtual EventUPtr configuration_event(Timestamp timestamp, MirInputConfigurationAction action) = 0;
 

=== modified file 'include/test/mir/test/event_matchers.h'
--- include/test/mir/test/event_matchers.h	2015-10-13 16:25:36 +0000
+++ include/test/mir/test/event_matchers.h	2015-10-14 12:41:48 +0000
@@ -353,6 +353,14 @@
     return true;
 }
 
+MATCHER_P(PointerEventWithModifiers, modifiers, "")
+{
+    auto pev = maybe_pointer_event(to_address(arg));
+    if (pev && mir_pointer_event_modifiers(pev) == modifiers)
+        return true;
+    return false;
+}
+
 MATCHER_P2(PointerEventWithDiff, dx, dy, "")
 {
     auto pev = maybe_pointer_event(to_address(arg));

=== modified file 'src/client/events/event_builders.cpp'
--- src/client/events/event_builders.cpp	2015-10-07 12:07:00 +0000
+++ src/client/events/event_builders.cpp	2015-10-14 12:41:48 +0000
@@ -165,6 +165,28 @@
     return make_event_uptr(e);
 }
 
+
+void mev::set_modifier(MirEvent& event, MirInputEventModifiers modifiers)
+{
+    switch(event.type)
+    {
+    case mir_event_type_key:
+        {
+            auto& kev = event.key;
+            kev.modifiers = modifiers;
+            break;
+        }
+    case mir_event_type_motion:
+        {
+            auto& mev = event.motion;
+            mev.modifiers = modifiers;
+            break;
+        }
+    default:
+        BOOST_THROW_EXCEPTION(std::invalid_argument("Input event modifiers are only valid for pointer, key and touch events."));
+    }
+}
+
 // Deprecated version without mac
 mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
     MirKeyboardAction action, xkb_keysym_t key_code,

=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2015-10-08 21:11:44 +0000
+++ src/client/symbols.map	2015-10-14 12:41:48 +0000
@@ -243,3 +243,11 @@
       mir::operator???std::ostream???Mir*
     }; 
 };
+
+MIR_CLIENT_DETAIL_v0.18.0 {
+  global:
+    extern "C++" { 
+      mir::events::set_modifier*;
+    };
+} MIR_CLIENT_DETAIL_9;
+

=== modified file 'src/platforms/evdev/CMakeLists.txt'
--- src/platforms/evdev/CMakeLists.txt	2015-10-05 20:17:26 +0000
+++ src/platforms/evdev/CMakeLists.txt	2015-10-14 12:41:48 +0000
@@ -8,7 +8,7 @@
 
 add_library(mirevdevutilsobjects OBJECT
     evdev_device_detection.cpp
-    input_modifier_utils.cpp
+    button_utils.cpp
     )
 
 add_library(mirplatforminputevdevobjects OBJECT
@@ -34,8 +34,7 @@
 )
 
 target_link_libraries(mirplatforminputevdev
-  mirplatform
-  mirclient
+  mirplatform # udev wrapper
   ${Boost_PROGRAM_OPTIONS_LIBRARY}
   ${LIBINPUT_LDFLAGS} ${LIBINPUT_LIBRARIES}
 )

=== added file 'src/platforms/evdev/button_utils.cpp'
--- src/platforms/evdev/button_utils.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/evdev/button_utils.cpp	2015-10-14 12:41:48 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2015 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: Andreas Pokorny <[e-mail]>
+ */
+
+#include "button_utils.h"
+#include "boost/throw_exception.hpp"
+
+#include "linux/input.h"
+
+#include <stdexcept>
+
+MirPointerButton mir::input::evdev::to_pointer_button(int button)
+{
+    switch(button)
+    {
+    case BTN_LEFT: return mir_pointer_button_primary;
+    case BTN_RIGHT: return mir_pointer_button_secondary;
+    case BTN_MIDDLE: return mir_pointer_button_tertiary;
+    case BTN_BACK: return mir_pointer_button_back;
+    case BTN_FORWARD: return mir_pointer_button_forward;
+    }
+    BOOST_THROW_EXCEPTION(std::runtime_error("Invalid mouse button"));
+}

=== added file 'src/platforms/evdev/button_utils.h'
--- src/platforms/evdev/button_utils.h	1970-01-01 00:00:00 +0000
+++ src/platforms/evdev/button_utils.h	2015-10-14 12:41:48 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2015 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: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_EVDEV_BUTTON_UTILS_H_
+#define MIR_INPUT_EVDEV_BUTTON_UTILS_H_
+
+#include "mir_toolkit/event.h"
+
+namespace mir
+{
+namespace input
+{
+namespace evdev
+{
+MirPointerButton to_pointer_button(int button);
+}
+}
+}
+
+#endif

=== modified file 'src/platforms/evdev/libinput_device.cpp'
--- src/platforms/evdev/libinput_device.cpp	2015-10-07 15:32:10 +0000
+++ src/platforms/evdev/libinput_device.cpp	2015-10-14 12:41:48 +0000
@@ -19,8 +19,8 @@
 #include "libinput_device.h"
 #include "libinput_ptr.h"
 #include "libinput_device_ptr.h"
-#include "input_modifier_utils.h"
 #include "evdev_device_detection.h"
+#include "button_utils.h"
 
 #include "mir/input/input_sink.h"
 #include "mir/input/input_report.h"
@@ -53,8 +53,7 @@
 
 mie::LibInputDevice::LibInputDevice(std::shared_ptr<mi::InputReport> const& report, char const* path,
                                     LibInputDevicePtr dev)
-    : report{report}, accumulated_touch_event{nullptr, null_deleter}, pointer_pos{0, 0}, modifier_state{0},
-      button_state{0}
+    : report{report}, accumulated_touch_event{nullptr, null_deleter}, pointer_pos{0, 0}, button_state{0}
 {
     add_device_of_group(path, std::move(dev));
 }
@@ -138,18 +137,7 @@
     auto const code = libinput_event_keyboard_get_key(keyboard);
     report->received_event_from_kernel(time.count(), EV_KEY, code, action);
 
-    auto event = builder->key_event(time,
-                                    action,
-                                    xkb_keysym_t{0},
-                                    code,
-                                    mie::expand_modifiers(modifier_state));
-
-    if (action == mir_keyboard_action_down)
-        modifier_state |= mie::to_modifiers(code);
-    else
-        modifier_state &= ~mie::to_modifiers(code);
-
-    return event;
+    return builder->key_event(time, action, xkb_keysym_t{0}, code);
 }
 
 mir::EventUPtr mie::LibInputDevice::convert_button_event(libinput_event_pointer* pointer)
@@ -172,11 +160,8 @@
     else
         button_state = MirPointerButton(button_state & ~uint32_t(pointer_button));
 
-    auto event = builder->pointer_event(time, mie::expand_modifiers(modifier_state), action, button_state,
-                                        pointer_pos.x.as_float(), pointer_pos.y.as_float(), hscroll_value,
-                                        vscroll_value, relative_x_value, relative_y_value);
-
-    return event;
+    return builder->pointer_event(time, action, button_state, pointer_pos.x.as_float(), pointer_pos.y.as_float(),
+                                   hscroll_value, vscroll_value, relative_x_value, relative_y_value);
 }
 
 mir::EventUPtr mie::LibInputDevice::convert_motion_event(libinput_event_pointer* pointer)
@@ -195,11 +180,8 @@
 
     sink->confine_pointer(pointer_pos);
 
-    auto event = builder->pointer_event(time, mie::expand_modifiers(modifier_state), action, button_state,
-                                        pointer_pos.x.as_float(), pointer_pos.y.as_float(), hscroll_value,
-                                        vscroll_value, movement.dx.as_float(), movement.dy.as_float());
-
-    return event;
+    return builder->pointer_event(time, action, button_state, pointer_pos.x.as_float(), pointer_pos.y.as_float(),
+                                  hscroll_value, vscroll_value, movement.dx.as_float(), movement.dy.as_float());
 }
 
 mir::EventUPtr mie::LibInputDevice::convert_absolute_motion_event(libinput_event_pointer* pointer)
@@ -219,10 +201,8 @@
 
     sink->confine_pointer(pointer_pos);
 
-    auto event = builder->pointer_event(time, mie::expand_modifiers(modifier_state), action, button_state,
-                                        pointer_pos.x.as_float(), pointer_pos.y.as_float(), hscroll_value,
-                                        vscroll_value, movement.dx.as_float(), movement.dy.as_float());
-    return event;
+    return builder->pointer_event(time, action, button_state, pointer_pos.x.as_float(), pointer_pos.y.as_float(),
+                                  hscroll_value, vscroll_value, movement.dx.as_float(), movement.dy.as_float());
 }
 
 mir::EventUPtr mie::LibInputDevice::convert_axis_event(libinput_event_pointer* pointer)
@@ -239,10 +219,8 @@
         : 0.0f;
 
     report->received_event_from_kernel(time.count(), EV_REL, 0, 0);
-    auto event = builder->pointer_event(time, mie::expand_modifiers(modifier_state), action, button_state,
-                                        pointer_pos.x.as_float(), pointer_pos.y.as_float(), hscroll_value,
-                                        vscroll_value, relative_x_value, relative_y_value);
-    return event;
+    return builder->pointer_event(time, action, button_state, pointer_pos.x.as_float(), pointer_pos.y.as_float(),
+                                  hscroll_value, vscroll_value, relative_x_value, relative_y_value);
 }
 
 MirEvent& mie::LibInputDevice::get_accumulated_touch_event(std::chrono::nanoseconds timestamp)
@@ -250,7 +228,7 @@
     if (!accumulated_touch_event)
     {
         report->received_event_from_kernel(timestamp.count(), EV_SYN, 0, 0);
-        accumulated_touch_event = builder->touch_event(timestamp, mie::expand_modifiers(modifier_state));
+        accumulated_touch_event = builder->touch_event(timestamp);
     }
 
     return *accumulated_touch_event;

=== modified file 'src/platforms/evdev/libinput_device.h'
--- src/platforms/evdev/libinput_device.h	2015-10-07 15:32:10 +0000
+++ src/platforms/evdev/libinput_device.h	2015-10-14 12:41:48 +0000
@@ -84,7 +84,6 @@
 
     InputDeviceInfo info;
     mir::geometry::Point pointer_pos;
-    MirInputEventModifiers modifier_state;
     MirPointerButtons button_state;
 
     struct ContactData

=== modified file 'src/platforms/mesa/server/x11/input/input_platform.cpp'
--- src/platforms/mesa/server/x11/input/input_platform.cpp	2015-10-13 16:25:36 +0000
+++ src/platforms/mesa/server/x11/input/input_platform.cpp	2015-10-14 12:41:48 +0000
@@ -127,16 +127,6 @@
 #endif
                 XLookupString(&xkev, str, STRMAX, &keysym, NULL);
 
-                MirInputEventModifiers modifiers = mir_input_event_modifier_none;
-                if (xkev.state & ShiftMask)
-                    modifiers |= mir_input_event_modifier_shift;
-                if (xkev.state & ControlMask)
-                    modifiers |= mir_input_event_modifier_ctrl;
-                if (xkev.state & Mod1Mask)
-                    modifiers |= mir_input_event_modifier_alt;
-                if (xkev.state & Mod4Mask)
-                    modifiers |= mir_input_event_modifier_meta;
-
                 auto event_time =
                     std::chrono::duration_cast<std::chrono::nanoseconds>(
                         std::chrono::milliseconds{xkev.time});
@@ -155,8 +145,7 @@
                             mir_keyboard_action_down :
                             mir_keyboard_action_up,
                         keysym,
-                        xkev.keycode-8,
-                        modifiers
+                        xkev.keycode-8
                         )
                     );
                 break;
@@ -177,16 +166,6 @@
                               xbev.subwindow, xbev.time, xbev.x, xbev.y, xbev.x_root,
                               xbev.y_root, xbev.state, xbev.button, xbev.same_screen);
 #endif
-                MirInputEventModifiers modifiers = mir_input_event_modifier_none;
-                if (xbev.state & ShiftMask)
-                    modifiers |= mir_input_event_modifier_shift;
-                if (xbev.state & ControlMask)
-                    modifiers |= mir_input_event_modifier_ctrl;
-                if (xbev.state & Mod1Mask)
-                    modifiers |= mir_input_event_modifier_alt;
-                if (xbev.state & Mod4Mask)
-                    modifiers |= mir_input_event_modifier_meta;
-
                 auto event_time =
                     std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds{xbev.time});
 
@@ -207,13 +186,12 @@
 
 #ifdef MIR_ON_X11_INPUT_VERBOSE
                 mir::log_info("Mir button event : x=%d, y=%d, "
-                              "buttons_pressed=0x%0X, modifiers=0x%0X, event_time=%" PRId64,
-                              xbev.x, xbev.y, buttons_pressed, modifiers, event_time);
+                              "buttons_pressed=0x%0X, event_time=%" PRId64,
+                              xbev.x, xbev.y, buttons_pressed, event_time);
 #endif
                 core_pointer->sink->handle_input(
                     *core_pointer->builder->pointer_event(
                         event_time,
-                        modifiers,
                         xbev.type == ButtonPress ?
                             mir_pointer_action_button_down :
                             mir_pointer_action_button_up,
@@ -242,15 +220,6 @@
                               xmev.root, xmev.subwindow, xmev.time, xmev.x, xmev.y, xmev.x_root,
                               xmev.y_root, xmev.state, xmev.is_hint == NotifyNormal ? "no" : "yes", xmev.same_screen);
 #endif
-                MirInputEventModifiers modifiers = mir_input_event_modifier_none;
-                if (xmev.state & ShiftMask)
-                    modifiers |= mir_input_event_modifier_shift;
-                if (xmev.state & ControlMask)
-                    modifiers |=  mir_input_event_modifier_ctrl;
-                if (xmev.state & Mod1Mask)
-                    modifiers |=  mir_input_event_modifier_alt;
-                if (xmev.state & Mod4Mask)
-                    modifiers |=  mir_input_event_modifier_meta;
 
                 auto event_time =
                     std::chrono::duration_cast<std::chrono::nanoseconds>(
@@ -270,13 +239,12 @@
 
 #ifdef MIR_ON_X11_INPUT_VERBOSE
                 mir::log_info("Mir pointer event : "
-                              "x=%d, y=%d, buttons_pressed=0x%0X, modifiers=0x%0X, event_time=%" PRId64,
-                              xmev.x, xmev.y, buttons_pressed, modifiers, event_time);
+                              "x=%d, y=%d, buttons_pressed=0x%0X, event_time=%" PRId64,
+                              xmev.x, xmev.y, buttons_pressed, event_time);
 #endif
                 core_pointer->sink->handle_input(
                     *core_pointer->builder->pointer_event(
                         event_time,
-                        modifiers,
                         mir_pointer_action_motion,
                         buttons_pressed,
                         xmev.x,

=== modified file 'src/server/input/CMakeLists.txt'
--- src/server/input/CMakeLists.txt	2015-10-12 19:30:14 +0000
+++ src/server/input/CMakeLists.txt	2015-10-14 12:41:48 +0000
@@ -8,6 +8,8 @@
   default_event_builder.cpp
   default_input_manager.cpp
   default_input_device_hub.cpp
+  input_modifier_utils.cpp
+  seat.cpp
 
   surface_input_dispatcher.cpp
   event_filter_chain_dispatcher.cpp

=== modified file 'src/server/input/default_event_builder.cpp'
--- src/server/input/default_event_builder.cpp	2015-10-09 00:15:44 +0000
+++ src/server/input/default_event_builder.cpp	2015-10-14 12:41:48 +0000
@@ -33,21 +33,21 @@
 }
 
 mir::EventUPtr mi::DefaultEventBuilder::key_event(Timestamp timestamp, MirKeyboardAction action, xkb_keysym_t key_code,
-                                                  int scan_code, MirInputEventModifiers modifiers)
+                                                  int scan_code)
 {
     uint64_t mac = cookie_factory->timestamp_to_cookie(timestamp.count()).mac;
-    return me::make_event(device_id, timestamp, mac, action, key_code, scan_code, modifiers);
+    return me::make_event(device_id, timestamp, mac, action, key_code, scan_code, mir_input_event_modifier_none);
 }
 
-mir::EventUPtr mi::DefaultEventBuilder::touch_event(Timestamp timestamp, MirInputEventModifiers modifiers)
+mir::EventUPtr mi::DefaultEventBuilder::touch_event(Timestamp timestamp)
 {
-    return me::make_event(device_id, timestamp, 0, modifiers);
+    return me::make_event(device_id, timestamp, 0, mir_input_event_modifier_none);
 }
 
 void mi::DefaultEventBuilder::add_touch(MirEvent& event, MirTouchId touch_id, MirTouchAction action,
-                                                  MirTouchTooltype tooltype, float x_axis_value, float y_axis_value,
-                                                  float pressure_value, float touch_major_value,
-                                                  float touch_minor_value, float size_value)
+                                        MirTouchTooltype tooltype, float x_axis_value, float y_axis_value,
+                                        float pressure_value, float touch_major_value, float touch_minor_value,
+                                        float size_value)
 {
     if (action == mir_touch_action_up || action == mir_touch_action_down)
     {
@@ -59,17 +59,15 @@
                   touch_minor_value, size_value);
 }
 
-mir::EventUPtr mi::DefaultEventBuilder::pointer_event(Timestamp timestamp, MirInputEventModifiers modifiers,
-                                                      MirPointerAction action, MirPointerButtons buttons_pressed,
-                                                      float x_axis_value, float y_axis_value, float hscroll_value,
-                                                      float vscroll_value, float relative_x_value,
-                                                      float relative_y_value)
+mir::EventUPtr mi::DefaultEventBuilder::pointer_event(Timestamp timestamp, MirPointerAction action,
+                                                      MirPointerButtons buttons_pressed, float x_axis_value,
+                                                      float y_axis_value, float hscroll_value, float vscroll_value,
+                                                      float relative_x_value, float relative_y_value)
 {
     uint64_t mac = 0;
     if (action == mir_pointer_action_button_up || action == mir_pointer_action_button_down)
         mac = cookie_factory->timestamp_to_cookie(timestamp.count()).mac;
-
-    return me::make_event(device_id, timestamp, mac, modifiers, action, buttons_pressed, x_axis_value, y_axis_value,
+    return me::make_event(device_id, timestamp, mac, mir_input_event_modifier_none, action, buttons_pressed, x_axis_value, y_axis_value,
                           hscroll_value, vscroll_value, relative_x_value, relative_y_value);
 }
 

=== modified file 'src/server/input/default_event_builder.h'
--- src/server/input/default_event_builder.h	2015-10-08 00:23:43 +0000
+++ src/server/input/default_event_builder.h	2015-10-14 12:41:48 +0000
@@ -37,18 +37,16 @@
     explicit DefaultEventBuilder(MirInputDeviceId device_id,
                                  std::shared_ptr<cookie::CookieFactory> const& cookie_factory);
 
-    EventUPtr key_event(Timestamp timestamp, MirKeyboardAction action, xkb_keysym_t key_code, int scan_code,
-                        MirInputEventModifiers modifiers) override;
+    EventUPtr key_event(Timestamp timestamp, MirKeyboardAction action, xkb_keysym_t key_code, int scan_code) override;
 
-    EventUPtr touch_event(Timestamp timestamp, MirInputEventModifiers modifiers) override;
+    EventUPtr touch_event(Timestamp timestamp) override;
     void add_touch(MirEvent& event, MirTouchId touch_id, MirTouchAction action, MirTouchTooltype tooltype,
                    float x_axis_value, float y_axis_value, float pressure_value, float touch_major_value,
                    float touch_minor_value, float size_value) override;
 
-    EventUPtr pointer_event(Timestamp timestamp, MirInputEventModifiers modifiers, MirPointerAction action,
-                            MirPointerButtons buttons_pressed, float x_axis_value, float y_axis_value,
-                            float hscroll_value, float vscroll_value, float relative_x_value,
-                            float relative_y_value) override;
+    EventUPtr pointer_event(Timestamp timestamp, MirPointerAction action, MirPointerButtons buttons_pressed,
+                            float x_axis_value, float y_axis_value, float hscroll_value, float vscroll_value,
+                            float relative_x_value, float relative_y_value) override;
 
     EventUPtr configuration_event(Timestamp timestamp, MirInputConfigurationAction action) override;
 

=== modified file 'src/server/input/default_input_device_hub.cpp'
--- src/server/input/default_input_device_hub.cpp	2015-10-08 00:23:43 +0000
+++ src/server/input/default_input_device_hub.cpp	2015-10-14 12:41:48 +0000
@@ -19,11 +19,13 @@
 #include "default_input_device_hub.h"
 #include "device_handle.h"
 
+#include "seat.h"
 #include "mir/input/input_dispatcher.h"
 #include "mir/input/input_device.h"
 #include "mir/input/input_device_observer.h"
-#include "mir/input/cursor_listener.h"
 #include "mir/input/input_region.h"
+#include "mir/geometry/point.h"
+#include "mir/events/event_builders.h"
 #include "mir/dispatch/multiplexing_dispatchable.h"
 #include "mir/server_action_queue.h"
 #include "mir/cookie_factory.h"
@@ -36,6 +38,8 @@
 #include <atomic>
 
 namespace mi = mir::input;
+namespace geom = mir::geometry;
+namespace mev = mir::events;
 
 mi::DefaultInputDeviceHub::DefaultInputDeviceHub(
     std::shared_ptr<mi::InputDispatcher> const& input_dispatcher,
@@ -45,9 +49,13 @@
     std::shared_ptr<CursorListener> const& cursor_listener,
     std::shared_ptr<InputRegion> const& input_region,
     std::shared_ptr<mir::cookie::CookieFactory> const& cookie_factory)
-    : input_dispatcher(input_dispatcher), input_dispatchable{input_multiplexer}, observer_queue(observer_queue),
-      touch_visualizer(touch_visualizer), cursor_listener(cursor_listener), input_region(input_region),
-      cookie_factory(cookie_factory), device_id_generator{0}
+    : input_dispatcher(input_dispatcher),
+      input_dispatchable{input_multiplexer},
+      observer_queue(observer_queue),
+      input_region(input_region),
+      cookie_factory(cookie_factory),
+      seat(touch_visualizer, cursor_listener),
+      device_id_generator{0}
 {
 }
 
@@ -67,9 +75,10 @@
     {
         // send input device info to observer loop..
         devices.push_back(std::make_unique<RegisteredDevice>(
-            device, create_new_device_id(), input_dispatcher, input_dispatchable, cookie_factory, this));
+            device, create_new_device_id(), input_dispatcher, input_dispatchable, cookie_factory, this, &seat));
 
         auto const& dev = devices.back();
+        seat.add_device(dev->id());
 
         auto handle = std::make_shared<DefaultDevice>(
             dev->id(), device->get_device_info());
@@ -104,6 +113,7 @@
             if (item->device_matches(device))
             {
                 item->stop();
+                seat.remove_device(item->id());
 
                 // send input device info to observer queue..
                 observer_queue->enqueue(
@@ -131,9 +141,10 @@
     std::shared_ptr<InputDispatcher> const& dispatcher,
     std::shared_ptr<dispatch::MultiplexingDispatchable> const& multiplexer,
     std::shared_ptr<mir::cookie::CookieFactory> const& cookie_factory,
-    DefaultInputDeviceHub* hub)
+    DefaultInputDeviceHub* hub,
+    Seat* seat)
     : device_id(device_id), builder(device_id, cookie_factory), device(dev), dispatcher(dispatcher),
-      multiplexer(multiplexer), hub(hub)
+      multiplexer(multiplexer), hub(hub), seat(seat)
 {
 }
 
@@ -154,50 +165,13 @@
     if (type != mir_event_type_input)
         BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid input event receivd from device"));
 
-    update_spots(mir_event_get_input_event(&event));
-    notify_cursor_listener(mir_event_get_input_event(&event));
+    seat->update_seat_properties(mir_event_get_input_event(&event));
+
+    mev::set_modifier(event, seat->event_modifier());
+
     dispatcher->dispatch(event);
 }
 
-void mi::DefaultInputDeviceHub::RegisteredDevice::notify_cursor_listener(MirInputEvent const* event)
-{
-    if (mir_input_event_get_type(event) != mir_input_event_type_pointer)
-        return;
-
-    auto pointer_ev = mir_input_event_get_pointer_event(event);
-    hub->cursor_listener->cursor_moved_to(
-        mir_pointer_event_axis_value(pointer_ev, mir_pointer_axis_x),
-        mir_pointer_event_axis_value(pointer_ev, mir_pointer_axis_y)
-        );
-}
-
-void mi::DefaultInputDeviceHub::RegisteredDevice::update_spots(MirInputEvent const* event)
-{
-    if (mir_input_event_get_type(event) != mir_input_event_type_touch)
-        return;
-
-    auto const* touch_event = mir_input_event_get_touch_event(event);
-    auto count = mir_touch_event_point_count(touch_event);
-    touch_spots.reserve(count);
-    touch_spots.clear();
-    for (decltype(count) i = 0; i != count; ++i)
-    {
-        if (mir_touch_event_action(touch_event, i) == mir_touch_action_up)
-            continue;
-        touch_spots.push_back(mi::TouchVisualizer::Spot{
-            {mir_touch_event_axis_value(touch_event, i, mir_touch_axis_x),
-             mir_touch_event_axis_value(touch_event, i, mir_touch_axis_y)},
-            mir_touch_event_axis_value(touch_event, i, mir_touch_axis_pressure)});
-    }
-
-    hub->update_spots();
-}
-
-std::vector<mir::input::TouchVisualizer::Spot> const& mi::DefaultInputDeviceHub::RegisteredDevice::spots() const
-{
-    return touch_spots;
-}
-
 bool mi::DefaultInputDeviceHub::RegisteredDevice::device_matches(std::shared_ptr<InputDevice> const& dev) const
 {
     return dev == device;
@@ -278,13 +252,3 @@
 
     handles.erase(handle_it, end(handles));
 }
-
-void mi::DefaultInputDeviceHub::update_spots()
-{
-    std::vector<TouchVisualizer::Spot> spots;
-
-    for (auto const& dev : devices)
-        spots.insert(end(spots), begin(dev->spots()), end(dev->spots()));
-
-    touch_visualizer->visualize_touches(spots);
-}

=== modified file 'src/server/input/default_input_device_hub.h'
--- src/server/input/default_input_device_hub.h	2015-10-08 00:23:43 +0000
+++ src/server/input/default_input_device_hub.h	2015-10-14 12:41:48 +0000
@@ -20,12 +20,12 @@
 #define MIR_INPUT_DEFAULT_INPUT_DEVICE_HUB_H_
 
 #include "default_event_builder.h"
+#include "seat.h"
 
 #include "mir/input/input_device_registry.h"
 #include "mir/input/input_sink.h"
 #include "mir/input/input_device_hub.h"
 #include "mir/input/input_device_info.h"
-#include "mir/input/touch_visualizer.h"
 
 #include "mir_toolkit/event.h"
 
@@ -82,10 +82,9 @@
     std::shared_ptr<InputDispatcher> const input_dispatcher;
     std::shared_ptr<dispatch::MultiplexingDispatchable> const input_dispatchable;
     std::shared_ptr<ServerActionQueue> const observer_queue;
-    std::shared_ptr<TouchVisualizer> const touch_visualizer;
-    std::shared_ptr<CursorListener> const cursor_listener;
     std::shared_ptr<InputRegion> const input_region;
     std::shared_ptr<cookie::CookieFactory> const cookie_factory;
+    Seat seat;
 
     struct RegisteredDevice : public InputSink
     {
@@ -95,8 +94,8 @@
                          std::shared_ptr<InputDispatcher> const& dispatcher,
                          std::shared_ptr<dispatch::MultiplexingDispatchable> const& multiplexer,
                          std::shared_ptr<cookie::CookieFactory> const& cookie_factory,
-                         DefaultInputDeviceHub* hub);
-
+                         DefaultInputDeviceHub* hub,
+                         Seat* seat);
         void handle_input(MirEvent& event) override;
         void confine_pointer(mir::geometry::Point& position) override;
         mir::geometry::Rectangle bounding_rectangle() const override;
@@ -104,24 +103,21 @@
         void start();
         void stop();
         MirInputDeviceId id();
-        std::vector<TouchVisualizer::Spot> const& spots() const;
     private:
-        void update_spots(MirInputEvent const* event);
-        void notify_cursor_listener(MirInputEvent const* event);
         MirInputDeviceId device_id;
         DefaultEventBuilder builder;
         std::shared_ptr<InputDevice> const device;
         std::shared_ptr<InputDispatcher> const dispatcher;
         std::shared_ptr<dispatch::MultiplexingDispatchable> const multiplexer;
         DefaultInputDeviceHub* hub;
-        std::vector<TouchVisualizer::Spot> touch_spots;
+        Seat* seat;
         friend class DefaultInputDeviceHub;
     };
 
     std::vector<std::shared_ptr<DefaultDevice>> handles;
     std::vector<std::unique_ptr<RegisteredDevice>> devices;
     std::vector<std::shared_ptr<InputDeviceObserver>> observers;
-    
+
     MirInputDeviceId device_id_generator;
 };
 

=== renamed file 'src/platforms/evdev/input_modifier_utils.cpp' => 'src/server/input/input_modifier_utils.cpp'
--- src/platforms/evdev/input_modifier_utils.cpp	2015-09-17 06:40:14 +0000
+++ src/server/input/input_modifier_utils.cpp	2015-10-14 12:41:48 +0000
@@ -25,22 +25,9 @@
 
 #include <stdexcept>
 
-namespace mie = mir::input::evdev;
-
-MirPointerButton mie::to_pointer_button(int button)
-{
-    switch(button)
-    {
-    case BTN_LEFT: return mir_pointer_button_primary;
-    case BTN_RIGHT: return mir_pointer_button_secondary;
-    case BTN_MIDDLE: return mir_pointer_button_tertiary;
-    case BTN_BACK: return mir_pointer_button_back;
-    case BTN_FORWARD: return mir_pointer_button_forward;
-    }
-    BOOST_THROW_EXCEPTION(std::runtime_error("Invalid mouse button"));
-}
-
-MirInputEventModifiers mie::to_modifiers(int32_t scan_code)
+namespace mi = mir::input;
+
+MirInputEventModifiers mi::to_modifiers(int32_t scan_code)
 {
     switch(scan_code)
     {
@@ -71,7 +58,7 @@
     }
 }
 
-MirInputEventModifiers mie::expand_modifiers(MirInputEventModifiers modifiers)
+MirInputEventModifiers mi::expand_modifiers(MirInputEventModifiers modifiers)
 {
     if (modifiers == 0)
         return mir_input_event_modifier_none;
@@ -91,4 +78,3 @@
     return modifiers;
 }
 
-

=== renamed file 'src/platforms/evdev/input_modifier_utils.h' => 'src/server/input/input_modifier_utils.h'
--- src/platforms/evdev/input_modifier_utils.h	2015-09-17 06:40:14 +0000
+++ src/server/input/input_modifier_utils.h	2015-10-14 12:41:48 +0000
@@ -16,8 +16,8 @@
  * Authored by: Andreas Pokorny <[e-mail]>
  */
 
-#ifndef MIR_INPUT_EVDEV_INPUT_MODIFIER_UTILS_H_
-#define MIR_INPUT_EVDEV_INPUT_MODIFIER_UTILS_H_
+#ifndef MIR_INPUT_INPUT_MODIFIER_UTILS_H_
+#define MIR_INPUT_INPUT_MODIFIER_UTILS_H_
 
 #include "mir_toolkit/event.h"
 
@@ -25,13 +25,9 @@
 {
 namespace input
 {
-namespace evdev
-{
-MirPointerButton to_pointer_button(int button);
 MirInputEventModifiers to_modifiers(int32_t scan_code);
 MirInputEventModifiers expand_modifiers(MirInputEventModifiers modifiers);
 }
 }
-}
 
 #endif

=== added file 'src/server/input/seat.cpp'
--- src/server/input/seat.cpp	1970-01-01 00:00:00 +0000
+++ src/server/input/seat.cpp	2015-10-14 12:41:48 +0000
@@ -0,0 +1,153 @@
+/*
+ * Copyright © 2015 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:
+ *   Andreas Pokorny <[e-mail]>
+ */
+
+#include "seat.h"
+#include "mir/input/device.h"
+#include "mir/input/cursor_listener.h"
+
+#include "input_modifier_utils.h"
+
+#include <boost/throw_exception.hpp>
+
+#include <stdexcept>
+#include <algorithm>
+
+namespace mi = mir::input;
+
+mi::Seat::Seat(std::shared_ptr<TouchVisualizer> const& touch_visualizer,
+               std::shared_ptr<CursorListener> const& cursor_listener)
+    : touch_visualizer{touch_visualizer}, cursor_listener{cursor_listener}, modifier{0}
+{
+}
+
+void mi::Seat::add_device(MirInputDeviceId id)
+{
+    device_data[id];
+}
+
+void mi::Seat::remove_device(MirInputDeviceId id)
+{
+    auto stored_data = device_data.find(id);
+
+    if (stored_data == end(device_data))
+        BOOST_THROW_EXCEPTION(std::logic_error("Modifier for unknown device changed"));
+
+    bool mod_update_needed = stored_data->second.mod != mir_input_event_modifier_none;
+    bool spot_update_needed = !stored_data->second.spots.empty();
+
+    device_data.erase(stored_data);
+
+    if (mod_update_needed)
+        update_modifier();
+    if (spot_update_needed)
+        update_spots();
+}
+
+MirInputEventModifiers mi::Seat::event_modifier() const
+{
+    return expand_modifiers(modifier);
+}
+
+void mi::Seat::update_seat_properties(MirInputEvent const* event)
+{
+    auto id = mir_input_event_get_device_id(event);
+
+    auto stored_data = device_data.find(id);
+
+    if (stored_data == end(device_data))
+        BOOST_THROW_EXCEPTION(std::logic_error("Modifier for unknown device changed"));
+
+    switch(mir_input_event_get_type(event))
+    {
+    case mir_input_event_type_key:
+        {
+            auto const* key = mir_input_event_get_keyboard_event(event);
+            if (stored_data->second.update_modifier(mir_keyboard_event_action(key),
+                                                    mir_keyboard_event_scan_code(key)))
+                update_modifier();
+            break;
+        }
+    case mir_input_event_type_touch:
+        if (stored_data->second.update_spots(mir_input_event_get_touch_event(event)))
+            update_spots();
+        break;
+    case mir_input_event_type_pointer:
+        update_cursor(mir_input_event_get_pointer_event(event));
+        break;
+    default:
+        break;
+    }
+}
+
+bool mi::Seat::DeviceData::update_modifier(MirKeyboardAction key_action, int scan_code)
+{
+    auto mod_change = to_modifiers(scan_code);
+
+    if (mod_change == 0 || key_action == mir_keyboard_action_repeat)
+        return false;
+
+    if (key_action == mir_keyboard_action_down)
+        mod |= mod_change;
+    else if (key_action == mir_keyboard_action_up)
+        mod &= ~mod_change;
+
+    return true;
+}
+
+bool mi::Seat::DeviceData::update_spots(MirTouchEvent const* event)
+{
+    auto count = mir_touch_event_point_count(event);
+    spots.clear();
+    for (decltype(count) i = 0; i != count; ++i)
+    {
+        if (mir_touch_event_action(event, i) == mir_touch_action_up)
+            continue;
+        spots.push_back({{mir_touch_event_axis_value(event, i, mir_touch_axis_x),
+                          mir_touch_event_axis_value(event, i, mir_touch_axis_y)},
+                         mir_touch_event_axis_value(event, i, mir_touch_axis_pressure)});
+    }
+    return true;
+}
+
+void mi::Seat::update_spots()
+{
+    spots.clear();
+    for (auto const& dev : device_data)
+        spots.insert(end(spots), begin(dev.second.spots), end(dev.second.spots));
+
+    touch_visualizer->visualize_touches(spots);
+}
+
+void mi::Seat::update_modifier()
+{
+    modifier = std::accumulate(begin(device_data),
+                               end(device_data),
+                               MirInputEventModifiers{0},
+                               [](auto const& acc, auto const& item)
+                               {
+                                   return acc | item.second.mod;
+                               });
+}
+
+void mi::Seat::update_cursor(MirPointerEvent const* event)
+{
+    cursor_listener->cursor_moved_to(mir_pointer_event_axis_value(event, mir_pointer_axis_x),
+                                     mir_pointer_event_axis_value(event, mir_pointer_axis_y));
+}
+

=== added file 'src/server/input/seat.h'
--- src/server/input/seat.h	1970-01-01 00:00:00 +0000
+++ src/server/input/seat.h	2015-10-14 12:41:48 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright © 2015 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:
+ *   Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_DEFAULT_SEAT_H_
+#define MIR_INPUT_DEFAULT_SEAT_H_
+
+#include "mir/input/touch_visualizer.h"
+#include "mir_toolkit/event.h"
+#include <unordered_map>
+#include <memory>
+
+namespace mir
+{
+namespace input
+{
+class CursorListener;
+
+/*
+ * The seat bundles a group of devices. A cursor position, input event modifiers and the visible touch spots are properties
+ * controlled by this grouping of input devices.
+ */
+struct Seat
+{
+    Seat(std::shared_ptr<TouchVisualizer> const& touch_visualizer, std::shared_ptr<CursorListener> const& cursor_listener);
+    void add_device(MirInputDeviceId);
+    void remove_device(MirInputDeviceId);
+
+    MirInputEventModifiers event_modifier() const;
+    void update_seat_properties(MirInputEvent const* event);
+private:
+    void update_cursor(MirPointerEvent const* event);
+    void update_spots();
+    void update_modifier();
+
+    std::shared_ptr<TouchVisualizer> const touch_visualizer;
+    std::shared_ptr<CursorListener> const cursor_listener;
+
+    struct DeviceData
+    {
+        DeviceData() {}
+        bool update_modifier(MirKeyboardAction action, int scan_code);
+        bool update_spots(MirTouchEvent const* event);
+
+        MirInputEventModifiers mod{0};
+        std::vector<TouchVisualizer::Spot> spots;
+    };
+
+    MirInputEventModifiers modifier;
+    std::unordered_map<MirInputDeviceId, DeviceData> device_data;
+    std::vector<TouchVisualizer::Spot> spots;
+};
+
+}
+}
+
+#endif

=== modified file 'tests/mir_test_framework/fake_input_device_impl.cpp'
--- tests/mir_test_framework/fake_input_device_impl.cpp	2015-10-12 08:08:58 +0000
+++ tests/mir_test_framework/fake_input_device_impl.cpp	2015-10-14 12:41:48 +0000
@@ -25,7 +25,7 @@
 #include "mir/input/event_builder.h"
 #include "mir/dispatch/action_queue.h"
 #include "mir/geometry/displacement.h"
-#include "src/platforms/evdev/input_modifier_utils.h"
+#include "src/platforms/evdev/button_utils.h"
 
 #include "boost/throw_exception.hpp"
 
@@ -100,13 +100,7 @@
     auto input_action =
         (key_params.action == synthesis::EventAction::Down) ? mir_keyboard_action_down : mir_keyboard_action_up;
 
-    auto event_modifiers = mie::expand_modifiers(modifiers);
-    auto key_event = builder->key_event(event_time, input_action, key_code, key_params.scancode, event_modifiers);
-
-    if (key_params.action == synthesis::EventAction::Down)
-        modifiers |= mie::to_modifiers(key_params.scancode);
-    else
-        modifiers &= ~mie::to_modifiers(key_params.scancode);
+    auto key_event = builder->key_event(event_time, input_action, key_code, key_params.scancode);
 
     if (!sink)
         BOOST_THROW_EXCEPTION(std::runtime_error("Device is not started."));
@@ -118,9 +112,7 @@
     auto event_time = std::chrono::duration_cast<std::chrono::nanoseconds>(
         std::chrono::system_clock::now().time_since_epoch());
     auto action = update_buttons(button.action, mie::to_pointer_button(button.button));
-    auto event_modifiers = mie::expand_modifiers(modifiers);
     auto button_event = builder->pointer_event(event_time,
-                                               event_modifiers,
                                                action,
                                                buttons,
                                                pos.x.as_float(),
@@ -156,10 +148,8 @@
 
     auto event_time = std::chrono::duration_cast<std::chrono::nanoseconds>(
         std::chrono::system_clock::now().time_since_epoch());
-    auto event_modifiers = mie::expand_modifiers(modifiers);
     update_position(pointer.rel_x, pointer.rel_y);
     auto pointer_event = builder->pointer_event(event_time,
-                                                event_modifiers,
                                                 mir_pointer_action_motion,
                                                 buttons,
                                                 pos.x.as_float(),
@@ -185,9 +175,8 @@
 
     auto event_time = std::chrono::duration_cast<std::chrono::nanoseconds>(
         std::chrono::system_clock::now().time_since_epoch());
-    auto event_modifiers = mie::expand_modifiers(modifiers);
 
-    auto touch_event = builder->touch_event(event_time, event_modifiers);
+    auto touch_event = builder->touch_event(event_time);
 
     auto touch_action = mir_touch_action_up;
     if (touch.action == synthesis::TouchParameters::Action::Tap)

=== modified file 'tests/mir_test_framework/fake_input_device_impl.h'
--- tests/mir_test_framework/fake_input_device_impl.h	2015-09-01 07:41:29 +0000
+++ tests/mir_test_framework/fake_input_device_impl.h	2015-10-14 12:41:48 +0000
@@ -73,7 +73,6 @@
         mir::input::EventBuilder* builder{nullptr};
         mir::input::InputDeviceInfo info;
         std::shared_ptr<mir::dispatch::Dispatchable> const queue;
-        uint32_t modifiers{0};
         mir::geometry::Point pos, scroll;
         MirPointerButtons buttons;
     };

=== modified file 'tests/unit-tests/input/evdev/test_libinput_device.cpp'
--- tests/unit-tests/input/evdev/test_libinput_device.cpp	2015-10-07 16:41:50 +0000
+++ tests/unit-tests/input/evdev/test_libinput_device.cpp	2015-10-14 12:41:48 +0000
@@ -73,16 +73,15 @@
     mi::DefaultEventBuilder builder{MirInputDeviceId{3}, cookie_factory};
     MockEventBuilder()
     {
-        ON_CALL(*this, key_event(_,_,_,_,_))
-            .WillByDefault(Invoke([this](Timestamp time, MirKeyboardAction action, xkb_keysym_t key, int scan_code,
-                                         MirInputEventModifiers modifier)
+        ON_CALL(*this, key_event(_,_,_,_))
+            .WillByDefault(Invoke([this](Timestamp time, MirKeyboardAction action, xkb_keysym_t key, int scan_code)
                                   {
-                                        return builder.key_event(time, action, key, scan_code, modifier);
+                                        return builder.key_event(time, action, key, scan_code);
                                   }));
-        ON_CALL(*this, touch_event(_,_))
-            .WillByDefault(Invoke([this](Timestamp time, MirInputEventModifiers modifier)
+        ON_CALL(*this, touch_event(_))
+            .WillByDefault(Invoke([this](Timestamp time)
                                   {
-                                        return builder.touch_event(time, modifier);
+                                        return builder.touch_event(time);
                                   }));
         ON_CALL(*this, add_touch(_,_,_,_,_,_,_,_,_,_))
             .WillByDefault(Invoke([this](MirEvent& event, MirTouchId id, MirTouchAction action,
@@ -92,13 +91,12 @@
                                         return builder.add_touch(event, id, action, tooltype, x, y, major, minor,
                                                                  pressure, size);
                                   }));
-        ON_CALL(*this, pointer_event(_,_,_,_,_,_,_,_,_,_))
-            .WillByDefault(Invoke([this](Timestamp time, MirInputEventModifiers modifier, MirPointerAction action,
-                                         MirPointerButtons buttons, float x, float y, float hscroll, float vscroll,
-                                         float relative_x, float relative_y)
+        ON_CALL(*this, pointer_event(_, _, _, _, _, _, _, _, _))
+            .WillByDefault(Invoke([this](Timestamp time, MirPointerAction action, MirPointerButtons buttons, float x,
+                                         float y, float hscroll, float vscroll, float relative_x, float relative_y)
                                   {
-                                      return builder.pointer_event(time, modifier, action, buttons, x, y, hscroll,
-                                                                   vscroll, relative_x, relative_y);
+                                      return builder.pointer_event(time, action, buttons, x, y, hscroll, vscroll,
+                                                                   relative_x, relative_y);
                                   }));
         ON_CALL(*this, configuration_event(_,_))
             .WillByDefault(Invoke([this](Timestamp time, MirInputConfigurationAction action)
@@ -107,14 +105,14 @@
                                   }));
     }
     using EventBuilder::Timestamp;
-    MOCK_METHOD5(key_event, mir::EventUPtr(Timestamp, MirKeyboardAction, xkb_keysym_t, int, MirInputEventModifiers));
+    MOCK_METHOD4(key_event, mir::EventUPtr(Timestamp, MirKeyboardAction, xkb_keysym_t, int));
 
-    MOCK_METHOD2(touch_event, mir::EventUPtr(Timestamp, MirInputEventModifiers));
+    MOCK_METHOD1(touch_event, mir::EventUPtr(Timestamp));
     MOCK_METHOD10(add_touch, void(MirEvent&, MirTouchId, MirTouchAction, MirTouchTooltype, float, float, float, float,
                                   float, float));
 
-    MOCK_METHOD10(pointer_event, mir::EventUPtr(Timestamp, MirInputEventModifiers, MirPointerAction, MirPointerButtons,
-                                                float, float, float, float, float, float));
+    MOCK_METHOD9(pointer_event, mir::EventUPtr(Timestamp, MirPointerAction, MirPointerButtons, float, float, float,
+                                               float, float, float));
     MOCK_METHOD2(configuration_event, mir::EventUPtr(Timestamp, MirInputConfigurationAction));
 };
 
@@ -374,9 +372,9 @@
     setup_key_event(fake_event_1, event_time_1, KEY_A, LIBINPUT_KEY_STATE_PRESSED);
     setup_key_event(fake_event_2, event_time_2, KEY_A, LIBINPUT_KEY_STATE_RELEASED);
 
-    EXPECT_CALL(mock_builder, key_event(time_stamp_1, mir_keyboard_action_down, _, KEY_A, mir_input_event_modifier_none));
+    EXPECT_CALL(mock_builder, key_event(time_stamp_1, mir_keyboard_action_down, _, KEY_A));
     EXPECT_CALL(mock_sink, handle_input(AllOf(mt::KeyOfScanCode(KEY_A),mt::KeyDownEvent())));
-    EXPECT_CALL(mock_builder, key_event(time_stamp_2, mir_keyboard_action_up, _, KEY_A, mir_input_event_modifier_none));
+    EXPECT_CALL(mock_builder, key_event(time_stamp_2, mir_keyboard_action_up, _, KEY_A));
     EXPECT_CALL(mock_sink, handle_input(AllOf(mt::KeyOfScanCode(KEY_A),mt::KeyUpEvent())));
 
     dev.start(&mock_sink, &mock_builder);
@@ -384,36 +382,6 @@
     dev.process_event(fake_event_2);
 }
 
-TEST_F(LibInputDevice, process_event_accumulates_key_state)
-{
-    std::shared_ptr<libinput> lib = mie::make_libinput();
-    mie::LibInputDevice dev(mir::report::null_input_report(), path, mie::make_libinput_device(lib.get(), path));
-
-
-    setup_key_event(fake_event_1, event_time_1, KEY_C, LIBINPUT_KEY_STATE_PRESSED);
-    setup_key_event(fake_event_2, event_time_2, KEY_LEFTALT, LIBINPUT_KEY_STATE_PRESSED);
-    setup_key_event(fake_event_3, event_time_3, KEY_C, LIBINPUT_KEY_STATE_RELEASED);
-
-    InSequence seq;
-    EXPECT_CALL(mock_builder, key_event(time_stamp_1, mir_keyboard_action_down, _, KEY_C, mir_input_event_modifier_none));
-    EXPECT_CALL(mock_sink, handle_input(AllOf(mt::KeyOfScanCode(KEY_C),mt::KeyDownEvent())));
-    EXPECT_CALL(mock_builder, key_event(time_stamp_2, mir_keyboard_action_down, _, KEY_LEFTALT, mir_input_event_modifier_none));
-    EXPECT_CALL(mock_sink, handle_input(AllOf(mt::KeyOfScanCode(KEY_LEFTALT),mt::KeyDownEvent())));
-    EXPECT_CALL(mock_builder, key_event(time_stamp_3, mir_keyboard_action_up, _, KEY_C, mir_input_event_modifier_alt|mir_input_event_modifier_alt_left));
-    EXPECT_CALL(mock_sink, handle_input(AllOf(mt::KeyOfScanCode(KEY_C),
-                                              mt::KeyWithModifiers(
-                                                  MirInputEventModifiers{
-                                                      mir_input_event_modifier_alt|
-                                                      mir_input_event_modifier_alt_left
-                                                  }),
-                                              mt::KeyUpEvent())));
-
-    dev.start(&mock_sink, &mock_builder);
-    dev.process_event(fake_event_1);
-    dev.process_event(fake_event_2);
-    dev.process_event(fake_event_3);
-}
-
 TEST_F(LibInputDevice, process_event_converts_pointer_event)
 {
     std::shared_ptr<libinput> lib = mie::make_libinput();
@@ -499,9 +467,9 @@
 
     InSequence seq;
     // expect two scroll events..
-    EXPECT_CALL(mock_builder, pointer_event(time_stamp_1, mir_input_event_modifier_none, mir_pointer_action_motion, 0, 0.0f, 0.0f, 0.0f, 20.0f, 0.0f, 0.0f));
+    EXPECT_CALL(mock_builder, pointer_event(time_stamp_1, mir_pointer_action_motion, 0, 0.0f, 0.0f, 0.0f, 20.0f, 0.0f, 0.0f));
     EXPECT_CALL(mock_sink, handle_input(mt::PointerAxisChange(mir_pointer_axis_vscroll, 20.0f)));
-    EXPECT_CALL(mock_builder, pointer_event(time_stamp_2, mir_input_event_modifier_none, mir_pointer_action_motion, 0, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f));
+    EXPECT_CALL(mock_builder, pointer_event(time_stamp_2, mir_pointer_action_motion, 0, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f));
     EXPECT_CALL(mock_sink, handle_input(mt::PointerAxisChange(mir_pointer_axis_hscroll, 5.0f)));
 
     dev.start(&mock_sink, &mock_builder);
@@ -525,7 +493,7 @@
     setup_touch_frame(fake_event_2);
 
     InSequence seq;
-    EXPECT_CALL(mock_builder, touch_event(time_stamp_1, mir_input_event_modifier_none));
+    EXPECT_CALL(mock_builder, touch_event(time_stamp_1));
     EXPECT_CALL(mock_builder, add_touch(_, MirTouchId{0}, mir_touch_action_down, mir_touch_tooltype_finger, x, y,
                                         pressure, major, minor, major));
     EXPECT_CALL(mock_sink, handle_input(mt::TouchEvent(x,y)));
@@ -551,7 +519,7 @@
     setup_touch_frame(fake_event_2);
 
     InSequence seq;
-    EXPECT_CALL(mock_builder, touch_event(time_stamp_1, mir_input_event_modifier_none));
+    EXPECT_CALL(mock_builder, touch_event(time_stamp_1));
     EXPECT_CALL(mock_builder, add_touch(_, MirTouchId{0}, mir_touch_action_change, mir_touch_tooltype_finger, x, y,
                                         pressure, major, minor, major));
     EXPECT_CALL(mock_sink, handle_input(mt::TouchMovementEvent()));
@@ -579,12 +547,12 @@
     setup_touch_frame(fake_event_4);
 
     InSequence seq;
-    EXPECT_CALL(mock_builder, touch_event(time_stamp_1, mir_input_event_modifier_none));
+    EXPECT_CALL(mock_builder, touch_event(time_stamp_1));
     EXPECT_CALL(mock_builder, add_touch(_, MirTouchId{slot}, mir_touch_action_down, mir_touch_tooltype_finger, x, y,
                                         pressure, major, minor, major));
     EXPECT_CALL(mock_sink, handle_input(mt::TouchEvent(x,y)));
 
-    EXPECT_CALL(mock_builder, touch_event(time_stamp_2, mir_input_event_modifier_none));
+    EXPECT_CALL(mock_builder, touch_event(time_stamp_2));
     EXPECT_CALL(mock_builder, add_touch(_, MirTouchId{slot}, mir_touch_action_up, mir_touch_tooltype_finger, x, y,
                                         pressure, major, minor, major));
     EXPECT_CALL(mock_sink, handle_input(mt::TouchUpEvent(x,y)));

=== modified file 'tests/unit-tests/input/test_default_input_device_hub.cpp'
--- tests/unit-tests/input/test_default_input_device_hub.cpp	2015-10-07 16:41:50 +0000
+++ tests/unit-tests/input/test_default_input_device_hub.cpp	2015-10-14 12:41:48 +0000
@@ -268,7 +268,7 @@
     observer_loop.trigger_server_actions();
 
     auto event = builder->key_event(arbitrary_timestamp, mir_keyboard_action_down, 0,
-                                    KEY_A, mir_input_event_modifier_none);
+                                    KEY_A);
 
     EXPECT_CALL(mock_dispatcher, dispatch(AllOf(mt::InputDeviceIdMatches(handle->id()), mt::MirKeyEventMatches(event.get()))));
 
@@ -287,23 +287,23 @@
 
     observer_loop.trigger_server_actions();
 
-    auto touch_event_1 = builder->touch_event(arbitrary_timestamp, mir_input_event_modifier_none);
+    auto touch_event_1 = builder->touch_event(arbitrary_timestamp);
     builder->add_touch(*touch_event_1, 0, mir_touch_action_down, mir_touch_tooltype_finger, 21.0f, 34.0f, 50.0f, 15.0f,
                        5.0f, 4.0f);
 
-    auto touch_event_2 = builder->touch_event(arbitrary_timestamp, mir_input_event_modifier_none);
+    auto touch_event_2 = builder->touch_event(arbitrary_timestamp);
     builder->add_touch(*touch_event_2, 0, mir_touch_action_change, mir_touch_tooltype_finger, 24.0f, 34.0f, 50.0f,
                        15.0f, 5.0f, 4.0f);
     builder->add_touch(*touch_event_2, 1, mir_touch_action_down, mir_touch_tooltype_finger, 60.0f, 34.0f, 50.0f, 15.0f,
                        5.0f, 4.0f);
 
-    auto touch_event_3 = builder->touch_event(arbitrary_timestamp, mir_input_event_modifier_none);
+    auto touch_event_3 = builder->touch_event(arbitrary_timestamp);
     builder->add_touch(*touch_event_3, 0, mir_touch_action_up, mir_touch_tooltype_finger, 24.0f, 34.0f, 50.0f, 15.0f,
                        5.0f, 4.0f);
     builder->add_touch(*touch_event_3, 1, mir_touch_action_change, mir_touch_tooltype_finger, 70.0f, 30.0f, 50.0f,
                        15.0f, 5.0f, 4.0f);
 
-    auto touch_event_4 = builder->touch_event(arbitrary_timestamp, mir_input_event_modifier_none);
+    auto touch_event_4 = builder->touch_event(arbitrary_timestamp);
     builder->add_touch(*touch_event_4, 1, mir_touch_action_up, mir_touch_tooltype_finger, 70.0f, 35.0f, 50.0f, 15.0f,
                        5.0f, 4.0f);
 
@@ -372,17 +372,149 @@
     using namespace ::testing;
 
     auto x = 12.2f, y = 14.3f;
-    auto const mac = 0;
-
-    auto event = mir::events::make_event(0, 0ns, mac, mir_input_event_modifier_none, mir_pointer_action_motion, 0,
-        x, y, 0.0f, 0.0f, 0.0f, 0.0f);
+
+    mi::InputSink* sink;
+    mi::EventBuilder* builder;
+    capture_input_sink(device, sink, builder);
+    hub.add_device(mt::fake_shared(device));
+
+    auto event = builder->pointer_event(0ns, mir_pointer_action_motion, 0, x, y, 0.0f, 0.0f, 0.0f, 0.0f);
 
     EXPECT_CALL(mock_cursor_listener, cursor_moved_to(x, y)).Times(1);
 
-    mi::InputSink* sink;
-    mi::EventBuilder* builder;
-    capture_input_sink(device, sink, builder);
-    hub.add_device(mt::fake_shared(device));
-
     sink->handle_input(*event);
 }
+
+TEST_F(InputDeviceHubTest, input_sink_tracks_modifier)
+{
+    using namespace ::testing;
+
+    mi::InputSink* key_board_sink;
+    mi::EventBuilder* key_event_builder;
+    std::shared_ptr<mi::Device> key_handle;
+
+    capture_input_sink(device,  key_board_sink, key_event_builder);
+
+    InSequence seq;
+    EXPECT_CALL(mock_observer,device_added(_))
+        .WillOnce(SaveArg<0>(&key_handle));
+
+    hub.add_observer(mt::fake_shared(mock_observer));
+    hub.add_device(mt::fake_shared(device));
+
+    observer_loop.trigger_server_actions();
+
+    const MirInputEventModifiers shift_left = mir_input_event_modifier_shift_left | mir_input_event_modifier_shift;
+    auto shift_down =
+        key_event_builder->key_event(arbitrary_timestamp, mir_keyboard_action_down, 0, KEY_LEFTSHIFT);
+    auto shift_up =
+        key_event_builder->key_event(arbitrary_timestamp, mir_keyboard_action_up, 0, KEY_LEFTSHIFT);
+
+    EXPECT_CALL(mock_dispatcher, dispatch(mt::KeyWithModifiers(shift_left)));
+    EXPECT_CALL(mock_dispatcher, dispatch(mt::KeyWithModifiers(mir_input_event_modifier_none)));
+
+    key_board_sink->handle_input(*shift_down);
+    key_board_sink->handle_input(*shift_up);
+}
+
+TEST_F(InputDeviceHubTest, input_sink_unifies_modifier_state_accross_devices)
+{
+    using namespace ::testing;
+
+    mi::InputSink* mouse_sink;
+    mi::EventBuilder* mouse_event_builder;
+    mi::InputSink* key_board_sink;
+    mi::EventBuilder* key_event_builder;
+    std::shared_ptr<mi::Device> mouse_handle;
+    std::shared_ptr<mi::Device> key_handle;
+
+    capture_input_sink(device, mouse_sink, mouse_event_builder);
+    capture_input_sink(another_device, key_board_sink, key_event_builder);
+
+    InSequence seq;
+    EXPECT_CALL(mock_observer,device_added(_))
+        .WillOnce(SaveArg<0>(&mouse_handle));
+    EXPECT_CALL(mock_observer,device_added(_))
+        .WillOnce(SaveArg<0>(&key_handle));
+
+    hub.add_observer(mt::fake_shared(mock_observer));
+    hub.add_device(mt::fake_shared(device));
+    hub.add_device(mt::fake_shared(another_device));
+
+    observer_loop.trigger_server_actions();
+
+    const MirInputEventModifiers r_alt_modifier = mir_input_event_modifier_alt_right | mir_input_event_modifier_alt;
+    auto key =
+        key_event_builder->key_event(arbitrary_timestamp, mir_keyboard_action_down, 0, KEY_RIGHTALT);
+    auto motion =
+        mouse_event_builder->pointer_event(arbitrary_timestamp, mir_pointer_action_motion, 0, 12, 40, 0, 0, 12, 40);
+
+    EXPECT_CALL(mock_dispatcher, dispatch(mt::KeyWithModifiers(r_alt_modifier)));
+    EXPECT_CALL(mock_dispatcher, dispatch(mt::PointerEventWithModifiers(r_alt_modifier)));
+
+    key_board_sink->handle_input(*key);
+    mouse_sink->handle_input(*motion);
+
+    EXPECT_THAT(key_handle->id(), Ne(mouse_handle->id()));
+}
+
+TEST_F(InputDeviceHubTest, input_sink_reduces_modifier_state_accross_devices)
+{
+    using namespace ::testing;
+
+    mi::InputSink* mouse_sink;
+    mi::EventBuilder* mouse_event_builder;
+    mi::InputSink* key_board_sink_1;
+    mi::EventBuilder* key_event_builder_1;
+    mi::InputSink* key_board_sink_2;
+    mi::EventBuilder* key_event_builder_2;
+    std::shared_ptr<mi::Device> mouse_handle;
+    std::shared_ptr<mi::Device> key_handle_1;
+    std::shared_ptr<mi::Device> key_handle_2;
+
+    capture_input_sink(device, mouse_sink, mouse_event_builder);
+    capture_input_sink(another_device, key_board_sink_1, key_event_builder_1);
+    capture_input_sink(third_device, key_board_sink_2, key_event_builder_2);
+
+    InSequence seq;
+    EXPECT_CALL(mock_observer, device_added(_))
+        .WillOnce(SaveArg<0>(&mouse_handle));
+    EXPECT_CALL(mock_observer, device_added(_))
+        .WillOnce(SaveArg<0>(&key_handle_1));
+    EXPECT_CALL(mock_observer, device_added(_))
+        .WillOnce(SaveArg<0>(&key_handle_2));
+
+    hub.add_observer(mt::fake_shared(mock_observer));
+    hub.add_device(mt::fake_shared(device));
+    hub.add_device(mt::fake_shared(another_device));
+    hub.add_device(mt::fake_shared(third_device));
+
+    const MirInputEventModifiers r_alt_modifier = mir_input_event_modifier_alt_right | mir_input_event_modifier_alt;
+    const MirInputEventModifiers l_ctrl_modifier = mir_input_event_modifier_ctrl_left | mir_input_event_modifier_ctrl;
+    const MirInputEventModifiers combined_modifier = r_alt_modifier | l_ctrl_modifier;
+
+    observer_loop.trigger_server_actions();
+
+    auto alt_down = key_event_builder_1->key_event(arbitrary_timestamp, mir_keyboard_action_down, 0, KEY_RIGHTALT);
+    auto ctrl_down = key_event_builder_2->key_event(arbitrary_timestamp, mir_keyboard_action_down, 0, KEY_LEFTCTRL);
+    auto ctrl_up = key_event_builder_2->key_event(arbitrary_timestamp, mir_keyboard_action_up, 0, KEY_LEFTCTRL);
+
+    auto motion_1 =
+        mouse_event_builder->pointer_event(arbitrary_timestamp, mir_pointer_action_motion, 0, 12, 40, 0, 0, 12, 40);
+    auto motion_2 =
+        mouse_event_builder->pointer_event(arbitrary_timestamp, mir_pointer_action_motion, 0, 30, 50, 0, 0, 18, 10);
+
+    EXPECT_CALL(mock_dispatcher, dispatch(mt::KeyWithModifiers(r_alt_modifier)));
+    EXPECT_CALL(mock_dispatcher, dispatch(mt::KeyWithModifiers(combined_modifier)));
+    EXPECT_CALL(mock_dispatcher, dispatch(mt::PointerEventWithModifiers(combined_modifier)));
+    EXPECT_CALL(mock_dispatcher, dispatch(mt::KeyWithModifiers(r_alt_modifier)));
+    EXPECT_CALL(mock_dispatcher, dispatch(mt::PointerEventWithModifiers(r_alt_modifier)));
+
+    key_board_sink_1->handle_input(*alt_down);
+    key_board_sink_2->handle_input(*ctrl_down);
+    mouse_sink->handle_input(*motion_1);
+    key_board_sink_2->handle_input(*ctrl_up);
+    mouse_sink->handle_input(*motion_2);
+
+    EXPECT_THAT(key_handle_1->id(), Ne(key_handle_2->id()));
+}