Slop region check for multi-finger scroll

ui/events/gesture_detection/gesture_provider_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 "ui/events/gesture_detection/gesture_provider.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 927 matching lines @@
                             kFakeCoordY + delta_y);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(gesture_provider_->IsScrollInProgress());
 
   const GestureEventData* scroll_begin_gesture = GetActiveScrollBeginEvent();
   ASSERT_TRUE(scroll_begin_gesture);
   EXPECT_EQ(delta_x, scroll_begin_gesture->details.scroll_x_hint());
   EXPECT_EQ(delta_y, scroll_begin_gesture->details.scroll_y_hint());
 }
 
+// The follwoing three tests verify that slop regions are checked for
+// one and two finger scrolls. Three-finger tap doesn't exist, so,
+// no slop region check is needed for three-finger scrolls.

[tdresser, 2016/07/01 14:29:15]

following

Maybe add a blank line after this comment to make it clear that the comment
doesn't just refer to this test.

[sahel, 2016/07/05 20:36:35]

Done.

+TEST_F(GestureProviderTest, SlopRegionCheckOnOneFingerScroll) {
+  EnableTwoFingerTap(kMaxTwoFingerTapSeparation, base::TimeDelta());
+  const float scaled_touch_slop = GetTouchSlop();
+
+  base::TimeTicks event_time = base::TimeTicks::Now();
+
+  MockMotionEvent event =
+      ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 0, 0);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  // Move within slop region.
+  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_MOVE, 0,
+                            scaled_touch_slop / 2);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  // Exceed slop region.
+  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_MOVE, 0,
+                            2 * scaled_touch_slop);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_UP, 0,
+                            2 * scaled_touch_slop);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetReceivedGesture(2).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_END, GetReceivedGesture(3).type());
+  EXPECT_EQ(4U, GetReceivedGestureCount());
+}
+
+TEST_F(GestureProviderTest, SlopRegionCheckOnTwoFingerScroll) {
+  EnableTwoFingerTap(kMaxTwoFingerTapSeparation, base::TimeDelta());
+  const float scaled_touch_slop = GetTouchSlop();
+
+  base::TimeTicks event_time = base::TimeTicks::Now();
+
+  MockMotionEvent event =
+      ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 0, 0);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_DOWN, 0, 0,
+                            kMaxTwoFingerTapSeparation / 2, 0);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  // Move within slop region: two-finger tap happens.
+  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_MOVE, 0,
+                            scaled_touch_slop / 2,
+                            kMaxTwoFingerTapSeparation / 2, 0);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_UP, 0,
+                            scaled_touch_slop / 2,
+                            kMaxTwoFingerTapSeparation / 2, 0);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  // Exceed slop region: scroll.
+  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_DOWN, 0,
+                            scaled_touch_slop / 2,
+                            kMaxTwoFingerTapSeparation / 2, 0);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_MOVE, 0, scaled_touch_slop / 2,
+      kMaxTwoFingerTapSeparation / 2, 2 * scaled_touch_slop);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_POINTER_UP, 0, scaled_touch_slop / 2,
+      kMaxTwoFingerTapSeparation / 2, 2 * scaled_touch_slop);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_UP, 0,
+                            scaled_touch_slop / 2);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
+  EXPECT_EQ(ET_GESTURE_TWO_FINGER_TAP, GetReceivedGesture(1).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(2).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetReceivedGesture(3).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_END, GetReceivedGesture(4).type());
+  EXPECT_EQ(5U, GetReceivedGestureCount());
+}
+
+TEST_F(GestureProviderTest, NoSlopRegionCheckOnThreeFingerScroll) {
+  EnableTwoFingerTap(kMaxTwoFingerTapSeparation, base::TimeDelta());
+  const float scaled_touch_slop = GetTouchSlop();
+
+  base::TimeTicks event_time = base::TimeTicks::Now();
+
+  MockMotionEvent event =
+      ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 0, 0);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_DOWN, 0, 0,
+                            kMaxTwoFingerTapSeparation / 2, 0);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_DOWN, 0, 0,
+                            kMaxTwoFingerTapSeparation / 2, 0,
+                            2 * kMaxTwoFingerTapSeparation, 0);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  // Move within slop region, three-finger scroll always happens.
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_MOVE, 0, scaled_touch_slop / 2,
+      kMaxTwoFingerTapSeparation / 2, 0, 2 * kMaxTwoFingerTapSeparation, 0);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetReceivedGesture(2).type());
+  EXPECT_EQ(3U, GetReceivedGestureCount());
+}
+
 TEST_F(GestureProviderTest, LongPressAndTapCancelledWhenScrollBegins) {
   base::TimeTicks event_time = base::TimeTicks::Now();
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   event = ObtainMotionEvent(event_time + kOneMicrosecond,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX * 5,
                             kFakeCoordY * 5);
@@ skipping 1194 matching lines @@
 
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_POINTER_UP,
                             0,
                             0,
                             kMaxTwoFingerTapSeparation,
                             0);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
-  EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
-  EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetReceivedGesture(2).type());
-  EXPECT_EQ(ET_GESTURE_TWO_FINGER_TAP, GetReceivedGesture(3).type());
-  EXPECT_EQ(4U, GetReceivedGestureCount());
-
+  EXPECT_EQ(ET_GESTURE_TWO_FINGER_TAP, GetReceivedGesture(1).type());
+  EXPECT_EQ(2U, GetReceivedGestureCount());
   EXPECT_EQ(kMockTouchRadius * 2,
-            GetReceivedGesture(3).details.first_finger_width());
+            GetReceivedGesture(1).details.first_finger_width());
   EXPECT_EQ(kMockTouchRadius * 2,
-            GetReceivedGesture(3).details.first_finger_height());
+            GetReceivedGesture(1).details.first_finger_height());
 }
 
 // Test preventing a two finger tap via finger movement.
 TEST_F(GestureProviderTest, TwoFingerTapCancelledByFingerMovement) {
   EnableTwoFingerTap(kMaxTwoFingerTapSeparation, base::TimeDelta());
   const float scaled_touch_slop = GetTouchSlop();
   base::TimeTicks event_time = base::TimeTicks::Now();
 
   MockMotionEvent event = ObtainMotionEvent(
       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_POINTER_DOWN,
                             kFakeCoordX,
                             kFakeCoordY,
                             kFakeCoordX,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
-  event = ObtainMotionEvent(event_time,
-                            MotionEvent::ACTION_MOVE,
-                            kFakeCoordX,
-                            kFakeCoordY,
-                            kFakeCoordX + scaled_touch_slop + 0.1,
-                            kFakeCoordY);
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_MOVE, kFakeCoordX, kFakeCoordY,
+      kFakeCoordX + 2 * scaled_touch_slop + 2, kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_POINTER_UP,
                             kFakeCoordX,
                             kFakeCoordY,
                             kFakeCoordX,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
   EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
   EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetReceivedGesture(2).type());
-  EXPECT_FLOAT_EQ((scaled_touch_slop + 0.1) / 2,
+  // d_x = 2 * scaled_touch_slop + 2,
+  // d_focus_x = scaled_touch_slop + 1,
+  // touch_slop / event.GetPointerCount() is deducted from first scroll,
+  // scroll_x = scaled_touch_slop + 1 - scaled_touch_slop / 2
+  EXPECT_FLOAT_EQ(scaled_touch_slop / 2 + 1,
                   GetReceivedGesture(2).details.scroll_x());
   EXPECT_EQ(0, GetReceivedGesture(2).details.scroll_y());
   EXPECT_EQ(3U, GetReceivedGestureCount());
 }
 
 // Test preventing a two finger tap by waiting too long before releasing the
 // secondary pointer.
 TEST_F(GestureProviderTest, TwoFingerTapCancelledByDelay) {
   base::TimeDelta two_finger_tap_timeout = kOneSecond;
   EnableTwoFingerTap(kMaxTwoFingerTapSeparation, two_finger_tap_timeout);
@@ skipping 422 matching lines @@
   event = ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, kFakeCoordX,
                             kFakeCoordY + GetTouchSlop() / 2);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   event = ObtainMotionEvent(event_time, MotionEvent::ACTION_UP);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.tap_count());
 }
 
 }  // namespace ui