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

ui/events/ozone/evdev/event_converter_test_util.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 "ui/events/ozone/evdev/event_converter_test_util.h"
+
+#include "ui/events/ozone/device/device_manager.h"
+#include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
+#include "ui/events/ozone/evdev/event_factory_evdev.h"
+
+namespace ui {
+
+namespace {
+
+class TestDeviceManager : public ui::DeviceManager {
+ public:
+  TestDeviceManager() {}
+  ~TestDeviceManager() override {}
+
+  // DeviceManager:
+  void ScanDevices(DeviceEventObserver* observer) override {}
+  void AddObserver(DeviceEventObserver* observer) override {}
+  void RemoveObserver(DeviceEventObserver* observer) override {}
+};
+
+class TestDeviceEventDispatcherEvdev : public DeviceEventDispatcherEvdev {
+ public:
+  TestDeviceEventDispatcherEvdev(EventFactoryEvdev* event_factory_evdev)
+      : event_factory_evdev_(event_factory_evdev) {}
+  ~TestDeviceEventDispatcherEvdev() override {}
+
+  // DeviceEventDispatcher:
+  void DispatchKeyEvent(int device_id, unsigned int code, bool down) override {
+    event_factory_evdev_->DispatchKeyEvent(device_id, code, down);
+  }
+
+  void DispatchMouseMoveEvent(int device_id,
+                              const gfx::PointF& location) override {
+    event_factory_evdev_->DispatchMouseMoveEvent(device_id, location);
+  }
+
+  void DispatchMouseButtonEvent(int device_id,
+                                const gfx::PointF& location,
+                                unsigned int button,
+                                bool down,
+                                bool allow_remap) override {
+    event_factory_evdev_->DispatchMouseButtonEvent(device_id, location, button,
+                                                   down, allow_remap);
+  }
+
+  void DispatchMouseWheelEvent(int device_id,
+                               const gfx::PointF& location,
+                               const gfx::Vector2d& delta) override {
+    event_factory_evdev_->DispatchMouseWheelEvent(device_id, location, delta);
+  }
+
+  void DispatchScrollEvent(const ScrollEventParams& params) override {
+    event_factory_evdev_->DispatchScrollEvent(params);
+  }
+
+  void DispatchTouchEvent(const TouchEventParams& params) override {
+    event_factory_evdev_->DispatchTouchEvent(params);
+  }
+
+  void DispatchKeyboardDevicesUpdated(
+      const std::vector<KeyboardDevice>& devices) override {
+    event_factory_evdev_->DispatchKeyboardDevicesUpdated(devices);
+  }
+  void DispatchTouchscreenDevicesUpdated(
+      const std::vector<TouchscreenDevice>& devices) override {
+    event_factory_evdev_->DispatchTouchscreenDevicesUpdated(devices);
+  }
+  void DispatchMouseDevicesUpdated(
+      const std::vector<InputDevice>& devices) override {
+    event_factory_evdev_->DispatchMouseDevicesUpdated(devices);
+  }
+  void DispatchTouchpadDevicesUpdated(
+      const std::vector<InputDevice>& devices) override {
+    event_factory_evdev_->DispatchTouchpadDevicesUpdated(devices);
+  }
+
+ private:
+  EventFactoryEvdev* event_factory_evdev_;
+};
+
+class TestEventFactoryEvdev : public EventFactoryEvdev {
+ public:
+  TestEventFactoryEvdev(CursorDelegateEvdev* cursor,
+                        DeviceManager* device_manager,
+                        KeyboardLayoutEngine* keyboard_layout_engine,
+                        const EventDispatchCallback& callback)
+      : EventFactoryEvdev(cursor, device_manager, keyboard_layout_engine),
+        callback_(callback) {}
+  ~TestEventFactoryEvdev() override {}
+
+ private:
+  void PostUiEvent(scoped_ptr<Event> event) override {
+    callback_.Run(event.Pass());
+  }
+
+  EventDispatchCallback callback_;
+};
+
+}  // namespace
+
+scoped_ptr<DeviceEventDispatcherEvdev> CreateDeviceEventDispatcherEvdevForTest(
+    EventFactoryEvdev* event_factory) {
+  return make_scoped_ptr(new TestDeviceEventDispatcherEvdev(event_factory));
+}
+
+scoped_ptr<DeviceManager> CreateDeviceManagerForTest() {
+  return make_scoped_ptr(new TestDeviceManager());
+}
+
+scoped_ptr<EventFactoryEvdev> CreateEventFactoryEvdevForTest(
+    CursorDelegateEvdev* cursor,
+    DeviceManager* device_manager,
+    KeyboardLayoutEngine* keyboard_layout_engine,
+    const EventDispatchCallback& callback) {
+  return make_scoped_ptr(new TestEventFactoryEvdev(
+      cursor, device_manager, keyboard_layout_engine, callback));
+}
+
+}  // namespace ui