ozone: evdev: Add gamepad support

ui/events/ozone/evdev/event_factory_evdev.cc

 // Copyright 2014 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 "ui/events/ozone/evdev/event_factory_evdev.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/devices/input_device.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/ozone/device/device_event.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/events/ozone/evdev/cursor_delegate_evdev.h"
 #include "ui/events/ozone/evdev/input_controller_evdev.h"
 #include "ui/events/ozone/evdev/input_device_factory_evdev.h"
 #include "ui/events/ozone/evdev/input_device_factory_evdev_proxy.h"
 #include "ui/events/ozone/evdev/input_injector_evdev.h"
 #include "ui/events/ozone/evdev/touch_evdev_types.h"
+#include "ui/events/ozone/gamepad/gamepad_provider_ozone.h"
 
 namespace ui {
 
 namespace {
 
 // Thread safe dispatcher proxy for EventFactoryEvdev.
 //
 // This is used on the device I/O thread for dispatching to UI.
 class ProxyDeviceEventDispatcher : public DeviceEventDispatcherEvdev {
  public:
@@ skipping 40 matching lines @@
         FROM_HERE, base::Bind(&EventFactoryEvdev::DispatchScrollEvent,
                               event_factory_evdev_, params));
   }
 
   void DispatchTouchEvent(const TouchEventParams& params) override {
     ui_thread_runner_->PostTask(
         FROM_HERE, base::Bind(&EventFactoryEvdev::DispatchTouchEvent,
                               event_factory_evdev_, params));
   }
 
+  void DispatchGamepadEvent(const GamepadEvent& event) override {
+    ui_thread_runner_->PostTask(
+        FROM_HERE, base::Bind(&EventFactoryEvdev::DispatchGamepadEvent,
+                              event_factory_evdev_, event));
+  }
+
   void DispatchKeyboardDevicesUpdated(
       const std::vector<InputDevice>& devices) override {
     ui_thread_runner_->PostTask(
         FROM_HERE,
         base::Bind(&EventFactoryEvdev::DispatchKeyboardDevicesUpdated,
                    event_factory_evdev_, devices));
   }
   void DispatchTouchscreenDevicesUpdated(
       const std::vector<TouchscreenDevice>& devices) override {
     ui_thread_runner_->PostTask(
@@ skipping 19 matching lines @@
         FROM_HERE, base::Bind(&EventFactoryEvdev::DispatchDeviceListsComplete,
                               event_factory_evdev_));
   }
 
   void DispatchStylusStateChanged(StylusState stylus_state) override {
     ui_thread_runner_->PostTask(
         FROM_HERE, base::Bind(&EventFactoryEvdev::DispatchStylusStateChanged,
                               event_factory_evdev_, stylus_state));
   }
 
+  void DispatchGamepadDevicesUpdated(
+      const std::vector<InputDevice>& devices) override {
+    ui_thread_runner_->PostTask(
+        FROM_HERE, base::Bind(&EventFactoryEvdev::DispatchGamepadDevicesUpdated,
+                              event_factory_evdev_, devices));
+  }
+
  private:
   scoped_refptr<base::SingleThreadTaskRunner> ui_thread_runner_;
   base::WeakPtr<EventFactoryEvdev> event_factory_evdev_;
 };
 
 template <typename T>
 gfx::PointF GetTransformedEventLocation(const T& params) {
   float x = params.location.x();
   float y = params.location.y();
 
@@ skipping 17 matching lines @@
   details.radius_y = radius_y;
   return details;
 }
 
 }  // namespace
 
 EventFactoryEvdev::EventFactoryEvdev(CursorDelegateEvdev* cursor,
                                      DeviceManager* device_manager,
                                      KeyboardLayoutEngine* keyboard_layout)
     : device_manager_(device_manager),
+      gamepad_provider_(GamepadProviderOzone::GetInstance()),
       keyboard_(&modifiers_,
                 keyboard_layout,
                 base::Bind(&EventFactoryEvdev::DispatchUiEvent,
                            base::Unretained(this))),
       cursor_(cursor),
       input_controller_(&keyboard_, &button_map_),
       touch_id_generator_(0),
       weak_ptr_factory_(this) {
   DCHECK(device_manager_);
 }
@@ skipping 169 matching lines @@
   touch_event.set_root_location_f(location);
   touch_event.set_source_device_id(params.device_id);
   touch_event.set_pointer_details(details);
   DispatchUiEvent(&touch_event);
 
   if (params.type == ET_TOUCH_RELEASED || params.type == ET_TOUCH_CANCELLED) {
     touch_id_generator_.ReleaseGeneratedID(touch_event.pointer_details().id);
   }
 }
 
+void EventFactoryEvdev::DispatchGamepadEvent(const GamepadEvent& event) {
+  gamepad_provider_->DispatchGamepadEvent(event);
+}
+
 void EventFactoryEvdev::DispatchUiEvent(Event* event) {
   // DispatchEvent takes PlatformEvent which is void*. This function
   // wraps it with the real type.
   DispatchEvent(event);
 }
 
 void EventFactoryEvdev::DispatchKeyboardDevicesUpdated(
     const std::vector<InputDevice>& devices) {
   TRACE_EVENT0("evdev", "EventFactoryEvdev::DispatchKeyboardDevicesUpdated");
   DeviceHotplugEventObserver* observer = DeviceDataManager::GetInstance();
@@ skipping 32 matching lines @@
   DeviceHotplugEventObserver* observer = DeviceDataManager::GetInstance();
   observer->OnDeviceListsComplete();
 }
 
 void EventFactoryEvdev::DispatchStylusStateChanged(StylusState stylus_state) {
   TRACE_EVENT0("evdev", "EventFactoryEvdev::DispatchStylusStateChanged");
   DeviceHotplugEventObserver* observer = DeviceDataManager::GetInstance();
   observer->OnStylusStateChanged(stylus_state);
 };
 
+void EventFactoryEvdev::DispatchGamepadDevicesUpdated(
+    const std::vector<InputDevice>& devices) {
+  TRACE_EVENT0("evdev", "EventFactoryEvdev::DispatchGamepadDevicesUpdated");
+  gamepad_provider_->DispatchGamepadDevicesUpdated(devices);
+}
+
 void EventFactoryEvdev::OnDeviceEvent(const DeviceEvent& event) {
   if (event.device_type() != DeviceEvent::INPUT)
     return;
 
   switch (event.action_type()) {
     case DeviceEvent::ADD:
     case DeviceEvent::CHANGE: {
       TRACE_EVENT1("evdev", "EventFactoryEvdev::OnDeviceAdded", "path",
                    event.path().value());
       input_device_factory_proxy_->AddInputDevice(NextDeviceId(), event.path());
@@ skipping 54 matching lines @@
 
   // Scan & monitor devices.
   device_manager_->AddObserver(this);
   device_manager_->ScanDevices(this);
 
   // Notify device thread that initial scan is done.
   input_device_factory_proxy_->OnStartupScanComplete();
 }
 
 }  // namespace ui