Merge lp:~andreas-pokorny/mir/move-key-repeat-into-input-platforms into lp:mir

[Andreas Pokorny]

Introduces KeyboardSettings to configure key repeat and moves the responsibility out to input platforms

X11 forwards the settings to Xkb, while evdev and stub input implement the repeat handling via the KeyRepeater introduced in a previous change. With that the key repeat is also closer to be being runtime configureable. (wiring to mir::input::Device or the client API still outstanding).

This moves the key repeat tracking into the input platform. With that the dynamic_pointer_cast and the two step initialization required by the KeyRepeatDispatcher is no longer necessary.

Kludge: The mir option MIR_SERVER_KEY_REPEAT is still supported, by letting DefaultInputDeviceHub configure the default setting... That code cries out to be moved somewhere else...

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3421
https://mir-jenkins.ubuntu.com/job/mir-ci/644/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/580/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/616
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/608
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/608
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/590/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/590/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/590/console
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/590/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/590/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/590/console

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

review: Needs Fixing (continuous-integration)

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3421
https://mir-jenkins.ubuntu.com/job/mir-ci/665/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/611/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/648
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/640
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/640
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/621/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/621/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/621
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/621/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/621/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/621/console

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

review: Needs Fixing (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

Yay for deleting code!

+ std::shared_ptr<mir::time::Clock> const& clock)
+ : report{report},

+ std::unique_ptr<udev::Context>&& udev_context)
+ : report(report),

+mix::XInputDevice::XInputDevice(InputDeviceInfo const& device_info, std::shared_ptr<::Display> const& display)
+ : display{display}, info(device_info)

+ std::shared_ptr<::Display> const& conn)
+ : x11_connection{conn},

The : needs to go on the same line as the ctor (at lease according to the coding style). I see most of those were on the init list line before this branch. Feel free to fix them (just a nit).

+class Alarm;
I dont see that namespace used? (Unless i missed it :). Do we need this forward dec?

Do we just not care about the key_code here?
 sink->handle_input(*builder->key_event(event_time, mir_keyboard_action_repeat, 0, code));

Changes make sense.

review: Approve

[lp:~andreas-pokorny/mir/move-key-repeat-into-input-platforms]

3422. By Andreas Pokorny on 2016-03-30

removed fwd decl

[Andreas Pokorny (andreas-pokorny)]

> Yay for deleting code!
>
> + std::shared_ptr<mir::time::Clock> const&
> clock)
> + : report{report},
>
> + std::unique_ptr<udev::Context>&& udev_context)
> + : report(report),
>
> +mix::XInputDevice::XInputDevice(InputDeviceInfo const& device_info,
> std::shared_ptr<::Display> const& display)
> + : display{display}, info(device_info)
>
> + std::shared_ptr<::Display> const& conn)
> + : x11_connection{conn},
>
> The : needs to go on the same line as the ctor (at lease according to the
> coding style). I see most of those were on the init list line before this
> branch. Feel free to fix them (just a nit).

We have both variants in the style guide - for some reason our current clang-format setup seems to prefer the version above..

>
> +class Alarm;
> I dont see that namespace used? (Unless i missed it :). Do we need this
> forward dec?

ack removed.

> Do we just not care about the key_code here?
> sink->handle_input(*builder->key_event(event_time,
> mir_keyboard_action_repeat, 0, code));

I guess testing that the actual key code is repeated might be reasonable thing to test..

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3422
https://mir-jenkins.ubuntu.com/job/mir-ci/708/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/671/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-0-fetch/708/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/699/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/699/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/680/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/680/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/680/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/680/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/680/console

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

review: Needs Fixing (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

(Besides the conflicts, this looks good to me :)

review: Approve

[lp:~andreas-pokorny/mir/move-key-repeat-into-input-platforms]

3423. By Andreas Pokorny on 2016-03-31

merge prereq

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3423
https://mir-jenkins.ubuntu.com/job/mir-ci/718/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/682/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/719
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/710
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/710
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/691/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/691/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/691
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/691/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/691/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/691/console

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

review: Needs Fixing (continuous-integration)

[Kevin DuBois (kdub)]

nits:
+ KeyboardSettings() {}
not needed

1122: + settings.acceleration = mir_pointer_acceleration_none;
why indent further?

1031: braces around multiline if/else

lgtm otherwise

review: Approve

[Daniel van Vugt (vanvugt)]

The prerequisite branch is on hold. So should that make this one on hold too?

[Daniel van Vugt (vanvugt)]

review: Needs Information

Unmerged revisions

3423. By Andreas Pokorny on 2016-03-31

merge prereq

3422. By Andreas Pokorny on 2016-03-30

removed fwd decl

3421. By Andreas Pokorny on 2016-03-23

update libinput test fixture

3420. By Andreas Pokorny on 2016-03-23

Update X11 Unit tests

3419. By Andreas Pokorny on 2016-03-23

add missing file - KeyboardSettings

3418. By Andreas Pokorny on 2016-03-23

merge prereq

3417. By Andreas Pokorny on 2016-03-23

Integrate Key repeater into stub intput platform

3416. By Andreas Pokorny on 2016-03-23

Integrate Key Repeater

3415. By Andreas Pokorny on 2016-03-23

Add Key repeat utility

Similar to the key press tracking in KeyRepeatDispatcher, this class will support the evdev platform and fake input devices in implementing repeat handling.

3414. By Andreas Pokorny on 2016-03-22

Add mir::dispatch::AlarmFactory

Implementation of mir::time::AlarmFactory that works with mir::dispatch::Dispatchable and supports all the state transitions required by the test suite accumulated in test_glib_main_loop.cpp.

With this change several GPL interfaces defined inside the mirserver API have been moved to mircommon and LGPL.

=== modified file 'include/platform/mir/input/input_device.h'
--- include/platform/mir/input/input_device.h	2016-01-29 08:18:22 +0000
+++ include/platform/mir/input/input_device.h	2016-03-31 19:18:58 +0000
@@ -39,6 +39,7 @@
 
 class PointerSettings;
 class TouchpadSettings;
+class KeyboardSettings;
 
 /**
  * Represents an input device.
@@ -65,6 +66,9 @@
 
     virtual optional_value<TouchpadSettings> get_touchpad_settings() const = 0;
     virtual void apply_settings(TouchpadSettings const&) = 0;
+
+    virtual optional_value<KeyboardSettings> get_keyboard_settings() const = 0;
+    virtual void apply_settings(KeyboardSettings const&) = 0;
 protected:
     InputDevice(InputDevice const&) = delete;
     InputDevice& operator=(InputDevice const&) = delete;
 
=== added file 'include/platform/mir/input/keyboard_settings.h'
--- include/platform/mir/input/keyboard_settings.h	1970-01-01 00:00:00 +0000
+++ include/platform/mir/input/keyboard_settings.h	2016-03-31 19:18:58 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by:
+ *   Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_KEY_BOARD_SETTINGS_H_
+#define MIR_INPUT_KEY_BOARD_SETTINGS_H_
+
+#include "mir_toolkit/mir_input_device.h"
+#include <chrono>
+
+namespace mir
+{
+namespace input
+{
+
+struct KeyboardSettings
+{
+    KeyboardSettings() {}
+    bool repeat_enabled{true};
+    std::chrono::milliseconds repeat_delay{50};
+    std::chrono::milliseconds repeat_interval{500};
+};
+
+}
+}
+
+#endif
 
=== modified file 'src/platforms/evdev/key_repeater.cpp'
--- src/platforms/evdev/key_repeater.cpp	2016-03-31 19:18:58 +0000
+++ src/platforms/evdev/key_repeater.cpp	2016-03-31 19:18:58 +0000
@@ -29,6 +29,8 @@
 {
 }
 
+mie::KeyRepeater::~KeyRepeater() = default;
+
 void mie::KeyRepeater::enable(std::chrono::milliseconds repeat_delay, std::chrono::milliseconds repeat_interval)
 {
     enabled_ = true;
 
=== modified file 'src/platforms/evdev/key_repeater.h'
--- src/platforms/evdev/key_repeater.h	2016-03-31 19:18:58 +0000
+++ src/platforms/evdev/key_repeater.h	2016-03-31 19:18:58 +0000
@@ -39,6 +39,7 @@
 struct KeyRepeater
 {
     KeyRepeater(std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory, std::function<void(int32_t keycode)> const& send_repeat_key);
+    ~KeyRepeater();
     void enable(std::chrono::milliseconds repeat_delay, std::chrono::milliseconds repeat_interval);
     void disable();
     bool enabled() const;
 
=== modified file 'src/platforms/evdev/libinput_device.cpp'
--- src/platforms/evdev/libinput_device.cpp	2016-03-23 06:39:56 +0000
+++ src/platforms/evdev/libinput_device.cpp	2016-03-31 19:18:58 +0000
@@ -27,11 +27,11 @@
 #include "mir/input/device_capability.h"
 #include "mir/input/pointer_settings.h"
 #include "mir/input/touchpad_settings.h"
+#include "mir/input/keyboard_settings.h"
 #include "mir/input/input_device_info.h"
 #include "mir/events/event_builders.h"
 #include "mir/geometry/displacement.h"
-#include "mir/dispatch/dispatchable.h"
-#include "mir/fd.h"
+#include "mir/time/clock.h"
 #define MIR_LOG_COMPONENT "evdev"
 #include "mir/log.h"
 #include "mir/raii.h"
@@ -45,13 +45,19 @@
 #include <sstream>
 #include <algorithm>
 
-namespace md = mir::dispatch;
 namespace mi = mir::input;
 namespace mie = mi::evdev;
 using namespace std::literals::chrono_literals;
 
-mie::LibInputDevice::LibInputDevice(std::shared_ptr<mi::InputReport> const& report, LibInputDevicePtr dev)
-    : report{report}, pointer_pos{0, 0}, button_state{0}
+mie::LibInputDevice::LibInputDevice(std::shared_ptr<mi::InputReport> const& report,
+                                    LibInputDevicePtr dev,
+                                    std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
+                                    std::shared_ptr<mir::time::Clock> const& clock)
+    : report{report},
+      repeater{alarm_factory, [this](auto code) { this->handle_repeat(code); }},
+      clock{clock},
+      pointer_pos{0, 0},
+      button_state{0}
 {
     add_device_of_group(std::move(dev));
 }
@@ -135,6 +141,11 @@
     auto const code = libinput_event_keyboard_get_key(keyboard);
     report->received_event_from_kernel(time.count(), EV_KEY, code, action);
 
+    if (action == mir_keyboard_action_down)
+        repeater.press(code);
+    else
+        repeater.release(code);
+
     return builder->key_event(time, action, xkb_keysym_t{0}, code);
 }
 
@@ -476,3 +487,32 @@
                                                                  LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED :
                                                                  LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
 }
+
+mir::optional_value<mi::KeyboardSettings> mie::LibInputDevice::get_keyboard_settings() const
+{
+    if (!contains(info.capabilities, mi::DeviceCapability::keyboard))
+        return {};
+    mi::KeyboardSettings settings;
+
+    settings.repeat_enabled = repeater.enabled();
+    settings.repeat_delay = repeater.delay();
+    settings.repeat_interval = repeater.interval();
+    return settings;
+}
+
+void mie::LibInputDevice::apply_settings(mi::KeyboardSettings const& settings)
+{
+    if (!contains(info.capabilities, mi::DeviceCapability::keyboard))
+        return;
+
+    if (settings.repeat_enabled)
+        repeater.enable(settings.repeat_delay, settings.repeat_interval);
+    else
+        repeater.disable();
+}
+
+void mie::LibInputDevice::handle_repeat(int32_t code)
+{
+    auto const event_time = clock->now().time_since_epoch();
+    sink->handle_input(*builder->key_event(event_time, mir_keyboard_action_repeat, 0, code));
+}
 
=== modified file 'src/platforms/evdev/libinput_device.h'
--- src/platforms/evdev/libinput_device.h	2016-03-23 06:39:56 +0000
+++ src/platforms/evdev/libinput_device.h	2016-03-31 19:18:58 +0000
@@ -21,6 +21,7 @@
 
 #include "libinput_ptr.h"
 #include "libinput_device_ptr.h"
+#include "key_repeater.h"
 
 #include "mir/input/event_builder.h"
 #include "mir/input/input_device.h"
@@ -38,18 +39,23 @@
 
 namespace mir
 {
+namespace time
+{
+class Clock;
+class AlarmFactory;
+}
 namespace input
 {
 class InputReport;
 namespace evdev
 {
-struct PointerState;
-struct KeyboardState;
 
 class LibInputDevice : public input::InputDevice
 {
 public:
-    LibInputDevice(std::shared_ptr<InputReport> const& report, LibInputDevicePtr dev);
+    LibInputDevice(std::shared_ptr<InputReport> const& report, LibInputDevicePtr dev,
+                   std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
+                   std::shared_ptr<mir::time::Clock> const& clock);
     ~LibInputDevice();
     void start(InputSink* sink, EventBuilder* builder) override;
     void stop() override;
@@ -58,6 +64,8 @@
     void apply_settings(PointerSettings const&) override;
     optional_value<TouchpadSettings> get_touchpad_settings() const override;
     void apply_settings(TouchpadSettings const&) override;
+    optional_value<KeyboardSettings> get_keyboard_settings() const override;
+    void apply_settings(KeyboardSettings const&) override;
 
     void process_event(libinput_event* event);
     ::libinput_device* device() const;
@@ -75,10 +83,11 @@
     void handle_touch_motion(libinput_event_touch* touch);
     void update_device_info();
 
-    std::shared_ptr<InputReport> report;
+    std::shared_ptr<InputReport> const report;
+    KeyRepeater repeater;
+    std::shared_ptr<mir::time::Clock> const clock;
     std::shared_ptr<::libinput> lib;
     std::vector<LibInputDevicePtr> devices;
-    std::shared_ptr<dispatch::Dispatchable> dispatchable_fd;
 
     InputSink* sink{nullptr};
     EventBuilder* builder{nullptr};
@@ -98,6 +107,7 @@
     std::map<MirTouchId,ContactData> last_seen_properties;
 
     void update_contact_data(ContactData &data, MirTouchAction action, libinput_event_touch* touch);
+    void handle_repeat(int32_t code);
 };
 }
 }
 
=== modified file 'src/platforms/evdev/platform.cpp'
--- src/platforms/evdev/platform.cpp	2016-03-23 06:39:56 +0000
+++ src/platforms/evdev/platform.cpp	2016-03-31 19:18:58 +0000
@@ -22,7 +22,10 @@
 #include "mir/udev/wrapper.h"
 #include "mir/dispatch/dispatchable.h"
 #include "mir/dispatch/readable_fd.h"
+#include "mir/dispatch/alarm_factory.h"
 #include "mir/dispatch/multiplexing_dispatchable.h"
+#include "mir/time/steady_clock.h"
+#include "mir/time/steady_timer_fd.h"
 #include "mir/module_properties.h"
 #include "mir/assert_module_entry_point.h"
 
@@ -43,6 +46,7 @@
 
 namespace mi = mir::input;
 namespace md = mir::dispatch;
+namespace mt = mir::time;
 namespace mu = mir::udev;
 namespace mie = mi::evdev;
 
@@ -68,12 +72,14 @@
 } // namespace
 
 mie::Platform::Platform(std::shared_ptr<InputDeviceRegistry> const& registry,
-                              std::shared_ptr<InputReport> const& report,
-                              std::unique_ptr<udev::Context>&& udev_context) :
-    report(report),
-    udev_context(std::move(udev_context)),
-    input_device_registry(registry),
-    platform_dispatchable{std::make_shared<md::MultiplexingDispatchable>()}
+                        std::shared_ptr<InputReport> const& report,
+                        std::unique_ptr<udev::Context>&& udev_context)
+    : report(report),
+      udev_context(std::move(udev_context)),
+      input_device_registry(registry),
+      platform_dispatchable{std::make_shared<md::MultiplexingDispatchable>()},
+      clock{std::make_shared<mt::SteadyClock>()},
+      alarm_factory{std::make_shared<md::AlarmFactory>(clock, std::make_shared<mt::SteadyTimerFd>())}
 {
 }
 
@@ -91,6 +97,7 @@
             Fd{IntOwnedFd{libinput_get_fd(lib.get())}}, [this]{process_input_events();}
         );
     platform_dispatchable->add_watch(libinput_dispatchable);
+    platform_dispatchable->add_watch(alarm_factory);
 }
 
 void mie::Platform::process_input_events()
@@ -145,7 +152,7 @@
 
     try
     {
-        devices.emplace_back(std::make_shared<mie::LibInputDevice>(report, move(device_ptr)));
+        devices.emplace_back(std::make_shared<mie::LibInputDevice>(report, move(device_ptr), alarm_factory, clock));
 
         input_device_registry->add_device(devices.back());
 
@@ -186,6 +193,7 @@
 
 void mie::Platform::stop()
 {
+    platform_dispatchable->remove_watch(alarm_factory);
     platform_dispatchable->remove_watch(libinput_dispatchable);
     while (!devices.empty())
     {
 
=== modified file 'src/platforms/evdev/platform.h'
--- src/platforms/evdev/platform.h	2016-03-23 06:39:56 +0000
+++ src/platforms/evdev/platform.h	2016-03-31 19:18:58 +0000
@@ -37,10 +37,15 @@
 class Monitor;
 class Context;
 }
+namespace time
+{
+class Clock;
+}
 namespace dispatch
 {
 class MultiplexingDispatchable;
 class ReadableFd;
+class AlarmFactory;
 }
 namespace input
 {
@@ -73,6 +78,8 @@
     std::shared_ptr<udev::Context> const udev_context;
     std::shared_ptr<InputDeviceRegistry> const input_device_registry;
     std::shared_ptr<dispatch::MultiplexingDispatchable> const platform_dispatchable;
+    std::shared_ptr<time::Clock> const clock;
+    std::shared_ptr<dispatch::AlarmFactory> const alarm_factory;
     std::shared_ptr<::libinput> lib;
     std::shared_ptr<dispatch::ReadableFd> libinput_dispatchable;
 
 
=== modified file 'src/platforms/mesa/server/x11/input/input_device.cpp'
--- src/platforms/mesa/server/x11/input/input_device.cpp	2016-03-23 06:39:56 +0000
+++ src/platforms/mesa/server/x11/input/input_device.cpp	2016-03-31 19:18:58 +0000
@@ -20,13 +20,16 @@
 
 #include "mir/input/pointer_settings.h"
 #include "mir/input/touchpad_settings.h"
+#include "mir/input/keyboard_settings.h"
 #include "mir/input/input_device_info.h"
 #include "mir/input/device_capability.h"
 #include "mir/input/event_builder.h"
 #include "mir/input/input_sink.h"
 
+#include "mir/raii.h"
+
 #include <X11/Xlib.h>
-#include <iostream>
+#include <X11/XKBlib.h>
 
 namespace mi = mir::input;
 namespace geom = mir::geometry;
@@ -69,8 +72,8 @@
 
 }
 
-mix::XInputDevice::XInputDevice(InputDeviceInfo const& device_info)
-    : info(device_info)
+mix::XInputDevice::XInputDevice(InputDeviceInfo const& device_info, std::shared_ptr<::Display> const& display)
+    : display{display}, info(device_info)
 {
 }
 
@@ -210,3 +213,49 @@
             )
         );
 }
+
+void mix::XInputDevice::apply_settings(mi::KeyboardSettings const& settings)
+{
+    if (!contains(info.capabilities, mi::DeviceCapability::keyboard))
+        return;
+
+    XKeyboardControl repeat_enabled;
+    repeat_enabled.auto_repeat_mode = settings.repeat_enabled;
+    XChangeKeyboardControl(display.get(), KBAutoRepeatMode, &repeat_enabled);
+
+    int xkbopcode, xkbevent, xkberror;
+    int xkbmajor = XkbMajorVersion, xkbminor = XkbMinorVersion;
+    if (XkbQueryExtension(display.get(), &xkbopcode, &xkbevent, &xkberror, &xkbmajor, &xkbminor))
+    {
+        auto xkb = raii::deleter_for(XkbAllocKeyboard(), [](XkbDescPtr ptr){XkbFreeKeyboard(ptr, 0, True);});
+
+        XkbGetControls(display.get(), XkbRepeatKeysMask, xkb.get());
+        xkb->ctrls->repeat_delay = settings.repeat_delay.count();
+        xkb->ctrls->repeat_interval = settings.repeat_interval.count();
+        XkbSetControls(display.get(), XkbRepeatKeysMask, xkb.get());
+    }
+}
+
+mir::optional_value<mi::KeyboardSettings> mix::XInputDevice::get_keyboard_settings() const
+{
+    if (!contains(info.capabilities, mi::DeviceCapability::keyboard))
+        return {};
+
+    KeyboardSettings settings;
+    XKeyboardState repeat_enabled;
+    XGetKeyboardControl(display.get(), &repeat_enabled);
+    settings.repeat_enabled = repeat_enabled.global_auto_repeat;
+
+    int xkbopcode, xkbevent, xkberror;
+    int xkbmajor = XkbMajorVersion, xkbminor = XkbMinorVersion;
+    if (XkbQueryExtension(display.get(), &xkbopcode, &xkbevent, &xkberror, &xkbmajor, &xkbminor))
+    {
+        auto xkb = raii::deleter_for(XkbAllocKeyboard(), [](XkbDescPtr ptr){ XkbFreeKeyboard(ptr, 0, True);});
+
+        XkbGetControls(display.get(), XkbRepeatKeysMask, xkb.get());
+        settings.repeat_delay = std::chrono::milliseconds{xkb->ctrls->repeat_delay};
+        settings.repeat_interval = std::chrono::milliseconds{xkb->ctrls->repeat_interval};
+    }
+
+    return settings;
+}
 
=== modified file 'src/platforms/mesa/server/x11/input/input_device.h'
--- src/platforms/mesa/server/x11/input/input_device.h	2016-03-23 06:39:56 +0000
+++ src/platforms/mesa/server/x11/input/input_device.h	2016-03-31 19:18:58 +0000
@@ -26,6 +26,7 @@
 #include "mir/geometry/displacement.h"
 #include "mir/optional_value.h"
 
+#include <X11/Xlib.h>
 #include <chrono>
 
 namespace mir
@@ -39,7 +40,7 @@
 class XInputDevice : public input::InputDevice
 {
 public:
-    XInputDevice(InputDeviceInfo const& info);
+    XInputDevice(InputDeviceInfo const& info, std::shared_ptr<::Display> const& display);
 
     std::shared_ptr<dispatch::Dispatchable> dispatchable();
     void start(InputSink* destination, EventBuilder* builder) override;
@@ -50,6 +51,8 @@
     void apply_settings(PointerSettings const& settings) override;
     optional_value<TouchpadSettings> get_touchpad_settings() const override;
     void apply_settings(TouchpadSettings const& settings) override;
+    optional_value<KeyboardSettings> get_keyboard_settings() const override;
+    void apply_settings(KeyboardSettings const& settings) override;
 
     bool started() const;
     void key_press(std::chrono::nanoseconds event_time, xkb_keysym_t key_sym, int32_t key_code);
@@ -60,6 +63,7 @@
     void pointer_motion(std::chrono::nanoseconds event_time, mir::geometry::Point const& pos, mir::geometry::Displacement scroll);
 
 private:
+    std::shared_ptr<::Display> const display;
     MirPointerButtons button_state{0};
     InputSink* sink{nullptr};
     EventBuilder* builder{nullptr};
 
=== modified file 'src/platforms/mesa/server/x11/input/input_platform.cpp'
--- src/platforms/mesa/server/x11/input/input_platform.cpp	2016-03-23 06:39:56 +0000
+++ src/platforms/mesa/server/x11/input/input_platform.cpp	2016-03-31 19:18:58 +0000
@@ -46,18 +46,15 @@
 namespace mix = mi::X;
 
 mix::XInputPlatform::XInputPlatform(std::shared_ptr<mi::InputDeviceRegistry> const& input_device_registry,
-                                    std::shared_ptr<::Display> const& conn) :
-    x11_connection{conn},
-    xcon_dispatchable(std::make_shared<md::ReadableFd>(
-                                mir::Fd{mir::IntOwnedFd{XConnectionNumber(conn.get())}}, [this]()
-                                {
-                                    process_input_event();
-                                })),
-    registry(input_device_registry),
-    core_keyboard(std::make_shared<mix::XInputDevice>(
-            mi::InputDeviceInfo{"x11-keyboard-device", "x11-key-dev-1", mi::DeviceCapability::keyboard})),
-    core_pointer(std::make_shared<mix::XInputDevice>(
-            mi::InputDeviceInfo{"x11-mouse-device", "x11-mouse-dev-1", mi::DeviceCapability::pointer}))
+                                    std::shared_ptr<::Display> const& conn)
+    : x11_connection{conn},
+      xcon_dispatchable(std::make_shared<md::ReadableFd>(mir::Fd{mir::IntOwnedFd{XConnectionNumber(conn.get())}},
+                                                         [this]() { process_input_event(); })),
+      registry(input_device_registry),
+      core_keyboard(std::make_shared<mix::XInputDevice>(
+          mi::InputDeviceInfo{"x11-keyboard-device", "x11-key-dev-1", mi::DeviceCapability::keyboard}, conn)),
+      core_pointer(std::make_shared<mix::XInputDevice>(
+          mi::InputDeviceInfo{"x11-mouse-device", "x11-mouse-dev-1", mi::DeviceCapability::pointer}, conn))
 {
 }
 
 
=== modified file 'src/server/input/CMakeLists.txt'
--- src/server/input/CMakeLists.txt	2016-03-23 06:39:56 +0000
+++ src/server/input/CMakeLists.txt	2016-03-31 19:18:58 +0000
@@ -16,7 +16,6 @@
   event_filter_chain_dispatcher.cpp
   input_modifier_utils.cpp
   input_probe.cpp
-  key_repeat_dispatcher.cpp
   null_input_channel_factory.cpp
   null_input_dispatcher.cpp
   seat_input_device_tracker.cpp
 
=== modified file 'src/server/input/default_configuration.cpp'
--- src/server/input/default_configuration.cpp	2016-03-23 06:39:56 +0000
+++ src/server/input/default_configuration.cpp	2016-03-31 19:18:58 +0000
@@ -20,7 +20,6 @@
 
 #include "android/input_sender.h"
 #include "android/input_channel_factory.h"
-#include "key_repeat_dispatcher.h"
 #include "display_input_region.h"
 #include "event_filter_chain_dispatcher.h"
 #include "cursor_controller.h"
@@ -143,15 +142,7 @@
     return input_dispatcher(
         [this]()
         {
-            std::chrono::milliseconds const key_repeat_timeout{500};
-            std::chrono::milliseconds const key_repeat_delay{50};
-
-            auto const options = the_options();
-            auto enable_repeat = options->get<bool>(options::enable_key_repeat_opt);
-
-            return std::make_shared<mi::KeyRepeatDispatcher>(
-                the_event_filter_chain_dispatcher(), the_main_loop(), the_cookie_authority(),
-                enable_repeat, key_repeat_timeout, key_repeat_delay);
+            return the_event_filter_chain_dispatcher();
         });
 }
 
@@ -297,18 +288,13 @@
     return default_input_device_hub(
         [this]()
         {
-            auto input_dispatcher = the_input_dispatcher();
-            auto key_repeater = std::dynamic_pointer_cast<mi::KeyRepeatDispatcher>(input_dispatcher);
-            auto hub = std::make_shared<mi::DefaultInputDeviceHub>(
+            return std::make_shared<mi::DefaultInputDeviceHub>(
                 the_global_event_sink(),
                 the_seat(),
                 the_input_reading_multiplexer(),
                 the_main_loop(),
-                the_cookie_authority());
-
-            if (key_repeater)
-                key_repeater->set_input_device_hub(hub);
-            return hub;
+                the_cookie_authority(),
+                the_options()->get<bool>(options::enable_key_repeat_opt));
         });
 }
 
@@ -324,18 +310,13 @@
         return default_input_device_hub(
             [this]()
             {
-                auto input_dispatcher = the_input_dispatcher();
-                auto key_repeater = std::dynamic_pointer_cast<mi::KeyRepeatDispatcher>(input_dispatcher);
-                auto hub = std::make_shared<mi::DefaultInputDeviceHub>(
+                return std::make_shared<mi::DefaultInputDeviceHub>(
                     the_global_event_sink(),
                     the_seat(),
                     the_input_reading_multiplexer(),
                     the_main_loop(),
-                    the_cookie_authority());
-
-                if (key_repeater)
-                    key_repeater->set_input_device_hub(hub);
-                return hub;
+                    the_cookie_authority(),
+                    the_options()->get<bool>(options::enable_key_repeat_opt));
             });
     }
 }
 
=== modified file 'src/server/input/default_input_device_hub.cpp'
--- src/server/input/default_input_device_hub.cpp	2016-03-23 06:39:56 +0000
+++ src/server/input/default_input_device_hub.cpp	2016-03-31 19:18:58 +0000
@@ -21,6 +21,7 @@
 
 #include "mir/input/input_device.h"
 #include "mir/input/input_device_observer.h"
+#include "mir/input/keyboard_settings.h"
 #include "mir/geometry/point.h"
 #include "mir/dispatch/multiplexing_dispatchable.h"
 #include "mir/dispatch/action_queue.h"
@@ -43,14 +44,16 @@
     std::shared_ptr<mi::Seat> const& seat,
     std::shared_ptr<dispatch::MultiplexingDispatchable> const& input_multiplexer,
     std::shared_ptr<mir::ServerActionQueue> const& observer_queue,
-    std::shared_ptr<mir::cookie::Authority> const& cookie_authority)
+    std::shared_ptr<mir::cookie::Authority> const& cookie_authority,
+    bool repeat_enabled)
     : seat{seat},
       sink{sink},
       input_dispatchable{input_multiplexer},
       observer_queue(observer_queue),
       device_queue(std::make_shared<dispatch::ActionQueue>()),
       cookie_authority(cookie_authority),
-      device_id_generator{0}
+      device_id_generator{0},
+      repeat_enabled{repeat_enabled}
 {
     input_dispatchable->add_watch(device_queue);
 }
@@ -60,6 +63,13 @@
     if (!device)
         BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid input device"));
 
+    if (contains(device->get_device_info().capabilities, mir::input::DeviceCapability::keyboard))
+    {
+        auto key_settings = device->get_keyboard_settings().value();
+        key_settings.repeat_enabled = repeat_enabled;
+        device->apply_settings(key_settings);
+    }
+
     auto it = find_if(devices.cbegin(),
                       devices.cend(),
                       [&device](std::unique_ptr<RegisteredDevice> const& item)
 
=== modified file 'src/server/input/default_input_device_hub.h'
--- src/server/input/default_input_device_hub.h	2016-03-23 06:39:56 +0000
+++ src/server/input/default_input_device_hub.h	2016-03-31 19:18:58 +0000
@@ -65,7 +65,8 @@
                           std::shared_ptr<Seat> const& seat,
                           std::shared_ptr<dispatch::MultiplexingDispatchable> const& input_multiplexer,
                           std::shared_ptr<ServerActionQueue> const& observer_queue,
-                          std::shared_ptr<cookie::Authority> const& cookie_authority);
+                          std::shared_ptr<cookie::Authority> const& cookie_authority,
+                          bool repeat_enabled = true);
 
     // InputDeviceRegistry - calls from mi::Platform
     void add_device(std::shared_ptr<InputDevice> const& device) override;
@@ -117,6 +118,7 @@
     std::vector<std::shared_ptr<InputDeviceObserver>> observers;
 
     MirInputDeviceId device_id_generator;
+    bool repeat_enabled;
 };
 
 }
 
=== removed file 'src/server/input/key_repeat_dispatcher.cpp'
--- src/server/input/key_repeat_dispatcher.cpp	2016-03-29 23:37:32 +0000
+++ src/server/input/key_repeat_dispatcher.cpp	1970-01-01 00:00:00 +0000
@@ -1,186 +0,0 @@
-/*
- * Copyright © 2012 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Robert Carr <[e-mail]>
- */
-
-#include "key_repeat_dispatcher.h"
-
-#include "mir/input/device.h"
-#include "mir/input/input_device_hub.h"
-#include "mir/time/alarm_factory.h"
-#include "mir/time/alarm.h"
-#include "mir/events/event_private.h"
-#include "mir/cookie/authority.h"
-
-#include <boost/throw_exception.hpp>
-
-#include <algorithm>
-#include <stdexcept>
-#include <string.h>
-
-namespace mi = mir::input;
-
-namespace
-{
-struct DeviceRemovalFilter : mi::InputDeviceObserver
-{
-    DeviceRemovalFilter(std::function<void(MirInputDeviceId)> const& on_removal)
-        : on_removal(on_removal) {}
-
-    void device_added(std::shared_ptr<mi::Device> const&) override
-    {
-    }
-
-    void device_changed(std::shared_ptr<mi::Device> const&) override
-    {
-    }
-
-    void device_removed(std::shared_ptr<mi::Device> const& device) override
-    {
-        on_removal(device->id());
-    }
-
-    void changes_complete() override
-    {
-    }
-    std::function<void(MirInputDeviceId)> on_removal;
-};
-
-}
-
-mi::KeyRepeatDispatcher::KeyRepeatDispatcher(
-    std::shared_ptr<mi::InputDispatcher> const& next_dispatcher,
-    std::shared_ptr<mir::time::AlarmFactory> const& factory,
-    std::shared_ptr<mir::cookie::Authority> const& cookie_authority,
-    bool repeat_enabled,
-    std::chrono::milliseconds repeat_timeout,
-    std::chrono::milliseconds repeat_delay)
-    : next_dispatcher(next_dispatcher),
-      alarm_factory(factory),
-      cookie_authority(cookie_authority),
-      repeat_enabled(repeat_enabled),
-      repeat_timeout(repeat_timeout),
-      repeat_delay(repeat_delay)
-{
-}
-
-void mi::KeyRepeatDispatcher::set_input_device_hub(std::shared_ptr<InputDeviceHub> const& hub)
-{
-    hub->add_observer(std::make_shared<DeviceRemovalFilter>(
-            [this](MirInputDeviceId id)
-            {
-                std::unique_lock<std::mutex> lock(repeat_state_mutex);
-                repeat_state_by_device.erase(id); // destructor cancels alarms
-            }
-            ));
-}
-
-mi::KeyRepeatDispatcher::KeyboardState& mi::KeyRepeatDispatcher::ensure_state_for_device_locked(std::lock_guard<std::mutex> const&, MirInputDeviceId id)
-{
-    repeat_state_by_device.insert(std::make_pair(id, KeyboardState()));
-    return repeat_state_by_device[id];
-}
-
-bool mi::KeyRepeatDispatcher::dispatch(MirEvent const& event)
-{
-    if (!repeat_enabled) // if we made this mutable we'd need a guard
-    {
-	return next_dispatcher->dispatch(event);
-    }
-    
-    if (mir_event_get_type(&event) == mir_event_type_input)
-    {
-        auto iev = mir_event_get_input_event(&event);
-        if (mir_input_event_get_type(iev) != mir_input_event_type_key)
-            return next_dispatcher->dispatch(event);
-        if (!handle_key_input(mir_input_event_get_device_id(iev), mir_input_event_get_keyboard_event(iev)))
-            return next_dispatcher->dispatch(event);
-        else
-            return true;
-    }
-    return next_dispatcher->dispatch(event);
-}
-
-// Returns true if the original event has been handled, that is ::dispatch should not pass it on.
-bool mi::KeyRepeatDispatcher::handle_key_input(MirInputDeviceId id, MirKeyboardEvent const* kev)
-{
-    std::lock_guard<std::mutex> lg(repeat_state_mutex);
-    auto& device_state = ensure_state_for_device_locked(lg, id);
-
-    auto scan_code = mir_keyboard_event_scan_code(kev);
-
-    switch (mir_keyboard_event_action(kev))
-    {
-    case mir_keyboard_action_up:
-    {
-        auto it = device_state.repeat_alarms_by_scancode.find(scan_code);
-        if (it == device_state.repeat_alarms_by_scancode.end())
-        {
-            return false;
-        }
-        device_state.repeat_alarms_by_scancode.erase(it);
-        break;
-    }
-    case mir_keyboard_action_down:
-    {
-        MirKeyboardEvent new_kev = *kev;
-        new_kev.action = mir_keyboard_action_repeat;
-
-        auto it = device_state.repeat_alarms_by_scancode.find(scan_code);
-        if (it != device_state.repeat_alarms_by_scancode.end())
-        {
-            // When we receive a duplicated down we just replace the action
-            next_dispatcher->dispatch(new_kev);
-            return true;
-        }
-        auto& capture_alarm = device_state.repeat_alarms_by_scancode[scan_code];
-        std::shared_ptr<mir::time::Alarm> alarm = alarm_factory->create_alarm([this, &capture_alarm, new_kev]() mutable
-            {
-                std::lock_guard<std::mutex> lg(repeat_state_mutex);
-
-                new_kev.event_time = std::chrono::steady_clock::now().time_since_epoch();
-                auto const cookie = cookie_authority->make_cookie(new_kev.event_time.count());
-                auto const serialized_cookie = cookie->serialize();
-                std::copy_n(std::begin(serialized_cookie), new_kev.cookie.size(), std::begin(new_kev.cookie));
-                next_dispatcher->dispatch(new_kev);
-
-                capture_alarm->reschedule_in(repeat_delay);
-            });
-        alarm->reschedule_in(repeat_timeout);
-        device_state.repeat_alarms_by_scancode[scan_code] = {alarm};
-    }
-    case mir_keyboard_action_repeat:
-        // Should we consume existing repeats?
-        break;
-    default:
-        BOOST_THROW_EXCEPTION(std::logic_error("Unexpected key event action"));
-    }
-    return false;
-}
-
-void mi::KeyRepeatDispatcher::start()
-{
-    next_dispatcher->start();
-}
-
-void mi::KeyRepeatDispatcher::stop()
-{
-    std::lock_guard<std::mutex> lg(repeat_state_mutex);
-    
-    repeat_state_by_device.clear();
-        
-    next_dispatcher->stop();
-}
 
=== removed file 'src/server/input/key_repeat_dispatcher.h'
--- src/server/input/key_repeat_dispatcher.h	2016-03-23 06:39:56 +0000
+++ src/server/input/key_repeat_dispatcher.h	1970-01-01 00:00:00 +0000
@@ -1,84 +0,0 @@
-/*
- * Copyright © 2015-2016 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Robert Carr <[e-mail]>
- */
-
-#ifndef MIR_INPUT_KEY_REPEAT_DISPATCHER_H_
-#define MIR_INPUT_KEY_REPEAT_DISPATCHER_H_
-
-#include "mir/input/input_dispatcher.h"
-#include "mir/input/input_device_observer.h"
-
-#include <memory>
-#include <chrono>
-#include <mutex>
-#include <unordered_map>
-
-namespace mir
-{
-namespace cookie
-{
-class Authority;
-}
-namespace time
-{
-class AlarmFactory;
-class Alarm;
-}
-namespace input
-{
-class InputDeviceHub;
-class KeyRepeatDispatcher : public InputDispatcher
-{
-public:
-    KeyRepeatDispatcher(std::shared_ptr<InputDispatcher> const& next_dispatcher,
-                        std::shared_ptr<time::AlarmFactory> const& factory,
-                        std::shared_ptr<cookie::Authority> const& cookie_authority,
-                        bool repeat_enabled,
-                        std::chrono::milliseconds repeat_timeout, /* timeout before sending first repeat */
-                        std::chrono::milliseconds repeat_delay /* delay between repeated keys */);
-
-    // InputDispatcher
-    bool dispatch(MirEvent const& event) override;
-    void start() override;
-    void stop() override;
-
-    void set_input_device_hub(std::shared_ptr<InputDeviceHub> const& hub);
-
-private:
-    std::mutex repeat_state_mutex;
-
-    std::shared_ptr<InputDispatcher> const next_dispatcher;
-    std::shared_ptr<time::AlarmFactory> const alarm_factory;
-    std::shared_ptr<cookie::Authority> const cookie_authority;
-    bool const repeat_enabled;
-    std::chrono::milliseconds repeat_timeout;
-    std::chrono::milliseconds repeat_delay;
-
-    struct KeyboardState
-    {
-        std::unordered_map<int, std::shared_ptr<mir::time::Alarm>> repeat_alarms_by_scancode;
-    };
-    std::unordered_map<MirInputDeviceId, KeyboardState> repeat_state_by_device;
-    KeyboardState& ensure_state_for_device_locked(std::lock_guard<std::mutex> const&, MirInputDeviceId id);
-
-    bool handle_key_input(MirInputDeviceId id, MirKeyboardEvent const* ev);
-};
-
-}
-}
-
-#endif // MIR_INPUT_KEY_REPEAT_DISPATCHER_H_
 
=== modified file 'tests/include/mir/test/doubles/mock_input_device.h'
--- tests/include/mir/test/doubles/mock_input_device.h	2015-12-18 21:07:54 +0000
+++ tests/include/mir/test/doubles/mock_input_device.h	2016-03-31 19:18:58 +0000
@@ -23,6 +23,7 @@
 #include "mir/input/input_device_info.h" // needed for fake device setup
 #include "mir/input/pointer_settings.h"
 #include "mir/input/touchpad_settings.h"
+#include "mir/input/keyboard_settings.h"
 
 #include <gmock/gmock.h>
 
@@ -44,6 +45,8 @@
     MOCK_METHOD1(apply_settings, void(input::PointerSettings const&));
     MOCK_CONST_METHOD0(get_touchpad_settings, mir::optional_value<input::TouchpadSettings>());
     MOCK_METHOD1(apply_settings, void(input::TouchpadSettings const&));
+    MOCK_CONST_METHOD0(get_keyboard_settings, mir::optional_value<input::KeyboardSettings>());
+    MOCK_METHOD1(apply_settings, void(input::KeyboardSettings const&));
 };
 }
 }
 
=== modified file 'tests/include/mir/test/doubles/mock_x11.h'
--- tests/include/mir/test/doubles/mock_x11.h	2016-03-23 06:39:56 +0000
+++ tests/include/mir/test/doubles/mock_x11.h	2016-03-31 19:18:58 +0000
@@ -22,6 +22,7 @@
 #include <gmock/gmock.h>
 
 #include <X11/Xlib.h>
+#include <X11/XKBlib.h>
 #include <X11/Xutil.h>
 
 namespace mir
@@ -81,6 +82,13 @@
     MOCK_METHOD1(XSetErrorHandler, XErrorHandler(XErrorHandler));
     MOCK_METHOD0(XInitThreads, Status());
     MOCK_METHOD3(XSetWMHints, int(Display*, Window, XWMHints*));
+    MOCK_METHOD3(XChangeKeyboardControl, int(Display*, unsigned long, XKeyboardControl*));
+    MOCK_METHOD2(XGetKeyboardControl, int(Display*, XKeyboardState*));
+    MOCK_METHOD6(XkbQueryExtension, Bool(Display*, int*, int*, int*, int*, int*));
+    MOCK_METHOD3(XkbFreeKeyboard, void(XkbDescPtr, unsigned int, Bool));
+    MOCK_METHOD0(XkbAllocKeyboard, XkbDescPtr());
+    MOCK_METHOD3(XkbGetControls, Status(Display*, unsigned long, XkbDescPtr));
+    MOCK_METHOD3(XkbSetControls, Bool(Display*, unsigned long, XkbDescPtr));
 
     FakeX11Resources fake_x11;
 };
 
=== modified file 'tests/include/mir_test_framework/stub_input_platform.h'
--- tests/include/mir_test_framework/stub_input_platform.h	2016-01-29 08:18:22 +0000
+++ tests/include/mir_test_framework/stub_input_platform.h	2016-03-31 19:18:58 +0000
@@ -26,8 +26,16 @@
 
 namespace mir
 {
+namespace time
+{
+class AlarmFactory;
+class Clock;
+class SteadyTimerFd;
+class SteadyClock;
+}
 namespace dispatch
 {
+class AlarmFactory;
 class ActionQueue;
 class MultiplexingDispatchable;
 }
@@ -53,6 +61,8 @@
     static void remove(std::shared_ptr<mir::input::InputDevice> const& dev);
     static void register_dispatchable(std::shared_ptr<mir::dispatch::Dispatchable> const& queue);
     static void unregister_dispatchable(std::shared_ptr<mir::dispatch::Dispatchable> const& queue);
+    static std::shared_ptr<mir::time::AlarmFactory> get_alarm_factory();
+    static std::shared_ptr<mir::time::Clock> get_clock();
 
 private:
     std::shared_ptr<mir::dispatch::MultiplexingDispatchable> const platform_dispatchable;
@@ -61,6 +71,11 @@
     static std::atomic<StubInputPlatform*> stub_input_platform;
     static std::vector<std::weak_ptr<mir::input::InputDevice>> device_store;
     static std::mutex device_store_guard;
+    static std::shared_ptr<mir::time::SteadyClock> steady_clock;
+    static std::shared_ptr<mir::time::SteadyTimerFd> steady_timer_fd;
+    static std::shared_ptr<mir::dispatch::AlarmFactory> alarm_factory;
+
+
 };
 
 }
 
=== modified file 'tests/mir_test_doubles/mock_input_device.cpp'
--- tests/mir_test_doubles/mock_input_device.cpp	2015-12-18 21:07:54 +0000
+++ tests/mir_test_doubles/mock_input_device.cpp	2016-03-31 19:18:58 +0000
@@ -40,4 +40,12 @@
     else
         ON_CALL(*this, get_touchpad_settings())
             .WillByDefault(Return(mir::optional_value<input::TouchpadSettings>()));
+
+    if (contains(caps, input::DeviceCapability::keyboard))
+        ON_CALL(*this, get_keyboard_settings())
+            .WillByDefault(Return(input::KeyboardSettings()));
+    else
+        ON_CALL(*this, get_keyboard_settings())
+            .WillByDefault(Return(mir::optional_value<input::KeyboardSettings>()));
+
 }
 
=== modified file 'tests/mir_test_doubles/mock_x11.cpp'
--- tests/mir_test_doubles/mock_x11.cpp	2016-03-23 06:39:56 +0000
+++ tests/mir_test_doubles/mock_x11.cpp	2016-03-31 19:18:58 +0000
@@ -195,3 +195,38 @@
 {
     return global_mock->XPending(display);
 }
+
+int XChangeKeyboardControl(Display* display, unsigned long value_mask, XKeyboardControl* control)
+{
+    return global_mock->XChangeKeyboardControl(display, value_mask, control);
+}
+
+int XGetKeyboardControl(Display* display, XKeyboardState* control)
+{
+    return global_mock->XGetKeyboardControl(display, control);
+}
+
+Bool XkbQueryExtension(Display* dpy, int* opcode, int* event_base, int* error_base, int* major, int* minor)
+{
+    return global_mock->XkbQueryExtension(dpy, opcode, event_base, error_base, major, minor);
+}
+
+void XkbFreeKeyboard(XkbDescPtr xkb, unsigned int which, Bool free_desc)
+{
+    global_mock->XkbFreeKeyboard(xkb, which, free_desc);
+}
+
+XkbDescPtr XkbAllocKeyboard()
+{
+    return global_mock->XkbAllocKeyboard();
+}
+
+Status XkbGetControls(Display* dpy, unsigned long which, XkbDescPtr desc)
+{
+    return global_mock->XkbGetControls(dpy, which, desc);
+}
+
+Bool XkbSetControls(Display* dpy, unsigned long which, XkbDescPtr desc)
+{
+    return global_mock->XkbSetControls(dpy, which, desc);
+}
 
=== modified file 'tests/mir_test_framework/fake_input_device_impl.cpp'
--- tests/mir_test_framework/fake_input_device_impl.cpp	2016-03-23 06:39:56 +0000
+++ tests/mir_test_framework/fake_input_device_impl.cpp	2016-03-31 19:18:58 +0000
@@ -24,7 +24,9 @@
 #include "mir/input/input_sink.h"
 #include "mir/input/pointer_settings.h"
 #include "mir/input/touchpad_settings.h"
+#include "mir/input/keyboard_settings.h"
 #include "mir/input/event_builder.h"
+#include "mir/time/clock.h"
 #include "mir/dispatch/action_queue.h"
 #include "mir/geometry/displacement.h"
 #include "src/platforms/evdev/button_utils.h"
@@ -41,7 +43,9 @@
 namespace mtf = mir_test_framework;
 
 mtf::FakeInputDeviceImpl::FakeInputDeviceImpl(mi::InputDeviceInfo const& info)
-    : queue{std::make_shared<md::ActionQueue>()}, device{std::make_shared<InputDevice>(info, queue)}
+    : queue{std::make_shared<md::ActionQueue>()},
+      device{std::make_shared<InputDevice>(
+          info, queue, mtf::StubInputPlatform::get_clock(), mtf::StubInputPlatform::get_alarm_factory())}
 {
     mtf::StubInputPlatform::add(device);
 }
@@ -92,24 +96,31 @@
 }
 
 mtf::FakeInputDeviceImpl::InputDevice::InputDevice(mi::InputDeviceInfo const& info,
-                                                   std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchable)
-    : info(info), queue{dispatchable}, buttons{0}
+                                                   std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchable,
+                                                   std::shared_ptr<mir::time::Clock> const& clock,
+                                                   std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory)
+    : info(info), queue{dispatchable}, clock{clock}, buttons{0}, repeater{alarm_factory, [this](auto key_code) {
+    this->handle_repeat(key_code);}}
 {
-    // the default setup results in a direct mapping of input velocity to output velocity.
-    settings.acceleration = mir_pointer_acceleration_none;
-    settings.cursor_acceleration_bias = 0.0;
+        // the default setup results in a direct mapping of input velocity to output velocity.
+        settings.acceleration = mir_pointer_acceleration_none;
+        settings.cursor_acceleration_bias = 0.0;
 }
 
 void mtf::FakeInputDeviceImpl::InputDevice::synthesize_events(synthesis::KeyParameters const& key_params)
 {
     xkb_keysym_t key_code = 0;
 
-    auto event_time = std::chrono::duration_cast<std::chrono::nanoseconds>(
-        std::chrono::steady_clock::now().time_since_epoch());
+    auto const event_time = clock->now().time_since_epoch();
 
     auto input_action =
         (key_params.action == synthesis::EventAction::Down) ? mir_keyboard_action_down : mir_keyboard_action_up;
 
+    if (input_action == mir_keyboard_action_down)
+        repeater.press(key_params.scancode);
+    else
+        repeater.release(key_params.scancode);
+
     auto key_event = builder->key_event(event_time, input_action, key_code, key_params.scancode);
 
     if (!sink)
@@ -119,8 +130,7 @@
 
 void mtf::FakeInputDeviceImpl::InputDevice::synthesize_events(synthesis::ButtonParameters const& button)
 {
-    auto event_time = std::chrono::duration_cast<std::chrono::nanoseconds>(
-        std::chrono::steady_clock::now().time_since_epoch());
+    auto const event_time = clock->now().time_since_epoch();
     auto action = update_buttons(button.action, mie::to_pointer_button(button.button, settings.handedness));
     auto button_event = builder->pointer_event(event_time,
                                                action,
@@ -154,8 +164,7 @@
     if (!sink)
         BOOST_THROW_EXCEPTION(std::runtime_error("Device is not started."));
 
-    auto event_time = std::chrono::duration_cast<std::chrono::nanoseconds>(
-        std::chrono::steady_clock::now().time_since_epoch());
+    auto const event_time = clock->now().time_since_epoch();
     // constant scaling is used here to simplify checking for the
     // expected results. Default settings of the device lead to no
     // scaling at all.
@@ -179,8 +188,7 @@
     if (!sink)
         BOOST_THROW_EXCEPTION(std::runtime_error("Device is not started."));
 
-    auto event_time = std::chrono::duration_cast<std::chrono::nanoseconds>(
-        std::chrono::steady_clock::now().time_since_epoch());
+    auto const event_time = clock->now().time_since_epoch();
 
     auto touch_event = builder->touch_event(event_time);
 
@@ -247,6 +255,29 @@
     // forwards already interpreted events.
 }
 
+mir::optional_value<mi::KeyboardSettings> mtf::FakeInputDeviceImpl::InputDevice::get_keyboard_settings() const
+{
+    if (!contains(info.capabilities, mi::DeviceCapability::keyboard))
+        return {};
+    mi::KeyboardSettings settings;
+
+    settings.repeat_enabled = repeater.enabled();
+    settings.repeat_delay = repeater.delay();
+    settings.repeat_interval = repeater.interval();
+    return settings;
+}
+
+void mtf::FakeInputDeviceImpl::InputDevice::apply_settings(mi::KeyboardSettings const& settings)
+{
+    if (!contains(info.capabilities, mi::DeviceCapability::keyboard))
+        return;
+
+    if (settings.repeat_enabled)
+        repeater.enable(settings.repeat_delay, settings.repeat_interval);
+    else
+        repeater.disable();
+}
+
 void mtf::FakeInputDeviceImpl::InputDevice::map_touch_coordinates(float& x, float& y)
 {
     // TODO take orientation of input sink into account?
@@ -258,6 +289,15 @@
     y = (y - float(FakeInputDevice::minimum_touch_axis_value))*y_scale + area.top_left.y.as_float();
 }
 
+void mtf::FakeInputDeviceImpl::InputDevice::handle_repeat(int32_t code)
+{
+    if (!sink)
+        BOOST_THROW_EXCEPTION(std::runtime_error("Device is not started."));
+    auto const event_time = clock->now().time_since_epoch();
+    auto key_event = builder->key_event(event_time, mir_keyboard_action_repeat, 0, code);
+    sink->handle_input(*key_event);
+}
+
 void mtf::FakeInputDeviceImpl::InputDevice::start(mi::InputSink* destination, mi::EventBuilder* event_builder)
 {
     sink = destination;
 
=== modified file 'tests/mir_test_framework/fake_input_device_impl.h'
--- tests/mir_test_framework/fake_input_device_impl.h	2016-03-23 06:39:56 +0000
+++ tests/mir_test_framework/fake_input_device_impl.h	2016-03-31 19:18:58 +0000
@@ -20,6 +20,7 @@
 #define MIR_TEST_FRAMEWORK_FAKE_INPUT_DEVICE_IMPL_H_
 
 #include "mir_test_framework/fake_input_device.h"
+#include "src/platforms/evdev/key_repeater.h"
 
 #include "mir/input/input_device.h"
 #include "mir/input/pointer_settings.h"
@@ -28,6 +29,11 @@
 
 namespace mir
 {
+namespace time
+{
+class Clock;
+class AlarmFactory;
+}
 namespace dispatch
 {
 class ActionQueue;
@@ -52,7 +58,10 @@
     {
     public:
         InputDevice(mir::input::InputDeviceInfo const& info,
-                    std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchable);
+                    std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchable,
+                    std::shared_ptr<mir::time::Clock> const& clock,
+                    std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory
+                    );
 
         void start(mir::input::InputSink* destination, mir::input::EventBuilder* builder) override;
         void stop() override;
@@ -70,19 +79,24 @@
         void apply_settings(mir::input::PointerSettings const& settings) override;
         mir::optional_value<mir::input::TouchpadSettings> get_touchpad_settings() const override;
         void apply_settings(mir::input::TouchpadSettings const& settings) override;
+        mir::optional_value<mir::input::KeyboardSettings> get_keyboard_settings() const override;
+        void apply_settings(mir::input::KeyboardSettings const& settings) override;
 
     private:
         MirPointerAction update_buttons(synthesis::EventAction action, MirPointerButton button);
         void update_position(int rel_x, int rel_y);
         void map_touch_coordinates(float& x, float& y);
+        void handle_repeat(int32_t code);
 
         mir::input::InputSink* sink{nullptr};
         mir::input::EventBuilder* builder{nullptr};
         mir::input::InputDeviceInfo info;
         std::shared_ptr<mir::dispatch::Dispatchable> const queue;
+        std::shared_ptr<mir::time::Clock> const clock;
         mir::geometry::Point pos, scroll;
         MirPointerButtons buttons;
         mir::input::PointerSettings settings;
+        mir::input::evdev::KeyRepeater repeater;
     };
     std::shared_ptr<mir::dispatch::ActionQueue> queue;
     std::shared_ptr<InputDevice> device;
 
=== modified file 'tests/mir_test_framework/stub_input_platform.cpp'
--- tests/mir_test_framework/stub_input_platform.cpp	2016-03-23 06:39:56 +0000
+++ tests/mir_test_framework/stub_input_platform.cpp	2016-03-31 19:18:58 +0000
@@ -19,7 +19,10 @@
 #include "mir_test_framework/stub_input_platform.h"
 
 #include "mir/input/input_device_registry.h"
+#include "mir/time/steady_timer_fd.h"
+#include "mir/time/steady_clock.h"
 #include "mir/dispatch/action_queue.h"
+#include "mir/dispatch/alarm_factory.h"
 #include "mir/dispatch/multiplexing_dispatchable.h"
 #include "mir/module_deleter.h"
 
@@ -27,6 +30,8 @@
 
 namespace mtf = mir_test_framework;
 namespace mi = mir::input;
+namespace md = mir::dispatch;
+namespace mt = mir::time;
 
 mtf::StubInputPlatform::StubInputPlatform(
     std::shared_ptr<mi::InputDeviceRegistry> const& input_device_registry)
@@ -36,10 +41,12 @@
 {
     stub_input_platform = this;
     platform_dispatchable->add_watch(platform_queue);
+    platform_dispatchable->add_watch(alarm_factory);
 }
 
 mtf::StubInputPlatform::~StubInputPlatform()
 {
+    platform_dispatchable->remove_watch(alarm_factory);
     std::lock_guard<decltype(device_store_guard)> lk{device_store_guard};
     device_store.clear();
     stub_input_platform = nullptr;
@@ -128,6 +135,20 @@
     input_platform->platform_dispatchable->remove_watch(queue);
 }
 
+std::shared_ptr<mt::AlarmFactory> mtf::StubInputPlatform::get_alarm_factory()
+{
+    return alarm_factory;
+}
+
+std::shared_ptr<mt::Clock> mtf::StubInputPlatform::get_clock()
+{
+    return steady_clock;
+}
+
+std::shared_ptr<mt::SteadyClock> mtf::StubInputPlatform::steady_clock{std::make_shared<mt::SteadyClock>()};
+std::shared_ptr<mt::SteadyTimerFd> mtf::StubInputPlatform::steady_timer_fd{std::make_shared<mt::SteadyTimerFd>()};
+std::shared_ptr<md::AlarmFactory> mtf::StubInputPlatform::alarm_factory{
+    std::make_shared<md::AlarmFactory>(mtf::StubInputPlatform::steady_clock, mtf::StubInputPlatform::steady_timer_fd)};
 std::atomic<mtf::StubInputPlatform*> mtf::StubInputPlatform::stub_input_platform{nullptr};
 std::vector<std::weak_ptr<mir::input::InputDevice>> mtf::StubInputPlatform::device_store;
 std::mutex mtf::StubInputPlatform::device_store_guard;
 
=== modified file 'tests/unit-tests/input/CMakeLists.txt'
--- tests/unit-tests/input/CMakeLists.txt	2016-03-31 19:18:58 +0000
+++ tests/unit-tests/input/CMakeLists.txt	2016-03-31 19:18:58 +0000
@@ -14,7 +14,6 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_default_input_manager.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_surface_input_dispatcher.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_seat_input_device_tracker.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_key_repeat_dispatcher.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_key_repeater.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_validator.cpp
 )
 
=== modified file 'tests/unit-tests/input/evdev/test_evdev_device_detection.cpp'
--- tests/unit-tests/input/evdev/test_evdev_device_detection.cpp	2016-03-23 06:39:56 +0000
+++ tests/unit-tests/input/evdev/test_evdev_device_detection.cpp	2016-03-31 19:18:58 +0000
@@ -22,13 +22,18 @@
 #include "src/platforms/evdev/libinput_device.h"
 #include "src/server/report/null_report_factory.h"
 
+#include "mir/test/doubles/mock_alarm_factory.h"
+#include "mir/test/doubles/advanceable_clock.h"
 #include "mir_test_framework/libinput_environment.h"
+#include "mir/test/fake_shared.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <tuple>
 
 namespace mtf = mir_test_framework;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
 namespace mi = mir::input;
 namespace mie = mi::evdev;
 
@@ -44,7 +49,9 @@
     udev* ctx = reinterpret_cast<udev*>(1);
     auto dev = env.setup_device(std::get<0>(param));
     std::shared_ptr<libinput> lib = mie::make_libinput(ctx);
-    mie::LibInputDevice device(mir::report::null_input_report(), mie::make_libinput_device(lib, dev));
+    ::testing::NiceMock<mtd::MockAlarmFactory> mock_alarm_factory;
+    mtd::AdvanceableClock clock;
+    mie::LibInputDevice device(mir::report::null_input_report(), mie::make_libinput_device(lib, dev), mt::fake_shared(mock_alarm_factory), mt::fake_shared(clock));
     auto info = device.get_device_info();
     EXPECT_THAT(info.capabilities, Eq(std::get<1>(param)));
 }
 
=== modified file 'tests/unit-tests/input/evdev/test_libinput_device.cpp'
--- tests/unit-tests/input/evdev/test_libinput_device.cpp	2016-03-23 06:39:56 +0000
+++ tests/unit-tests/input/evdev/test_libinput_device.cpp	2016-03-31 19:18:58 +0000
@@ -25,12 +25,16 @@
 #include "mir/input/input_sink.h"
 #include "mir/input/pointer_settings.h"
 #include "mir/input/touchpad_settings.h"
+#include "mir/input/keyboard_settings.h"
 #include "mir/flags.h"
 #include "mir/geometry/point.h"
 #include "mir/geometry/rectangle.h"
 #include "mir/test/event_matchers.h"
 #include "mir/test/doubles/mock_libinput.h"
+#include "mir/test/doubles/fake_alarm_factory.h"
+#include "mir/test/doubles/advanceable_clock.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"
@@ -60,6 +64,7 @@
 };
 
 using namespace ::testing;
+using namespace std::chrono_literals;
 
 struct MockInputSink : mi::InputSink
 {
@@ -124,6 +129,8 @@
 struct LibInputDevice : public ::testing::Test
 {
     mtf::LibInputEnvironment env;
+    mtd::AdvanceableClock clock;
+    mtd::FakeAlarmFactory alarm_factory;
     ::testing::NiceMock<MockInputSink> mock_sink;
     ::testing::NiceMock<MockEventBuilder> mock_builder;
     std::shared_ptr<libinput> lib;
@@ -243,33 +250,33 @@
 struct LibInputDeviceOnLaptopKeyboard : public LibInputDevice
 {
     libinput_device*const fake_device = setup_laptop_keyboard();
-    mie::LibInputDevice keyboard{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device)};
+    mie::LibInputDevice keyboard{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device), mt::fake_shared(alarm_factory), mt::fake_shared(clock)};
 };
 
 struct LibInputDeviceOnMouse : public LibInputDevice
 {
     libinput_device*const fake_device = setup_mouse();
-    mie::LibInputDevice mouse{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device)};
+    mie::LibInputDevice mouse{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device), mt::fake_shared(alarm_factory), mt::fake_shared(clock)};
 };
 
 struct LibInputDeviceOnLaptopKeyboardAndMouse : public LibInputDevice
 {
     libinput_device*const fake_device = setup_mouse();
     libinput_device*const fake_device_2 = setup_laptop_keyboard();
-    mie::LibInputDevice keyboard{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device_2)};
-    mie::LibInputDevice mouse{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device)};
+    mie::LibInputDevice keyboard{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device_2), mt::fake_shared(alarm_factory), mt::fake_shared(clock)};
+    mie::LibInputDevice mouse{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device), mt::fake_shared(alarm_factory), mt::fake_shared(clock)};
 };
 
 struct LibInputDeviceOnTouchScreen : public LibInputDevice
 {
     libinput_device*const fake_device = setup_touchscreen();
-    mie::LibInputDevice touch_screen{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device)};
+    mie::LibInputDevice touch_screen{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device), mt::fake_shared(alarm_factory), mt::fake_shared(clock)};
 };
 
 struct LibInputDeviceOnTouchpad : public LibInputDevice
 {
     libinput_device*const fake_device = setup_touchpad();
-    mie::LibInputDevice touchpad{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device)};
+    mie::LibInputDevice touchpad{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device), mt::fake_shared(alarm_factory), mt::fake_shared(clock)};
 };
 }
 
@@ -284,7 +291,7 @@
         .Times(1);
 
     mie::LibInputDevice dev(mir::report::null_input_report(),
-                            mie::make_libinput_device(lib, fake_device));
+                            mie::make_libinput_device(lib, fake_device), mt::fake_shared(alarm_factory), mt::fake_shared(clock));
     dev.start(&mock_sink, &mock_builder);
 }
 
@@ -299,7 +306,7 @@
     EXPECT_CALL(env.mock_libinput, libinput_device_ref(second_fake_device)).Times(1);
 
     mie::LibInputDevice dev(mir::report::null_input_report(),
-                            mie::make_libinput_device(lib, fake_device));
+                            mie::make_libinput_device(lib, fake_device), mt::fake_shared(alarm_factory), mt::fake_shared(clock));
     dev.add_device_of_group(mie::make_libinput_device(lib, second_fake_device));
     dev.start(&mock_sink, &mock_builder);
 }
@@ -310,7 +317,7 @@
     auto second_fake_device = setup_trackpad();
 
     mie::LibInputDevice dev(mir::report::null_input_report(),
-                            mie::make_libinput_device(lib, fake_device));
+                            mie::make_libinput_device(lib, fake_device), mt::fake_shared(alarm_factory), mt::fake_shared(clock));
     dev.add_device_of_group(mie::make_libinput_device(lib, second_fake_device));
     auto info = dev.get_device_info();
 
@@ -327,7 +334,7 @@
     EXPECT_CALL(env.mock_libinput, libinput_device_unref(fake_device))
         .Times(1);
 
-    mie::LibInputDevice dev(mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device));
+    mie::LibInputDevice dev(mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device), mt::fake_shared(alarm_factory), mt::fake_shared(clock));
 }
 
 TEST_F(LibInputDeviceOnLaptopKeyboard, process_event_converts_key_event)
@@ -343,6 +350,31 @@
     process_events(keyboard);
 }
 
+TEST_F(LibInputDeviceOnLaptopKeyboard, key_press_triggers_repeat)
+{
+    mi::KeyboardSettings keyboard_settings;
+    keyboard_settings.repeat_delay = 600ms;
+    keyboard_settings.repeat_interval = 200ms;
+    std::function<void()> timer_callback;
+
+    EXPECT_CALL(mock_sink, handle_input(AllOf(
+                mt::KeyOfScanCode(KEY_A),
+                mt::KeyDownEvent())))
+        .Times(1);
+    EXPECT_CALL(mock_sink, handle_input(AllOf(
+                mt::KeyOfScanCode(KEY_A),
+                mt::KeyRepeatEvent())))
+        .Times(2);
+
+    keyboard.start(&mock_sink, &mock_builder);
+    keyboard.apply_settings(keyboard_settings);
+    env.mock_libinput.setup_key_event(fake_device, event_time_1, KEY_A, LIBINPUT_KEY_STATE_PRESSED);
+    process_events(keyboard);
+
+    alarm_factory.advance_by(601ms);
+    alarm_factory.advance_by(201ms);
+}
+
 TEST_F(LibInputDeviceOnLaptopKeyboard, process_event_accumulates_key_state)
 {
     InSequence seq;
 
=== modified file 'tests/unit-tests/input/test_default_device.cpp'
--- tests/unit-tests/input/test_default_device.cpp	2016-03-23 06:39:56 +0000
+++ tests/unit-tests/input/test_default_device.cpp	2016-03-31 19:18:58 +0000
@@ -21,54 +21,23 @@
 #include "mir/input/touchpad_configuration.h"
 #include "mir/input/pointer_configuration.h"
 #include "mir/dispatch/action_queue.h"
+#include "mir/test/doubles/mock_input_device.h"
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <stdexcept>
 
 namespace mi = mir::input;
+namespace mtd = mir::test::doubles;
 namespace md = mir::dispatch;
 using namespace ::testing;
 namespace
 {
-struct MockInputDevice : public mi::InputDevice
-{
-    MOCK_METHOD2(start, void(mi::InputSink* destination, mi::EventBuilder* builder));
-    MOCK_METHOD0(stop, void());
-    MOCK_METHOD0(get_device_info, mi::InputDeviceInfo());
-    MOCK_CONST_METHOD0(get_pointer_settings, mir::optional_value<mi::PointerSettings>());
-    MOCK_METHOD1(apply_settings, void(mi::PointerSettings const&));
-    MOCK_CONST_METHOD0(get_touchpad_settings, mir::optional_value<mi::TouchpadSettings>());
-    MOCK_METHOD1(apply_settings, void(mi::TouchpadSettings const&));
-};
-
 struct DefaultDevice : Test
 {
-    NiceMock<MockInputDevice> touchpad;
-    NiceMock<MockInputDevice> mouse;
-    NiceMock<MockInputDevice> keyboard;
+    NiceMock<mtd::MockInputDevice> touchpad{"name", "unique", mi::DeviceCapability::touchpad|mi::DeviceCapability::pointer};
+    NiceMock<mtd::MockInputDevice> mouse{"name", "unique", mi::DeviceCapability::pointer};
+    NiceMock<mtd::MockInputDevice> keyboard{"name", "unique", mi::DeviceCapability::keyboard};
     std::shared_ptr<md::ActionQueue> queue{std::make_shared<md::ActionQueue>()};
-
-    DefaultDevice()
-    {
-        using optional_pointer_settings = mir::optional_value<mi::PointerSettings>;
-        using optional_touchpad_settings = mir::optional_value<mi::TouchpadSettings>;
-        ON_CALL(touchpad, get_device_info())
-            .WillByDefault(Return(mi::InputDeviceInfo{"name", "unique", mi::DeviceCapability::touchpad|mi::DeviceCapability::pointer}));
-        ON_CALL(touchpad, get_pointer_settings())
-            .WillByDefault(Return(optional_pointer_settings{mi::PointerSettings{}}));
-        ON_CALL(touchpad, get_touchpad_settings())
-            .WillByDefault(Return(optional_touchpad_settings{mi::TouchpadSettings{}}));
-
-        ON_CALL(mouse, get_device_info())
-            .WillByDefault(Return(mi::InputDeviceInfo{"name", "unique", mi::DeviceCapability::pointer}));
-        ON_CALL(mouse, get_pointer_settings()).WillByDefault(Return(optional_pointer_settings{mi::PointerSettings{}}));
-        ON_CALL(mouse, get_touchpad_settings()).WillByDefault(Return(optional_touchpad_settings{}));
-
-        ON_CALL(keyboard, get_device_info())
-            .WillByDefault(Return(mi::InputDeviceInfo{"name", "unique", mi::DeviceCapability::keyboard}));
-        ON_CALL(keyboard, get_pointer_settings()).WillByDefault(Return(optional_pointer_settings{}));
-        ON_CALL(keyboard, get_touchpad_settings()).WillByDefault(Return(optional_touchpad_settings{}));
-    }
 };
 
 }
@@ -91,7 +60,6 @@
     EXPECT_THROW({dev.apply_pointer_configuration(pointer_conf);}, std::invalid_argument);
 }
 
-
 TEST_F(DefaultDevice, accepts_pointer_config_on_mice)
 {
     mi::DefaultDevice dev(MirInputDeviceId{17}, queue, mouse);
@@ -118,6 +86,7 @@
     queue->dispatch(md::FdEvent::readable);
 }
 
+
 TEST_F(DefaultDevice, ensures_cursor_accleration_bias_is_in_range)
 {
     mi::DefaultDevice dev(MirInputDeviceId{17}, queue, touchpad);
 
=== removed file 'tests/unit-tests/input/test_key_repeat_dispatcher.cpp'
--- tests/unit-tests/input/test_key_repeat_dispatcher.cpp	2016-03-23 06:39:56 +0000
+++ tests/unit-tests/input/test_key_repeat_dispatcher.cpp	1970-01-01 00:00:00 +0000
@@ -1,184 +0,0 @@
-/*
- * 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: Robert Carr <[e-mail]>
- */
-
-#include "src/server/input/key_repeat_dispatcher.h"
-
-#include "mir/events/event_private.h"
-#include "mir/events/event_builders.h"
-#include "mir/time/alarm.h"
-#include "mir/time/alarm_factory.h"
-#include "mir/cookie/authority.h"
-#include "mir/input/input_device_observer.h"
-#include "mir/input/pointer_configuration.h"
-#include "mir/input/touchpad_configuration.h"
-#include "mir/input/device.h"
-
-#include "mir/test/fake_shared.h"
-#include "mir/test/event_matchers.h"
-#include "mir/test/doubles/mock_input_dispatcher.h"
-#include "mir/test/doubles/mock_input_device_hub.h"
-
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-namespace mi = mir::input;
-namespace mev = mir::events;
-namespace mt = mir::test;
-namespace mtd = mt::doubles;
-
-using namespace ::testing;
-
-namespace
-{
-struct MockAlarm : public mir::time::Alarm
-{
-    MOCK_METHOD0(cancel, bool());
-    MOCK_CONST_METHOD0(state, mir::time::Alarm::State());
-    MOCK_METHOD1(reschedule_in, bool(std::chrono::milliseconds));
-    MOCK_METHOD1(reschedule_for, bool(mir::time::Timestamp));
-
-    // destructor cancels the alarm
-    ~MockAlarm()
-    {
-        cancel();
-    }
-};
-
-struct MockAlarmFactory : public mir::time::AlarmFactory
-{
-    MOCK_METHOD1(create_alarm_adapter, mir::time::Alarm*(std::function<void()> const&));
-    std::unique_ptr<mir::time::Alarm> create_alarm(std::function<void()> const& cb)
-    {
-        return std::unique_ptr<mir::time::Alarm>(create_alarm_adapter(cb));
-    }
-
-    std::unique_ptr<mir::time::Alarm> create_alarm(std::shared_ptr<mir::LockableCallback> const&)
-    {
-        return nullptr;
-    }
-};
-
-struct StubDevice : public mi::Device
-{
-    MirInputDeviceId device_id;
-    StubDevice(MirInputDeviceId id) : device_id(id) {}
-    MirInputDeviceId id() const { return device_id;}
-    mi::DeviceCapabilities capabilities() const {return mi::DeviceCapability::keyboard;}
-    std::string name() const {return {};}
-    std::string unique_id() const {return {};}
-
-    mir::optional_value<mi::PointerConfiguration> pointer_configuration() const {return {};}
-    void apply_pointer_configuration(mi::PointerConfiguration const&) {;}
-    mir::optional_value<mi::TouchpadConfiguration> touchpad_configuration() const {return {};}
-    void apply_touchpad_configuration(mi::TouchpadConfiguration const&) {}
-};
-
-struct KeyRepeatDispatcher : public testing::Test
-{
-    KeyRepeatDispatcher()
-        : dispatcher(mock_next_dispatcher, mock_alarm_factory, cookie_authority, true, repeat_time, repeat_delay)
-    {
-        ON_CALL(hub,add_observer(_)).WillByDefault(SaveArg<0>(&observer));
-        dispatcher.set_input_device_hub(mt::fake_shared(hub));
-    }
-    void simulate_device_removal()
-    {
-        StubDevice dev(test_device);
-        observer->device_removed(mt::fake_shared(dev));
-        observer->changes_complete();
-    }
-
-    const MirInputDeviceId test_device = 123;
-    std::shared_ptr<mtd::MockInputDispatcher> mock_next_dispatcher = std::make_shared<mtd::MockInputDispatcher>();
-    std::shared_ptr<MockAlarmFactory> mock_alarm_factory = std::make_shared<MockAlarmFactory>();
-    std::shared_ptr<mir::cookie::Authority> cookie_authority = mir::cookie::Authority::create();
-    std::chrono::milliseconds const repeat_time{2};
-    std::chrono::milliseconds const repeat_delay{1};
-    std::shared_ptr<mi::InputDeviceObserver> observer;
-    NiceMock<mtd::MockInputDeviceHub> hub;
-    mi::KeyRepeatDispatcher dispatcher;
-
-    mir::EventUPtr a_key_down_event()
-    {
-        return mev::make_event(test_device, std::chrono::nanoseconds(0), std::vector<uint8_t>{}, mir_keyboard_action_down, 0, 0, mir_input_event_modifier_alt);
-    }
-
-    mir::EventUPtr a_key_up_event()
-    {
-        return mev::make_event(test_device, std::chrono::nanoseconds(0), std::vector<uint8_t>{}, mir_keyboard_action_up, 0, 0, mir_input_event_modifier_alt);
-    }
-};
-}
-
-TEST_F(KeyRepeatDispatcher, forwards_start_stop)
-{
-    InSequence seq;
-    EXPECT_CALL(*mock_next_dispatcher, start()).Times(1);
-    EXPECT_CALL(*mock_next_dispatcher, stop()).Times(1);
-
-    dispatcher.start();
-    dispatcher.stop();
-}
-
-TEST_F(KeyRepeatDispatcher, schedules_alarm_to_repeat_key_down)
-{
-    MockAlarm *mock_alarm = new MockAlarm; // deleted by AlarmFactory
-    std::function<void()> alarm_function;
-
-    InSequence seq;
-    EXPECT_CALL(*mock_alarm_factory, create_alarm_adapter(_)).Times(1).
-        WillOnce(DoAll(SaveArg<0>(&alarm_function), Return(mock_alarm)));
-    // Once for initial down and again when invoked
-    EXPECT_CALL(*mock_alarm, reschedule_in(repeat_time)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(*mock_next_dispatcher, dispatch(mt::KeyDownEvent())).Times(1);
-    EXPECT_CALL(*mock_next_dispatcher, dispatch(mt::KeyRepeatEvent())).Times(1);
-    EXPECT_CALL(*mock_alarm, reschedule_in(repeat_delay)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(*mock_next_dispatcher, dispatch(mt::KeyUpEvent())).Times(1);
-
-    // Schedule the repeat
-    dispatcher.dispatch(*a_key_down_event());
-    // Trigger the repeat
-    alarm_function();
-    // Trigger the cancel
-    dispatcher.dispatch(*a_key_up_event());
-}
-
-TEST_F(KeyRepeatDispatcher, stops_repeat_on_device_removal)
-{
-    MockAlarm *mock_alarm = new MockAlarm;
-    std::function<void()> alarm_function;
-    bool alarm_canceled = false;
-
-    InSequence seq;
-    EXPECT_CALL(*mock_alarm_factory, create_alarm_adapter(_)).Times(1).
-        WillOnce(DoAll(SaveArg<0>(&alarm_function), Return(mock_alarm)));
-    // Once for initial down and again when invoked
-    EXPECT_CALL(*mock_alarm, reschedule_in(repeat_time)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(*mock_next_dispatcher, dispatch(mt::KeyDownEvent())).Times(1);
-    EXPECT_CALL(*mock_next_dispatcher, dispatch(mt::KeyRepeatEvent())).Times(1);
-    EXPECT_CALL(*mock_alarm, reschedule_in(repeat_delay)).Times(1).WillOnce(Return(true));
-    ON_CALL(*mock_alarm, cancel()).WillByDefault(Invoke([&](){alarm_canceled = true; return true;}));
-
-    dispatcher.dispatch(*a_key_down_event());
-
-    alarm_function();
-    Mock::VerifyAndClearExpectations(mock_alarm); // mock_alarm will be deleted after this
-
-    simulate_device_removal();
-    EXPECT_THAT(alarm_canceled, Eq(true));
-}
 
=== modified file 'tests/unit-tests/input/test_x11_platform.cpp'
--- tests/unit-tests/input/test_x11_platform.cpp	2016-03-23 06:39:56 +0000
+++ tests/unit-tests/input/test_x11_platform.cpp	2016-03-31 19:18:58 +0000
@@ -34,12 +34,15 @@
 #include "mir/cookie/authority.h"
 #include "mir/test/event_matchers.h"
 
+#include "mir/input/keyboard_settings.h"
+
 namespace md = mir::dispatch;
 namespace mi = mir::input;
 namespace mt = mir::test;
 namespace mtd = mt::doubles;
 
 using namespace ::testing;
+using namespace std::chrono_literals;
 
 namespace
 {
@@ -245,3 +248,80 @@
 
     process_input_event();
 }
+
+TEST_F(X11PlatformTest, keyboard_device_forwards_x11_repeat_settings)
+{
+    XkbControlsRec ctrls_desc;
+    XkbDescRec xkb_desc;
+    ctrls_desc.repeat_delay = 600;
+    ctrls_desc.repeat_interval = 100;
+    EXPECT_CALL(mock_x11, XGetKeyboardControl(_,_))
+        .WillOnce(Invoke([](Display*, XKeyboardState* state)
+                         {
+                             state->global_auto_repeat = 1;
+                             return 1;
+                         }));
+    EXPECT_CALL(mock_x11, XkbQueryExtension(_,_,_,_,_,_))
+        .WillOnce(Return(1));
+    EXPECT_CALL(mock_x11, XkbAllocKeyboard())
+        .WillOnce(Return(&xkb_desc));
+    EXPECT_CALL(mock_x11, XkbGetControls(_,XkbRepeatKeysMask, &xkb_desc))
+        .WillOnce(Invoke([&](Display*, int, XkbDescPtr)
+                         {
+                             xkb_desc.ctrls = &ctrls_desc;
+                             return 1;
+                         }));
+    EXPECT_CALL(mock_x11, XkbFreeKeyboard(&xkb_desc, _, _));
+
+
+    capture_devices(); x11_platform.start();
+
+    for (auto const device : devices)
+    {
+        if (contains(device->get_device_info().capabilities,mi::DeviceCapability::keyboard))
+        {
+            auto settings = device->get_keyboard_settings();
+            EXPECT_THAT(settings.value().repeat_enabled, Eq(true));
+            EXPECT_THAT(settings.value().repeat_delay, Eq(600ms));
+            EXPECT_THAT(settings.value().repeat_interval, Eq(100ms));
+        }
+    }
+}
+
+TEST_F(X11PlatformTest, keyboard_device_forwards_settings_to_x11)
+{
+    XkbControlsRec ctrls_desc;
+    XkbDescRec xkb_desc;
+
+    EXPECT_CALL(mock_x11, XChangeKeyboardControl(_, KBAutoRepeatMode,_));
+    EXPECT_CALL(mock_x11, XkbQueryExtension(_,_,_,_,_,_))
+        .WillOnce(Return(1));
+    EXPECT_CALL(mock_x11, XkbAllocKeyboard())
+        .WillOnce(Return(&xkb_desc));
+    EXPECT_CALL(mock_x11, XkbGetControls(_,XkbRepeatKeysMask, &xkb_desc))
+        .WillOnce(Invoke([&](Display*, int, XkbDescPtr)
+                         {
+                             xkb_desc.ctrls = &ctrls_desc;
+                             return 1;
+                         }));
+    EXPECT_CALL(mock_x11, XkbSetControls(_,XkbRepeatKeysMask, &xkb_desc))
+        .WillOnce(Return(1));
+    EXPECT_CALL(mock_x11, XkbFreeKeyboard(&xkb_desc, _, _));
+
+
+    capture_devices(); x11_platform.start();
+
+    for (auto const device : devices)
+    {
+        if (contains(device->get_device_info().capabilities,mi::DeviceCapability::keyboard))
+        {
+            mi::KeyboardSettings settings;
+            settings.repeat_interval = 23ms;
+            settings.repeat_delay = 1000ms;
+            device->apply_settings(settings);
+
+            EXPECT_THAT(ctrls_desc.repeat_delay, Eq(1000));
+            EXPECT_THAT(ctrls_desc.repeat_interval, Eq(23));
+        }
+    }
+}