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());
 }
 
+// Verify that slop regions are checked for one and two finger scrolls,
+// three-finger tap doesn't exist, no slop region check is needed for
+// three-finger scrolls.
+TEST_F(GestureProviderTest, SlopRegionCheckOnScroll) {

[tdresser, 2016/06/28 15:24:19]

Can we split this into three tests, one per number of fingers?

[sahel, 2016/06/29 16:26:19]

Done.

+  EnableTwoFingerTap(kMaxTwoFingerTapSeparation, base::TimeDelta());
+  const float scaled_touch_slop = GetTouchSlop();
+
+  base::TimeTicks event_time = base::TimeTicks::Now();
+
+
+

[tdresser, 2016/06/28 15:24:19]

This is a bit more whitespace than we'd usually use - I'd say just go with a
single line of whitespace.

[sahel, 2016/06/29 16:26:19]

Done.

+  // Scrolls with one pointer down.
+  MockMotionEvent event =
+      ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 0, 0);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  // Moves within slop region.
+  event = ObtainMotionEvent(event_time,
+                            MotionEvent::ACTION_MOVE,
+                            0,
+                            scaled_touch_slop / 2);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  // Exceeds 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));
+
+
+
+  // Scrolls with two pointers down.
+  event_time += kOneSecond;
+  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));
+
+  // Moves within slop region: two-finger tap.
+  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));
+
+  // Exceeds 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));
+
+
+
+  // Scrolls with three pointers down.
+  event_time += kOneSecond;
+  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));
+
+  // Moves 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));
+
+
+
+  // One finger scroll

[tdresser, 2016/06/28 15:24:19]

Missing periods.

+  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());
+
+  // Two-finger scroll
+  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(4).type());
+  EXPECT_EQ(ET_GESTURE_TWO_FINGER_TAP, GetReceivedGesture(5).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(6).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetReceivedGesture(7).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_END, GetReceivedGesture(8).type());
+
+  // Three-finger scroll
+  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(9).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(10).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetReceivedGesture(11).type());
+
+  EXPECT_EQ(12U, 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,
+                            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