Support pen in TouchEventConverterEvdev

ui/events/ozone/evdev/touch_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 "ui/events/ozone/evdev/touch_event_converter_evdev.h"
 
 #include <errno.h>
 #include <linux/input.h>
 #include <stddef.h>
 #include <unistd.h>
@@ skipping 30 matching lines @@
   EXPECT_TRUE(CapabilitiesToDeviceInfo(kLinkTouchscreen, &devinfo));
   device->Initialize(devinfo);
 }
 
 void InitEloTouchscreen(TouchEventConverterEvdev* device) {
   EventDeviceInfo devinfo;
   EXPECT_TRUE(CapabilitiesToDeviceInfo(kElo_TouchSystems_2700, &devinfo));
   device->Initialize(devinfo);
 }
 
+enum class GenericEventParamsType { MOUSE_MOVE, MOUSE_BUTTON, TOUCH };
+
+struct GenericEventParams {
+  GenericEventParams() {}
+  GenericEventParams(const GenericEventParams& other) {
+    type = other.type;
+    switch (type) {
+      case GenericEventParamsType::MOUSE_MOVE:
+        mouse_move = other.mouse_move;
+        break;
+      case GenericEventParamsType::MOUSE_BUTTON:
+        mouse_button = other.mouse_button;
+        break;
+      case GenericEventParamsType::TOUCH:
+        touch = other.touch;
+        break;
+    }
+  }
+  ~GenericEventParams() {}
+
+  GenericEventParamsType type;
+  union {
+    MouseMoveEventParams mouse_move;
+    MouseButtonEventParams mouse_button;
+    TouchEventParams touch;
+  };
+};
+
 }  // namespace
 
 class MockTouchEventConverterEvdev : public TouchEventConverterEvdev {
  public:
   MockTouchEventConverterEvdev(int fd,
                                base::FilePath path,
                                const EventDeviceInfo& devinfo,
                                DeviceEventDispatcherEvdev* dispatcher);
   ~MockTouchEventConverterEvdev() override;
 
@@ skipping 18 matching lines @@
  private:
   int read_pipe_;
   int write_pipe_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTouchEventConverterEvdev);
 };
 
 class MockDeviceEventDispatcherEvdev : public DeviceEventDispatcherEvdev {
  public:
   MockDeviceEventDispatcherEvdev(
-      const base::Callback<void(const TouchEventParams& params)>& callback)
+      const base::Callback<void(const GenericEventParams& params)>& callback)
       : callback_(callback) {}
   ~MockDeviceEventDispatcherEvdev() override {}
 
   // DeviceEventDispatcherEvdev:
   void DispatchKeyEvent(const KeyEventParams& params) override {}
-  void DispatchMouseMoveEvent(const MouseMoveEventParams& params) override {}
+  void DispatchMouseMoveEvent(const MouseMoveEventParams& params) override {
+    GenericEventParams generic;
+    generic.type = GenericEventParamsType::MOUSE_MOVE;
+    generic.mouse_move = params;
+    callback_.Run(generic);
+  }
   void DispatchMouseButtonEvent(const MouseButtonEventParams& params) override {
+    GenericEventParams generic;
+    generic.type = GenericEventParamsType::MOUSE_BUTTON;
+    generic.mouse_button = params;
+    callback_.Run(generic);
   }
   void DispatchMouseWheelEvent(const MouseWheelEventParams& params) override {}
   void DispatchPinchEvent(const PinchEventParams& params) override {}
   void DispatchScrollEvent(const ScrollEventParams& params) override {}
   void DispatchTouchEvent(const TouchEventParams& params) override {
-    callback_.Run(params);
+    GenericEventParams generic;
+    generic.type = GenericEventParamsType::TOUCH;
+    generic.touch = params;
+    callback_.Run(generic);
   }
 
   void DispatchKeyboardDevicesUpdated(
       const std::vector<InputDevice>& devices) override {}
   void DispatchTouchscreenDevicesUpdated(
       const std::vector<TouchscreenDevice>& devices) override {}
   void DispatchMouseDevicesUpdated(
       const std::vector<InputDevice>& devices) override {}
   void DispatchTouchpadDevicesUpdated(
       const std::vector<InputDevice>& devices) override {}
   void DispatchDeviceListsComplete() override {}
 
  private:
-  base::Callback<void(const TouchEventParams& params)> callback_;
+  base::Callback<void(const GenericEventParams& params)> callback_;
 };
 
 MockTouchEventConverterEvdev::MockTouchEventConverterEvdev(
     int fd,
     base::FilePath path,
     const EventDeviceInfo& devinfo,
     DeviceEventDispatcherEvdev* dispatcher)
     : TouchEventConverterEvdev(fd,
                                path,
                                1,
@@ skipping 62 matching lines @@
   }
 
   void TearDown() override {
     device_.reset();
     delete loop_;
   }
 
   ui::MockTouchEventConverterEvdev* device() { return device_.get(); }
 
   unsigned size() { return dispatched_events_.size(); }
-  const ui::TouchEventParams& dispatched_event(unsigned index) {
+  const ui::TouchEventParams& dispatched_touch_event(unsigned index) {
     DCHECK_GT(dispatched_events_.size(), index);
-    return dispatched_events_[index];
+    EXPECT_EQ(GenericEventParamsType::TOUCH, dispatched_events_[index].type);
+    return dispatched_events_[index].touch;
   }
-
+  const ui::MouseMoveEventParams& dispatched_mouse_move_event(unsigned index) {
+    DCHECK_GT(dispatched_events_.size(), index);
+    EXPECT_EQ(GenericEventParamsType::MOUSE_MOVE,
+              dispatched_events_[index].type);
+    return dispatched_events_[index].mouse_move;
+  }
+  const ui::MouseButtonEventParams& dispatched_mouse_button_event(
+      unsigned index) {
+    DCHECK_GT(dispatched_events_.size(), index);
+    EXPECT_EQ(GenericEventParamsType::MOUSE_BUTTON,
+              dispatched_events_[index].type);
+    return dispatched_events_[index].mouse_button;
+  }
   void ClearDispatchedEvents() { dispatched_events_.clear(); }
 
   void DestroyDevice() { device_.reset(); }
 
  private:
   base::MessageLoop* loop_;
   std::unique_ptr<ui::MockTouchEventConverterEvdev> device_;
   std::unique_ptr<ui::MockDeviceEventDispatcherEvdev> dispatcher_;
 
   int events_out_;
   int events_in_;
 
-  void DispatchCallback(const ui::TouchEventParams& params) {
+  void DispatchCallback(const GenericEventParams& params) {
     dispatched_events_.push_back(params);
   }
-  std::vector<ui::TouchEventParams> dispatched_events_;
+  std::vector<GenericEventParams> dispatched_events_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchEventConverterEvdevTest);
 };
 
 TEST_F(TouchEventConverterEvdevTest, NoEvents) {
   ui::MockTouchEventConverterEvdev* dev = device();
   dev->ConfigureReadMock(NULL, 0, 0);
   EXPECT_EQ(0u, size());
 }
 
@@ skipping 34 matching lines @@
       {time, EV_KEY, BTN_TOUCH, 0},
       {time, EV_ABS, ABS_PRESSURE, 0},
       {time, EV_SYN, SYN_REPORT, 0},
   };
 
   // Press.
   dev->ConfigureReadMock(mock_kernel_queue_press,
                          arraysize(mock_kernel_queue_press), 0);
   dev->ReadNow();
   EXPECT_EQ(1u, size());
-  ui::TouchEventParams event = dispatched_event(0);
+  ui::TouchEventParams event = dispatched_touch_event(0);
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, event.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(1427323282019203),
             event.timestamp);
   EXPECT_EQ(295, event.location.x());
   EXPECT_EQ(421, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
             event.pointer_details.pointer_type);
   EXPECT_FLOAT_EQ(58.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.13333334f, event.pointer_details.force);
 
   // Move.
   dev->ConfigureReadMock(mock_kernel_queue_move,
                          arraysize(mock_kernel_queue_move), 0);
   dev->ReadNow();
   EXPECT_EQ(2u, size());
-  event = dispatched_event(1);
+  event = dispatched_touch_event(1);
   EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(1427323282034693),
             event.timestamp);
   EXPECT_EQ(312, event.location.x());
   EXPECT_EQ(432, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
             event.pointer_details.pointer_type);
   EXPECT_FLOAT_EQ(50.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.16862745f, event.pointer_details.force);
 
   // Release.
   dev->ConfigureReadMock(mock_kernel_queue_release,
                          arraysize(mock_kernel_queue_release), 0);
   dev->ReadNow();
   EXPECT_EQ(3u, size());
-  event = dispatched_event(2);
+  event = dispatched_touch_event(2);
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(1427323282144540),
             event.timestamp);
   EXPECT_EQ(312, event.location.x());
   EXPECT_EQ(432, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
             event.pointer_details.pointer_type);
   EXPECT_FLOAT_EQ(50.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.16862745f, event.pointer_details.force);
@@ skipping 29 matching lines @@
     {{0, 0}, EV_ABS, ABS_MT_SLOT, 1}, {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 686},
     {{0, 0}, EV_ABS, ABS_MT_TOUCH_MAJOR, 3},
     {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 101},
     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 102}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
   };
   // Move on 0, press on 1.
   dev->ConfigureReadMock(mock_kernel_queue_move0press1, 9, 0);
   dev->ReadNow();
   EXPECT_EQ(4u, size());
-  ui::TouchEventParams ev0 = dispatched_event(2);
-  ui::TouchEventParams ev1 = dispatched_event(3);
+  ui::TouchEventParams ev0 = dispatched_touch_event(2);
+  ui::TouchEventParams ev1 = dispatched_touch_event(3);
 
   // Move
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev0.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev0.timestamp);
   EXPECT_EQ(40, ev0.location.x());
   EXPECT_EQ(51, ev0.location.y());
   EXPECT_EQ(0, ev0.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev0.pointer_details.force);
 
   // Press
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, ev1.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev1.timestamp);
   EXPECT_EQ(101, ev1.location.x());
   EXPECT_EQ(102, ev1.location.y());
   EXPECT_EQ(1, ev1.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev1.pointer_details.force);
 
   // Stationary 0, Moves 1.
   struct input_event mock_kernel_queue_stationary0_move1[] = {
     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
   };
   dev->ConfigureReadMock(mock_kernel_queue_stationary0_move1, 2, 0);
   dev->ReadNow();
   EXPECT_EQ(5u, size());
-  ev1 = dispatched_event(4);
+  ev1 = dispatched_touch_event(4);
 
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev1.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev1.timestamp);
   EXPECT_EQ(40, ev1.location.x());
   EXPECT_EQ(102, ev1.location.y());
   EXPECT_EQ(1, ev1.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev1.pointer_details.force);
 
   // Move 0, stationary 1.
   struct input_event mock_kernel_queue_move0_stationary1[] = {
     {{0, 0}, EV_ABS, ABS_MT_SLOT, 0}, {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 39},
     {{0, 0}, EV_SYN, SYN_REPORT, 0}
   };
   dev->ConfigureReadMock(mock_kernel_queue_move0_stationary1, 3, 0);
   dev->ReadNow();
   EXPECT_EQ(6u, size());
-  ev0 = dispatched_event(5);
+  ev0 = dispatched_touch_event(5);
 
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev0.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev0.timestamp);
   EXPECT_EQ(39, ev0.location.x());
   EXPECT_EQ(51, ev0.location.y());
   EXPECT_EQ(0, ev0.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev0.pointer_details.force);
 
   // Release 0, move 1.
   struct input_event mock_kernel_queue_release0_move1[] = {
     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1}, {{0, 0}, EV_ABS, ABS_MT_SLOT, 1},
     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 38}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
   };
   dev->ConfigureReadMock(mock_kernel_queue_release0_move1, 4, 0);
   dev->ReadNow();
   EXPECT_EQ(8u, size());
-  ev0 = dispatched_event(6);
-  ev1 = dispatched_event(7);
+  ev0 = dispatched_touch_event(6);
+  ev1 = dispatched_touch_event(7);
 
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, ev0.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev0.timestamp);
   EXPECT_EQ(39, ev0.location.x());
   EXPECT_EQ(51, ev0.location.y());
   EXPECT_EQ(0, ev0.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev0.pointer_details.force);
 
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev1.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev1.timestamp);
   EXPECT_EQ(38, ev1.location.x());
   EXPECT_EQ(102, ev1.location.y());
   EXPECT_EQ(1, ev1.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev1.pointer_details.force);
 
   // Release 1.
   struct input_event mock_kernel_queue_release1[] = {
     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1}, {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
   dev->ConfigureReadMock(mock_kernel_queue_release1, 2, 0);
   dev->ReadNow();
   EXPECT_EQ(9u, size());
-  ev1 = dispatched_event(8);
+  ev1 = dispatched_touch_event(8);
 
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, ev1.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(0), ev1.timestamp);
   EXPECT_EQ(38, ev1.location.x());
   EXPECT_EQ(102, ev1.location.y());
   EXPECT_EQ(1, ev1.slot);
   EXPECT_FLOAT_EQ(0.17647059f, ev1.pointer_details.force);
 }
 
 TEST_F(TouchEventConverterEvdevTest, Unsync) {
@@ skipping 53 matching lines @@
   // Any report should suffice to dispatch the update.. do an empty one.
   struct input_event mock_kernel_queue_empty_report[] = {
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
 
   dev->ConfigureReadMock(mock_kernel_queue_empty_report,
                          arraysize(mock_kernel_queue_empty_report), 0);
   dev->ReadNow();
   EXPECT_EQ(1u, size());
 
-  ui::TouchEventParams ev = dispatched_event(0);
+  ui::TouchEventParams ev = dispatched_touch_event(0);
   EXPECT_EQ(ET_TOUCH_PRESSED, ev.type);
   EXPECT_EQ(0, ev.slot);
   EXPECT_FLOAT_EQ(50.f, ev.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(50.f, ev.pointer_details.radius_y);
   EXPECT_FLOAT_EQ(0.50196081f, ev.pointer_details.force);
 }
 
 TEST_F(TouchEventConverterEvdevTest, ShouldReleaseContactsOnStop) {
   ui::MockTouchEventConverterEvdev* dev = device();
 
@@ skipping 13 matching lines @@
       {time, EV_ABS, ABS_Y, 749},
       {time, EV_ABS, ABS_PRESSURE, 50},
       {time, EV_SYN, SYN_REPORT, 0},
   };
 
   dev->ConfigureReadMock(mock_kernel_queue_press,
                          arraysize(mock_kernel_queue_press), 0);
   dev->ReadNow();
   EXPECT_EQ(1u, size());
 
-  ui::TouchEventParams ev1 = dispatched_event(0);
+  ui::TouchEventParams ev1 = dispatched_touch_event(0);
   EXPECT_EQ(ET_TOUCH_PRESSED, ev1.type);
   EXPECT_EQ(0, ev1.slot);
 
   DestroyDevice();
   EXPECT_EQ(2u, size());
 
-  ui::TouchEventParams ev2 = dispatched_event(1);
+  ui::TouchEventParams ev2 = dispatched_touch_event(1);
   EXPECT_EQ(ET_TOUCH_RELEASED, ev2.type);
   EXPECT_EQ(0, ev2.slot);
 }
 
 TEST_F(TouchEventConverterEvdevTest, ShouldRemoveContactsWhenDisabled) {
   ui::MockTouchEventConverterEvdev* dev = device();
 
   EventDeviceInfo devinfo;
   EXPECT_TRUE(CapabilitiesToDeviceInfo(kLinkTouchscreen, &devinfo));
 
@@ skipping 14 matching lines @@
   };
 
   // Initialize the device.
   dev->Initialize(devinfo);
 
   dev->ConfigureReadMock(mock_kernel_queue_press,
                          arraysize(mock_kernel_queue_press), 0);
   dev->ReadNow();
   EXPECT_EQ(1u, size());
 
-  ui::TouchEventParams ev1 = dispatched_event(0);
+  ui::TouchEventParams ev1 = dispatched_touch_event(0);
   EXPECT_EQ(ET_TOUCH_PRESSED, ev1.type);
   EXPECT_EQ(0, ev1.slot);
   EXPECT_EQ(1003, ev1.location.x());
   EXPECT_EQ(749, ev1.location.y());
 
   // Disable the device (should release the contact).
   dev->SetEnabled(false);
   EXPECT_EQ(2u, size());
 
-  ui::TouchEventParams ev2 = dispatched_event(1);
+  ui::TouchEventParams ev2 = dispatched_touch_event(1);
   EXPECT_EQ(ET_TOUCH_RELEASED, ev2.type);
   EXPECT_EQ(0, ev2.slot);
 
   // Set up the previous contact in slot 0.
   devinfo.SetAbsMtSlot(ABS_MT_TRACKING_ID, 0, 0);
   devinfo.SetAbsMtSlot(ABS_MT_TOUCH_MAJOR, 0, 116);
   devinfo.SetAbsMtSlot(ABS_MT_POSITION_X, 0, 1003);
   devinfo.SetAbsMtSlot(ABS_MT_POSITION_Y, 0, 749);
   devinfo.SetAbsMtSlot(ABS_MT_PRESSURE, 0, 50);
 
   // Re-enable the device (should re-apply the contact).
   dev->SimulateReinitialize(devinfo);
   dev->SetEnabled(true);
   EXPECT_EQ(3u, size());
 
-  ui::TouchEventParams ev3 = dispatched_event(2);
+  ui::TouchEventParams ev3 = dispatched_touch_event(2);
   EXPECT_EQ(ET_TOUCH_PRESSED, ev3.type);
   EXPECT_EQ(0, ev3.slot);
   EXPECT_EQ(1003, ev3.location.x());
   EXPECT_EQ(749, ev3.location.y());
 }
 
 // crbug.com/477695
 TEST_F(TouchEventConverterEvdevTest, ShouldUseLeftButtonIfNoTouchButton) {
   ui::MockTouchEventConverterEvdev* dev = device();
 
@@ skipping 27 matching lines @@
       {time, EV_KEY, BTN_LEFT, 0},
       {time, EV_ABS, ABS_MISC, 0},
       {time, EV_SYN, SYN_REPORT, 0},
   };
 
   // Press.
   dev->ConfigureReadMock(mock_kernel_queue_press,
                          arraysize(mock_kernel_queue_press), 0);
   dev->ReadNow();
   EXPECT_EQ(1u, size());
-  ui::TouchEventParams event = dispatched_event(0);
+  ui::TouchEventParams event = dispatched_touch_event(0);
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, event.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(1433965490837958),
             event.timestamp);
   EXPECT_EQ(3654, event.location.x());
   EXPECT_EQ(1055, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.force);
 
   // Move.
   dev->ConfigureReadMock(mock_kernel_queue_move,
                          arraysize(mock_kernel_queue_move), 0);
   dev->ReadNow();
   EXPECT_EQ(2u, size());
-  event = dispatched_event(1);
+  event = dispatched_touch_event(1);
   EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(1433965491001953),
             event.timestamp);
   EXPECT_EQ(3644, event.location.x());
   EXPECT_EQ(1059, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.force);
 
   // Release.
   dev->ConfigureReadMock(mock_kernel_queue_release,
                          arraysize(mock_kernel_queue_release), 0);
   dev->ReadNow();
   EXPECT_EQ(3u, size());
-  event = dispatched_event(2);
+  event = dispatched_touch_event(2);
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
   EXPECT_EQ(base::TimeTicks::FromInternalValue(1433965491225959),
             event.timestamp);
   EXPECT_EQ(3644, event.location.x());
   EXPECT_EQ(1059, event.location.y());
   EXPECT_EQ(0, event.slot);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.radius_x);
   EXPECT_FLOAT_EQ(0.f, event.pointer_details.force);
 
   // No dispatch on destruction.
@@ skipping 27 matching lines @@
 
   // Check that two events are generated.
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
 
   const unsigned int kExpectedEventCount = 2;
   EXPECT_EQ(kExpectedEventCount, size());
   if (kExpectedEventCount != size())
     return;
 
-  ui::TouchEventParams ev0 = dispatched_event(0);
-  ui::TouchEventParams ev1 = dispatched_event(1);
+  ui::TouchEventParams ev0 = dispatched_touch_event(0);
+  ui::TouchEventParams ev1 = dispatched_touch_event(1);
 
   EXPECT_EQ(0, ev0.slot);
   EXPECT_EQ(999, ev0.location.x());
   EXPECT_EQ(888, ev0.location.y());
   EXPECT_FLOAT_EQ(0.21568628f, ev0.pointer_details.force);
 
   EXPECT_EQ(1, ev1.slot);
   EXPECT_EQ(777, ev1.location.x());
   EXPECT_EQ(666, ev1.location.y());
   EXPECT_FLOAT_EQ(0.17254902f, ev1.pointer_details.force);
@@ skipping 120 matching lines @@
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
   ASSERT_EQ(0u, size());
 
   ClearDispatchedEvents();
   SetTouchNoiseFilter(std::unique_ptr<TouchNoiseFilter>(
       new EventTypeTouchNoiseFilter(ET_TOUCH_MOVED)));
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
   ASSERT_EQ(2u, size());
-  TouchEventParams event0 = dispatched_event(0);
+  TouchEventParams event0 = dispatched_touch_event(0);
   EXPECT_EQ(ET_TOUCH_PRESSED, event0.type);
   EXPECT_EQ(40, event0.location.x());
   EXPECT_EQ(41, event0.location.y());
-  EXPECT_EQ(ET_TOUCH_CANCELLED, dispatched_event(1).type);
+  EXPECT_EQ(ET_TOUCH_CANCELLED, dispatched_touch_event(1).type);
 
   ClearDispatchedEvents();
   SetTouchNoiseFilter(std::unique_ptr<TouchNoiseFilter>(
       new EventTypeTouchNoiseFilter(ET_TOUCH_RELEASED)));
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
   ASSERT_EQ(3u, size());
-  event0 = dispatched_event(0);
+  event0 = dispatched_touch_event(0);
   EXPECT_EQ(ET_TOUCH_PRESSED, event0.type);
   EXPECT_EQ(40, event0.location.x());
   EXPECT_EQ(41, event0.location.y());
-  TouchEventParams event1 = dispatched_event(1);
+  TouchEventParams event1 = dispatched_touch_event(1);
   EXPECT_EQ(ET_TOUCH_MOVED, event1.type);
   EXPECT_EQ(42, event1.location.x());
   EXPECT_EQ(43, event1.location.y());
-  EXPECT_EQ(ET_TOUCH_CANCELLED, dispatched_event(2).type);
+  EXPECT_EQ(ET_TOUCH_CANCELLED, dispatched_touch_event(2).type);
 }
 
 // Test that TouchEventConverterEvdev keeps sending events to
 // TouchNoiseFinder after the touch is canceled.
 TEST_F(TouchEventConverterEvdevTouchNoiseTest,
        DoNotSendTouchCancelsToTouchNoiseFinder) {
   struct input_event mock_kernel_queue[] = {
     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 684},
     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40},
     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 41},
@@ skipping 43 matching lines @@
       {{0, 0}, EV_ABS, ABS_X, 9173},
       {{0, 0}, EV_ABS, ABS_Y, 3906},
       {{0, 0}, EV_ABS, ABS_PRESSURE, 0},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 0},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
 
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
-  EXPECT_EQ(2u, size());
+  EXPECT_EQ(5u, size());
 
-  ui::TouchEventParams event = dispatched_event(0);
-  EXPECT_EQ(ui::ET_TOUCH_PRESSED, event.type);
-  EXPECT_EQ(9170, event.location.x());
-  EXPECT_EQ(3658, event.location.y());
-  EXPECT_EQ(60.f / 1024, event.pointer_details.force);
+  ui::MouseMoveEventParams move_event = dispatched_mouse_move_event(0);
+  EXPECT_EQ(9170, move_event.location.x());
+  EXPECT_EQ(3658, move_event.location.y());
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
+            move_event.pointer_details.pointer_type);
 
-  event = dispatched_event(1);
-  EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
-  EXPECT_EQ(9173, event.location.x());
-  EXPECT_EQ(3906, event.location.y());
-  EXPECT_EQ(0.f / 1024, event.pointer_details.force);
+  ui::MouseButtonEventParams button_event = dispatched_mouse_button_event(1);
+  EXPECT_EQ(9170, button_event.location.x());
+  EXPECT_EQ(3658, button_event.location.y());
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
+            button_event.pointer_details.pointer_type);
+  EXPECT_EQ(60.f / 1024, button_event.pointer_details.force);
+  EXPECT_EQ(button_event.button, static_cast<unsigned int>(BTN_LEFT));
+  EXPECT_EQ(button_event.down, true);
+
+  move_event = dispatched_mouse_move_event(2);
+  EXPECT_EQ(9170, move_event.location.x());
+  EXPECT_EQ(3658, move_event.location.y());
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
+            move_event.pointer_details.pointer_type);
+  EXPECT_EQ(60.f / 1024, move_event.pointer_details.force);
+
+  button_event = dispatched_mouse_button_event(3);
+  EXPECT_EQ(9173, button_event.location.x());
+  EXPECT_EQ(3906, button_event.location.y());
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
+            button_event.pointer_details.pointer_type);
+  EXPECT_EQ(button_event.button, static_cast<unsigned int>(BTN_LEFT));
+  EXPECT_EQ(button_event.down, false);
+
+  move_event = dispatched_mouse_move_event(4);
+  EXPECT_EQ(9173, move_event.location.x());
+  EXPECT_EQ(3906, move_event.location.y());
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
+            move_event.pointer_details.pointer_type);
 }
 
 TEST_F(TouchEventConverterEvdevTest, ActiveStylusMotion) {
   ui::MockTouchEventConverterEvdev* dev = device();
   EventDeviceInfo devinfo;
   EXPECT_TRUE(CapabilitiesToDeviceInfo(kWilsonBeachActiveStylus, &devinfo));
   dev->Initialize(devinfo);
 
   struct input_event mock_kernel_queue[]{
       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 1},
@@ skipping 13 matching lines @@
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
       {{0, 0}, EV_KEY, BTN_TOUCH, 0},
       {{0, 0}, EV_ABS, ABS_PRESSURE, 0},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 0},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
 
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
-  EXPECT_EQ(4u, size());
+  EXPECT_EQ(7u, size());
 
-  ui::TouchEventParams event = dispatched_event(0);
-  EXPECT_EQ(ui::ET_TOUCH_PRESSED, event.type);
+  ui::MouseMoveEventParams event = dispatched_mouse_move_event(0);
+  EXPECT_EQ(8921, event.location.x());
+  EXPECT_EQ(1072, event.location.y());
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
+            event.pointer_details.pointer_type);
+  EXPECT_EQ(0.f / 1024, event.pointer_details.force);
+
+  ui::MouseButtonEventParams button_event = dispatched_mouse_button_event(1);
+  EXPECT_EQ(8921, button_event.location.x());
+  EXPECT_EQ(1072, button_event.location.y());
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
+            button_event.pointer_details.pointer_type);
+  EXPECT_EQ(35.f / 1024, button_event.pointer_details.force);
+  EXPECT_EQ(button_event.button, static_cast<unsigned int>(BTN_LEFT));
+  EXPECT_EQ(button_event.down, true);
+
+  event = dispatched_mouse_move_event(2);
   EXPECT_EQ(8921, event.location.x());
   EXPECT_EQ(1072, event.location.y());
   EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
             event.pointer_details.pointer_type);
   EXPECT_EQ(35.f / 1024, event.pointer_details.force);
 
-  event = dispatched_event(1);
-  EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
+  event = dispatched_mouse_move_event(3);
   EXPECT_EQ(8934, event.location.x());
   EXPECT_EQ(981, event.location.y());
   EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
             event.pointer_details.pointer_type);
   EXPECT_EQ(184.f / 1024, event.pointer_details.force);
 
-  event = dispatched_event(2);
-  EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
+  event = dispatched_mouse_move_event(4);
   EXPECT_EQ(8930, event.location.x());
   EXPECT_EQ(980, event.location.y());
   EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
             event.pointer_details.pointer_type);
   EXPECT_EQ(348.f / 1024, event.pointer_details.force);
 
-  event = dispatched_event(3);
-  EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
+  button_event = dispatched_mouse_button_event(5);
+  EXPECT_EQ(8930, button_event.location.x());
+  EXPECT_EQ(980, button_event.location.y());
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
+            button_event.pointer_details.pointer_type);
+  EXPECT_EQ(button_event.button, static_cast<unsigned int>(BTN_LEFT));
+  EXPECT_EQ(button_event.down, false);
+
+  event = dispatched_mouse_move_event(6);
   EXPECT_EQ(8930, event.location.x());
   EXPECT_EQ(980, event.location.y());
   EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
             event.pointer_details.pointer_type);
   EXPECT_EQ(0.f / 1024, event.pointer_details.force);
 }
 
 }  // namespace ui