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 150 matching lines @@
 
     VLOG(1) << "applying touch calibration: "
             << base::StringPrintf("[%d, %d, %d, %d]", cal.bezel_left,
                                   cal.bezel_right, cal.bezel_top,
                                   cal.bezel_bottom);
   }
 
   // TODO(denniskempin): Use EVIOCGKEY to synchronize key state.
 
   events_.resize(touch_points_);
-
+  bool cancelled_state = false;
   if (has_mt_) {
     for (size_t i = 0; i < events_.size(); ++i) {
       events_[i].x = info.GetAbsMtSlotValueWithDefault(ABS_MT_POSITION_X, i, 0);
       events_[i].y = info.GetAbsMtSlotValueWithDefault(ABS_MT_POSITION_Y, i, 0);
       events_[i].tracking_id = info.GetAbsMtSlotValueWithDefault(
           ABS_MT_TRACKING_ID, i, kTrackingIdForUnusedSlot);
       events_[i].touching = (events_[i].tracking_id >= 0);
       events_[i].slot = i;
 
       // Dirty the slot so we'll update the consumer at the first opportunity.
       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_);
+      events_[i].cancelled = major_max_ > 0 && touch_major == major_max_;
+      if (events_[i].cancelled)
+        cancelled_state = true;
     }
   } 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;
     events_[0].radius_y = 0;
     events_[0].pressure = 0;
     events_[0].tool_code = 0;
     events_[0].cancelled = false;
   }
+  if (cancelled_state)
+    CancelAllTouches();
 }
 
 void TouchEventConverterEvdev::Reinitialize() {
   ReleaseButtons();
 
   EventDeviceInfo info;
   if (!info.Initialize(fd_, path_)) {
     LOG(ERROR) << "Failed to synchronize state for touch device: "
                << path_.value();
     Stop();
@@ skipping 221 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() {
+  // TODO(denniskempin): Remove once upper layers properly handle single
+  // cancelled touches.
+  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_)
     touch_noise_finder_->HandleTouches(events_, timestamp);
 
   for (size_t i = 0; i < events_.size(); i++) {
     InProgressTouchEvdev* event = &events_[i];
+    if (event->altered && (event->cancelled ||
+                           (touch_noise_finder_ &&
+                            touch_noise_finder_->SlotHasNoise(event->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