Port Chromium OS touch noise filtering to Chromium

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 <errno.h>
 #include <fcntl.h>
 #include <linux/input.h>
 #include <unistd.h>
 
 #include <vector>
 
 #include "base/bind.h"
+#include "base/command_line.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/devices/device_data_manager.h"
+#include "ui/events/event_switches.h"
 #include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
+#include "ui/events/ozone/evdev/touch_evdev_types.h"
 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
+#include "ui/events/ozone/evdev/touch_noise/touch_noise_filter.h"
+#include "ui/events/ozone/evdev/touch_noise/touch_noise_finder.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_source.h"
 
+namespace ui {
+
 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 MockTouchEventConverterEvdev : public TouchEventConverterEvdev {
  public:
   MockTouchEventConverterEvdev(int fd,
                                base::FilePath path,
                                DeviceEventDispatcherEvdev* dispatcher);
   ~MockTouchEventConverterEvdev() override {}
 
   void ConfigureReadMock(struct input_event* queue,
                          long read_this_many,
                          long queue_index);
 
   // Actually dispatch the event reader code.
   void ReadNow() {
     OnFileCanReadWithoutBlocking(read_pipe_);
     base::RunLoop().RunUntilIdle();
   }
 
   void Initialize(const EventDeviceInfo& device_info) override {}
   bool Reinitialize() override { return true; }
 
+  TouchNoiseFinder* touch_noise_finder() { return touch_noise_finder_.get(); }
+
  private:
   int read_pipe_;
   int write_pipe_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTouchEventConverterEvdev);
 };
 
 class MockDeviceEventDispatcherEvdev : public DeviceEventDispatcherEvdev {
  public:
   MockDeviceEventDispatcherEvdev(
@@ skipping 43 matching lines @@
 
   if (pipe(fds))
     PLOG(FATAL) << "failed pipe";
 
   EXPECT_FALSE(SetNonBlocking(fds[0]) || SetNonBlocking(fds[1]))
     << "failed to set non-blocking: " << strerror(errno);
 
   read_pipe_ = fds[0];
   write_pipe_ = fds[1];
 
-  events_.resize(MAX_FINGERS);
+  events_.resize(ui::kNumTouchEvdevSlots);
+  for (size_t i = 0; i < events_.size(); ++i)
+    events_[i].slot = i;
 }
 
 void MockTouchEventConverterEvdev::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;
 }
 
-}  // namespace ui
-
 // Test fixture.
 class TouchEventConverterEvdevTest : public testing::Test {
  public:
   TouchEventConverterEvdevTest() {}
 
   // Overridden from testing::Test:
   void SetUp() override {
     // Set up pipe to satisfy message pump (unused).
     int evdev_io[2];
     if (pipe(evdev_io))
@@ skipping 20 matching lines @@
   }
 
   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];
   }
 
+  void ClearDispatchedEvents() {
+    dispatched_events_.clear();
+  }
+
  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);
@@ skipping 364 matching lines @@
 
 // crbug.com/446939
 TEST_F(TouchEventConverterEvdevTest, CheckSlotLimit) {
   ui::MockTouchEventConverterEvdev* dev = device();
 
   struct input_event mock_kernel_queue[] = {
       {{0, 0}, EV_ABS, ABS_MT_SLOT, 0},
       {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 100},
       {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 999},
       {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 888},
-      {{0, 0}, EV_ABS, ABS_MT_SLOT, ui::TouchEventConverterEvdev::MAX_FINGERS},
+      {{0, 0}, EV_ABS, ABS_MT_SLOT, ui::kNumTouchEvdevSlots},
       {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 200},
       {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 777},
       {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 666},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
   };
 
   // Check that one 1 event is generated
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
   EXPECT_EQ(1u, size());
 }
+
+namespace {
+
+// TouchNoiseFilter which:
+// - Considers all events of type |noise_event_type| as noise.
+// - Keeps track of the events that it receives.
+class EventTypeTouchNoiseFilter : public TouchNoiseFilter {
+ public:
+  explicit EventTypeTouchNoiseFilter(EventType noise_event_type)
+      : noise_event_type_(noise_event_type) {}
+  ~EventTypeTouchNoiseFilter() override {}
+
+  // TouchNoiseFilter:
+  void Filter(const std::vector<InProgressTouchEvdev>& touches,
+              base::TimeDelta time,
+              std::bitset<kNumTouchEvdevSlots>* slots_with_noise) override {
+    for (const InProgressTouchEvdev& touch : touches) {
+      EventType event_type = EventTypeFromTouch(touch);
+      ++counts_[event_type];
+      if (event_type == noise_event_type_)
+        slots_with_noise->set(touch.slot);
+    }
+  }
+
+  // Returns the number of received events of |type|.
+  size_t num_events(EventType type) const {
+    std::map<EventType, size_t>::const_iterator it = counts_.find(type);
+    return it == counts_.end() ? 0u : it->second;
+  }
+
+ private:
+  EventType EventTypeFromTouch(const InProgressTouchEvdev& touch) const {
+    if (touch.touching)
+      return touch.was_touching ? ET_TOUCH_MOVED : ET_TOUCH_PRESSED;
+    return touch.was_touching ? ET_TOUCH_RELEASED : ET_UNKNOWN;
+  }
+
+  EventType noise_event_type_;
+  std::map<EventType, size_t> counts_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventTypeTouchNoiseFilter);
+};
+
+}  // namespace
+
+class TouchEventConverterEvdevTouchNoiseTest
+    : public TouchEventConverterEvdevTest {
+ public:
+  TouchEventConverterEvdevTouchNoiseTest() {}
+  ~TouchEventConverterEvdevTouchNoiseTest() override {}
+
+  // Makes the TouchNoiseFinder use |filter| and only |filter| to filter out
+  // touch noise.
+  void SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter> filter) {
+    TouchNoiseFinder* finder = device()->touch_noise_finder();
+    finder->filters_.clear();
+    finder->filters_.push_back(filter.release());
+  }
+
+  // Returns the first of TouchNoiseFinder's filters.
+  ui::TouchNoiseFilter* first_filter() {
+    TouchNoiseFinder* finder = device()->touch_noise_finder();
+    return finder->filters_.empty() ? nullptr : *finder->filters_.begin();
+  }
+
+  // TouchEventConverterEvdevTest:
+  void SetUp() override {
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kExtraTouchNoiseFiltering);
+    TouchEventConverterEvdevTest::SetUp();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TouchEventConverterEvdevTouchNoiseTest);
+};
+
+// Test that if TouchNoiseFinder identifies an event for an in-progress touch as
+// noise, that the event is converted to ET_TOUCH_CANCELLED and that all
+// subsequent events for the in-progress touch are cancelled.
+TEST_F(TouchEventConverterEvdevTouchNoiseTest, TouchNoiseFiltering) {
+  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},
+    {{0, 0}, EV_SYN, SYN_REPORT, 0},
+
+    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
+    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 43},
+    {{0, 0}, EV_SYN, SYN_REPORT, 0},
+
+    {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1},
+    {{0, 0}, EV_SYN, SYN_REPORT, 0}
+  };
+
+  MockTouchEventConverterEvdev* dev = device();
+  SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter>(
+      new EventTypeTouchNoiseFilter(ET_TOUCH_PRESSED)));
+  dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
+  dev->ReadNow();
+  ASSERT_EQ(0u, size());
+
+  ClearDispatchedEvents();
+  SetTouchNoiseFilter(scoped_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);
+  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);
+
+  ClearDispatchedEvents();
+  SetTouchNoiseFilter(scoped_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);
+  EXPECT_EQ(ET_TOUCH_PRESSED, event0.type);
+  EXPECT_EQ(40, event0.location.x());
+  EXPECT_EQ(41, event0.location.y());
+  TouchEventParams event1 = dispatched_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);
+}
+
+// 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},
+    {{0, 0}, EV_SYN, SYN_REPORT, 0},
+
+    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
+    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 43},
+    {{0, 0}, EV_SYN, SYN_REPORT, 0},
+
+    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 43},
+    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 44},
+    {{0, 0}, EV_SYN, SYN_REPORT, 0},
+
+    {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1},
+    {{0, 0}, EV_SYN, SYN_REPORT, 0}
+  };
+
+  MockTouchEventConverterEvdev* dev = device();
+  SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter>(
+      new EventTypeTouchNoiseFilter(ET_TOUCH_PRESSED)));
+  dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
+  dev->ReadNow();
+  ASSERT_EQ(0u, size());
+
+  EventTypeTouchNoiseFilter* filter =
+      static_cast<EventTypeTouchNoiseFilter*>(first_filter());
+  EXPECT_EQ(1u, filter->num_events(ET_TOUCH_PRESSED));
+  EXPECT_EQ(2u, filter->num_events(ET_TOUCH_MOVED));
+  EXPECT_EQ(1u, filter->num_events(ET_TOUCH_RELEASED));
+}
+
+}  // namespace ui