This CL implements the gamepads wayland API. Since js device nodes on linux can be opened multiple …

components/exo/wayland/server.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/exo/wayland/server.h"
 
 #include <grp.h>
 #include <linux/input.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <viewporter-server-protocol.h>
 #include <wayland-server-core.h>
 #include <wayland-server-protocol-core.h>
 
 // Note: core wayland headers need to be included before protocol headers.
 #include <alpha-compositing-unstable-v1-server-protocol.h>  // NOLINT
+#include <gaming-input-unstable-v1-server-protocol.h>       // NOLINT
 #include <remote-shell-unstable-v1-server-protocol.h>       // NOLINT
 #include <secure-output-unstable-v1-server-protocol.h>      // NOLINT
 #include <xdg-shell-unstable-v5-server-protocol.h>          // NOLINT
 #include <vsync-feedback-unstable-v1-server-protocol.h>     // NOLINT
 
 #include <algorithm>
 #include <cstdlib>
 #include <iterator>
 #include <string>
 #include <utility>
 
 #include "ash/common/display/display_info.h"
 #include "ash/common/shell_observer.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/free_deleter.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/exo/buffer.h"
 #include "components/exo/display.h"
+#include "components/exo/gamepad.h"
+#include "components/exo/gamepad_delegate.h"
 #include "components/exo/keyboard.h"
 #include "components/exo/keyboard_delegate.h"
 #include "components/exo/notification_surface.h"
 #include "components/exo/notification_surface_manager.h"
 #include "components/exo/pointer.h"
 #include "components/exo/pointer_delegate.h"
 #include "components/exo/shared_memory.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/sub_surface.h"
 #include "components/exo/surface.h"
@@ skipping 68 matching lines @@
                                  DestroyUserData<T>);
 }
 
 // Convert a timestamp to a time value that can be used when interfacing
 // with wayland. Note that we cast a int64_t value to uint32_t which can
 // potentially overflow.
 uint32_t TimeTicksToMilliseconds(base::TimeTicks ticks) {
   return (ticks - base::TimeTicks()).InMilliseconds();
 }
 
+uint32_t NowInMilliseconds() {
+  return TimeTicksToMilliseconds(base::TimeTicks::Now());
+}
+
 // A property key containing the surface resource that is associated with
 // window. If unset, no surface resource is associated with window.
 DEFINE_SURFACE_PROPERTY_KEY(wl_resource*, kSurfaceResourceKey, nullptr);
 
 // A property key containing a boolean set to true if a viewport is associated
 // with window.
 DEFINE_SURFACE_PROPERTY_KEY(bool, kSurfaceHasViewportKey, false);
 
 // A property key containing a boolean set to true if a security object is
 // associated with window.
@@ skipping 2644 matching lines @@
                             void* data,
                             uint32_t version,
                             uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &zwp_alpha_compositing_v1_interface, 1, id);
 
   wl_resource_set_implementation(resource, &alpha_compositing_implementation,
                                  data, nullptr);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// gaming_input_interface:
+
+// Gamepad delegate class that forwards gamepad events to the client resource.
+class WaylandGamepadDelegate : public GamepadDelegate {
+ public:
+  explicit WaylandGamepadDelegate(wl_resource* gamepad_resource)
+      : gamepad_resource_(gamepad_resource) {}
+
+  // Overridden from GamepadDelegate:
+  void OnGamepadDestroying(Gamepad* gamepad) override { delete this; }
+  bool CanAcceptGamepadEventsForSurface(Surface* surface) const override {
+    wl_resource* surface_resource = GetSurfaceResource(surface);
+    return surface_resource &&
+           wl_resource_get_client(surface_resource) == client();
+  }
+  void OnStateChange(bool connected) override {
+    uint32_t status = connected ? ZWP_GAMEPAD_V1_GAMEPAD_STATE_ON
+                                : ZWP_GAMEPAD_V1_GAMEPAD_STATE_OFF;
+    zwp_gamepad_v1_send_state_change(gamepad_resource_, status);
+    wl_client_flush(client());
+  }
+  void OnAxis(int axis, double value) override {
+    zwp_gamepad_v1_send_axis(gamepad_resource_, NowInMilliseconds(), axis,
+                             wl_fixed_from_double(value));
+  }
+  void OnButton(int button, bool pressed, double value) override {
+    uint32_t state = pressed ? ZWP_GAMEPAD_V1_BUTTON_STATE_PRESSED
+                             : ZWP_GAMEPAD_V1_BUTTON_STATE_RELEASED;
+    zwp_gamepad_v1_send_button(gamepad_resource_, NowInMilliseconds(), button,
+                               state, wl_fixed_from_double(value));
+  }
+  void OnFrame() override {
+    zwp_gamepad_v1_send_frame(gamepad_resource_, NowInMilliseconds());
+    wl_client_flush(client());
+  }
+
+ private:
+  // The client who own this gamepad instance.
+  wl_client* client() const {
+    return wl_resource_get_client(gamepad_resource_);
+  }
+
+  // The gamepad resource associated with the gamepad.
+  wl_resource* const gamepad_resource_;
+
+  DISALLOW_COPY_AND_ASSIGN(WaylandGamepadDelegate);
+};
+
+void gamepad_destroy(wl_client* client, wl_resource* resource) {
+  wl_resource_destroy(resource);
+}
+
+const struct zwp_gamepad_v1_interface gamepad_implementation = {
+    gamepad_destroy};
+
+void gaming_input_get_gamepad(wl_client* client,
+                              wl_resource* resource,
+                              uint32_t id,
+                              wl_resource* seat) {
+  wl_resource* gamepad_resource = wl_resource_create(
+      client, &zwp_gamepad_v1_interface, wl_resource_get_version(resource), id);
+
+  base::Thread* gaming_input_thread = GetUserDataAs<base::Thread>(resource);
+
+  SetImplementation(
+      gamepad_resource, &gamepad_implementation,
+      base::WrapUnique(new Gamepad(new WaylandGamepadDelegate(gamepad_resource),
+                                   gaming_input_thread->task_runner().get())));
+}
+
+const struct zwp_gaming_input_v1_interface gaming_input_implementation = {
+    gaming_input_get_gamepad};
+
+void bind_gaming_input(wl_client* client,
+                       void* data,
+                       uint32_t version,
+                       uint32_t id) {
+  wl_resource* resource =
+      wl_resource_create(client, &zwp_gaming_input_v1_interface, version, id);
+
+  std::unique_ptr<base::Thread> gaming_input_thread(
+      new base::Thread("Exo gaming input polling thread."));
+  gaming_input_thread->StartWithOptions(
+      base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
+
+  SetImplementation(resource, &gaming_input_implementation,
+                    std::move(gaming_input_thread));
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Server, public:
 
 Server::Server(Display* display)
     : display_(display), wl_display_(wl_display_create()) {
   wl_global_create(wl_display_.get(), &wl_compositor_interface,
                    compositor_version, display_, bind_compositor);
   wl_global_create(wl_display_.get(), &wl_shm_interface, 1, display_, bind_shm);
@@ skipping 18 matching lines @@
   wl_global_create(wl_display_.get(), &wl_seat_interface, seat_version,
                    display_, bind_seat);
   wl_global_create(wl_display_.get(), &wp_viewporter_interface, 1, display_,
                    bind_viewporter);
   wl_global_create(wl_display_.get(), &zwp_secure_output_v1_interface, 1,
                    display_, bind_secure_output);
   wl_global_create(wl_display_.get(), &zwp_alpha_compositing_v1_interface, 1,
                    display_, bind_alpha_compositing);
   wl_global_create(wl_display_.get(), &zwp_remote_shell_v1_interface,
                    remote_shell_version, display_, bind_remote_shell);
+  wl_global_create(wl_display_.get(), &zwp_gaming_input_v1_interface, 1,
+                   display_, bind_gaming_input);
 }
 
 Server::~Server() {}
 
 // static
 std::unique_ptr<Server> Server::Create(Display* display) {
   std::unique_ptr<Server> server(new Server(display));
 
   char* runtime_dir = getenv("XDG_RUNTIME_DIR");
   if (!runtime_dir) {
@@ skipping 51 matching lines @@
   DCHECK(event_loop);
   wl_event_loop_dispatch(event_loop, timeout.InMilliseconds());
 }
 
 void Server::Flush() {
   wl_display_flush_clients(wl_display_.get());
 }
 
 }  // namespace wayland
 }  // namespace exo