ozone: Cancel all touches once a single touch is cancelled

ui/events/ozone/evdev/touch_event_converter_evdev.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 <fcntl.h>
 #include <linux/input.h>
 #include <poll.h>
@@ skipping 170 matching lines @@
       events_[i].altered = true;
 
       // Optional bits.
       int touch_major =
           info.GetAbsMtSlotValueWithDefault(ABS_MT_TOUCH_MAJOR, i, 0);
       events_[i].radius_x = touch_major / 2.0f;
       events_[i].radius_y =
           info.GetAbsMtSlotValueWithDefault(ABS_MT_TOUCH_MINOR, i, 0) / 2.0f;
       events_[i].pressure = ScalePressure(
           info.GetAbsMtSlotValueWithDefault(ABS_MT_PRESSURE, i, 0));
-      events_[i].cancelled = (major_max_ > 0 && touch_major == major_max_);
+      if (major_max_ > 0 && touch_major == major_max_) {
+        CancelAllTouches();

[spang, 2017/01/19 01:25:51]

Can this move after the loop so it runs at most once?

After this change Initialize() will never set |cancelled| to false. Is that
intended?

[denniskempin, 2017/01/20 02:04:39]

Done.

+      }
     }
   } else {
     // TODO(spang): Add key state to EventDeviceInfo to allow initial contact.
     // (and make sure to take into account quirk_left_mouse_button_)
     events_[0].x = 0;
     events_[0].y = 0;
     events_[0].tracking_id = kTrackingIdForUnusedSlot;
     events_[0].touching = false;
     events_[0].slot = 0;
     events_[0].radius_x = 0;
@@ skipping 162 matching lines @@
 void TouchEventConverterEvdev::ProcessAbs(const input_event& input) {
   switch (input.code) {
     case ABS_MT_TOUCH_MAJOR:
       // TODO(spang): If we have all of major, minor, and orientation,
       // we can scale the ellipse correctly. However on the Pixel we get
       // neither minor nor orientation, so this is all we can do.
       events_[current_slot_].radius_x = input.value / 2.0f;
 
       // The MT protocol cannot communicate cancelled touches, so some kernel
       // drivers will identify palms by setting touch major to max.
-      if (major_max_ > 0 && input.value == major_max_)
-        events_[current_slot_].cancelled = true;
+      if (major_max_ > 0 && input.value == major_max_) {
+        CancelAllTouches();

[spang, 2017/01/19 01:25:51]

What if we get a new contact with a lower numbered slot before the syn_report ?
Such a press will be reordered before all of the cancels and will still be alive
despite the attempt to cancel everything.

We really shouldn't to do anything here other than update events_[current_slot_]
to match our view the kernel internal state.

[denniskempin, 2017/01/20 02:04:39]

Done.

+      }
       break;
     case ABS_MT_TOUCH_MINOR:
       events_[current_slot_].radius_y = input.value / 2.0f;
       break;
     case ABS_MT_POSITION_X:
       events_[current_slot_].x = input.value;
       break;
     case ABS_MT_POSITION_Y:
       events_[current_slot_].y = input.value;
       break;
@@ skipping 52 matching lines @@
     EventType event_type,
     base::TimeTicks timestamp) {
   ui::PointerDetails details(event.reported_tool_type, event.radius_x,
                              event.radius_y, event.pressure,
                              /* tilt_x */ 0.0f, /* tilt_y */ 0.0f);
   dispatcher_->DispatchTouchEvent(
       TouchEventParams(input_device_.id, event.slot, event_type,
                        gfx::PointF(event.x, event.y), details, timestamp));
 }
 
+void TouchEventConverterEvdev::CancelAllTouches() {
+  for (size_t i = 0; i < events_.size(); i++) {
+    InProgressTouchEvdev* event = &events_[i];
+    if (event->was_touching || event->touching) {
+      event->cancelled = true;
+      event->altered = true;
+    }
+  }
+}
+
 void TouchEventConverterEvdev::ReportEvents(base::TimeTicks timestamp) {
   if (dropped_events_) {
     Reinitialize();
     dropped_events_ = false;
   }
 
-  if (touch_noise_finder_)
+  if (touch_noise_finder_) {
     touch_noise_finder_->HandleTouches(events_, timestamp);
+    for (size_t i = 0; i < events_.size(); i++) {
+      if (touch_noise_finder_->SlotHasNoise(events_[i].slot)) {
+        CancelAllTouches();
+        break;
+      }
+    }
+  }
 
   for (size_t i = 0; i < events_.size(); i++) {
     InProgressTouchEvdev* event = &events_[i];
     if (!event->altered)
       continue;
 
     if (enable_palm_suppression_callback_)
       enable_palm_suppression_callback_.Run(event->tool_code > 0);
 
-    if (touch_noise_finder_ && touch_noise_finder_->SlotHasNoise(event->slot))
-      event->cancelled = true;
-
     EventType event_type = GetEventTypeForTouch(*event);
     // The tool type is fixed with the touch pressed event and does not change.
     if (event_type == ET_TOUCH_PRESSED)
       event->reported_tool_type = GetEventPointerType(event->tool_code);
     if (event_type != ET_UNKNOWN)
       ReportTouchEvent(*event, event_type, timestamp);
 
     event->was_cancelled = event->cancelled;
     event->was_touching = event->touching;
     event->altered = false;
@@ skipping 54 matching lines @@
   if (pressure_max_ - pressure_min_)
     pressure /= pressure_max_ - pressure_min_;
   return pressure;
 }
 
 int TouchEventConverterEvdev::NextTrackingId() {
   return next_tracking_id_++ & kMaxTrackingId;
 }
 
 }  // namespace ui