[PATCH 4/11] ozone: evdev: Move EventModifiersEvdev usage to EventFactoryEvdev

ui/events/ozone/evdev/tablet_event_converter_evdev_unittest.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 <errno.h>
 #include <fcntl.h>
 #include <linux/input.h>
 #include <unistd.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
+#include "ui/events/ozone/device/device_manager.h"
+#include "ui/events/ozone/evdev/event_factory_evdev.h"
 #include "ui/events/ozone/evdev/tablet_event_converter_evdev.h"
+#include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_source.h"
 
 namespace {
 
 static int SetNonBlocking(int fd) {
   int flags = fcntl(fd, F_GETFL, 0);
   if (flags == -1)
     flags = 0;
   return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 }
 
 const char kTestDevicePath[] = "/dev/input/test-device";
 
 }  // namespace
 
 namespace ui {
 
 class MockTabletEventConverterEvdev : public TabletEventConverterEvdev {
  public:
-  MockTabletEventConverterEvdev(int fd,
-                                base::FilePath path,
-                                EventModifiersEvdev* modifiers,
-                                CursorDelegateEvdev* cursor);
+  MockTabletEventConverterEvdev(
+      int fd,
+      base::FilePath path,
+      CursorDelegateEvdev* cursor,
+      const MouseMoveEventDispatchCallback& mouse_move_callback,
+      const MouseButtonEventDispatchCallback& mouse_button_callback);
   ~MockTabletEventConverterEvdev() override {};
 
   void ConfigureReadMock(struct input_event* queue,
                          long read_this_many,
                          long queue_index);
 
-  unsigned size() { return dispatched_events_.size(); }
-  MouseEvent* event(unsigned index) {
-    DCHECK_GT(dispatched_events_.size(), index);
-    Event* ev = dispatched_events_[index];
-    DCHECK(ev->IsMouseEvent());
-    return static_cast<MouseEvent*>(ev);
-  }
-
   // Actually dispatch the event reader code.
   void ReadNow() {
     OnFileCanReadWithoutBlocking(read_pipe_);
     base::RunLoop().RunUntilIdle();
   }
 
-  void DispatchCallback(scoped_ptr<Event> event) {
-    dispatched_events_.push_back(event.release());
-  }
-
  private:
   int read_pipe_;
   int write_pipe_;
 
   ScopedVector<Event> dispatched_events_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTabletEventConverterEvdev);
 };
 
 class MockTabletCursorEvdev : public CursorDelegateEvdev {
@@ skipping 16 matching lines @@
 
  private:
   gfx::PointF cursor_location_;
   gfx::Rect cursor_display_bounds_;
   DISALLOW_COPY_AND_ASSIGN(MockTabletCursorEvdev);
 };
 
 MockTabletEventConverterEvdev::MockTabletEventConverterEvdev(
     int fd,
     base::FilePath path,
-    EventModifiersEvdev* modifiers,
-    CursorDelegateEvdev* cursor)
-    : TabletEventConverterEvdev(
-          fd,
-          path,
-          1,
-          INPUT_DEVICE_UNKNOWN,
-          modifiers,
-          cursor,
-          EventDeviceInfo(),
-          base::Bind(&MockTabletEventConverterEvdev::DispatchCallback,
-                     base::Unretained(this))) {
+    CursorDelegateEvdev* cursor,
+    const MouseMoveEventDispatchCallback& mouse_move_callback,
+    const MouseButtonEventDispatchCallback& mouse_button_callback)
+    : TabletEventConverterEvdev(fd,
+                                path,
+                                1,
+                                INPUT_DEVICE_UNKNOWN,
+                                cursor,
+                                EventDeviceInfo(),
+                                mouse_move_callback,
+                                mouse_button_callback) {
   // Real values taken from Wacom Intuos 4
   x_abs_min_ = 0;
   x_abs_range_ = 65024;
   y_abs_min_ = 0;
   y_abs_range_ = 40640;
 
   int fds[2];
 
   if (pipe(fds))
     PLOG(FATAL) << "failed pipe";
 
   DCHECK(SetNonBlocking(fds[0]) == 0)
       << "SetNonBlocking for pipe fd[0] failed, errno: " << errno;
   DCHECK(SetNonBlocking(fds[1]) == 0)
       << "SetNonBlocking for pipe fd[0] failed, errno: " << errno;
   read_pipe_ = fds[0];
   write_pipe_ = fds[1];
 }
 
 void MockTabletEventConverterEvdev::ConfigureReadMock(struct input_event* queue,
                                                       long read_this_many,
                                                       long queue_index) {
   int nwrite = HANDLE_EINTR(write(write_pipe_, queue + queue_index,
                                   sizeof(struct input_event) * read_this_many));
   DCHECK(nwrite ==
          static_cast<int>(sizeof(struct input_event) * read_this_many))
       << "write() failed, errno: " << errno;
 }
 
+class MockDeviceManager : public ui::DeviceManager {
+ public:
+  MockDeviceManager() {}
+  ~MockDeviceManager() override {}
+
+  // DeviceManager:
+  void ScanDevices(DeviceEventObserver* observer) override {}
+  void AddObserver(DeviceEventObserver* observer) override {}
+  void RemoveObserver(DeviceEventObserver* observer) override {}
+};
+
+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 ui
 
 // Test fixture.
 class TabletEventConverterEvdevTest : public testing::Test {
  public:
   TabletEventConverterEvdevTest() {}
 
   // Overridden from testing::Test:
   void SetUp() override {
     // Set up pipe to satisfy message pump (unused).
     int evdev_io[2];
     if (pipe(evdev_io))
       PLOG(FATAL) << "failed pipe";
     events_in_ = evdev_io[0];
     events_out_ = evdev_io[1];
 
     cursor_.reset(new ui::MockTabletCursorEvdev());
-    modifiers_.reset(new ui::EventModifiersEvdev());
+    device_manager_.reset(new ui::MockDeviceManager);
+    event_factory_.reset(new ui::TestEventFactoryEvdev(
+        cursor_.get(), device_manager_.get(),
+        ui::KeyboardLayoutEngineManager::GetKeyboardLayoutEngine(),
+        base::Bind(&TabletEventConverterEvdevTest::DispatchEventForTest,
+                   base::Unretained(this))));
     device_.reset(new ui::MockTabletEventConverterEvdev(
-        events_in_, base::FilePath(kTestDevicePath), modifiers_.get(),
-        cursor_.get()));
+        events_in_, base::FilePath(kTestDevicePath), cursor_.get(),
+        base::Bind(&ui::EventFactoryEvdev::PostMouseMoveEvent,
+                   base::Unretained(event_factory_.get())),
+        base::Bind(&ui::EventFactoryEvdev::PostMouseButtonEvent,
+                   base::Unretained(event_factory_.get()))));
   }
 
   void TearDown() override {
-    modifiers_.reset();
     cursor_.reset();
     device_.reset();
   }
 
   ui::MockTabletEventConverterEvdev* device() { return device_.get(); }
   ui::CursorDelegateEvdev* cursor() { return cursor_.get(); }
-  ui::EventModifiersEvdev* modifiers() { return modifiers_.get(); }
+
+  unsigned size() { return dispatched_events_.size(); }
+  ui::MouseEvent* dispatched_event(unsigned index) {
+    DCHECK_GT(dispatched_events_.size(), index);
+    ui::Event* ev = dispatched_events_[index];
+    DCHECK(ev->IsMouseEvent());
+    return static_cast<ui::MouseEvent*>(ev);
+  }
+
+  void DispatchEventForTest(scoped_ptr<ui::Event> event) {
+    dispatched_events_.push_back(event.release());
+  }
 
  private:
+  scoped_ptr<ui::MockTabletCursorEvdev> cursor_;
+  scoped_ptr<ui::DeviceManager> device_manager_;
+  scoped_ptr<ui::EventFactoryEvdev> event_factory_;
   scoped_ptr<ui::MockTabletEventConverterEvdev> device_;
-  scoped_ptr<ui::MockTabletCursorEvdev> cursor_;
-  scoped_ptr<ui::EventModifiersEvdev> modifiers_;
+
+  ScopedVector<ui::Event> dispatched_events_;
 
   int events_out_;
   int events_in_;
 
   DISALLOW_COPY_AND_ASSIGN(TabletEventConverterEvdevTest);
 };
 
 #define EPSILON 20
 
 // Uses real data captured from Wacom Intuos 4
@@ skipping 12 matching lines @@
       {{0, 0}, EV_ABS, ABS_Y, 0},
       {{0, 0}, EV_ABS, ABS_DISTANCE, 0},
       {{0, 0}, EV_ABS, ABS_TILT_X, 0},
       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 0},
       {{0, 0}, EV_ABS, ABS_MISC, 0},
       {{0, 0}, EV_MSC, MSC_SERIAL, 159403517},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
 
   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
-  EXPECT_EQ(1u, dev->size());
+  EXPECT_EQ(1u, size());
 
-  ui::MouseEvent* event = dev->event(0);
+  ui::MouseEvent* event = dispatched_event(0);
   EXPECT_EQ(ui::ET_MOUSE_MOVED, event->type());
 
   EXPECT_LT(cursor()->GetLocation().x(), EPSILON);
   EXPECT_LT(cursor()->GetLocation().y(), EPSILON);
 }
 
 TEST_F(TabletEventConverterEvdevTest, MoveTopRight) {
   ui::MockTabletEventConverterEvdev* dev = device();
 
   struct input_event mock_kernel_queue[] = {
@@ skipping 10 matching lines @@
       {{0, 0}, EV_ABS, ABS_DISTANCE, 0},
       {{0, 0}, EV_ABS, ABS_TILT_X, 0},
       {{0, 0}, EV_ABS, ABS_TILT_Y, 0},
       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 0},
       {{0, 0}, EV_ABS, ABS_MISC, 0},
       {{0, 0}, EV_MSC, MSC_SERIAL, 159403517},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
 
   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
-  EXPECT_EQ(1u, dev->size());
+  EXPECT_EQ(1u, size());
 
-  ui::MouseEvent* event = dev->event(0);
+  ui::MouseEvent* event = dispatched_event(0);
   EXPECT_EQ(ui::ET_MOUSE_MOVED, event->type());
 
   EXPECT_GT(cursor()->GetLocation().x(),
             cursor()->GetCursorDisplayBounds().width() - EPSILON);
   EXPECT_LT(cursor()->GetLocation().y(), EPSILON);
 }
 
 TEST_F(TabletEventConverterEvdevTest, MoveBottomLeft) {
   ui::MockTabletEventConverterEvdev* dev = device();
 
@@ skipping 10 matching lines @@
       {{0, 0}, EV_ABS, ABS_DISTANCE, 0},
       {{0, 0}, EV_ABS, ABS_TILT_X, 0},
       {{0, 0}, EV_ABS, ABS_TILT_Y, 0},
       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 0},
       {{0, 0}, EV_ABS, ABS_MISC, 0},
       {{0, 0}, EV_MSC, MSC_SERIAL, 159403517},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
 
   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
-  EXPECT_EQ(1u, dev->size());
+  EXPECT_EQ(1u, size());
 
-  ui::MouseEvent* event = dev->event(0);
+  ui::MouseEvent* event = dispatched_event(0);
   EXPECT_EQ(ui::ET_MOUSE_MOVED, event->type());
 
   EXPECT_LT(cursor()->GetLocation().x(), EPSILON);
   EXPECT_GT(cursor()->GetLocation().y(),
             cursor()->GetCursorDisplayBounds().height() - EPSILON);
 }
 
 TEST_F(TabletEventConverterEvdevTest, MoveBottomRight) {
   ui::MockTabletEventConverterEvdev* dev = device();
 
@@ skipping 12 matching lines @@
       {{0, 0}, EV_ABS, ABS_DISTANCE, 0},
       {{0, 0}, EV_ABS, ABS_TILT_X, 0},
       {{0, 0}, EV_ABS, ABS_TILT_Y, 0},
       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 0},
       {{0, 0}, EV_ABS, ABS_MISC, 0},
       {{0, 0}, EV_MSC, MSC_SERIAL, 159403517},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
 
   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
-  EXPECT_EQ(1u, dev->size());
+  EXPECT_EQ(1u, size());
 
-  ui::MouseEvent* event = dev->event(0);
+  ui::MouseEvent* event = dispatched_event(0);
   EXPECT_EQ(ui::ET_MOUSE_MOVED, event->type());
 
   EXPECT_GT(cursor()->GetLocation().x(),
             cursor()->GetCursorDisplayBounds().height() - EPSILON);
   EXPECT_GT(cursor()->GetLocation().y(),
             cursor()->GetCursorDisplayBounds().height() - EPSILON);
 }
 
 TEST_F(TabletEventConverterEvdevTest, Tap) {
   ui::MockTabletEventConverterEvdev* dev = device();
@@ skipping 27 matching lines @@
       {{0, 0}, EV_ABS, ABS_DISTANCE, 0},
       {{0, 0}, EV_ABS, ABS_TILT_X, 0},
       {{0, 0}, EV_ABS, ABS_TILT_Y, 0},
       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 0},
       {{0, 0}, EV_ABS, ABS_MISC, 0},
       {{0, 0}, EV_MSC, MSC_SERIAL, 159403517},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
 
   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
-  EXPECT_EQ(3u, dev->size());
+  EXPECT_EQ(3u, size());
 
-  ui::MouseEvent* event = dev->event(0);
+  ui::MouseEvent* event = dispatched_event(0);
   EXPECT_EQ(ui::ET_MOUSE_MOVED, event->type());
-  event = dev->event(1);
+  event = dispatched_event(1);
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, event->type());
   EXPECT_EQ(true, event->IsLeftMouseButton());
-  event = dev->event(2);
+  event = dispatched_event(2);
   EXPECT_EQ(ui::ET_MOUSE_RELEASED, event->type());
   EXPECT_EQ(true, event->IsLeftMouseButton());
 }
 
 TEST_F(TabletEventConverterEvdevTest, StylusButtonPress) {
   ui::MockTabletEventConverterEvdev* dev = device();
 
   struct input_event mock_kernel_queue[] = {
       {{0, 0}, EV_ABS, ABS_X, 30055},
       {{0, 0}, EV_ABS, ABS_Y, 18094},
@@ skipping 19 matching lines @@
       {{0, 0}, EV_ABS, ABS_DISTANCE, 0},
       {{0, 0}, EV_ABS, ABS_TILT_X, 0},
       {{0, 0}, EV_ABS, ABS_TILT_Y, 0},
       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 0},
       {{0, 0}, EV_ABS, ABS_MISC, 0},
       {{0, 0}, EV_MSC, MSC_SERIAL, 159403517},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
 
   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
-  EXPECT_EQ(3u, dev->size());
+  EXPECT_EQ(3u, size());
 
-  ui::MouseEvent* event = dev->event(0);
+  ui::MouseEvent* event = dispatched_event(0);
   EXPECT_EQ(ui::ET_MOUSE_MOVED, event->type());
-  event = dev->event(1);
+  event = dispatched_event(1);
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, event->type());
   EXPECT_EQ(true, event->IsRightMouseButton());
-  event = dev->event(2);
+  event = dispatched_event(2);
   EXPECT_EQ(ui::ET_MOUSE_RELEASED, event->type());
   EXPECT_EQ(true, event->IsRightMouseButton());
 }
 
 // Should only get an event if BTN_TOOL received
 TEST_F(TabletEventConverterEvdevTest, CheckStylusFiltering) {
   ui::MockTabletEventConverterEvdev* dev = device();
 
   struct input_event mock_kernel_queue[] = {
       {{0, 0}, EV_ABS, ABS_X, 0},
       {{0, 0}, EV_ABS, ABS_Y, 0},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
 
   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
-  EXPECT_EQ(0u, dev->size());
+  EXPECT_EQ(0u, size());
 }