exo: Implement wayland gamepad support

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 <gamepads-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 <iterator>
 #include <string>
 #include <utility>
 
 #include "ash/common/shell_observer.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/display_info.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/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/exo/buffer.h"
 #include "components/exo/display.h"
+#include "components/exo/gamepads.h"
+#include "components/exo/gamepads_delegate.h"
 #include "components/exo/keyboard.h"
 #include "components/exo/keyboard_delegate.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"
 #include "components/exo/surface_property.h"
 #include "components/exo/touch.h"
@@ skipping 62 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 2521 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);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// zwp_gamepads_v1:
+
+// Gamepads delegate class that forwards gamepad events to the client resource.
+class WaylandGamepadsDelegate : public GamepadsDelegate {
+ public:
+  explicit WaylandGamepadsDelegate(wl_resource* gamepads_resource)
+      : gamepads_resource_(gamepads_resource) {}
+
+  // Overridden from GamepadsDelegate:
+  void OnGamepadsDestroying(Gamepads* gamepads) override { delete this; }
+
+  void OnConnected(int id) override {
+    zwp_gamepads_v1_send_connected(gamepads_resource_, id);
+    wl_client_flush(client());
+  }
+  void OnDisconnected(int id) override {
+    zwp_gamepads_v1_send_disconnected(gamepads_resource_, id);
+    wl_client_flush(client());
+  }
+  void OnAxis(int id, int axis, double value) override {
+    zwp_gamepads_v1_send_axis(gamepads_resource_, NowInMilliseconds(), id,
+                              axis, wl_fixed_from_double(value));
+  }
+  void OnButton(int id, int button, bool pressed, double value) override {
+    zwp_gamepads_v1_send_button(gamepads_resource_, NowInMilliseconds(), id,
+                                button, pressed, wl_fixed_from_double(value));
+  }
+  void OnFrame(int id) override {
+    zwp_gamepads_v1_send_frame(gamepads_resource_, NowInMilliseconds(), id);
+    wl_client_flush(client());
+  }
+
+ private:
+  // The client who own this gamepads instance.
+  wl_client* client() const {
+    return wl_resource_get_client(gamepads_resource_);
+  }
+
+  // The gamepads resource associated with the gamepads.
+  wl_resource* const gamepads_resource_;
+
+  DISALLOW_COPY_AND_ASSIGN(WaylandGamepadsDelegate);
+};
+
+void gamepads_destroy(wl_client* client, wl_resource* resource) {
+  wl_resource_destroy(resource);
+}
+
+const struct zwp_gamepads_v1_interface gamepads_implementation = {
+    gamepads_destroy};
+
+void bind_gamepads(wl_client* client,
+                   void* data,
+                   uint32_t version,
+                   uint32_t id) {
+  wl_resource* resource =
+      wl_resource_create(client, &zwp_gamepads_v1_interface, version, id);
+
+  auto gamepads = new Gamepads(new WaylandGamepadsDelegate(resource));
+  SetImplementation(resource, &gamepads_implementation,
+                    base::WrapUnique(gamepads));
+}
+
 }  // 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_gamepads_v1_interface, 1, display_,
+                   bind_gamepads);
 }
 
 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