Port Chromium OS touch noise filtering to Chromium

ui/events/ozone/evdev/touch_event_converter_evdev.cc

Index: ui/events/ozone/evdev/touch_event_converter_evdev.cc
diff --git a/ui/events/ozone/evdev/touch_event_converter_evdev.cc b/ui/events/ozone/evdev/touch_event_converter_evdev.cc
index 3aaaa315ba28df765aca924afa6efc9d139e583e..996e68ce5ef5530fcea47d84cbeb38da46e797fd 100644
--- a/ui/events/ozone/evdev/touch_event_converter_evdev.cc
+++ b/ui/events/ozone/evdev/touch_event_converter_evdev.cc
@@ -29,6 +29,7 @@
 #include "ui/events/event_constants.h"
 #include "ui/events/event_switches.h"
 #include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
+#include "ui/events/ozone/evdev/touch_noise/touch_noise_remover.h"
 
 namespace {
 
@@ -83,6 +84,10 @@ TouchEventConverterEvdev::TouchEventConverterEvdev(
       is_type_a_(false),
       touch_points_(0),
       current_slot_(0) {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kExtraTouchNoiseFiltering)) {
+    touch_noise_remover_.reset(new TouchNoiseRemover);
+  }
 }
 
 TouchEventConverterEvdev::~TouchEventConverterEvdev() {
@@ -276,19 +281,16 @@ void TouchEventConverterEvdev::ProcessSyn(const input_event& input) {
   }
 }
 
-void TouchEventConverterEvdev::ReportEvent(int touch_id,
-                                           const InProgressEvents& event,
-                                           const base::TimeDelta& timestamp) {
-  dispatcher_->DispatchTouchEvent(TouchEventParams(
-      id_, touch_id, event.type_, gfx::PointF(event.x_, event.y_),
-      gfx::Vector2dF(event.radius_x_, event.radius_y_), event.pressure_,
-      timestamp));
-}
-
 void TouchEventConverterEvdev::ReportEvents(base::TimeDelta delta) {
+  std::vector<TouchEventParams> to_dispatch;

[flackr, 2015/03/10 05:23:40]

If I understand correctly, we construct and copy changed events into this temp
vector, and then effectively reconstruct the events_ array in
touch_noise_remover from the changed events vector, and then search for canceled
touches in that copy of the touches array to remove from the to_dispatch vector,
so that we can iterate over it and dispatch.

This seems fairly inefficient. Couldn't we have touch_noise_remover look
directly at the events_ array and maintain a canceled touches bool array or even
update the event type to ET_TOUCH_CANCELLED as necessary? I recognize that this
will require a bit of refactoring of the filters to use the fields from events_
but this is called at 60Hz or more so it's probably worth making sure it's fast.

[pkotwicz, 2015/03/13 03:53:16]

I have refactored this as you requested

[flackr, 2015/03/13 15:08:35]

Thanks!

   for (size_t i = 0; i < events_.size(); i++) {
     if (events_[i].altered_) {
-      ReportEvent(i, events_[i], delta);
+      const InProgressEvents& event = events_[i];
+      to_dispatch.push_back(
+          TouchEventParams(id_, i, event.finger_, event.type_,
+                           gfx::PointF(event.x_, event.y_),
+                           gfx::Vector2dF(event.radius_x_, event.radius_y_),
+                           event.pressure_, delta));
 
       // Subsequent events for this finger will be touch-move until it
       // is released.
@@ -296,6 +298,12 @@ void TouchEventConverterEvdev::ReportEvents(base::TimeDelta delta) {
       events_[i].altered_ = false;
     }
   }
+
+  if (touch_noise_remover_)
+    touch_noise_remover_->RemoveNoise(&to_dispatch, delta);

[flackr, 2015/03/10 05:23:39]

Can't just remove updates for noisy touches and not dispatch events for them. In
some cases, we don't identify that a touch is noise on the very first frame in
which that finger shows up. If this happens we'll deliver a touch start, perhaps
some touch moves, and then never send a touch end. 

Instead we need to dispatch an ET_TOUCH_CANCELLED event if an existing touch is
cancelled (doesn't hurt to always send a touch cancelled which is I believe the
current behavior in X). This will cancel any touch start effects (like :active
css pseudoclass) and prevent generation of timer based events (i.e. long press).

[pkotwicz, 2015/03/13 03:53:16]

I have changed the code to dispatch ET_TOUCH_CANCELLED when a touch is
cancelled. This is slightly different from what events_x.cc does.
GetTouchEventType() drops cancelled ET_TOUCH_PRESSes and ET_TOUCH_MOVEs. It
converts cancelled ET_TOUCH_RELEASEs to ET_TOUCH_CANCELLEDs

I have added a test as you requested:
TouchEventConverterEvdevTouchNoiseTest.TouchNoiseFiltering

[flackr, 2015/03/13 15:08:35]

Thanks. That's very strange that we used to keep the "noisy" touch as valid
until the release, and not at all the intention.

+
+  for (const TouchEventParams& params : to_dispatch)
+    dispatcher_->DispatchTouchEvent(params);
 }
 
 }  // namespace ui