[PATCH 5/11] ozone: evdev: Replace dispatch callbacks with an interface

ui/events/ozone/evdev/touch_event_converter_evdev_unittest.cc

Index: ui/events/ozone/evdev/touch_event_converter_evdev_unittest.cc
diff --git a/ui/events/ozone/evdev/touch_event_converter_evdev_unittest.cc b/ui/events/ozone/evdev/touch_event_converter_evdev_unittest.cc
index 3a48c2f27e0557351527ca7ecb2b55e51e2dda62..659c1910712e6de9c798b98f0a88caf962b8683b 100644
--- a/ui/events/ozone/evdev/touch_event_converter_evdev_unittest.cc
+++ b/ui/events/ozone/evdev/touch_event_converter_evdev_unittest.cc
@@ -17,6 +17,7 @@
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/devices/device_data_manager.h"
+#include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_source.h"
@@ -38,29 +39,21 @@ namespace ui {
 
 class MockTouchEventConverterEvdev : public TouchEventConverterEvdev {
  public:
-  MockTouchEventConverterEvdev(int fd, base::FilePath path);
+  MockTouchEventConverterEvdev(int fd,
+                               base::FilePath path,
+                               DeviceEventDispatcherEvdev* dispatcher);
   ~MockTouchEventConverterEvdev() override {}
 
   void ConfigureReadMock(struct input_event* queue,
                          long read_this_many,
                          long queue_index);
 
-  unsigned size() { return dispatched_events_.size(); }
-  const TouchEventParams& event(unsigned index) {
-    DCHECK_GT(dispatched_events_.size(), index);
-    return dispatched_events_[index];
-  }
-
   // Actually dispatch the event reader code.
   void ReadNow() {
     OnFileCanReadWithoutBlocking(read_pipe_);
     base::RunLoop().RunUntilIdle();
   }
 
-  void DispatchCallback(const TouchEventParams& params) {
-    dispatched_events_.push_back(params);
-  }
-
   void Initialize(const EventDeviceInfo& device_info) override {}
   bool Reinitialize() override { return true; }
 
@@ -68,20 +61,36 @@ class MockTouchEventConverterEvdev : public TouchEventConverterEvdev {
   int read_pipe_;
   int write_pipe_;
 
-  std::vector<TouchEventParams> dispatched_events_;
-
   DISALLOW_COPY_AND_ASSIGN(MockTouchEventConverterEvdev);
 };
 
-MockTouchEventConverterEvdev::MockTouchEventConverterEvdev(int fd,
-                                                           base::FilePath path)
-    : TouchEventConverterEvdev(
-          fd,
-          path,
-          1,
-          INPUT_DEVICE_UNKNOWN,
-          base::Bind(&MockTouchEventConverterEvdev::DispatchCallback,
-                     base::Unretained(this))) {
+class MockDeviceEventDispatcherEvdev : public DeviceEventDispatcherEvdev {
+ public:
+  MockDeviceEventDispatcherEvdev(
+      const base::Callback<void(const TouchEventParams& params)>& callback)
+      : callback_(callback) {}
+  ~MockDeviceEventDispatcherEvdev() {}
+
+  // DeviceEventDispatcherEvdev:
+  void DispatchKeyEvent(const KeyEventParams& params) override {}
+  void DispatchMouseMoveEvent(const MouseMoveEventParams& params) override {}
+  void DispatchMouseButtonEvent(const MouseButtonEventParams& params) override {
+  }
+  void DispatchMouseWheelEvent(const MouseWheelEventParams& params) override {}
+  void DispatchScrollEvent(const ScrollEventParams& params) override {}
+  void DispatchTouchEvent(const TouchEventParams& params) override {
+    callback_.Run(params);
+  }
+
+ private:
+  base::Callback<void(const TouchEventParams& params)> callback_;
+};
+
+MockTouchEventConverterEvdev::MockTouchEventConverterEvdev(
+    int fd,
+    base::FilePath path,
+    DeviceEventDispatcherEvdev* dispatcher)
+    : TouchEventConverterEvdev(fd, path, 1, INPUT_DEVICE_UNKNOWN, dispatcher) {
   pressure_min_ = 30;
   pressure_max_ = 60;
 
@@ -134,8 +143,11 @@ class TouchEventConverterEvdevTest : public testing::Test {
     // Device creation happens on a worker thread since it may involve blocking
     // operations. Simulate that by creating it before creating a UI message
     // loop.
+    dispatcher_.reset(new ui::MockDeviceEventDispatcherEvdev(
+        base::Bind(&TouchEventConverterEvdevTest::DispatchCallback,
+                   base::Unretained(this))));
     device_ = new ui::MockTouchEventConverterEvdev(
-        events_in_, base::FilePath(kTestDevicePath));
+        events_in_, base::FilePath(kTestDevicePath), dispatcher_.get());
     loop_ = new base::MessageLoopForUI;
 
     ui::DeviceDataManager::CreateInstance();
@@ -148,13 +160,25 @@ class TouchEventConverterEvdevTest : public testing::Test {
 
   ui::MockTouchEventConverterEvdev* device() { return device_; }
 
+  unsigned size() { return dispatched_events_.size(); }
+  const ui::TouchEventParams& dispatched_event(unsigned index) {
+    DCHECK_GT(dispatched_events_.size(), index);
+    return dispatched_events_[index];
+  }
+
  private:
   base::MessageLoop* loop_;
   ui::MockTouchEventConverterEvdev* device_;
+  scoped_ptr<ui::MockDeviceEventDispatcherEvdev> dispatcher_;
 
   int events_out_;
   int events_in_;
 
+  void DispatchCallback(const ui::TouchEventParams& params) {
+    dispatched_events_.push_back(params);
+  }
+  std::vector<ui::TouchEventParams> dispatched_events_;
+
   DISALLOW_COPY_AND_ASSIGN(TouchEventConverterEvdevTest);
 };
 
@@ -172,17 +196,17 @@ TEST_F(TouchEventConverterEvdevTest, TouchDown) {
 
   dev->ConfigureReadMock(mock_kernel_queue, 1, 0);
   dev->ReadNow();
-  EXPECT_EQ(0u, dev->size());
+  EXPECT_EQ(0u, size());
 
   dev->ConfigureReadMock(mock_kernel_queue, 2, 1);
   dev->ReadNow();
-  EXPECT_EQ(0u, dev->size());
+  EXPECT_EQ(0u, size());
 
   dev->ConfigureReadMock(mock_kernel_queue, 3, 3);
   dev->ReadNow();
-  EXPECT_EQ(1u, dev->size());
+  EXPECT_EQ(1u, size());
 
-  ui::TouchEventParams event = dev->event(0);
+  ui::TouchEventParams event = dispatched_event(0);
 
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, event.type);
   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), event.timestamp);
@@ -196,7 +220,7 @@ TEST_F(TouchEventConverterEvdevTest, TouchDown) {
 TEST_F(TouchEventConverterEvdevTest, NoEvents) {
   ui::MockTouchEventConverterEvdev* dev = device();
   dev->ConfigureReadMock(NULL, 0, 0);
-  EXPECT_EQ(0u, dev->size());
+  EXPECT_EQ(0u, size());
 }
 
 TEST_F(TouchEventConverterEvdevTest, TouchMove) {
@@ -223,12 +247,12 @@ TEST_F(TouchEventConverterEvdevTest, TouchMove) {
   // Setup and discard a press.
   dev->ConfigureReadMock(mock_kernel_queue_press, 6, 0);
   dev->ReadNow();
-  EXPECT_EQ(1u, dev->size());
+  EXPECT_EQ(1u, size());
 
   dev->ConfigureReadMock(mock_kernel_queue_move1, 4, 0);
   dev->ReadNow();
-  EXPECT_EQ(2u, dev->size());
-  ui::TouchEventParams event = dev->event(1);
+  EXPECT_EQ(2u, size());
+  ui::TouchEventParams event = dispatched_event(1);
 
   EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), event.timestamp);
@@ -239,8 +263,8 @@ TEST_F(TouchEventConverterEvdevTest, TouchMove) {
 
   dev->ConfigureReadMock(mock_kernel_queue_move2, 2, 0);
   dev->ReadNow();
-  EXPECT_EQ(3u, dev->size());
-  event = dev->event(2);
+  EXPECT_EQ(3u, size());
+  event = dispatched_event(2);
 
   EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), event.timestamp);
@@ -268,13 +292,13 @@ TEST_F(TouchEventConverterEvdevTest, TouchRelease) {
   // Setup and discard a press.
   dev->ConfigureReadMock(mock_kernel_queue_press, 6, 0);
   dev->ReadNow();
-  EXPECT_EQ(1u, dev->size());
-  ui::TouchEventParams event = dev->event(0);
+  EXPECT_EQ(1u, size());
+  ui::TouchEventParams event = dispatched_event(0);
 
   dev->ConfigureReadMock(mock_kernel_queue_release, 2, 0);
   dev->ReadNow();
-  EXPECT_EQ(2u, dev->size());
-  event = dev->event(1);
+  EXPECT_EQ(2u, size());
+  event = dispatched_event(1);
 
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), event.timestamp);
@@ -297,7 +321,7 @@ TEST_F(TouchEventConverterEvdevTest, TwoFingerGesture) {
   // Setup and discard a press.
   dev->ConfigureReadMock(mock_kernel_queue_press0, 6, 0);
   dev->ReadNow();
-  EXPECT_EQ(1u, dev->size());
+  EXPECT_EQ(1u, size());
 
   struct input_event mock_kernel_queue_move0[] = {
     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
@@ -305,7 +329,7 @@ TEST_F(TouchEventConverterEvdevTest, TwoFingerGesture) {
   // Setup and discard a move.
   dev->ConfigureReadMock(mock_kernel_queue_move0, 2, 0);
   dev->ReadNow();
-  EXPECT_EQ(2u, dev->size());
+  EXPECT_EQ(2u, size());
 
   struct input_event mock_kernel_queue_move0press1[] = {
     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0},
@@ -318,9 +342,9 @@ TEST_F(TouchEventConverterEvdevTest, TwoFingerGesture) {
   // Move on 0, press on 1.
   dev->ConfigureReadMock(mock_kernel_queue_move0press1, 9, 0);
   dev->ReadNow();
-  EXPECT_EQ(4u, dev->size());
-  ui::TouchEventParams ev0 = dev->event(2);
-  ui::TouchEventParams ev1 = dev->event(3);
+  EXPECT_EQ(4u, size());
+  ui::TouchEventParams ev0 = dispatched_event(2);
+  ui::TouchEventParams ev1 = dispatched_event(3);
 
   // Move
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev0.type);
@@ -344,8 +368,8 @@ TEST_F(TouchEventConverterEvdevTest, TwoFingerGesture) {
   };
   dev->ConfigureReadMock(mock_kernel_queue_stationary0_move1, 2, 0);
   dev->ReadNow();
-  EXPECT_EQ(5u, dev->size());
-  ev1 = dev->event(4);
+  EXPECT_EQ(5u, size());
+  ev1 = dispatched_event(4);
 
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev1.type);
   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1.timestamp);
@@ -362,8 +386,8 @@ TEST_F(TouchEventConverterEvdevTest, TwoFingerGesture) {
   };
   dev->ConfigureReadMock(mock_kernel_queue_move0_stationary1, 3, 0);
   dev->ReadNow();
-  EXPECT_EQ(6u, dev->size());
-  ev0 = dev->event(5);
+  EXPECT_EQ(6u, size());
+  ev0 = dispatched_event(5);
 
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev0.type);
   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev0.timestamp);
@@ -379,9 +403,9 @@ TEST_F(TouchEventConverterEvdevTest, TwoFingerGesture) {
   };
   dev->ConfigureReadMock(mock_kernel_queue_release0_move1, 4, 0);
   dev->ReadNow();
-  EXPECT_EQ(8u, dev->size());
-  ev0 = dev->event(6);
-  ev1 = dev->event(7);
+  EXPECT_EQ(8u, size());
+  ev0 = dispatched_event(6);
+  ev1 = dispatched_event(7);
 
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, ev0.type);
   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev0.timestamp);
@@ -403,8 +427,8 @@ TEST_F(TouchEventConverterEvdevTest, TwoFingerGesture) {
   };
   dev->ConfigureReadMock(mock_kernel_queue_release1, 2, 0);
   dev->ReadNow();
-  EXPECT_EQ(9u, dev->size());
-  ev1 = dev->event(8);
+  EXPECT_EQ(9u, size());
+  ev1 = dispatched_event(8);
 
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, ev1.type);
   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1.timestamp);
@@ -433,7 +457,7 @@ TEST_F(TouchEventConverterEvdevTest, TypeA) {
   // Check that two events are generated.
   dev->ConfigureReadMock(mock_kernel_queue_press0, 10, 0);
   dev->ReadNow();
-  EXPECT_EQ(2u, dev->size());
+  EXPECT_EQ(2u, size());
 }
 
 TEST_F(TouchEventConverterEvdevTest, Unsync) {
@@ -449,7 +473,7 @@ TEST_F(TouchEventConverterEvdevTest, Unsync) {
 
   dev->ConfigureReadMock(mock_kernel_queue_press0, 6, 0);
   dev->ReadNow();
-  EXPECT_EQ(1u, dev->size());
+  EXPECT_EQ(1u, size());
 
   // Prepare a move with a drop.
   struct input_event mock_kernel_queue_move0[] = {
@@ -460,7 +484,7 @@ TEST_F(TouchEventConverterEvdevTest, Unsync) {
   // Verify that we didn't receive it/
   dev->ConfigureReadMock(mock_kernel_queue_move0, 3, 0);
   dev->ReadNow();
-  EXPECT_EQ(1u, dev->size());
+  EXPECT_EQ(1u, size());
 
   struct input_event mock_kernel_queue_move1[] = {
     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
@@ -469,7 +493,7 @@ TEST_F(TouchEventConverterEvdevTest, Unsync) {
   // Verify that it re-syncs after a SYN_REPORT.
   dev->ConfigureReadMock(mock_kernel_queue_move1, 2, 0);
   dev->ReadNow();
-  EXPECT_EQ(2u, dev->size());
+  EXPECT_EQ(2u, size());
 }
 
 // crbug.com/407386
@@ -499,12 +523,12 @@ TEST_F(TouchEventConverterEvdevTest,
   dev->ReadNow();
 
   const unsigned int kExpectedEventCount = 2;
-  EXPECT_EQ(kExpectedEventCount, dev->size());
-  if (kExpectedEventCount != dev->size())
+  EXPECT_EQ(kExpectedEventCount, size());
+  if (kExpectedEventCount != size())
     return;
 
-  ui::TouchEventParams ev0 = dev->event(0);
-  ui::TouchEventParams ev1 = dev->event(1);
+  ui::TouchEventParams ev0 = dispatched_event(0);
+  ui::TouchEventParams ev1 = dispatched_event(1);
 
   EXPECT_EQ(0, ev0.touch_id);
   EXPECT_EQ(999, ev0.location.x());
@@ -536,5 +560,5 @@ TEST_F(TouchEventConverterEvdevTest, CheckSlotLimit) {
   // Check that one 1 event is generated
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
-  EXPECT_EQ(1u, dev->size());
+  EXPECT_EQ(1u, size());
 }