Merge lp:~raof/mir/wayland-touch-support into lp:mir

[Chris Halse Rogers]

Wayland: Implement touch support.

This is mostly complete - it does not support touchpoint shape/size, but we only expose wl_seat v5 (as that's the version supported by Xenial's wayland) and the size/shape protocol was added in v6 anyway.

Fixes: https://bugs.launchpad.net/mir/+bug/1718732

=== modified file 'src/server/frontend/wayland/wayland_connector.cpp'
--- src/server/frontend/wayland/wayland_connector.cpp	2017-09-26 16:00:49 +0000
+++ src/server/frontend/wayland/wayland_connector.cpp	2017-09-26 17:51:10 +0000
@@ -158,8 +158,29 @@
 
 struct ClientPrivate
 {
+    ClientPrivate(std::shared_ptr<mf::Session> const& session, mf::Shell& shell)
+        : session{session},
+          shell{&shell}
+    {
+    }
+
+    ~ClientPrivate()
+    {
+        shell->close_session(session);
+        /*
+         * This ensures that further calls to
+         * wl_client_get_destroy_listener(client, &cleanup_private)
+         * - and hence session_for_client(client) - return nullptr.
+         */
+        wl_list_remove(&destroy_listener.link);
+    }
+
     wl_listener destroy_listener;
-    std::shared_ptr<mf::Session> session;
+    std::shared_ptr<mf::Session> const session;
+    /*
+     * This shell is owned by the ClientSessionConstructor, which outlives all clients.
+     */
+    mf::Shell* const shell;
 };
 
 static_assert(
@@ -182,9 +203,10 @@
 {
     auto listener = wl_client_get_destroy_listener(client, &cleanup_private);
 
-    assert(listener && "Client session requested for malformed client");
+    if (listener)
+        return private_from_listener(listener)->session;
 
-    return private_from_listener(listener)->session;
+    return nullptr;
 }
 
 struct ClientSessionConstructor
@@ -220,9 +242,8 @@
         "",
         std::make_shared<WaylandEventSink>([](auto){}));
 
-    auto client_context = new ClientPrivate;
+    auto client_context = new ClientPrivate{session, *construction_context->shell};
     client_context->destroy_listener.notify = &cleanup_private;
-    client_context->session = session;
     wl_client_add_destroy_listener(client, &client_context->destroy_listener);
 }
 
@@ -295,6 +316,19 @@
 
     return buffer;
 }
+
+template<typename Callable>
+auto run_unless(std::shared_ptr<bool> const& condition, Callable&& callable)
+{
+    return
+        [callable = std::move(callable), condition]()
+        {
+            if (*condition)
+                return;
+
+            callable();
+        };
+}
 }
 
 class WlShmBuffer :
@@ -511,7 +545,8 @@
           allocator{allocator},
           executor{executor},
           pending_buffer{nullptr},
-          pending_frames{std::make_shared<std::vector<wl_resource*>>()}
+          pending_frames{std::make_shared<std::vector<wl_resource*>>()},
+          destroyed{std::make_shared<bool>(false)}
     {
         auto session = session_for_client(client);
         mg::BufferProperties const props{
@@ -527,6 +562,13 @@
         stream->allow_framedropping(true);
     }
 
+    ~WlSurface()
+    {
+        *destroyed = true;
+        if (auto session = session_for_client(client))
+            session->destroy_buffer_stream(stream_id);
+    }
+
     void set_resize_handler(std::function<void(geom::Size)> const& handler)
     {
         resize_handler = handler;
@@ -548,6 +590,7 @@
 
     wl_resource* pending_buffer;
     std::shared_ptr<std::vector<wl_resource*>> const pending_frames;
+    std::shared_ptr<bool> const destroyed;
 
     void destroy();
     void attach(std::experimental::optional<wl_resource*> const& buffer, int32_t x, int32_t y);
@@ -620,9 +663,10 @@
         std::shared_ptr<mg::Buffer> mir_buffer;
         auto shm_buffer = wl_shm_buffer_get(pending_buffer);
         auto send_frame_notifications =
-            [executor = executor, frames = pending_frames]()
+            [executor = executor, frames = pending_frames, destroyed = destroyed]()
             {
-                executor->spawn(
+                executor->spawn(run_unless(
+                    destroyed,
                     [frames]()
                     {
                         /*
@@ -639,7 +683,7 @@
                             wl_resource_destroy(frame);
                         }
                         frames->clear();
-                    });
+                    }));
             };
 
         if (shm_buffer)
@@ -745,19 +789,6 @@
 class WlPointer;
 class WlTouch;
 
-template<typename Callable>
-auto run_unless(std::shared_ptr<bool> const& condition, Callable&& callable)
-{
-    return
-        [callable = std::move(callable), condition]()
-        {
-            if (*condition)
-                return;
-
-            callable();
-        };
-}
-
 class WlKeyboard : public wayland::Keyboard
 {
 public:
@@ -1034,8 +1065,81 @@
         *destroyed = true;
     }
 
-    void handle_event(MirInputEvent const* /*event*/, wl_resource* /*target*/)
+    void handle_event(MirInputEvent const* event, wl_resource* target)
     {
+        executor->spawn(run_unless(
+            destroyed,
+            [ev = mcl::Event{mir_input_event_get_event(event)}, target = target, this]()
+            {
+                auto const input_ev = mir_event_get_input_event(ev);
+                auto const touch_ev = mir_input_event_get_touch_event(input_ev);
+
+                for (auto i = 0u; i < mir_touch_event_point_count(touch_ev); ++i)
+                {
+                    auto const touch_id = mir_touch_event_id(touch_ev, i);
+                    auto const action = mir_touch_event_action(touch_ev, i);
+                    auto const x = mir_touch_event_axis_value(
+                        touch_ev,
+                        i,
+                        mir_touch_axis_x);
+                    auto const y = mir_touch_event_axis_value(
+                        touch_ev,
+                        i,
+                        mir_touch_axis_y);
+
+                    switch (action)
+                    {
+                    case mir_touch_action_down:
+                        wl_touch_send_down(
+                            resource,
+                            wl_display_get_serial(wl_client_get_display(client)),
+                            mir_input_event_get_event_time(input_ev) / 1000,
+                            target,
+                            touch_id,
+                            wl_fixed_from_double(x),
+                            wl_fixed_from_double(y));
+                        break;
+                    case mir_touch_action_up:
+                        wl_touch_send_up(
+                            resource,
+                            wl_display_get_serial(wl_client_get_display(client)),
+                            mir_input_event_get_event_time(input_ev) / 1000,
+                            touch_id);
+                        break;
+                    case mir_touch_action_change:
+                        wl_touch_send_motion(
+                            resource,
+                            mir_input_event_get_event_time(input_ev) / 1000,
+                            touch_id,
+                            wl_fixed_from_double(x),
+                            wl_fixed_from_double(y));
+                        break;
+                    case mir_touch_actions:
+                        /*
+                         * We should never receive an event with this action set;
+                         * the only way would be if a *new* action has been added
+                         * to the enum, and this hasn't been updated.
+                         *
+                         * There's nothing to do here, but don't use default: so
+                         * that the compiler will warn if a new enum value is added.
+                         */
+                        break;
+                    }
+                }
+
+                if (mir_touch_event_point_count(touch_ev) > 0)
+                {
+                    /*
+                     * This is mostly paranoia; I assume we won't actually be called
+                     * with an empty touch event.
+                     *
+                     * Regardless, the Wayland protocol requires that there be at least
+                     * one event sent before we send the ending frame, so make that explicit.
+                     */
+                    wl_touch_send_frame(resource);
+                }
+            }
+            ));
     }
 
     // Touch interface
@@ -1158,7 +1262,8 @@
         wl_seat_send_capabilities(
             resource,
             WL_SEAT_CAPABILITY_POINTER |
-            WL_SEAT_CAPABILITY_KEYBOARD);
+            WL_SEAT_CAPABILITY_KEYBOARD |
+            WL_SEAT_CAPABILITY_TOUCH);
         wl_seat_send_name(
             resource,
             "seat0");
@@ -1554,15 +1659,15 @@
                 hide_spec.state = mir_window_state_hidden;
                 shell->modify_surface(session, id, hide_spec);
             });
-
-        auto shim = new DestructionShim{session, shell, surface_id};
-        shim->destruction_listener.notify = &cleanup_surface;
-        wl_resource_add_destroy_listener(
-            resource,
-            &shim->destruction_listener);
-    }
-
-    ~WlShellSurface() override = default;
+    }
+
+    ~WlShellSurface() override
+    {
+        if (auto session = session_for_client(client))
+        {
+            shell->destroy_surface(session, surface_id);
+        }
+    }
 protected:
     void pong(uint32_t /*serial*/) override
     {
@@ -1602,7 +1707,6 @@
 
         auto const session = session_for_client(client);
         shell->modify_surface(session, surface_id, mods);
-
     }
 
     void set_popup(
@@ -1635,38 +1739,6 @@
     {
     }
 private:
-    struct DestructionShim
-    {
-        DestructionShim(
-            std::shared_ptr<mf::Session> const& session,
-            std::shared_ptr<mf::Shell> const& shell,
-            mf::SurfaceId id)
-            : session{session},
-              shell{shell},
-              surface_id{id}
-        {
-        }
-
-        std::shared_ptr<mf::Session> const session;
-        std::shared_ptr<mf::Shell> const shell;
-        mf::SurfaceId const surface_id;
-        wl_listener destruction_listener;
-    };
-
-    static_assert(
-        std::is_standard_layout<DestructionShim>::value,
-        "DestructionShim must be Standard Layout for wl_container_of to be defined behaviour");
-
-    static void cleanup_surface(wl_listener* listener, void*)
-    {
-        DestructionShim* shim;
-        shim = wl_container_of(listener, shim, destruction_listener);
-
-        shim->shell->destroy_surface(shim->session, shim->surface_id);
-
-        delete shim;
-    }
-
     std::shared_ptr<mf::Shell> const shell;
     mf::SurfaceId surface_id;
 };