ui/events/ozone/evdev/touch_event_converter_evdev_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <errno.h>
   6 #include <fcntl.h>
   7 #include <linux/input.h>
   8 #include <unistd.h>
   9
  10 #include <vector>
  11
  12 #include "base/bind.h"
  13 #include "base/command_line.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/posix/eintr_wrapper.h"
  16 #include "base/run_loop.h"
  17 #include "base/time/time.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "ui/events/devices/device_data_manager.h"
  20 #include "ui/events/event_switches.h"
  21 #include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
  22 #include "ui/events/ozone/evdev/event_device_test_util.h"
  23 #include "ui/events/ozone/evdev/touch_evdev_types.h"
  24 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
  25 #include "ui/events/ozone/evdev/touch_noise/touch_noise_filter.h"
  26 #include "ui/events/ozone/evdev/touch_noise/touch_noise_finder.h"
  27 #include "ui/events/platform/platform_event_dispatcher.h"
  28 #include "ui/events/platform/platform_event_source.h"
  29
  30 namespace ui {
  31
  32 namespace {
  33
  34 static int SetNonBlocking(int fd) {
  35   int flags = fcntl(fd, F_GETFL, 0);
  36   if (flags == -1)
  37     flags = 0;
  38   return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
  39 }
  40
  41 const char kTestDevicePath[] = "/dev/input/test-device";
  42
  43 void InitPixelTouchscreen(TouchEventConverterEvdev* device) {
  44   EventDeviceInfo devinfo;
  45   EXPECT_TRUE(CapabilitiesToDeviceInfo(kLinkTouchscreen, &devinfo));
  46   device->Initialize(devinfo);
  47 }
  48
  49 void InitEloTouchscreen(TouchEventConverterEvdev* device) {
  50   EventDeviceInfo devinfo;
  51   EXPECT_TRUE(CapabilitiesToDeviceInfo(kElo_TouchSystems_2700, &devinfo));
  52   device->Initialize(devinfo);
  53 }
  54
  55 }  // namespace
  56
  57 class MockTouchEventConverterEvdev : public TouchEventConverterEvdev {
  58  public:
  59   MockTouchEventConverterEvdev(int fd,
  60                                base::FilePath path,
  61                                const EventDeviceInfo& devinfo,
  62                                DeviceEventDispatcherEvdev* dispatcher);
  63   ~MockTouchEventConverterEvdev() override;
  64
  65   void ConfigureReadMock(struct input_event* queue,
  66                          long read_this_many,
  67                          long queue_index);
  68
  69   // Actually dispatch the event reader code.
  70   void ReadNow() {
  71     OnFileCanReadWithoutBlocking(read_pipe_);
  72     base::RunLoop().RunUntilIdle();
  73   }
  74
  75   void SimulateReinitialize(const EventDeviceInfo& devinfo) {
  76     Initialize(devinfo);
  77   }
  78
  79   void Reinitialize() override {}
  80
  81   TouchNoiseFinder* touch_noise_finder() { return touch_noise_finder_.get(); }
  82
  83  private:
  84   int read_pipe_;
  85   int write_pipe_;
  86
  87   DISALLOW_COPY_AND_ASSIGN(MockTouchEventConverterEvdev);
  88 };
  89
  90 class MockDeviceEventDispatcherEvdev : public DeviceEventDispatcherEvdev {
  91  public:
  92   MockDeviceEventDispatcherEvdev(
  93       const base::Callback<void(const TouchEventParams& params)>& callback)
  94       : callback_(callback) {}
  95   ~MockDeviceEventDispatcherEvdev() override {}
  96
  97   // DeviceEventDispatcherEvdev:
  98   void DispatchKeyEvent(const KeyEventParams& params) override {}
  99   void DispatchMouseMoveEvent(const MouseMoveEventParams& params) override {}
 100   void DispatchMouseButtonEvent(const MouseButtonEventParams& params) override {
 101   }
 102   void DispatchMouseWheelEvent(const MouseWheelEventParams& params) override {}
 103   void DispatchScrollEvent(const ScrollEventParams& params) override {}
 104   void DispatchTouchEvent(const TouchEventParams& params) override {
 105     callback_.Run(params);
 106   }
 107
 108   void DispatchKeyboardDevicesUpdated(
 109       const std::vector<KeyboardDevice>& devices) override {}
 110   void DispatchTouchscreenDevicesUpdated(
 111       const std::vector<TouchscreenDevice>& devices) override {}
 112   void DispatchMouseDevicesUpdated(
 113       const std::vector<InputDevice>& devices) override {}
 114   void DispatchTouchpadDevicesUpdated(
 115       const std::vector<InputDevice>& devices) override {}
 116   void DispatchDeviceListsComplete() override {}
 117
 118  private:
 119   base::Callback<void(const TouchEventParams& params)> callback_;
 120 };
 121
 122 MockTouchEventConverterEvdev::MockTouchEventConverterEvdev(
 123     int fd,
 124     base::FilePath path,
 125     const EventDeviceInfo& devinfo,
 126     DeviceEventDispatcherEvdev* dispatcher)
 127     : TouchEventConverterEvdev(fd,
 128                                path,
 129                                1,
 130                                devinfo,
 131                                dispatcher) {
 132   int fds[2];
 133
 134   if (pipe(fds))
 135     PLOG(FATAL) << "failed pipe";
 136
 137   EXPECT_FALSE(SetNonBlocking(fds[0]) || SetNonBlocking(fds[1]))
 138     << "failed to set non-blocking: " << strerror(errno);
 139
 140   read_pipe_ = fds[0];
 141   write_pipe_ = fds[1];
 142
 143   events_.resize(ui::kNumTouchEvdevSlots);
 144   for (size_t i = 0; i < events_.size(); ++i)
 145     events_[i].slot = i;
 146
 147   SetEnabled(true);
 148 }
 149
 150 MockTouchEventConverterEvdev::~MockTouchEventConverterEvdev() {
 151   SetEnabled(false);
 152 }
 153
 154 void MockTouchEventConverterEvdev::ConfigureReadMock(struct input_event* queue,
 155                                                      long read_this_many,
 156                                                      long queue_index) {
 157   int nwrite = HANDLE_EINTR(write(write_pipe_,
 158                                   queue + queue_index,
 159                                   sizeof(struct input_event) * read_this_many));
 160   DCHECK(nwrite ==
 161          static_cast<int>(sizeof(struct input_event) * read_this_many))
 162       << "write() failed, errno: " << errno;
 163 }
 164
 165 // Test fixture.
 166 class TouchEventConverterEvdevTest : public testing::Test {
 167  public:
 168   TouchEventConverterEvdevTest() {}
 169
 170   // Overridden from testing::Test:
 171   void SetUp() override {
 172     // Set up pipe to satisfy message pump (unused).
 173     int evdev_io[2];
 174     if (pipe(evdev_io))
 175       PLOG(FATAL) << "failed pipe";
 176     events_in_ = evdev_io[0];
 177     events_out_ = evdev_io[1];
 178
 179     // Device creation happens on a worker thread since it may involve blocking
 180     // operations. Simulate that by creating it before creating a UI message
 181     // loop.
 182     EventDeviceInfo devinfo;
 183     dispatcher_.reset(new ui::MockDeviceEventDispatcherEvdev(
 184         base::Bind(&TouchEventConverterEvdevTest::DispatchCallback,
 185                    base::Unretained(this))));
 186     device_.reset(new ui::MockTouchEventConverterEvdev(
 187         events_in_, base::FilePath(kTestDevicePath), devinfo,
 188         dispatcher_.get()));
 189     loop_ = new base::MessageLoopForUI;
 190
 191     ui::DeviceDataManager::CreateInstance();
 192   }
 193
 194   void TearDown() override {
 195     device_.reset();
 196     delete loop_;
 197   }
 198
 199   ui::MockTouchEventConverterEvdev* device() { return device_.get(); }
 200
 201   unsigned size() { return dispatched_events_.size(); }
 202   const ui::TouchEventParams& dispatched_event(unsigned index) {
 203     DCHECK_GT(dispatched_events_.size(), index);
 204     return dispatched_events_[index];
 205   }
 206
 207   void ClearDispatchedEvents() { dispatched_events_.clear(); }
 208
 209   void DestroyDevice() { device_.reset(); }
 210
 211  private:
 212   base::MessageLoop* loop_;
 213   scoped_ptr<ui::MockTouchEventConverterEvdev> device_;
 214   scoped_ptr<ui::MockDeviceEventDispatcherEvdev> dispatcher_;
 215
 216   int events_out_;
 217   int events_in_;
 218
 219   void DispatchCallback(const ui::TouchEventParams& params) {
 220     dispatched_events_.push_back(params);
 221   }
 222   std::vector<ui::TouchEventParams> dispatched_events_;
 223
 224   DISALLOW_COPY_AND_ASSIGN(TouchEventConverterEvdevTest);
 225 };
 226
 227 TEST_F(TouchEventConverterEvdevTest, NoEvents) {
 228   ui::MockTouchEventConverterEvdev* dev = device();
 229   dev->ConfigureReadMock(NULL, 0, 0);
 230   EXPECT_EQ(0u, size());
 231 }
 232
 233 TEST_F(TouchEventConverterEvdevTest, TouchMove) {
 234   ui::MockTouchEventConverterEvdev* dev = device();
 235
 236   InitPixelTouchscreen(dev);
 237
 238   // Captured from Chromebook Pixel (Link).
 239   timeval time;
 240   time = {1427323282, 19203};
 241   struct input_event mock_kernel_queue_press[] = {
 242       {time, EV_ABS, ABS_MT_TRACKING_ID, 3},
 243       {time, EV_ABS, ABS_MT_POSITION_X, 295},
 244       {time, EV_ABS, ABS_MT_POSITION_Y, 421},
 245       {time, EV_ABS, ABS_MT_PRESSURE, 34},
 246       {time, EV_ABS, ABS_MT_TOUCH_MAJOR, 116},
 247       {time, EV_KEY, BTN_TOUCH, 1},
 248       {time, EV_ABS, ABS_X, 295},
 249       {time, EV_ABS, ABS_Y, 421},
 250       {time, EV_ABS, ABS_PRESSURE, 34},
 251       {time, EV_SYN, SYN_REPORT, 0},
 252   };
 253   time = {1427323282, 34693};
 254   struct input_event mock_kernel_queue_move[] = {
 255       {time, EV_ABS, ABS_MT_POSITION_X, 312},
 256       {time, EV_ABS, ABS_MT_POSITION_Y, 432},
 257       {time, EV_ABS, ABS_MT_PRESSURE, 43},
 258       {time, EV_ABS, ABS_MT_TOUCH_MAJOR, 100},
 259       {time, EV_ABS, ABS_X, 312},
 260       {time, EV_ABS, ABS_Y, 432},
 261       {time, EV_ABS, ABS_PRESSURE, 43},
 262       {time, EV_SYN, SYN_REPORT, 0},
 263   };
 264   time = {1427323282, 144540};
 265   struct input_event mock_kernel_queue_release[] = {
 266       {time, EV_ABS, ABS_MT_TRACKING_ID, -1},
 267       {time, EV_KEY, BTN_TOUCH, 0},
 268       {time, EV_ABS, ABS_PRESSURE, 0},
 269       {time, EV_SYN, SYN_REPORT, 0},
 270   };
 271
 272   // Press.
 273   dev->ConfigureReadMock(mock_kernel_queue_press,
 274                          arraysize(mock_kernel_queue_press), 0);
 275   dev->ReadNow();
 276   EXPECT_EQ(1u, size());
 277   ui::TouchEventParams event = dispatched_event(0);
 278   EXPECT_EQ(ui::ET_TOUCH_PRESSED, event.type);
 279   EXPECT_EQ(base::TimeDelta::FromMicroseconds(1427323282019203),
 280             event.timestamp);
 281   EXPECT_EQ(295, event.location.x());
 282   EXPECT_EQ(421, event.location.y());
 283   EXPECT_EQ(0, event.slot);
 284   EXPECT_FLOAT_EQ(58.f, event.radii.x());
 285   EXPECT_FLOAT_EQ(0.13333334f, event.pressure);
 286
 287   // Move.
 288   dev->ConfigureReadMock(mock_kernel_queue_move,
 289                          arraysize(mock_kernel_queue_move), 0);
 290   dev->ReadNow();
 291   EXPECT_EQ(2u, size());
 292   event = dispatched_event(1);
 293   EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
 294   EXPECT_EQ(base::TimeDelta::FromMicroseconds(1427323282034693),
 295             event.timestamp);
 296   EXPECT_EQ(312, event.location.x());
 297   EXPECT_EQ(432, event.location.y());
 298   EXPECT_EQ(0, event.slot);
 299   EXPECT_FLOAT_EQ(50.f, event.radii.x());
 300   EXPECT_FLOAT_EQ(0.16862745f, event.pressure);
 301
 302   // Release.
 303   dev->ConfigureReadMock(mock_kernel_queue_release,
 304                          arraysize(mock_kernel_queue_release), 0);
 305   dev->ReadNow();
 306   EXPECT_EQ(3u, size());
 307   event = dispatched_event(2);
 308   EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
 309   EXPECT_EQ(base::TimeDelta::FromMicroseconds(1427323282144540),
 310             event.timestamp);
 311   EXPECT_EQ(312, event.location.x());
 312   EXPECT_EQ(432, event.location.y());
 313   EXPECT_EQ(0, event.slot);
 314   EXPECT_FLOAT_EQ(50.f, event.radii.x());
 315   EXPECT_FLOAT_EQ(0.16862745f, event.pressure);
 316 }
 317
 318 TEST_F(TouchEventConverterEvdevTest, TwoFingerGesture) {
 319   ui::MockTouchEventConverterEvdev* dev = device();
 320
 321   InitPixelTouchscreen(dev);
 322
 323   struct input_event mock_kernel_queue_press0[] = {
 324     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 684},
 325     {{0, 0}, EV_ABS, ABS_MT_TOUCH_MAJOR, 3},
 326     {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
 327     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
 328     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 51}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
 329   };
 330   // Setup and discard a press.
 331   dev->ConfigureReadMock(mock_kernel_queue_press0, 6, 0);
 332   dev->ReadNow();
 333   EXPECT_EQ(1u, size());
 334
 335   struct input_event mock_kernel_queue_move0[] = {
 336     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
 337   };
 338   // Setup and discard a move.
 339   dev->ConfigureReadMock(mock_kernel_queue_move0, 2, 0);
 340   dev->ReadNow();
 341   EXPECT_EQ(2u, size());
 342
 343   struct input_event mock_kernel_queue_move0press1[] = {
 344     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0},
 345     {{0, 0}, EV_ABS, ABS_MT_SLOT, 1}, {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 686},
 346     {{0, 0}, EV_ABS, ABS_MT_TOUCH_MAJOR, 3},
 347     {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
 348     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 101},
 349     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 102}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
 350   };
 351   // Move on 0, press on 1.
 352   dev->ConfigureReadMock(mock_kernel_queue_move0press1, 9, 0);
 353   dev->ReadNow();
 354   EXPECT_EQ(4u, size());
 355   ui::TouchEventParams ev0 = dispatched_event(2);
 356   ui::TouchEventParams ev1 = dispatched_event(3);
 357
 358   // Move
 359   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev0.type);
 360   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev0.timestamp);
 361   EXPECT_EQ(40, ev0.location.x());
 362   EXPECT_EQ(51, ev0.location.y());
 363   EXPECT_EQ(0, ev0.slot);
 364   EXPECT_FLOAT_EQ(0.17647059f, ev0.pressure);
 365
 366   // Press
 367   EXPECT_EQ(ui::ET_TOUCH_PRESSED, ev1.type);
 368   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1.timestamp);
 369   EXPECT_EQ(101, ev1.location.x());
 370   EXPECT_EQ(102, ev1.location.y());
 371   EXPECT_EQ(1, ev1.slot);
 372   EXPECT_FLOAT_EQ(0.17647059f, ev1.pressure);
 373
 374   // Stationary 0, Moves 1.
 375   struct input_event mock_kernel_queue_stationary0_move1[] = {
 376     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
 377   };
 378   dev->ConfigureReadMock(mock_kernel_queue_stationary0_move1, 2, 0);
 379   dev->ReadNow();
 380   EXPECT_EQ(5u, size());
 381   ev1 = dispatched_event(4);
 382
 383   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev1.type);
 384   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1.timestamp);
 385   EXPECT_EQ(40, ev1.location.x());
 386   EXPECT_EQ(102, ev1.location.y());
 387   EXPECT_EQ(1, ev1.slot);
 388   EXPECT_FLOAT_EQ(0.17647059f, ev1.pressure);
 389
 390   // Move 0, stationary 1.
 391   struct input_event mock_kernel_queue_move0_stationary1[] = {
 392     {{0, 0}, EV_ABS, ABS_MT_SLOT, 0}, {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 39},
 393     {{0, 0}, EV_SYN, SYN_REPORT, 0}
 394   };
 395   dev->ConfigureReadMock(mock_kernel_queue_move0_stationary1, 3, 0);
 396   dev->ReadNow();
 397   EXPECT_EQ(6u, size());
 398   ev0 = dispatched_event(5);
 399
 400   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev0.type);
 401   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev0.timestamp);
 402   EXPECT_EQ(39, ev0.location.x());
 403   EXPECT_EQ(51, ev0.location.y());
 404   EXPECT_EQ(0, ev0.slot);
 405   EXPECT_FLOAT_EQ(0.17647059f, ev0.pressure);
 406
 407   // Release 0, move 1.
 408   struct input_event mock_kernel_queue_release0_move1[] = {
 409     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1}, {{0, 0}, EV_ABS, ABS_MT_SLOT, 1},
 410     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 38}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
 411   };
 412   dev->ConfigureReadMock(mock_kernel_queue_release0_move1, 4, 0);
 413   dev->ReadNow();
 414   EXPECT_EQ(8u, size());
 415   ev0 = dispatched_event(6);
 416   ev1 = dispatched_event(7);
 417
 418   EXPECT_EQ(ui::ET_TOUCH_RELEASED, ev0.type);
 419   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev0.timestamp);
 420   EXPECT_EQ(39, ev0.location.x());
 421   EXPECT_EQ(51, ev0.location.y());
 422   EXPECT_EQ(0, ev0.slot);
 423   EXPECT_FLOAT_EQ(0.17647059f, ev0.pressure);
 424
 425   EXPECT_EQ(ui::ET_TOUCH_MOVED, ev1.type);
 426   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1.timestamp);
 427   EXPECT_EQ(38, ev1.location.x());
 428   EXPECT_EQ(102, ev1.location.y());
 429   EXPECT_EQ(1, ev1.slot);
 430   EXPECT_FLOAT_EQ(0.17647059f, ev1.pressure);
 431
 432   // Release 1.
 433   struct input_event mock_kernel_queue_release1[] = {
 434     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1}, {{0, 0}, EV_SYN, SYN_REPORT, 0},
 435   };
 436   dev->ConfigureReadMock(mock_kernel_queue_release1, 2, 0);
 437   dev->ReadNow();
 438   EXPECT_EQ(9u, size());
 439   ev1 = dispatched_event(8);
 440
 441   EXPECT_EQ(ui::ET_TOUCH_RELEASED, ev1.type);
 442   EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1.timestamp);
 443   EXPECT_EQ(38, ev1.location.x());
 444   EXPECT_EQ(102, ev1.location.y());
 445   EXPECT_EQ(1, ev1.slot);
 446   EXPECT_FLOAT_EQ(0.17647059f, ev1.pressure);
 447 }
 448
 449 TEST_F(TouchEventConverterEvdevTest, Unsync) {
 450   ui::MockTouchEventConverterEvdev* dev = device();
 451
 452   InitPixelTouchscreen(dev);
 453
 454   struct input_event mock_kernel_queue_press0[] = {
 455     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 684},
 456     {{0, 0}, EV_ABS, ABS_MT_TOUCH_MAJOR, 3},
 457     {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
 458     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
 459     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 51}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
 460   };
 461
 462   dev->ConfigureReadMock(mock_kernel_queue_press0, 6, 0);
 463   dev->ReadNow();
 464   EXPECT_EQ(1u, size());
 465
 466   // Prepare a move with a drop.
 467   struct input_event mock_kernel_queue_move0[] = {
 468     {{0, 0}, EV_SYN, SYN_DROPPED, 0},
 469     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
 470   };
 471
 472   // Verify that we didn't receive it/
 473   dev->ConfigureReadMock(mock_kernel_queue_move0, 3, 0);
 474   dev->ReadNow();
 475   EXPECT_EQ(1u, size());
 476
 477   struct input_event mock_kernel_queue_move1[] = {
 478     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
 479   };
 480
 481   // Verify that it re-syncs after a SYN_REPORT.
 482   dev->ConfigureReadMock(mock_kernel_queue_move1, 2, 0);
 483   dev->ReadNow();
 484   EXPECT_EQ(2u, size());
 485 }
 486
 487 TEST_F(TouchEventConverterEvdevTest, ShouldResumeExistingContactsOnStart) {
 488   ui::MockTouchEventConverterEvdev* dev = device();
 489
 490   EventDeviceInfo devinfo;
 491   EXPECT_TRUE(CapabilitiesToDeviceInfo(kLinkTouchscreen, &devinfo));
 492
 493   // Set up an existing contact in slot 0.
 494   devinfo.SetAbsMtSlot(ABS_MT_TRACKING_ID, 0, 1);
 495   devinfo.SetAbsMtSlot(ABS_MT_TOUCH_MAJOR, 0, 100);
 496   devinfo.SetAbsMtSlot(ABS_MT_POSITION_X, 0, 100);
 497   devinfo.SetAbsMtSlot(ABS_MT_POSITION_Y, 0, 100);
 498   devinfo.SetAbsMtSlot(ABS_MT_PRESSURE, 0, 128);
 499
 500   // Initialize the device.
 501   dev->Initialize(devinfo);
 502
 503   // Any report should suffice to dispatch the update.. do an empty one.
 504   struct input_event mock_kernel_queue_empty_report[] = {
 505       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 506   };
 507
 508   dev->ConfigureReadMock(mock_kernel_queue_empty_report,
 509                          arraysize(mock_kernel_queue_empty_report), 0);
 510   dev->ReadNow();
 511   EXPECT_EQ(1u, size());
 512
 513   ui::TouchEventParams ev = dispatched_event(0);
 514   EXPECT_EQ(ET_TOUCH_PRESSED, ev.type);
 515   EXPECT_EQ(0, ev.slot);
 516   EXPECT_FLOAT_EQ(50.f, ev.radii.x());
 517   EXPECT_FLOAT_EQ(0.f, ev.radii.y());
 518   EXPECT_FLOAT_EQ(0.50196081f, ev.pressure);
 519 }
 520
 521 TEST_F(TouchEventConverterEvdevTest, ShouldReleaseContactsOnStop) {
 522   ui::MockTouchEventConverterEvdev* dev = device();
 523
 524   InitPixelTouchscreen(dev);
 525
 526   // Captured from Chromebook Pixel (Link).
 527   timeval time;
 528   time = {1429651083, 686882};
 529   struct input_event mock_kernel_queue_press[] = {
 530       {time, EV_ABS, ABS_MT_TRACKING_ID, 0},
 531       {time, EV_ABS, ABS_MT_POSITION_X, 1003},
 532       {time, EV_ABS, ABS_MT_POSITION_Y, 749},
 533       {time, EV_ABS, ABS_MT_PRESSURE, 50},
 534       {time, EV_ABS, ABS_MT_TOUCH_MAJOR, 116},
 535       {time, EV_KEY, BTN_TOUCH, 1},
 536       {time, EV_ABS, ABS_X, 1003},
 537       {time, EV_ABS, ABS_Y, 749},
 538       {time, EV_ABS, ABS_PRESSURE, 50},
 539       {time, EV_SYN, SYN_REPORT, 0},
 540   };
 541
 542   dev->ConfigureReadMock(mock_kernel_queue_press,
 543                          arraysize(mock_kernel_queue_press), 0);
 544   dev->ReadNow();
 545   EXPECT_EQ(1u, size());
 546
 547   ui::TouchEventParams ev1 = dispatched_event(0);
 548   EXPECT_EQ(ET_TOUCH_PRESSED, ev1.type);
 549   EXPECT_EQ(0, ev1.slot);
 550
 551   DestroyDevice();
 552   EXPECT_EQ(2u, size());
 553
 554   ui::TouchEventParams ev2 = dispatched_event(1);
 555   EXPECT_EQ(ET_TOUCH_RELEASED, ev2.type);
 556   EXPECT_EQ(0, ev2.slot);
 557 }
 558
 559 TEST_F(TouchEventConverterEvdevTest, ShouldRemoveContactsWhenDisabled) {
 560   ui::MockTouchEventConverterEvdev* dev = device();
 561
 562   EventDeviceInfo devinfo;
 563   EXPECT_TRUE(CapabilitiesToDeviceInfo(kLinkTouchscreen, &devinfo));
 564
 565   // Captured from Chromebook Pixel (Link).
 566   timeval time;
 567   time = {1429651083, 686882};
 568   struct input_event mock_kernel_queue_press[] = {
 569       {time, EV_ABS, ABS_MT_TRACKING_ID, 0},
 570       {time, EV_ABS, ABS_MT_POSITION_X, 1003},
 571       {time, EV_ABS, ABS_MT_POSITION_Y, 749},
 572       {time, EV_ABS, ABS_MT_PRESSURE, 50},
 573       {time, EV_ABS, ABS_MT_TOUCH_MAJOR, 116},
 574       {time, EV_KEY, BTN_TOUCH, 1},
 575       {time, EV_ABS, ABS_X, 1003},
 576       {time, EV_ABS, ABS_Y, 749},
 577       {time, EV_ABS, ABS_PRESSURE, 50},
 578       {time, EV_SYN, SYN_REPORT, 0},
 579   };
 580
 581   // Initialize the device.
 582   dev->Initialize(devinfo);
 583
 584   dev->ConfigureReadMock(mock_kernel_queue_press,
 585                          arraysize(mock_kernel_queue_press), 0);
 586   dev->ReadNow();
 587   EXPECT_EQ(1u, size());
 588
 589   ui::TouchEventParams ev1 = dispatched_event(0);
 590   EXPECT_EQ(ET_TOUCH_PRESSED, ev1.type);
 591   EXPECT_EQ(0, ev1.slot);
 592   EXPECT_EQ(1003, ev1.location.x());
 593   EXPECT_EQ(749, ev1.location.y());
 594
 595   // Disable the device (should release the contact).
 596   dev->SetEnabled(false);
 597   EXPECT_EQ(2u, size());
 598
 599   ui::TouchEventParams ev2 = dispatched_event(1);
 600   EXPECT_EQ(ET_TOUCH_RELEASED, ev2.type);
 601   EXPECT_EQ(0, ev2.slot);
 602
 603   // Set up the previous contact in slot 0.
 604   devinfo.SetAbsMtSlot(ABS_MT_TRACKING_ID, 0, 0);
 605   devinfo.SetAbsMtSlot(ABS_MT_TOUCH_MAJOR, 0, 116);
 606   devinfo.SetAbsMtSlot(ABS_MT_POSITION_X, 0, 1003);
 607   devinfo.SetAbsMtSlot(ABS_MT_POSITION_Y, 0, 749);
 608   devinfo.SetAbsMtSlot(ABS_MT_PRESSURE, 0, 50);
 609
 610   // Re-enable the device (should re-apply the contact).
 611   dev->SimulateReinitialize(devinfo);
 612   dev->SetEnabled(true);
 613   EXPECT_EQ(3u, size());
 614
 615   ui::TouchEventParams ev3 = dispatched_event(2);
 616   EXPECT_EQ(ET_TOUCH_PRESSED, ev3.type);
 617   EXPECT_EQ(0, ev3.slot);
 618   EXPECT_EQ(1003, ev3.location.x());
 619   EXPECT_EQ(749, ev3.location.y());
 620 }
 621
 622 // crbug.com/477695
 623 TEST_F(TouchEventConverterEvdevTest, ShouldUseLeftButtonIfNoTouchButton) {
 624   ui::MockTouchEventConverterEvdev* dev = device();
 625
 626   InitEloTouchscreen(dev);
 627
 628   // Captured from Elo TouchSystems 2700.
 629   timeval time;
 630   time = {1433965490, 837958};
 631   struct input_event mock_kernel_queue_press[] = {
 632       {time, EV_ABS, ABS_X, 3654},
 633       {time, EV_ABS, ABS_Y, 1054},
 634       {time, EV_ABS, ABS_MISC, 18},
 635       {time, EV_SYN, SYN_REPORT, 0},
 636
 637       {time, EV_MSC, MSC_SCAN, 90001},
 638       {time, EV_KEY, BTN_LEFT, 1},
 639       {time, EV_ABS, ABS_Y, 1055},
 640       {time, EV_ABS, ABS_MISC, 25},
 641       {time, EV_SYN, SYN_REPORT, 0},
 642   };
 643   time = {1433965491, 1953};
 644   struct input_event mock_kernel_queue_move[] = {
 645       {time, EV_ABS, ABS_X, 3644},
 646       {time, EV_ABS, ABS_Y, 1059},
 647       {time, EV_ABS, ABS_MISC, 36},
 648       {time, EV_SYN, SYN_REPORT, 0},
 649   };
 650   time = {1433965491, 225959};
 651   struct input_event mock_kernel_queue_release[] = {
 652       {time, EV_MSC, MSC_SCAN, 90001},
 653       {time, EV_KEY, BTN_LEFT, 0},
 654       {time, EV_ABS, ABS_MISC, 0},
 655       {time, EV_SYN, SYN_REPORT, 0},
 656   };
 657
 658   // Press.
 659   dev->ConfigureReadMock(mock_kernel_queue_press,
 660                          arraysize(mock_kernel_queue_press), 0);
 661   dev->ReadNow();
 662   EXPECT_EQ(1u, size());
 663   ui::TouchEventParams event = dispatched_event(0);
 664   EXPECT_EQ(ui::ET_TOUCH_PRESSED, event.type);
 665   EXPECT_EQ(base::TimeDelta::FromMicroseconds(1433965490837958),
 666             event.timestamp);
 667   EXPECT_EQ(3654, event.location.x());
 668   EXPECT_EQ(1055, event.location.y());
 669   EXPECT_EQ(0, event.slot);
 670   EXPECT_FLOAT_EQ(0.f, event.radii.x());
 671   EXPECT_FLOAT_EQ(0.f, event.pressure);
 672
 673   // Move.
 674   dev->ConfigureReadMock(mock_kernel_queue_move,
 675                          arraysize(mock_kernel_queue_move), 0);
 676   dev->ReadNow();
 677   EXPECT_EQ(2u, size());
 678   event = dispatched_event(1);
 679   EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
 680   EXPECT_EQ(base::TimeDelta::FromMicroseconds(1433965491001953),
 681             event.timestamp);
 682   EXPECT_EQ(3644, event.location.x());
 683   EXPECT_EQ(1059, event.location.y());
 684   EXPECT_EQ(0, event.slot);
 685   EXPECT_FLOAT_EQ(0.f, event.radii.x());
 686   EXPECT_FLOAT_EQ(0.f, event.pressure);
 687
 688   // Release.
 689   dev->ConfigureReadMock(mock_kernel_queue_release,
 690                          arraysize(mock_kernel_queue_release), 0);
 691   dev->ReadNow();
 692   EXPECT_EQ(3u, size());
 693   event = dispatched_event(2);
 694   EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
 695   EXPECT_EQ(base::TimeDelta::FromMicroseconds(1433965491225959),
 696             event.timestamp);
 697   EXPECT_EQ(3644, event.location.x());
 698   EXPECT_EQ(1059, event.location.y());
 699   EXPECT_EQ(0, event.slot);
 700   EXPECT_FLOAT_EQ(0.f, event.radii.x());
 701   EXPECT_FLOAT_EQ(0.f, event.pressure);
 702
 703   // No dispatch on destruction.
 704   DestroyDevice();
 705   EXPECT_EQ(3u, size());
 706 }
 707
 708 // crbug.com/407386
 709 TEST_F(TouchEventConverterEvdevTest,
 710        DontChangeMultitouchPositionFromLegacyAxes) {
 711   ui::MockTouchEventConverterEvdev* dev = device();
 712
 713   InitPixelTouchscreen(dev);
 714
 715   struct input_event mock_kernel_queue[] = {
 716       {{0, 0}, EV_ABS, ABS_MT_SLOT, 0},
 717       {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 100},
 718       {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 999},
 719       {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 888},
 720       {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 55},
 721       {{0, 0}, EV_ABS, ABS_MT_SLOT, 1},
 722       {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 200},
 723       {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 44},
 724       {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 777},
 725       {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 666},
 726       {{0, 0}, EV_ABS, ABS_X, 999},
 727       {{0, 0}, EV_ABS, ABS_Y, 888},
 728       {{0, 0}, EV_ABS, ABS_PRESSURE, 55},
 729       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 730   };
 731
 732   // Check that two events are generated.
 733   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
 734   dev->ReadNow();
 735
 736   const unsigned int kExpectedEventCount = 2;
 737   EXPECT_EQ(kExpectedEventCount, size());
 738   if (kExpectedEventCount != size())
 739     return;
 740
 741   ui::TouchEventParams ev0 = dispatched_event(0);
 742   ui::TouchEventParams ev1 = dispatched_event(1);
 743
 744   EXPECT_EQ(0, ev0.slot);
 745   EXPECT_EQ(999, ev0.location.x());
 746   EXPECT_EQ(888, ev0.location.y());
 747   EXPECT_FLOAT_EQ(0.21568628f, ev0.pressure);
 748
 749   EXPECT_EQ(1, ev1.slot);
 750   EXPECT_EQ(777, ev1.location.x());
 751   EXPECT_EQ(666, ev1.location.y());
 752   EXPECT_FLOAT_EQ(0.17254902f, ev1.pressure);
 753 }
 754
 755 // crbug.com/446939
 756 TEST_F(TouchEventConverterEvdevTest, CheckSlotLimit) {
 757   ui::MockTouchEventConverterEvdev* dev = device();
 758
 759   struct input_event mock_kernel_queue[] = {
 760       {{0, 0}, EV_ABS, ABS_MT_SLOT, 0},
 761       {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 100},
 762       {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 999},
 763       {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 888},
 764       {{0, 0}, EV_ABS, ABS_MT_SLOT, ui::kNumTouchEvdevSlots},
 765       {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 200},
 766       {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 777},
 767       {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 666},
 768       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 769   };
 770
 771   // Check that one 1 event is generated
 772   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
 773   dev->ReadNow();
 774   EXPECT_EQ(1u, size());
 775 }
 776
 777 namespace {
 778
 779 // TouchNoiseFilter which:
 780 // - Considers all events of type |noise_event_type| as noise.
 781 // - Keeps track of the events that it receives.
 782 class EventTypeTouchNoiseFilter : public TouchNoiseFilter {
 783  public:
 784   explicit EventTypeTouchNoiseFilter(EventType noise_event_type)
 785       : noise_event_type_(noise_event_type) {}
 786   ~EventTypeTouchNoiseFilter() override {}
 787
 788   // TouchNoiseFilter:
 789   void Filter(const std::vector<InProgressTouchEvdev>& touches,
 790               base::TimeDelta time,
 791               std::bitset<kNumTouchEvdevSlots>* slots_with_noise) override {
 792     for (const InProgressTouchEvdev& touch : touches) {
 793       EventType event_type = EventTypeFromTouch(touch);
 794       ++counts_[event_type];
 795       if (event_type == noise_event_type_)
 796         slots_with_noise->set(touch.slot);
 797     }
 798   }
 799
 800   // Returns the number of received events of |type|.
 801   size_t num_events(EventType type) const {
 802     std::map<EventType, size_t>::const_iterator it = counts_.find(type);
 803     return it == counts_.end() ? 0u : it->second;
 804   }
 805
 806  private:
 807   EventType EventTypeFromTouch(const InProgressTouchEvdev& touch) const {
 808     if (touch.touching)
 809       return touch.was_touching ? ET_TOUCH_MOVED : ET_TOUCH_PRESSED;
 810     return touch.was_touching ? ET_TOUCH_RELEASED : ET_UNKNOWN;
 811   }
 812
 813   EventType noise_event_type_;
 814   std::map<EventType, size_t> counts_;
 815
 816   DISALLOW_COPY_AND_ASSIGN(EventTypeTouchNoiseFilter);
 817 };
 818
 819 }  // namespace
 820
 821 class TouchEventConverterEvdevTouchNoiseTest
 822     : public TouchEventConverterEvdevTest {
 823  public:
 824   TouchEventConverterEvdevTouchNoiseTest() {}
 825   ~TouchEventConverterEvdevTouchNoiseTest() override {}
 826
 827   // Makes the TouchNoiseFinder use |filter| and only |filter| to filter out
 828   // touch noise.
 829   void SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter> filter) {
 830     TouchNoiseFinder* finder = device()->touch_noise_finder();
 831     finder->filters_.clear();
 832     finder->filters_.push_back(filter.release());
 833   }
 834
 835   // Returns the first of TouchNoiseFinder's filters.
 836   ui::TouchNoiseFilter* first_filter() {
 837     TouchNoiseFinder* finder = device()->touch_noise_finder();
 838     return finder->filters_.empty() ? nullptr : *finder->filters_.begin();
 839   }
 840
 841   // TouchEventConverterEvdevTest:
 842   void SetUp() override {
 843     base::CommandLine::ForCurrentProcess()->AppendSwitch(
 844         switches::kExtraTouchNoiseFiltering);
 845     TouchEventConverterEvdevTest::SetUp();
 846   }
 847
 848  private:
 849   DISALLOW_COPY_AND_ASSIGN(TouchEventConverterEvdevTouchNoiseTest);
 850 };
 851
 852 // Test that if TouchNoiseFinder identifies an event for an in-progress touch as
 853 // noise, that the event is converted to ET_TOUCH_CANCELLED and that all
 854 // subsequent events for the in-progress touch are cancelled.
 855 TEST_F(TouchEventConverterEvdevTouchNoiseTest, TouchNoiseFiltering) {
 856   struct input_event mock_kernel_queue[] = {
 857     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 684},
 858     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40},
 859     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 41},
 860     {{0, 0}, EV_SYN, SYN_REPORT, 0},
 861
 862     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
 863     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 43},
 864     {{0, 0}, EV_SYN, SYN_REPORT, 0},
 865
 866     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1},
 867     {{0, 0}, EV_SYN, SYN_REPORT, 0}
 868   };
 869
 870   MockTouchEventConverterEvdev* dev = device();
 871   SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter>(
 872       new EventTypeTouchNoiseFilter(ET_TOUCH_PRESSED)));
 873   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
 874   dev->ReadNow();
 875   ASSERT_EQ(0u, size());
 876
 877   ClearDispatchedEvents();
 878   SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter>(
 879       new EventTypeTouchNoiseFilter(ET_TOUCH_MOVED)));
 880   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
 881   dev->ReadNow();
 882   ASSERT_EQ(2u, size());
 883   TouchEventParams event0 = dispatched_event(0);
 884   EXPECT_EQ(ET_TOUCH_PRESSED, event0.type);
 885   EXPECT_EQ(40, event0.location.x());
 886   EXPECT_EQ(41, event0.location.y());
 887   EXPECT_EQ(ET_TOUCH_CANCELLED, dispatched_event(1).type);
 888
 889   ClearDispatchedEvents();
 890   SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter>(
 891       new EventTypeTouchNoiseFilter(ET_TOUCH_RELEASED)));
 892   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
 893   dev->ReadNow();
 894   ASSERT_EQ(3u, size());
 895   event0 = dispatched_event(0);
 896   EXPECT_EQ(ET_TOUCH_PRESSED, event0.type);
 897   EXPECT_EQ(40, event0.location.x());
 898   EXPECT_EQ(41, event0.location.y());
 899   TouchEventParams event1 = dispatched_event(1);
 900   EXPECT_EQ(ET_TOUCH_MOVED, event1.type);
 901   EXPECT_EQ(42, event1.location.x());
 902   EXPECT_EQ(43, event1.location.y());
 903   EXPECT_EQ(ET_TOUCH_CANCELLED, dispatched_event(2).type);
 904 }
 905
 906 // Test that TouchEventConverterEvdev keeps sending events to
 907 // TouchNoiseFinder after the touch is canceled.
 908 TEST_F(TouchEventConverterEvdevTouchNoiseTest,
 909        DoNotSendTouchCancelsToTouchNoiseFinder) {
 910   struct input_event mock_kernel_queue[] = {
 911     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 684},
 912     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40},
 913     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 41},
 914     {{0, 0}, EV_SYN, SYN_REPORT, 0},
 915
 916     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
 917     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 43},
 918     {{0, 0}, EV_SYN, SYN_REPORT, 0},
 919
 920     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 43},
 921     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 44},
 922     {{0, 0}, EV_SYN, SYN_REPORT, 0},
 923
 924     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1},
 925     {{0, 0}, EV_SYN, SYN_REPORT, 0}
 926   };
 927
 928   MockTouchEventConverterEvdev* dev = device();
 929   SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter>(
 930       new EventTypeTouchNoiseFilter(ET_TOUCH_PRESSED)));
 931   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
 932   dev->ReadNow();
 933   ASSERT_EQ(0u, size());
 934
 935   EventTypeTouchNoiseFilter* filter =
 936       static_cast<EventTypeTouchNoiseFilter*>(first_filter());
 937   EXPECT_EQ(1u, filter->num_events(ET_TOUCH_PRESSED));
 938   EXPECT_EQ(2u, filter->num_events(ET_TOUCH_MOVED));
 939   EXPECT_EQ(1u, filter->num_events(ET_TOUCH_RELEASED));
 940 }
 941
 942 TEST_F(TouchEventConverterEvdevTest, ActiveStylusTouchAndRelease) {
 943   ui::MockTouchEventConverterEvdev* dev = device();
 944   EventDeviceInfo devinfo;
 945   EXPECT_TRUE(CapabilitiesToDeviceInfo(kWilsonBeachActiveStylus, &devinfo));
 946   dev->Initialize(devinfo);
 947
 948   struct input_event mock_kernel_queue[]{
 949       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 1},
 950       {{0, 0}, EV_ABS, ABS_X, 9170},
 951       {{0, 0}, EV_ABS, ABS_Y, 3658},
 952       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 953       {{0, 0}, EV_KEY, BTN_TOUCH, 1},
 954       {{0, 0}, EV_ABS, ABS_PRESSURE, 60},
 955       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 956       {{0, 0}, EV_KEY, BTN_TOUCH, 0},
 957       {{0, 0}, EV_ABS, ABS_X, 9173},
 958       {{0, 0}, EV_ABS, ABS_Y, 3906},
 959       {{0, 0}, EV_ABS, ABS_PRESSURE, 0},
 960       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 961       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 0},
 962       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 963   };
 964
 965   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
 966   dev->ReadNow();
 967   EXPECT_EQ(2u, size());
 968
 969   ui::TouchEventParams event = dispatched_event(0);
 970   EXPECT_EQ(ui::ET_TOUCH_PRESSED, event.type);
 971   EXPECT_EQ(9170, event.location.x());
 972   EXPECT_EQ(3658, event.location.y());
 973   EXPECT_EQ(60.f / 1024, event.pressure);
 974
 975   event = dispatched_event(1);
 976   EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
 977   EXPECT_EQ(9173, event.location.x());
 978   EXPECT_EQ(3906, event.location.y());
 979   EXPECT_EQ(0.f / 1024, event.pressure);
 980 }
 981
 982 TEST_F(TouchEventConverterEvdevTest, ActiveStylusMotion) {
 983   ui::MockTouchEventConverterEvdev* dev = device();
 984   EventDeviceInfo devinfo;
 985   EXPECT_TRUE(CapabilitiesToDeviceInfo(kWilsonBeachActiveStylus, &devinfo));
 986   dev->Initialize(devinfo);
 987
 988   struct input_event mock_kernel_queue[]{
 989       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 1},
 990       {{0, 0}, EV_ABS, ABS_X, 8921},
 991       {{0, 0}, EV_ABS, ABS_Y, 1072},
 992       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 993       {{0, 0}, EV_KEY, BTN_TOUCH, 1},
 994       {{0, 0}, EV_ABS, ABS_PRESSURE, 35},
 995       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 996       {{0, 0}, EV_ABS, ABS_X, 8934},
 997       {{0, 0}, EV_ABS, ABS_Y, 981},
 998       {{0, 0}, EV_ABS, ABS_PRESSURE, 184},
 999       {{0, 0}, EV_SYN, SYN_REPORT, 0},
1000       {{0, 0}, EV_ABS, ABS_X, 8930},
1001       {{0, 0}, EV_ABS, ABS_Y, 980},
1002       {{0, 0}, EV_ABS, ABS_PRESSURE, 348},
1003       {{0, 0}, EV_SYN, SYN_REPORT, 0},
1004       {{0, 0}, EV_KEY, BTN_TOUCH, 0},
1005       {{0, 0}, EV_ABS, ABS_PRESSURE, 0},
1006       {{0, 0}, EV_SYN, SYN_REPORT, 0},
1007       {{0, 0}, EV_KEY, BTN_TOOL_PEN, 0},
1008       {{0, 0}, EV_SYN, SYN_REPORT, 0},
1009   };
1010
1011   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
1012   dev->ReadNow();
1013   EXPECT_EQ(4u, size());
1014
1015   ui::TouchEventParams event = dispatched_event(0);
1016   EXPECT_EQ(ui::ET_TOUCH_PRESSED, event.type);
1017   EXPECT_EQ(8921, event.location.x());
1018   EXPECT_EQ(1072, event.location.y());
1019   EXPECT_EQ(35.f / 1024, event.pressure);
1020
1021   event = dispatched_event(1);
1022   EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
1023   EXPECT_EQ(8934, event.location.x());
1024   EXPECT_EQ(981, event.location.y());
1025   EXPECT_EQ(184.f / 1024, event.pressure);
1026
1027   event = dispatched_event(2);
1028   EXPECT_EQ(ui::ET_TOUCH_MOVED, event.type);
1029   EXPECT_EQ(8930, event.location.x());
1030   EXPECT_EQ(980, event.location.y());
1031   EXPECT_EQ(348.f / 1024, event.pressure);
1032
1033   event = dispatched_event(3);
1034   EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
1035   EXPECT_EQ(8930, event.location.x());
1036   EXPECT_EQ(980, event.location.y());
1037   EXPECT_EQ(0.f / 1024, event.pressure);
1038 }
1039
1040 }  // namespace ui