Consuming a touch move prevents only the next scroll update.

content/browser/renderer_host/input/touch_disposition_gesture_filter_unittest.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 "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/renderer_host/input/touch_disposition_gesture_filter.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 #include "content/common/input/web_input_event_traits.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 193 matching lines @@
   PushGesture(WebInputEvent::GestureScrollBegin);
   PressTouchPoint(1, 1);
   EXPECT_FALSE(GesturesSent());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
                             GetAndResetSentGestures()));
 
   // Multiple gestures can be queued for a single event.
   PushGesture(WebInputEvent::GestureFlingStart);
   PushGesture(WebInputEvent::GestureFlingCancel);
-  MoveTouchPoint(0, 1, 1);
+  ReleaseTouchPoint(0);
   EXPECT_FALSE(GesturesSent());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingStart,
                                      WebInputEvent::GestureFlingCancel),
                             GetAndResetSentGestures()));
+}
 
+TEST_F(TouchDispositionGestureFilterTest, BasicGesturesConsumed) {
   // A consumed touch's gesture should not be sent.
+  PushGesture(WebInputEvent::GestureScrollBegin);
+  PressTouchPoint(1, 1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
   PushGesture(WebInputEvent::GestureFlingStart);
   PushGesture(WebInputEvent::GestureFlingCancel);
   ReleaseTouchPoint(0);
-  EXPECT_FALSE(GesturesSent());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, ConsumedThenNotConsumed) {
   // A consumed touch's gesture should not be sent.
   PushGesture(WebInputEvent::GestureScrollBegin);
   PressTouchPoint(1, 1);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   // Even if the subsequent touch is not consumed, continue dropping gestures.
   PushGesture(WebInputEvent::GestureScrollUpdate);
   MoveTouchPoint(0, 2, 2);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   // Even if the subsequent touch had no consumer, continue dropping gestures.
   PushGesture(WebInputEvent::GestureFlingStart);
   ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);

[jdduke (slow), 2014/02/13 19:40:00]

Why this change?

[tdresser, 2014/02/13 20:34:31]

It must have made sense to me at one point, but it sure doesn't anymore...
Removed.

   EXPECT_FALSE(GesturesSent());
 }
 
+TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenConsumed) {
+  // A not consumed touch's gesture should be sent.
+  PushGesture(WebInputEvent::GestureScrollBegin);
+  PressTouchPoint(1, 1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+                            GetAndResetSentGestures()));
+
+  // A newly consumed gesture should not be sent.
+  PushGesture(WebInputEvent::GesturePinchBegin);
+  PressTouchPoint(10, 10);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
+  // And subsequent non-consumed pinch updates should not be sent.
+  PushGesture(WebInputEvent::GestureScrollUpdate);
+  PushGesture(WebInputEvent::GesturePinchUpdate);
+  MoveTouchPoint(0, 2, 2);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollUpdate),
+                            GetAndResetSentGestures()));
+
+  // End events dispatched only when their start events were.
+  PushGesture(WebInputEvent::GesturePinchEnd);
+  ReleaseTouchPoint(1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
+  PushGesture(WebInputEvent::GestureScrollEnd);
+  ReleaseTouchPoint(0);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollEnd),
+                            GetAndResetSentGestures()));
+}
+
+TEST_F(TouchDispositionGestureFilterTest, ScrollAlternatelyConsumed) {
+  // A consumed touch's gesture should not be sent.
+  PushGesture(WebInputEvent::GestureScrollBegin);
+  PressTouchPoint(1, 1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+                            GetAndResetSentGestures()));
+
+  for (size_t i = 0; i < 3; ++i) {
+    PushGesture(WebInputEvent::GestureScrollUpdate);

[jdduke (slow), 2014/02/13 19:40:00]

Nice.

+    MoveTouchPoint(0, 2, 2);
+    SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+    EXPECT_FALSE(GesturesSent());
+
+    PushGesture(WebInputEvent::GestureScrollUpdate);
+    MoveTouchPoint(0, 3, 3);
+    SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollUpdate),
+                              GetAndResetSentGestures()));
+  }

[jdduke (slow), 2014/02/13 19:40:00]

For completeness, could we add a final TouchEnd and make sure a GestureScrollEnd
gets through (when the TouchEnd is consumed)?  I think we handle this below but
it's nice to see the full sequence handled properly.

[tdresser, 2014/02/13 20:34:31]

Done.

+}
+
 TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenNoConsumer) {
   // An unconsumed touch's gesture should be sent.
   PushGesture(WebInputEvent::GestureScrollBegin);
   PressTouchPoint(1, 1);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
                             GetAndResetSentGestures()));
 
   // If the subsequent touch has no consumer (e.g., a secondary pointer is
   // pressed but not on a touch handling rect), send the gesture.
   PushGesture(WebInputEvent::GesturePinchBegin);
   PressTouchPoint(2, 2);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchBegin),
                             GetAndResetSentGestures()));
 
-  // If the subsequent touch is consumed, then the remaining gesture sequence
-  // should be dropped, regardless of subsequent touch ack disposition.
+  // End events should be dispatched when their start events were, independent
+  // of the ack state.
+  PushGesture(WebInputEvent::GesturePinchEnd);
+  ReleaseTouchPoint(1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchEnd),
+                            GetAndResetSentGestures()));
+
+  PushGesture(WebInputEvent::GestureScrollEnd);
+  ReleaseTouchPoint(0);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollEnd),
+                            GetAndResetSentGestures()));
+}
+
+TEST_F(TouchDispositionGestureFilterTest, EndingEventsSent) {
+  PushGesture(WebInputEvent::GestureScrollBegin);
+  PressTouchPoint(1, 1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+                            GetAndResetSentGestures()));
+
+  PushGesture(WebInputEvent::GesturePinchBegin);
+  PressTouchPoint(2, 2);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchBegin),
+                            GetAndResetSentGestures()));
+
+  // Consuming the touchend event can't suppress the match end gesture.
+  PushGesture(WebInputEvent::GesturePinchEnd);
+  ReleaseTouchPoint(1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchEnd),
+                            GetAndResetSentGestures()));
+
+  // But other events in the same packet are still suppressed.
   PushGesture(WebInputEvent::GestureScrollUpdate);
-  PushGesture(WebInputEvent::GesturePinchUpdate);
+  PushGesture(WebInputEvent::GestureScrollEnd);
+  ReleaseTouchPoint(0);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollEnd),
+                            GetAndResetSentGestures()));
+
+  // GestureScrollEnd and GestureFlingStart behave the same in this regard.
+  PushGesture(WebInputEvent::GestureScrollBegin);
+  PressTouchPoint(1, 1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+                            GetAndResetSentGestures()));
+
+  PushGesture(WebInputEvent::GestureFlingStart);
+  ReleaseTouchPoint(0);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingStart),
+                            GetAndResetSentGestures()));
+}
+
+TEST_F(TouchDispositionGestureFilterTest, EndingEventsNotSent) {
+  // Consuming a begin event ensures no end events are sent.
+  PushGesture(WebInputEvent::GestureScrollBegin);
+  PressTouchPoint(1, 1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
+  PushGesture(WebInputEvent::GesturePinchBegin);
+  PressTouchPoint(2, 2);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
+  PushGesture(WebInputEvent::GesturePinchEnd);
+  ReleaseTouchPoint(1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
+  PushGesture(WebInputEvent::GestureScrollEnd);
+  ReleaseTouchPoint(0);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+}
+
+TEST_F(TouchDispositionGestureFilterTest, UpdateEventsSuppressedPerEvent) {
+  PushGesture(WebInputEvent::GestureScrollBegin);
+  PressTouchPoint(1, 1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+                            GetAndResetSentGestures()));
+
+  // Consuming a single scroll or pinch update should suppress only that event.
+  PushGesture(WebInputEvent::GestureScrollUpdate);
   MoveTouchPoint(0, 2, 2);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
+  PushGesture(WebInputEvent::GesturePinchBegin);
+  PressTouchPoint(2, 2);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchBegin),
+                            GetAndResetSentGestures()));
+
+  PushGesture(WebInputEvent::GesturePinchUpdate);
+  MoveTouchPoint(1, 2, 3);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
+  // Subsequent updates should not be affected.
+  PushGesture(WebInputEvent::GestureScrollUpdate);
+  MoveTouchPoint(0, 4, 4);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollUpdate),
+                            GetAndResetSentGestures()));
+
+  PushGesture(WebInputEvent::GesturePinchUpdate);
+  MoveTouchPoint(0, 4, 5);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchUpdate),
+                            GetAndResetSentGestures()));
+
+  PushGesture(WebInputEvent::GesturePinchEnd);
+  ReleaseTouchPoint(1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchEnd),
+                            GetAndResetSentGestures()));
+
+  PushGesture(WebInputEvent::GestureScrollEnd);
+  ReleaseTouchPoint(0);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollEnd),
+                            GetAndResetSentGestures()));
+}
+
+TEST_F(TouchDispositionGestureFilterTest, UpdateEventsDependOnBeginEvents) {
+  PushGesture(WebInputEvent::GestureScrollBegin);
+  PressTouchPoint(1, 1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
+  // Independent packets are never sent when the global state is to drop.
+  PushGesture(WebInputEvent::GestureScrollUpdate);
+  MoveTouchPoint(0, 2, 2);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
+  PushGesture(WebInputEvent::GesturePinchBegin);
+  PressTouchPoint(2, 2);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
+  PushGesture(WebInputEvent::GesturePinchUpdate);
+  MoveTouchPoint(1, 2, 3);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
   PushGesture(WebInputEvent::GesturePinchEnd);
   ReleaseTouchPoint(1);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   PushGesture(WebInputEvent::GestureScrollEnd);
   ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, MultipleTouchSequences) {
   // Queue two touch-to-gestures sequences.
-  PushGesture(WebInputEvent::GestureFlingStart);
+  PushGesture(WebInputEvent::GestureTapDown);
   PressTouchPoint(1, 1);
-  PushGesture(WebInputEvent::GestureFlingCancel);
+  PushGesture(WebInputEvent::GestureTap);
   ReleaseTouchPoint(0);
-  PushGesture(WebInputEvent::GestureFlingStart);
+  PushGesture(WebInputEvent::GestureScrollBegin);
   PressTouchPoint(1, 1);
-  PushGesture(WebInputEvent::GestureFlingCancel);
+  PushGesture(WebInputEvent::GestureScrollEnd);
   ReleaseTouchPoint(0);
 
   // The first gesture sequence should not be allowed.
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   // The subsequent sequence should "reset" allowance.
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingStart,
-                                     WebInputEvent::GestureFlingCancel),
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin,
+                                     WebInputEvent::GestureScrollEnd),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnNewTouchSequence) {
   // Simulate a fling.
+  PushGesture(WebInputEvent::GestureScrollBegin);
   PressTouchPoint(1, 1);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+                            GetAndResetSentGestures()));
   PushGesture(WebInputEvent::GestureFlingStart);
   ReleaseTouchPoint(0);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingStart),
                             GetAndResetSentGestures()));
 
   // A new touch seqeuence should cancel the outstanding fling.
   PressTouchPoint(1, 1);
-  ReleaseTouchPoint(0);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingCancel),
                             GetAndResetSentGestures()));
+  ReleaseTouchPoint(0);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
+  EXPECT_FALSE(GesturesSent());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnScrollBegin) {
   // Simulate a fling sequence.
   PushGesture(WebInputEvent::GestureScrollBegin);
   PushGesture(WebInputEvent::GestureFlingStart);
   PressTouchPoint(1, 1);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin,
                                      WebInputEvent::GestureFlingStart),
                             GetAndResetSentGestures()));
 
   // The new fling should cancel the preceding one.
   PushGesture(WebInputEvent::GestureScrollBegin);
   PushGesture(WebInputEvent::GestureFlingStart);
   ReleaseTouchPoint(0);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingCancel,
                                      WebInputEvent::GestureScrollBegin,
                                      WebInputEvent::GestureFlingStart),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, FlingNotCancelledIfGFCEventReceived) {
   // Simulate a fling that is started then cancelled.
+  PushGesture(WebInputEvent::GestureScrollBegin);
+  PressTouchPoint(1, 1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   PushGesture(WebInputEvent::GestureFlingStart);
-  PressTouchPoint(1, 1);
+  MoveTouchPoint(0, 1, 1);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   PushGesture(WebInputEvent::GestureFlingCancel);
   ReleaseTouchPoint(0);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingStart,
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin,
+                                     WebInputEvent::GestureFlingStart,
                                      WebInputEvent::GestureFlingCancel),
                             GetAndResetSentGestures()));
 
   // A new touch sequence will not inject a GestureFlingCancel, as the fling
   // has already been cancelled.
   PressTouchPoint(1, 1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   ReleaseTouchPoint(0);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   EXPECT_FALSE(GesturesSent());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, TapCancelledWhenScrollBegins) {
   PushGesture(WebInputEvent::GestureTapDown);
   PressTouchPoint(1, 1);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapDown),
@@ skipping 88 matching lines @@
 }
 
 TEST_F(TouchDispositionGestureFilterTest, SpuriousAcksIgnored) {
   // Acks received when the queue is empty will be safely ignored.
   ASSERT_TRUE(IsEmpty());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   PushGesture(WebInputEvent::GestureScrollBegin);
   PressTouchPoint(1, 1);
-  PushGesture(WebInputEvent::GestureScrollEnd);
-  ReleaseTouchPoint(0);
+  PushGesture(WebInputEvent::GestureScrollUpdate);
+  MoveTouchPoint(0, 3,3);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin,
-                                     WebInputEvent::GestureScrollEnd),
+                                     WebInputEvent::GestureScrollUpdate),
                             GetAndResetSentGestures()));
 
   // Even if all packets have been dispatched, the filter may not be empty as
   // there could be follow-up timeout events.  Spurious acks in such cases
   // should also be safely ignored.
   ASSERT_FALSE(IsEmpty());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 }
 
@@ skipping 10 matching lines @@
   EXPECT_TRUE(IsEmpty());
 
   WebTouchEvent touch;
   touch.type = WebInputEvent::TouchCancel;
   EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_ORDER,
             SendTouchGestures(WebInputEvent::GestureShowPress,
                               GestureEventPacket()));
   EXPECT_TRUE(IsEmpty());
 }
 
+TEST_F(TouchDispositionGestureFilterTest, ConsumedTouchCancel) {
+  // An unconsumed touch's gesture should be sent.
+  PushGesture(WebInputEvent::GestureTapDown);
+  PressTouchPoint(1, 1);
+  EXPECT_FALSE(GesturesSent());
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapDown),
+                            GetAndResetSentGestures()));
+
+  PushGesture(WebInputEvent::GestureTapCancel);
+  PushGesture(WebInputEvent::GestureScrollEnd);
+  CancelTouchPoint(0);
+  EXPECT_FALSE(GesturesSent());
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapCancel,
+                                     WebInputEvent::GestureScrollEnd),
+                            GetAndResetSentGestures()));
+}
+
+TEST_F(TouchDispositionGestureFilterTest, TimeoutEventAfterRelease) {

[jdduke (slow), 2014/02/13 19:40:00]

Awesome, thanks!

+  PressTouchPoint(1, 1);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+  PushGesture(WebInputEvent::GestureTapUnconfirmed);
+  ReleaseTouchPoint(0);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapUnconfirmed),
+                            GetAndResetSentGestures()));
+
+  SendTimeoutGesture(WebInputEvent::GestureTap);
+  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTap),
+                            GetAndResetSentGestures()));
+}
+
 }  // namespace content