Don't treat first touch move differently from future touch moves

ui/aura/gestures/gesture_recognizer_unittest.cc

 // Copyright (c) 2012 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/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 2073 matching lines @@
   ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(101, 50),
                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_TRUE(delegate->pinch_begin());
 
   tes.SendScrollEvent(event_processor(), 350, 350, kTouchId1, delegate.get());
   EXPECT_TRUE(delegate->pinch_update());
 }
 
 TEST_P(GestureRecognizerTest, GestureEventPinchFromTap) {
-  // TODO(tdresser): enable this test with unified GR once two finger tap.
+  // Disabled under unified gesture recognizer due to behavior differences in
+  // scroll and bounding box behavior.
   if (UsingUnifiedGR())
     return;
 
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 3;
   const int kTouchId2 = 5;
@@ skipping 1025 matching lines @@
   EXPECT_FALSE(delegate->scroll_end());
 
   // Move the touch-point enough so that it would normally be considered a
   // scroll. But since the touch-moves will be consumed, the scroll should not
   // start.
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
-  EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
+  // With the unified gesture detector, consuming the first touch move event
+  // won't prevent all future scrolling.
+  if (UsingUnifiedGR())
+    EXPECT_TRUE(delegate->scroll_begin());
+  else
+    EXPECT_FALSE(delegate->scroll_begin());
+
   // Release the touch back at the start point. This should end without causing
   // a tap.
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(130, 230),
                          kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
+
+  if (UsingUnifiedGR())
+    EXPECT_TRUE(delegate->scroll_end());
+  else
+    EXPECT_FALSE(delegate->scroll_end());
 }
 
 // Tests the behavior of 2F scroll when all the touch-move events are consumed.
 TEST_P(GestureRecognizerTest, GestureEventScrollTwoFingerTouchMoveConsumed) {
   // TODO(tdresser): enable this test with unified GR once two finger tap is
   // supported. See crbug.com/354396.
   if (UsingUnifiedGR())
     return;
 
   scoped_ptr<ConsumesTouchMovesDelegate> delegate(
@@ skipping 126 matching lines @@
   EXPECT_FALSE(delegate->scroll_end());
 
   // Move the touch-point enough so that it would normally be considered a
   // scroll. But since the touch-moves will be consumed, the scroll should not
   // start.
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
-  EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
+  // With the unified gesture detector, consuming the first touch move event
+  // won't prevent all future scrolling.
+  if (UsingUnifiedGR())
+    EXPECT_TRUE(delegate->scroll_begin());
+  else
+    EXPECT_FALSE(delegate->scroll_begin());
+
   // Now, stop consuming touch-move events, and move the touch-point again.
   delegate->set_consume_touch_move(false);
   tes.SendScrollEvent(event_processor(), 159, 259, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
-  // No scroll has occurred, because an early touch move was consumed.
-  EXPECT_EQ(0, delegate->scroll_x());
-  EXPECT_EQ(0, delegate->scroll_y());
-  EXPECT_EQ(gfx::Point(0, 0).ToString(),
-            delegate->scroll_begin_position().ToString());
+
+  if (UsingUnifiedGR()) {
+    // Scroll not prevented by consumed first touch move.
+    EXPECT_TRUE(delegate->scroll_update());
+    EXPECT_EQ(29, delegate->scroll_x());
+    EXPECT_EQ(29, delegate->scroll_y());
+    EXPECT_EQ(gfx::Point(0, 0).ToString(),
+              delegate->scroll_begin_position().ToString());
+  } else {
+    EXPECT_FALSE(delegate->scroll_update());
+    // No scroll has occurred, because an early touch move was consumed.
+    EXPECT_EQ(0, delegate->scroll_x());
+    EXPECT_EQ(0, delegate->scroll_y());
+    EXPECT_EQ(gfx::Point(0, 0).ToString(),
+              delegate->scroll_begin_position().ToString());
+  }
 
   // Start consuming touch-move events again.
   delegate->set_consume_touch_move(true);
 
   // Move some more to generate a few more scroll updates.
   tes.SendScrollEvent(event_processor(), 110, 211, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
@@ skipping 19 matching lines @@
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                          kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(delegate->fling());
+
+  if (UsingUnifiedGR())
+    EXPECT_TRUE(delegate->scroll_end());
+  else
+    EXPECT_FALSE(delegate->scroll_end());
 }
 
 // Check that appropriate touch events generate double tap gesture events.
 TEST_P(GestureRecognizerTest, GestureEventDoubleTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
@@ skipping 317 matching lines @@
 
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                        kTouchId, tes.Now());
 
   delegate->set_consume_touch_move(false);
   DispatchEventUsingWindowDispatcher(&press);
   delegate->set_consume_touch_move(true);
   delegate->Reset();
   // Move the touch-point enough so that it would normally be considered a
-  // scroll. But since the touch-moves will be consumed, the scroll should not
-  // start.
+  // scroll. But since the touch-moves will be consumed, no scrolling should
+  // occur.
+  // With the unified gesture detector, we will receive a scroll begin gesture,
+  // whereas with the aura gesture recognizer we won't.
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
-  EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 }
 
 TEST_P(GestureRecognizerTest,
        TransferEventDispatchesTouchCancel) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 800;
@@ skipping 178 matching lines @@
   ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(10, 10),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
   delegate->ReceivedAckPreventDefaulted();
 
   ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(20, 20),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   delegate->ReceivedAck();
 
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
+  if (UsingUnifiedGR()) {
+    // With the unified gesture detector, consuming the first touch move event
+    // won't prevent all future scrolling.
+    EXPECT_TRUE(delegate->scroll_begin());
+    EXPECT_TRUE(delegate->scroll_update());
+  } else {
+    EXPECT_FALSE(delegate->scroll_begin());
+    EXPECT_FALSE(delegate->scroll_update());
+  }
 }
 
 // Test that consuming the first touch move event of a touch point doesn't
 // prevent pinching once an additional touch has been pressed.
 TEST_P(GestureRecognizerTest, GestureEventConsumedTouchMovePinchTest) {
   // Consuming moves within the touch slop and the the disposition handling of
   // pinch events behave differently between the Unified GR and the Aura GR.
   if (UsingUnifiedGR())
     return;
 
@@ skipping 411 matching lines @@
   EXPECT_TRUE(delegate->show_press());
   EXPECT_EQ(0U, delegate->latency_info().latency_components.size());
 }
 
 INSTANTIATE_TEST_CASE_P(GestureRecognizer,
                         GestureRecognizerTest,
                         ::testing::Bool());
 
 }  // namespace test
 }  // namespace aura