Clear pending events upon main frame navigation

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 "base/auto_reset.h"
 #include "base/logging.h"
 #include "ui/events/gesture_event_details.h"
 
@@ skipping 165 matching lines @@
     return;
 
   if (Head().empty())
     PopGestureSequence();
 
   GestureSequence& sequence = Head();
 
   // Dispatch the packet corresponding to the ack'ed touch, as well as any
   // additional timeout-based packets queued before the ack was received.
   bool touch_packet_for_current_ack_handled = false;
+  bool sequence_cancelled = false;
   while (!sequence.empty()) {
     DCHECK_NE(sequence.front().gesture_source(),
               GestureEventDataPacket::UNDEFINED);
     DCHECK_NE(sequence.front().gesture_source(),
               GestureEventDataPacket::INVALID);
 
     GestureEventDataPacket::GestureSource source =
         sequence.front().gesture_source();
     if (source != GestureEventDataPacket::TOUCH_TIMEOUT) {
       // We should handle at most one non-timeout based packet.
       if (touch_packet_for_current_ack_handled)
         break;
       state_.OnTouchEventAck(event_consumed, IsTouchStartEvent(source));
       touch_packet_for_current_ack_handled = true;
+      sequence_cancelled =
+          source == GestureEventDataPacket::TOUCH_SEQUENCE_CANCEL;
     }
     // We need to pop the current sequence before sending the packet, because
     // sending the packet could result in this method being re-entered (e.g. on
     // Aura, we could trigger a touch-cancel). As popping the sequence destroys
     // the packet, we copy the packet before popping it.
     const GestureEventDataPacket packet = sequence.front();
     sequence.pop();
     FilterAndSendPacket(packet);
   }
+
+  if (sequence.empty() && sequence_cancelled)
+    PopGestureSequence();
+
   DCHECK(touch_packet_for_current_ack_handled);
 }
 
 bool TouchDispositionGestureFilter::IsEmpty() const {
   return sequences_.empty();
 }
 
 void TouchDispositionGestureFilter::FilterAndSendPacket(
     const GestureEventDataPacket& packet) {
   if (packet.gesture_source() == GestureEventDataPacket::TOUCH_SEQUENCE_START) {
@@ skipping 199 matching lines @@
        last_gesture_of_type_dropped_.has_bit(
            GetGestureTypeIndex(antecedent_event_type)))) {
     last_gesture_of_type_dropped_.mark_bit(GetGestureTypeIndex(gesture_type));
     return true;
   }
   last_gesture_of_type_dropped_.clear_bit(GetGestureTypeIndex(gesture_type));
   return false;
 }
 
 }  // namespace content