Suppressed MEs for gestures from cancelled PEs

ui/events/gesture_detection/touch_disposition_gesture_filter.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/gesture_detection/touch_disposition_gesture_filter.h"
 
 #include <stddef.h>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "ui/events/gesture_event_details.h"
 
 namespace ui {
 namespace {
 
 // A BitSet32 is used for tracking dropped gesture types.
 static_assert(ET_GESTURE_TYPE_END - ET_GESTURE_TYPE_START < 32,
               "gesture type count too large");
 
 GestureEventData CreateGesture(EventType type,
                                int motion_event_id,
                                MotionEvent::ToolType primary_tool_type,
                                const GestureEventDataPacket& packet) {
   // As the event is purely synthetic, we needn't be strict with event flags.
   int flags = EF_NONE;
   GestureEventDetails details(type);
   details.set_device_type(GestureDeviceType::DEVICE_TOUCHSCREEN);
-  return GestureEventData(
-      details, motion_event_id, primary_tool_type, packet.timestamp(),
-      packet.touch_location().x(), packet.touch_location().y(),
-      packet.raw_touch_location().x(), packet.raw_touch_location().y(), 1,
-      gfx::RectF(packet.touch_location(), gfx::SizeF()), flags);
+  return GestureEventData(details,
+                          motion_event_id,
+                          primary_tool_type,
+                          packet.timestamp(),
+                          packet.touch_location().x(),
+                          packet.touch_location().y(),
+                          packet.raw_touch_location().x(),
+                          packet.raw_touch_location().y(),
+                          1,
+                          gfx::RectF(packet.touch_location(), gfx::SizeF()),
+                          flags,
+                          packet.unique_touch_event_id());
 }
 
 enum RequiredTouches {
   RT_NONE = 0,
   RT_START = 1 << 0,
   RT_CURRENT = 1 << 1,
 };
 
 struct DispositionHandlingInfo {
   // A bitwise-OR of |RequiredTouches|.
@@ skipping 133 matching lines @@
   if (!Head().empty()) {
     DCHECK_NE(packet.unique_touch_event_id(),
               Head().front().unique_touch_event_id());
 
   }
 
   Tail().push(packet);
   return SUCCESS;
 }
 
-void TouchDispositionGestureFilter::OnTouchEventAck(uint32_t unique_event_id,
-                                                    bool event_consumed) {
+void TouchDispositionGestureFilter::OnTouchEventAck(
+    uint32_t unique_touch_event_id, bool event_consumed) {
   // Spurious asynchronous acks should not trigger a crash.
   if (IsEmpty() || (Head().empty() && sequences_.size() == 1))
     return;
 
   if (Head().empty())
     PopGestureSequence();
 
   if (!Tail().empty() &&
-      Tail().back().unique_touch_event_id() == unique_event_id) {
+      Tail().back().unique_touch_event_id() == unique_touch_event_id) {
     Tail().back().Ack(event_consumed);
     if (sequences_.size() == 1 && Tail().size() == 1)
       SendAckedEvents();
   } else {
     DCHECK(!Head().empty());
-    DCHECK_EQ(Head().front().unique_touch_event_id(), unique_event_id);
+    DCHECK_EQ(Head().front().unique_touch_event_id(), unique_touch_event_id);
     Head().front().Ack(event_consumed);
     SendAckedEvents();
   }
 }
 
 void TouchDispositionGestureFilter::SendAckedEvents() {
   // Dispatch all packets corresponding to ack'ed touches, as well as
   // any pending timeout-based packets.
   bool touch_packet_for_current_ack_handled = false;
   while (!IsEmpty() && (!Head().empty() || sequences_.size() != 1)) {
@@ skipping 82 matching lines @@
     EndScrollIfNecessary(packet);
   }
   // Always send the ET_GESTURE_END event as the last one for every touch event.
   if (gesture_end_index >= 0)
     SendGesture(packet.gesture(gesture_end_index), packet);
 }
 
 void TouchDispositionGestureFilter::SendGesture(
     const GestureEventData& event,
     const GestureEventDataPacket& packet_being_sent) {
+  DCHECK(event.unique_touch_event_id ==
+         packet_being_sent.unique_touch_event_id());
+
   // TODO(jdduke): Factor out gesture stream reparation code into a standalone
   // utility class.
   switch (event.type()) {
     case ET_GESTURE_LONG_TAP:
       if (!needs_tap_ending_event_)
         return;
       CancelTapIfNecessary(packet_being_sent);
       CancelFlingIfNecessary(packet_being_sent);
       break;
     case ET_GESTURE_TAP_DOWN:
@@ skipping 153 matching lines @@
   return false;
 }
 
 bool TouchDispositionGestureFilter::GestureHandlingState::
     HasFilteredGestureType(EventType gesture_type) const {
   return any_gesture_of_type_dropped_.has_bit(
       GetGestureTypeIndex(gesture_type));
 }
 
 }  // namespace content