[PATCH 9/11] ozone: evdev: Add a device event dispatcher that forwards to UI thread

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 "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/devices/input_device.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_injector_evdev.h"
 
 namespace ui {
 
+namespace {
+
+class ForwardingDeviceEventDispatcher : public DeviceEventDispatcherEvdev {

[alexst (slow to review), 2015/01/28 18:35:30]

DeviceEventDispatcherProxy?

+ public:
+  ForwardingDeviceEventDispatcher(
+      scoped_refptr<base::SingleThreadTaskRunner> ui_thread_runner,
+      base::WeakPtr<EventFactoryEvdev> event_factory_evdev)
+      : ui_thread_runner_(ui_thread_runner),
+        event_factory_evdev_(event_factory_evdev) {}
+  ~ForwardingDeviceEventDispatcher() override {}
+
+  // DeviceEventDispatcher:
+  void DispatchKeyEvent(int device_id, unsigned int code, bool down) override {
+    ui_thread_runner_->PostTask(
+        FROM_HERE, base::Bind(&EventFactoryEvdev::DispatchKeyEvent,
+                              event_factory_evdev_, device_id, code, down));
+  }
+
+  void DispatchMouseMoveEvent(int device_id,
+                              const gfx::PointF& location) override {
+    ui_thread_runner_->PostTask(
+        FROM_HERE, base::Bind(&EventFactoryEvdev::DispatchMouseMoveEvent,
+                              event_factory_evdev_, device_id, location));
+  }
+
+  void DispatchMouseButtonEvent(int device_id,
+                                const gfx::PointF& location,
+                                unsigned int button,
+                                bool down,
+                                bool allow_remap) override {
+    ui_thread_runner_->PostTask(
+        FROM_HERE, base::Bind(&EventFactoryEvdev::DispatchMouseButtonEvent,
+                              event_factory_evdev_, device_id, location, button,
+                              down, allow_remap));
+  }
+
+  void DispatchMouseWheelEvent(int device_id,
+                               const gfx::PointF& location,
+                               const gfx::Vector2d& delta) override {
+    ui_thread_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&EventFactoryEvdev::DispatchMouseWheelEvent,
+                   event_factory_evdev_, device_id, location, delta));
+  }
+
+  void DispatchScrollEvent(const ScrollEventParams& params) override {
+    ui_thread_runner_->PostTask(
+        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 DispatchKeyboardDevicesUpdated(
+      const std::vector<KeyboardDevice>& 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(
+        FROM_HERE,
+        base::Bind(&EventFactoryEvdev::DispatchTouchscreenDevicesUpdated,
+                   event_factory_evdev_, devices));
+  }
+  void DispatchMouseDevicesUpdated(
+      const std::vector<InputDevice>& devices) override {
+    ui_thread_runner_->PostTask(
+        FROM_HERE, base::Bind(&EventFactoryEvdev::DispatchMouseDevicesUpdated,
+                              event_factory_evdev_, devices));
+  }
+  void DispatchTouchpadDevicesUpdated(
+      const std::vector<InputDevice>& devices) override {
+    ui_thread_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&EventFactoryEvdev::DispatchTouchpadDevicesUpdated,
+                   event_factory_evdev_, devices));
+  }
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> ui_thread_runner_;
+  base::WeakPtr<EventFactoryEvdev> event_factory_evdev_;
+};
+
+}  // namespace
+
 EventFactoryEvdev::EventFactoryEvdev(CursorDelegateEvdev* cursor,
                                      DeviceManager* device_manager,
                                      KeyboardLayoutEngine* keyboard_layout)
     : last_device_id_(0),
       device_manager_(device_manager),
       dispatch_callback_(
           base::Bind(&EventFactoryEvdev::PostUiEvent, base::Unretained(this))),
       keyboard_(&modifiers_, keyboard_layout, dispatch_callback_),
       cursor_(cursor),
       input_controller_(&keyboard_, &button_map_),
       initialized_(false),
       weak_ptr_factory_(this) {
   DCHECK(device_manager_);
 }
 
 EventFactoryEvdev::~EventFactoryEvdev() {
 }
 
 void EventFactoryEvdev::Init() {
   DCHECK(!initialized_);
 
   // Set up device factory.
-  input_device_factory_.reset(new InputDeviceFactoryEvdev(
-      this, base::ThreadTaskRunnerHandle::Get(), cursor_));
+  scoped_ptr<DeviceEventDispatcherEvdev> dispatcher(
+      new ForwardingDeviceEventDispatcher(base::ThreadTaskRunnerHandle::Get(),
+                                          weak_ptr_factory_.GetWeakPtr()));
+  input_device_factory_.reset(
+      new InputDeviceFactoryEvdev(dispatcher.Pass(), cursor_));
+
   // TODO(spang): This settings interface is really broken. crbug.com/450899
   input_controller_.SetInputDeviceFactory(input_device_factory_.get());
 
   // Scan & monitor devices.
   device_manager_->AddObserver(this);
   device_manager_->ScanDevices(this);
 
   initialized_ = true;
 }
 
@@ skipping 164 matching lines @@
                                                modifiers_.GetModifierFlags(),
                                                /* changed_button_flags */ 0)));
   }
 }
 
 int EventFactoryEvdev::NextDeviceId() {
   return ++last_device_id_;
 }
 
 }  // namespace ui