Add touch scrolling modes experimental flags (DEPRECATED)

content/browser/renderer_host/input/gesture_event_queue_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/gesture_event_queue.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 180 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()));
+}
 
-  // A consumed touch's gesture should not be sent.
+TEST_F(GestureEventQueueTest, BasicGesturesConsumed) {
+  // An consumed touch's gesture should be sent.

[tdresser, 2014/02/03 15:52:58]

I'm not clear on the purpose of this comment modification.
Aren't we still testing that consumed a consumed touch's gesture should not be
sent?

Also, "An" -> "A". 

[tdresser, 2014/02/03 18:55:14]

Done.

+  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(GestureEventQueueTest, 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);
   EXPECT_FALSE(GesturesSent());
 }
 
+
+TEST_F(GestureEventQueueTest, 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 updates should not be sent.
+  PushGesture(WebInputEvent::GestureScrollUpdate);
+  PushGesture(WebInputEvent::GesturePinchUpdate);
+  MoveTouchPoint(0, 2, 2);
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_FALSE(GesturesSent());
+
+  // 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(GestureEventQueueTest, 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 dispatched when their start events were independent

[tdresser, 2014/02/03 15:52:58]

"when their start events were" -> "when their start events were,"

[tdresser, 2014/02/03 18:55:14]

Done.

+  // 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(GestureEventQueueTest, 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(GestureEventQueueTest, 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(GestureEventQueueTest, IndependentPacketsAllowed) {
+  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(GestureEventQueueTest, IndependentPacketsNotAllowed) {
+  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(GestureEventQueueTest, 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(GestureEventQueueTest, 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(GestureEventQueueTest, 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(GestureEventQueueTest, 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(GestureEventQueueTest, TapCancelledWhenScrollBegins) {
   PushGesture(WebInputEvent::GestureTapDown);
   PressTouchPoint(1, 1);
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapDown),
@@ skipping 80 matching lines @@
 
   SendTimeoutGesture(WebInputEvent::GestureLongPress);
   EXPECT_FALSE(GesturesSent());
 
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureLongPress),
                             GetAndResetSentGestures()));
 }
 
 }  // namespace content