Merge lp:~andreas-pokorny/mir/fix-1536279 into lp:mir

[Andreas Pokorny]

Clear keystate and keymap on device removal (LP: #1536279)

  A client window may have a "default" keymap configured. So a keystate will be tracked for each keyboard device individually. Switching away from the vt of the mirserver will trigger a removal of all devices, switching back to the server will make those devices reappear.

 If the keystate is not cleared on removal any pressed key will be stuck during a vt switch.

This makes the keymapper in the client behave like the server on device removal.

The keystate gets cleared and when the device reappears and will be used again the default keymap will be used to create a clean keystate again.

Majority of the change is about constructing the test to have a mirserver with a nested server a focused window with a keymap configured followed by a vt switch and key presses..

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

FAILED: Continuous integration, rev:4080
https://mir-jenkins.ubuntu.com/job/mir-ci/3120/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/4188/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/4275
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/4265
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/4265
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/4265
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4215/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4215
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4215/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4215
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4215/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4215
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4215/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4215
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4215/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4215/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:4081
https://mir-jenkins.ubuntu.com/job/mir-ci/3164/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/4245/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/4332
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/4322
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/4322
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/4322
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4272/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4272/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4272/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4272/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4272/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4272/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:4082
https://mir-jenkins.ubuntu.com/job/mir-ci/3167/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/4249/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/4336
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/4326
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/4326
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/4326
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4276/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4276/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4276
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4276/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4276
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4276/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4276
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4276/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4276
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4276/artifact/output/*zip*/output.zip

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

review: Needs Fixing (continuous-integration)

[Andreas Pokorny (andreas-pokorny)]

^ the new test fails, the client does not receive the keymap in the time frame.

review: Needs Fixing

[Andreas Pokorny (andreas-pokorny)]

should be fine now..

review: Abstain

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

PASSED: Continuous integration, rev:4083
https://mir-jenkins.ubuntu.com/job/mir-ci/3173/
Executed test runs:
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-mir/4258
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/4345
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/4335
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/4335
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/4335
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4285
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4285/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4285
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4285/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4285
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4285/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4285
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4285/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4285
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4285/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4285
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4285/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

+ static void for_each_window(std::function<void(MirSurface &surf)> const& fun);

could we use ConnectionSurfaceMap here? (In the future, I think it would be good to remove the system of checking valid surfaces in favor of using the connection-saved map).

Alright by me otherwise.

review: Needs Information

[Andreas Pokorny (andreas-pokorny)]

> + static void for_each_window(std::function<void(MirSurface &surf)> const&
> fun);
>
> could we use ConnectionSurfaceMap here? (In the future, I think it would be
> good to remove the system of checking valid surfaces in favor of using the
> connection-saved map).

ok

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

PASSED: Continuous integration, rev:4085
https://mir-jenkins.ubuntu.com/job/mir-ci/3227/
Executed test runs:
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-mir/4342
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/4429
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/4419
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/4419
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/4419
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4374
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4374/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4374
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4374/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4374
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4374/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4374
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4374/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4374
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4374/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4374
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4374/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

thanks, lgtm

review: Approve

[Alan Griffiths (alan-griffiths)]

SurfaceTrackingShell looks familiar. Is the duplication useful or accidental?

review: Needs Information

[Cemil Azizoglu (cemil-azizoglu)]

LGTM

review: Approve

[Andreas Pokorny (andreas-pokorny)]

> SurfaceTrackingShell looks familiar. Is the duplication useful or accidental?

I am not sure it can be classified as accidental. And only useful until we discover a general problem...

[Alan Griffiths (alan-griffiths)]

> > SurfaceTrackingShell looks familiar. Is the duplication useful or
> accidental?
>
> I am not sure it can be classified as accidental. And only useful until we
> discover a general problem...

/shrug. But I will block a third copy.

review: Abstain

=== modified file 'src/client/buffer_vault.cpp'
--- src/client/buffer_vault.cpp	2017-01-30 08:13:20 +0000
+++ src/client/buffer_vault.cpp	2017-03-23 16:39:46 +0000
@@ -18,10 +18,10 @@
 
 #include "mir/client_buffer_factory.h"
 #include "mir/client_buffer.h"
+#include "mir/client/surface_map.h"
 #include "buffer_vault.h"
 #include "buffer.h"
 #include "buffer_factory.h"
-#include "surface_map.h"
 #include "mir_protobuf.pb.h"
 #include "protobuf_to_native_buffer.h"
 #include "connection_surface_map.h"

=== modified file 'src/client/connection_surface_map.cpp'
--- src/client/connection_surface_map.cpp	2017-03-14 04:41:33 +0000
+++ src/client/connection_surface_map.cpp	2017-03-23 16:39:46 +0000
@@ -136,3 +136,10 @@
         BOOST_THROW_EXCEPTION(std::runtime_error("could not find render surface"));
 }
 #pragma GCC diagnostic pop
+
+void mcl::ConnectionSurfaceMap::with_all_windows_do(std::function<void(MirWindow*)> const& fn) const
+{
+    std::shared_lock<decltype(stream_guard)> lk(guard);
+    for(auto const& window : surfaces)
+        fn(window.second.get());
+}

=== modified file 'src/client/connection_surface_map.h'
--- src/client/connection_surface_map.h	2017-03-14 04:41:33 +0000
+++ src/client/connection_surface_map.h	2017-03-23 16:39:46 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_CLIENT_CONNECTION_SURFACE_MAP_H_
 #define MIR_CLIENT_CONNECTION_SURFACE_MAP_H_
 
-#include "surface_map.h"
+#include "mir/client/surface_map.h"
 
 #include <shared_mutex>
 #include <unordered_map>
@@ -56,6 +56,7 @@
     void insert(void* render_surface_key, std::shared_ptr<MirRenderSurface> const& render_surface);
     std::shared_ptr<MirRenderSurface> render_surface(void* render_surface_key) const;
 #pragma GCC diagnostic pop
+    void with_all_windows_do(std::function<void(MirWindow*)> const&) const override;
 private:
     std::shared_timed_mutex mutable guard;
     std::unordered_map<frontend::SurfaceId, std::shared_ptr<MirWindow>> surfaces;

=== modified file 'src/client/default_connection_configuration.cpp'
--- src/client/default_connection_configuration.cpp	2017-02-15 14:45:41 +0000
+++ src/client/default_connection_configuration.cpp	2017-03-23 16:39:46 +0000
@@ -118,9 +118,9 @@
 mcl::DefaultConnectionConfiguration::the_input_devices()
 {
     return input_devices(
-        []
+        [this]
         {
-            return std::make_shared<mir::input::InputDevices>();
+            return std::make_shared<mir::input::InputDevices>(the_surface_map());
         });
 }
 

=== modified file 'src/client/input/input_devices.cpp'
--- src/client/input/input_devices.cpp	2017-01-18 02:29:37 +0000
+++ src/client/input/input_devices.cpp	2017-03-23 16:39:46 +0000
@@ -18,19 +18,57 @@
 
 #include "mir/input/input_devices.h"
 #include "mir/input/mir_input_config_serialization.h"
+#include "mir/input/mir_input_config_serialization.h"
+#include "mir/input/xkb_mapper.h"
+#include "../mir_surface.h"
+
+#include <unordered_set>
 
 namespace mi = mir::input;
 
+namespace
+{
+std::unordered_set<MirInputDeviceId> get_removed_devices(MirInputConfig const& old_config, MirInputConfig const& new_config)
+{
+    std::unordered_set<MirInputDeviceId> removed;
+    old_config.for_each(
+        [&new_config, &removed](MirInputDevice const& dev)
+        {
+            if (nullptr == new_config.get_device_config_by_id(dev.id()))
+                removed.insert(dev.id());
+        });
+    return removed;
+}
+}
+
+mi::InputDevices::InputDevices(std::shared_ptr<client::SurfaceMap> const& windows)
+    : windows{windows}
+{
+}
+
 void mi::InputDevices::update_devices(std::string const& config_buffer)
 {
     std::function<void()> stored_callback;
 
+    std::unordered_set<MirInputDeviceId> ids;
     {
+        auto new_configuration = mi::deserialize_input_config(config_buffer);
         std::unique_lock<std::mutex> lock(devices_access);
-        configuration = mi::deserialize_input_config(config_buffer);
+        ids = get_removed_devices(new_configuration, configuration);
+        configuration = new_configuration;
         stored_callback = callback;
     }
 
+    auto window_map = windows.lock();
+    if (window_map)
+        window_map->with_all_windows_do(
+            [&ids](MirWindow* window)
+            {
+                auto keymapper = window->get_keymapper();
+                for (auto const& id : ids)
+                    keymapper->clear_keymap_for_device(id);
+            });
+
     if (stored_callback)
         stored_callback();
 }

=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2017-03-17 15:32:15 +0000
+++ src/client/mir_surface.cpp	2017-03-23 16:39:46 +0000
@@ -838,4 +838,9 @@
     return frame_clock;
 }
 
+std::shared_ptr<mir::input::receiver::XKBMapper> MirSurface::get_keymapper() const
+{
+    return keymapper;
+}
+
 #pragma GCC diagnostic pop

=== modified file 'src/client/mir_surface.h'
--- src/client/mir_surface.h	2017-03-17 15:32:15 +0000
+++ src/client/mir_surface.h	2017-03-23 16:39:46 +0000
@@ -221,6 +221,7 @@
     MirConnection* connection() const;
 
     std::shared_ptr<mir::client::FrameClock> get_frame_clock() const;
+    std::shared_ptr<mir::input::receiver::XKBMapper> get_keymapper() const;
 
 private:
     std::mutex mutable mutex; // Protects all members of *this

=== modified file 'src/client/rpc/mir_protobuf_rpc_channel.cpp'
--- src/client/rpc/mir_protobuf_rpc_channel.cpp	2017-03-17 17:20:09 +0000
+++ src/client/rpc/mir_protobuf_rpc_channel.cpp	2017-03-23 16:39:46 +0000
@@ -19,7 +19,7 @@
 #include "mir_protobuf_rpc_channel.h"
 #include "rpc_report.h"
 
-#include "../surface_map.h"
+#include "mir/client/surface_map.h"
 #include "../buffer.h"
 #include "../presentation_chain.h"
 #include "../buffer_factory.h"

=== renamed file 'src/client/surface_map.h' => 'src/include/client/mir/client/surface_map.h'
--- src/client/surface_map.h	2017-01-18 04:43:15 +0000
+++ src/include/client/mir/client/surface_map.h	2017-03-23 16:39:46 +0000
@@ -43,7 +43,8 @@
     virtual void with_all_streams_do(std::function<void(MirBufferStream*)> const&) const = 0;
     virtual std::shared_ptr<MirBuffer> buffer(int buffer_id) const = 0;
     virtual void insert(int buffer_id, std::shared_ptr<MirBuffer> const& buffer) = 0;
-    virtual void erase(int buffer_id) = 0;  
+    virtual void erase(int buffer_id) = 0;
+    virtual void with_all_windows_do(std::function<void(MirWindow*)> const&) const = 0;
 
 protected:
     virtual ~SurfaceMap() = default;

=== modified file 'src/include/client/mir/input/input_devices.h'
--- src/include/client/mir/input/input_devices.h	2017-01-18 02:29:37 +0000
+++ src/include/client/mir/input/input_devices.h	2017-03-23 16:39:46 +0000
@@ -20,6 +20,7 @@
 #define MIR_INPUT_INPUT_DEVICES_H_
 
 #include "mir/input/mir_input_config.h"
+#include "mir/client/surface_map.h"
 
 #include <mutex>
 #include <string>
@@ -32,11 +33,12 @@
 class InputDevices
 {
 public:
-    InputDevices() = default;
+    InputDevices(std::shared_ptr<client::SurfaceMap> const& windows);
     void update_devices(std::string const& device_buffer);
     MirInputConfig devices();
     void set_change_callback(std::function<void()> const& callback);
 private:
+    std::weak_ptr<client::SurfaceMap> const windows;
     std::mutex devices_access;
     MirInputConfig configuration;
     std::function<void()> callback;

=== modified file 'tests/acceptance-tests/test_nested_input.cpp'
--- tests/acceptance-tests/test_nested_input.cpp	2017-03-23 16:39:46 +0000
+++ tests/acceptance-tests/test_nested_input.cpp	2017-03-23 16:39:46 +0000
@@ -22,6 +22,10 @@
 #include "mir/input/event_filter.h"
 #include "mir/input/composite_event_filter.h"
 #include "mir/input/mir_input_config.h"
+#include "mir/shell/shell_wrapper.h"
+#include "mir/scene/session.h"
+#include "mir/scene/surface.h"
+#include "mir/graphics/event_handler_register.h"
 
 #include "mir_test_framework/fake_input_device.h"
 #include "mir_test_framework/stub_server_platform_factory.h"
@@ -30,6 +34,7 @@
 #include "mir_test_framework/any_surface.h"
 #include "mir/test/doubles/nested_mock_egl.h"
 #include "mir/test/doubles/mock_input_device_observer.h"
+#include "mir/test/doubles/fake_display.h"
 #include "mir/test/event_factory.h"
 #include "mir/test/event_matchers.h"
 #include "mir/test/fake_shared.h"
@@ -48,6 +53,7 @@
 namespace mis = mi::synthesis;
 
 namespace mt = mir::test;
+namespace mg = mir::graphics;
 namespace mtd = mt::doubles;
 namespace mtf = mir_test_framework;
 
@@ -56,6 +62,71 @@
 
 namespace
 {
+
+struct SurfaceTrackingShell : mir::shell::ShellWrapper
+{
+    SurfaceTrackingShell(
+        std::shared_ptr<mir::shell::Shell> wrapped_shell)
+        : ShellWrapper{wrapped_shell}, wrapped_shell{wrapped_shell}
+    {}
+
+    mir::frontend::SurfaceId create_surface(
+        std::shared_ptr<mir::scene::Session> const& session,
+        mir::scene::SurfaceCreationParameters const& params,
+        std::shared_ptr<mir::frontend::EventSink> const& sink) override
+    {
+        auto surface_id = wrapped_shell->create_surface(session, params, sink);
+
+        tracked_surfaces[session->name()] =  TrackedSurface{session, surface_id};
+
+        return surface_id;
+    }
+
+    std::shared_ptr<mir::scene::Surface> get_surface(std::string const& session_name)
+    {
+        if (end(tracked_surfaces) == tracked_surfaces.find(session_name))
+            return nullptr;
+        TrackedSurface & tracked_surface = tracked_surfaces[session_name];
+        auto session = tracked_surface.session.lock();
+        if (!session)
+            return nullptr;
+        return session->surface(tracked_surface.surface);
+    }
+
+    struct TrackedSurface
+    {
+        std::weak_ptr<mir::scene::Session> session;
+        mir::frontend::SurfaceId surface;
+    };
+    std::unordered_map<std::string, TrackedSurface> tracked_surfaces;
+    std::shared_ptr<mir::shell::Shell> wrapped_shell;
+};
+
+struct Display : mtd::FakeDisplay
+{
+    using mtd::FakeDisplay::FakeDisplay;
+
+    void register_pause_resume_handlers(
+                     mg::EventHandlerRegister&,
+                     mg::DisplayPauseHandler const& pause_handler,
+                     mg::DisplayResumeHandler const& resume_handler) override
+    {
+        pause_function = pause_handler;
+        resume_function = resume_handler;
+    }
+
+    void trigger_pause()
+    {
+        pause_function();
+    }
+    void trigger_resume()
+    {
+        resume_function();
+    }
+    std::function<bool()> pause_function{[](){return false;}};
+    std::function<bool()> resume_function{[](){return false;}};
+};
+
 size_t get_index_of(MirInputConfig const* config, std::string const& id)
 {
     for (size_t i = 0, e = mir_input_config_device_count(config);i != e;++i)
@@ -75,11 +146,11 @@
 struct MockEventFilter : public mi::EventFilter
 {
     // Work around GMock wanting to know how to construct MirEvent
-    MOCK_METHOD1(handle, bool(MirEvent const*));
+    MOCK_METHOD1(handle, void(MirEvent const*));
     bool handle(MirEvent const& ev)
     {
         handle(&ev);
-        return true;
+        return false;
     }
 };
 
@@ -94,7 +165,15 @@
                                     std::shared_ptr<MockEventFilter> const& event_filter)
         : mtf::HeadlessNestedServerRunner(connection_string), mock_event_filter{event_filter}
     {
-        server.the_composite_event_filter()->append(mock_event_filter);
+        server.the_composite_event_filter()->prepend(mock_event_filter);
+        server.wrap_shell(
+            [this](std::shared_ptr<mir::shell::Shell> const& wrapped)
+            {
+                surfaces = std::make_shared<SurfaceTrackingShell>(wrapped);
+                return surfaces;
+            });
+
+
         start_server();
     }
     NestedServerWithMockEventFilter(std::string const& connection_string)
@@ -107,14 +186,24 @@
         stop_server();
     }
 
+    std::shared_ptr<mir::scene::Surface> get_surface(std::string const& name)
+    {
+        return surfaces->get_surface(name);
+    }
+    std::shared_ptr<SurfaceTrackingShell> surfaces;
     std::shared_ptr<MockEventFilter> const mock_event_filter;
 };
 
 struct NestedInput : public mtf::HeadlessInProcessServer
 {
+    Display display{display_geometry};
+    NestedInput()
+    {
+        preset_display(mt::fake_shared(display));
+    }
+
     void SetUp()
     {
-        initial_display_layout(display_geometry);
         mtf::HeadlessInProcessServer::SetUp();
     }
 
@@ -143,10 +232,10 @@
 {
 public:
     using UniqueInputConfig = std::unique_ptr<MirInputConfig , void(*)(MirInputConfig const*)>;
-    ExposedSurface(std::string const& connect_string)
+    ExposedSurface(std::string const& connect_string, std::string const& session_name = "ExposedSurface")
     {
         // Ensure the nested server posts a frame
-        connection = mir_connect_sync(connect_string.c_str(), __PRETTY_FUNCTION__);
+        connection = mir_connect_sync(connect_string.c_str(), session_name.c_str());
 
         mir_connection_set_input_config_change_callback(
             connection,
@@ -163,6 +252,8 @@
     }
 
     MOCK_METHOD1(handle_input, void(MirEvent const*));
+    MOCK_METHOD1(handle_device_state, void(MirEvent const*));
+    MOCK_METHOD0(handle_keymap, void());
 
     void handle_window_event(MirWindowEvent const* event)
     {
@@ -177,7 +268,12 @@
             mir_window_focus_state_focused == value)
             focused = true;
 
-        if (exposed && focused)
+        test_and_raise();
+    }
+
+    void test_and_raise()
+    {
+        if (exposed && focused && input_device_state_received)
             ready_to_accept_events.raise();
     }
 
@@ -207,8 +303,17 @@
             client->handle_window_event(window_event);
 
         }
+        if (type == mir_event_type_keymap)
+            client->handle_keymap();
         if (type == mir_event_type_input)
             client->handle_input(ev);
+        if (type == mir_event_type_input_device_state)
+        {
+            client->input_device_state_received = true;
+            client->test_and_raise();
+            client->handle_device_state(ev);
+        }
+
     }
 
     static void null_event_handler(MirWindow*, MirEvent const*, void*) {};
@@ -229,6 +334,7 @@
     MirWindow *window;
     bool exposed{false};
     bool focused{false};
+    bool input_device_state_received = false;
     std::function<void(MirInputConfig const* confg)> input_config{[](MirInputConfig const*){}};
 };
 
@@ -243,15 +349,14 @@
 
     InSequence seq;
     EXPECT_CALL(nested_event_filter, handle(mt::InputDeviceStateEvent()))
-        .WillOnce(DoAll(mt::WakeUp(&devices_ready), Return(true)));
+        .WillOnce(mt::WakeUp(&devices_ready));
     EXPECT_CALL(nested_event_filter, handle(mt::KeyOfScanCode(KEY_A))).
         Times(AtLeast(1)).
-        WillRepeatedly(DoAll(InvokeWithoutArgs(increase_key_a_events), Return(true)));
+        WillRepeatedly(InvokeWithoutArgs(increase_key_a_events));
 
     EXPECT_CALL(nested_event_filter, handle(mt::KeyOfScanCode(KEY_RIGHTSHIFT))).
         Times(2).
-        WillOnce(Return(true)).
-        WillOnce(DoAll(mt::WakeUp(&all_events_received), Return(true)));
+        WillOnce(mt::WakeUp(&all_events_received));
 
     NestedServerWithMockEventFilter nested_mir{new_connection(), mt::fake_shared(nested_event_filter)};
     ExposedSurface client(nested_mir.new_connection());
@@ -348,7 +453,7 @@
         .WillOnce(mt::WakeUp(&client_to_host_event_received));
     EXPECT_CALL(nested_event_filter,
                 handle(mt::DeviceStateWithPressedKeys(std::vector<uint32_t>({KEY_LEFTALT, KEY_TAB}))))
-        .WillOnce(DoAll(mt::WakeUp(&client_to_nested_event_received), Return(true)));
+        .WillOnce(mt::WakeUp(&client_to_nested_event_received));
 
     fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_LEFTALT));
     fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_TAB));
@@ -367,12 +472,12 @@
     mt::Signal devices_ready;
     mt::Signal event_received;
     EXPECT_CALL(nested_event_filter, handle(mt::InputDeviceStateEvent()))
-        .WillOnce(DoAll(mt::WakeUp(&devices_ready), Return(true)));
+        .WillOnce(mt::WakeUp(&devices_ready));
 
     EXPECT_CALL(nested_event_filter,
                 handle(AllOf(mt::PointerEventWithPosition(initial_movement_x, initial_movement_y),
                              mt::PointerEventWithDiff(initial_movement_x, initial_movement_y))))
-        .WillOnce(DoAll(mt::WakeUp(&event_received), Return(true)));
+        .WillOnce(mt::WakeUp(&event_received));
 
     NestedServerWithMockEventFilter nested_mir{new_connection(), mt::fake_shared(nested_event_filter)};
     ExposedSurface client_to_nested_mir(nested_mir.new_connection());
@@ -388,7 +493,7 @@
     EXPECT_CALL(nested_event_filter,
                 handle(AllOf(mt::PointerEventWithPosition(initial_movement_x + second_movement_x, initial_movement_y + second_movement_y),
                              mt::PointerEventWithDiff(second_movement_x, second_movement_y))))
-        .WillOnce(DoAll(mt::WakeUp(&event_received), Return(true)));
+        .WillOnce(mt::WakeUp(&event_received));
 
     fake_mouse->emit_event(mis::a_pointer_event().with_movement(second_movement_x, second_movement_y));
     ASSERT_TRUE(event_received.wait_for(60s));
@@ -410,11 +515,11 @@
 
     EXPECT_CALL(nested_event_filter, handle(
             mt::DeviceStateWithPosition(initial_x, initial_y)))
-        .WillOnce(DoAll(mt::WakeUp(&devices_ready), Return(true)));
+        .WillOnce(mt::WakeUp(&devices_ready));
     EXPECT_CALL(nested_event_filter,
                 handle(AllOf(mt::PointerEventWithPosition(final_x, final_y),
                              mt::PointerEventWithDiff(x[2], y[2]))))
-        .WillOnce(DoAll(mt::WakeUp(&event_received), Return(true)));
+        .WillOnce(mt::WakeUp(&event_received));
 
     NestedServerWithMockEventFilter nested_mir{new_connection(), mt::fake_shared(nested_event_filter)};
     ExposedSurface client_to_nested_mir(nested_mir.new_connection());
@@ -464,3 +569,44 @@
     EXPECT_THAT(mir_pointer_config_get_acceleration_bias(ptr_conf), acceleration_bias);
 }
 
+TEST_F(NestedInput, pressed_keys_on_vt_switch_are_forgotten)
+{
+    mt::Signal keymap_received;
+    mt::Signal devices_ready;
+    mt::Signal initial_keys_received;
+    mt::Signal keys_without_modifier_received;
+    NiceMock<MockEventFilter> nested_event_filter;
+    ON_CALL(nested_event_filter, handle(
+            mt::InputDeviceStateEvent()))
+        .WillByDefault(mt::WakeUp(&devices_ready));
+
+    NestedServerWithMockEventFilter nested_mir{new_connection(), mt::fake_shared(nested_event_filter)};
+    ExposedSurface client_to_nested(nested_mir.new_connection(), "with_keymap");
+
+    ASSERT_TRUE(devices_ready.wait_for(10s));
+    EXPECT_CALL(client_to_nested, handle_keymap())
+        .WillOnce(mt::WakeUp(&keymap_received));
+    EXPECT_CALL(client_to_nested, handle_input(mt::KeyOfScanCode(KEY_RIGHTALT)));
+    EXPECT_CALL(client_to_nested, handle_input(mt::KeyOfScanCode(KEY_RIGHTCTRL)))
+        .WillOnce(mt::WakeUp(&initial_keys_received));
+
+    nested_mir.get_surface("with_keymap")->set_keymap(MirInputDeviceId{0}, "pc105", "de", "", "");
+
+    ASSERT_TRUE(client_to_nested.ready_to_accept_events.wait_for(10s));
+    EXPECT_TRUE(keymap_received.wait_for(10s));
+
+    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_RIGHTALT));
+    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_RIGHTCTRL));
+
+    EXPECT_TRUE(initial_keys_received.wait_for(10s));
+
+    display.trigger_pause();
+    display.trigger_resume();
+
+    EXPECT_CALL(client_to_nested,
+                handle_input(AllOf(mt::KeyOfScanCode(KEY_A), mt::KeyWithModifiers(mir_input_event_modifier_none))))
+        .WillOnce(mt::WakeUp(&keys_without_modifier_received));
+
+    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_A));
+    EXPECT_TRUE(keys_without_modifier_received.wait_for(10s));
+}

=== modified file 'tests/include/mir/test/test_protobuf_client.h'
--- tests/include/mir/test/test_protobuf_client.h	2017-01-18 02:29:37 +0000
+++ tests/include/mir/test/test_protobuf_client.h	2017-03-23 16:39:46 +0000
@@ -33,7 +33,11 @@
 
 namespace mir
 {
-namespace client { namespace rpc {class MirBasicRpcChannel;}}
+namespace client
+{
+class SurfaceMap;
+namespace rpc {class MirBasicRpcChannel;}
+}
 namespace dispatch
 {
 class ThreadedDispatcher;
@@ -49,6 +53,7 @@
     TestProtobufClient(std::string socket_file, int timeout_ms);
 
     std::shared_ptr<doubles::MockRpcReport> rpc_report;
+    std::shared_ptr<mir::client::SurfaceMap> surface_map;
     std::shared_ptr<mir::client::rpc::MirBasicRpcChannel> channel;
     std::shared_ptr<dispatch::ThreadedDispatcher> eventloop;
     mir::client::rpc::DisplayServer display_server;

=== modified file 'tests/mir_test_doubles/test_protobuf_client.cpp'
--- tests/mir_test_doubles/test_protobuf_client.cpp	2017-01-18 02:29:37 +0000
+++ tests/mir_test_doubles/test_protobuf_client.cpp	2017-03-23 16:39:46 +0000
@@ -42,12 +42,13 @@
 
 mir::test::TestProtobufClient::TestProtobufClient(std::string socket_file, int timeout_ms) :
     rpc_report(std::make_shared<testing::NiceMock<doubles::MockRpcReport>>()),
+    surface_map{std::make_shared<mir::client::ConnectionSurfaceMap>()},
     channel(mclr::make_rpc_channel(
         socket_file,
-        std::make_shared<mir::client::ConnectionSurfaceMap>(),
+        surface_map,
         std::make_shared<mir::client::BufferFactory>(),
         std::make_shared<mir::client::DisplayConfiguration>(),
-        std::make_shared<mir::input::InputDevices>(),
+        std::make_shared<mir::input::InputDevices>(surface_map),
         rpc_report,
         std::make_shared<mir::client::LifecycleControl>(),
         std::make_shared<mir::client::AtomicCallback<int32_t>>(),

=== modified file 'tests/unit-tests/client/test_protobuf_rpc_channel.cpp'
--- tests/unit-tests/client/test_protobuf_rpc_channel.cpp	2017-03-10 19:47:57 +0000
+++ tests/unit-tests/client/test_protobuf_rpc_channel.cpp	2017-03-23 16:39:46 +0000
@@ -19,7 +19,6 @@
 #include "src/client/rpc/mir_protobuf_rpc_channel.h"
 #include "src/client/rpc/stream_transport.h"
 #include "src/client/rpc/mir_display_server.h"
-#include "src/client/surface_map.h"
 #include "src/client/display_configuration.h"
 #include "src/client/rpc/null_rpc_report.h"
 #include "src/client/lifecycle_control.h"
@@ -29,6 +28,7 @@
 #include "mir/variable_length_array.h"
 #include "mir_protobuf.pb.h"
 #include "mir_protobuf_wire.pb.h"
+#include "mir/client/surface_map.h"
 #include "mir/input/input_devices.h"
 
 #include "mir/test/doubles/null_client_event_sink.h"
@@ -67,7 +67,9 @@
     MOCK_METHOD2(insert, void(int, std::shared_ptr<mcl::MirBuffer> const&));
     MOCK_METHOD2(insert, void(mir::frontend::BufferStreamId, std::shared_ptr<MirPresentationChain> const&));
     MOCK_METHOD1(erase, void(int));
-}; 
+    MOCK_CONST_METHOD1(with_all_windows_do,
+        void(std::function<void(MirWindow*)> const&));
+};
  
 class StubSurfaceMap : public mcl::SurfaceMap
 {
@@ -96,6 +98,9 @@
     void erase(int) override
     {
     }
+    void with_all_windows_do(std::function<void(MirWindow*)> const&) const override
+    {
+    }
 };
 
 class MockStreamTransport : public mclr::StreamTransport
@@ -235,12 +240,13 @@
     MirProtobufRpcChannelTest()
         : transport{new testing::NiceMock<MockStreamTransport>},
           lifecycle{std::make_shared<mcl::LifecycleControl>()},
+          surface_map{std::make_shared<StubSurfaceMap>()},
           channel{new mclr::MirProtobufRpcChannel{
                   std::unique_ptr<MockStreamTransport>{transport},
-                  std::make_shared<StubSurfaceMap>(),
+                  surface_map,
                   std::make_shared<mcl::BufferFactory>(),
                   std::make_shared<mcl::DisplayConfiguration>(),
-                  std::make_shared<mir::input::InputDevices>(),
+                  std::make_shared<mir::input::InputDevices>(surface_map),
                   std::make_shared<mclr::NullRpcReport>(),
                   lifecycle,
                   std::make_shared<mir::client::PingHandler>(),
@@ -251,6 +257,7 @@
 
     MockStreamTransport* transport;
     std::shared_ptr<mcl::LifecycleControl> lifecycle;
+    std::shared_ptr<mcl::SurfaceMap> surface_map;
     std::shared_ptr<mclr::MirProtobufRpcChannel> channel;
     mtd::MockMirBufferStream stream;
 };
@@ -395,7 +402,7 @@
                   stream_map,
                   std::make_shared<mcl::BufferFactory>(),
                   std::make_shared<mcl::DisplayConfiguration>(),
-                  std::make_shared<mir::input::InputDevices>(),
+                  std::make_shared<mir::input::InputDevices>(stream_map),
                   std::make_shared<mclr::NullRpcReport>(),
                   lifecycle,
                   std::make_shared<mir::client::PingHandler>(),
@@ -745,7 +752,7 @@
                   stream_map,
                   mock_buffer_factory,
                   std::make_shared<mcl::DisplayConfiguration>(),
-                  std::make_shared<mir::input::InputDevices>(),
+                  std::make_shared<mir::input::InputDevices>(stream_map),
                   std::make_shared<mclr::NullRpcReport>(),
                   lifecycle,
                   std::make_shared<mir::client::PingHandler>(),
@@ -780,7 +787,7 @@
                   stream_map,
                   mock_buffer_factory,
                   std::make_shared<mcl::DisplayConfiguration>(),
-                  std::make_shared<mir::input::InputDevices>(),
+                  std::make_shared<mir::input::InputDevices>(stream_map),
                   std::make_shared<mclr::NullRpcReport>(),
                   lifecycle,
                   std::make_shared<mir::client::PingHandler>(),
@@ -813,7 +820,7 @@
                   stream_map,
                   mock_buffer_factory,
                   std::make_shared<mcl::DisplayConfiguration>(),
-                  std::make_shared<mir::input::InputDevices>(),
+                  std::make_shared<mir::input::InputDevices>(stream_map),
                   std::make_shared<mclr::NullRpcReport>(),
                   lifecycle,
                   std::make_shared<mir::client::PingHandler>(),

=== modified file 'tests/unit-tests/frontend/stress_protobuf_communicator.cpp'
--- tests/unit-tests/frontend/stress_protobuf_communicator.cpp	2017-03-20 12:08:08 +0000
+++ tests/unit-tests/frontend/stress_protobuf_communicator.cpp	2017-03-23 16:39:46 +0000
@@ -59,6 +59,7 @@
     StubProtobufClient(std::string socket_file, int timeout_ms);
 
     std::shared_ptr<mir::client::rpc::RpcReport> rpc_report;
+    std::shared_ptr<mir::client::SurfaceMap> surface_map;
     std::shared_ptr<mir::client::rpc::MirBasicRpcChannel> channel;
     mir::client::rpc::DisplayServer display_server;
     mir::protobuf::ConnectParameters connect_parameters;
@@ -162,12 +163,13 @@
     std::string socket_file,
     int timeout_ms) :
     rpc_report(std::make_shared<mir::client::rpc::NullRpcReport>()),
+    surface_map(std::make_shared<mir::client::ConnectionSurfaceMap>()),
     channel(mir::client::rpc::make_rpc_channel(
         socket_file,
-        std::make_shared<mir::client::ConnectionSurfaceMap>(),
+        surface_map,
         std::make_shared<mir::client::BufferFactory>(),
         std::make_shared<mir::client::DisplayConfiguration>(),
-        std::make_shared<mir::input::InputDevices>(),
+        std::make_shared<mir::input::InputDevices>(surface_map),
         rpc_report,
         std::make_shared<mir::client::LifecycleControl>(),
         std::make_shared<mir::client::PingHandler>(),