[Android] Use DIP coordinates with MotionEventAndroid

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 "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 113 matching lines @@
 
   const GestureEventData* GetActiveScrollBeginEvent() const {
     return active_scroll_begin_event_ ? active_scroll_begin_event_.get() : NULL;
   }
 
   const GestureProvider::Config& GetDefaultConfig() const {
     static GestureProvider::Config sConfig = CreateDefaultConfig();
     return sConfig;
   }
 
-  int GetTouchSlop() const {
-    return GetDefaultConfig().gesture_detector_config.scaled_touch_slop;
+  float GetTouchSlop() const {
+    return GetDefaultConfig().gesture_detector_config.touch_slop;
   }
 
   base::TimeDelta GetLongPressTimeout() const {
     return GetDefaultConfig().gesture_detector_config.longpress_timeout;
   }
 
   base::TimeDelta GetShowPressTimeout() const {
     return GetDefaultConfig().gesture_detector_config.showpress_timeout;
   }
 
   void SetBeginEndTypesEnabled(bool enabled) {
     GestureProvider::Config config = GetDefaultConfig();
     config.gesture_begin_end_types_enabled = true;
     gesture_provider_.reset(new GestureProvider(config, this));
     gesture_provider_->SetMultiTouchSupportEnabled(false);
   }
 
   bool HasDownEvent() const { return gesture_provider_->current_down_event(); }
 
  protected:
   void CheckScrollEventSequenceForEndActionType(
       MotionEvent::Action end_action_type) {
     base::TimeTicks event_time = base::TimeTicks::Now();
-    const int scroll_to_x = kFakeCoordX + 100;
-    const int scroll_to_y = kFakeCoordY + 100;
+    const float scroll_to_x = kFakeCoordX + 100;
+    const float scroll_to_y = kFakeCoordY + 100;
     int motion_event_id = 0;
 
     MockMotionEvent event =
         ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
     event.SetId(++motion_event_id);
 
     EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
     event = ObtainMotionEvent(event_time + kOneSecond,
                               MotionEvent::ACTION_MOVE,
@@ skipping 355 matching lines @@
                             kFakeCoordX,
                             kFakeCoordY - 200);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_PINCH_END));
   EXPECT_EQ(ET_GESTURE_SCROLL_END, GetMostRecentGestureEventType());
 }
 
 // Generate a scroll gesture and verify that the resulting scroll motion event
 // has both absolute and relative position information.
 TEST_F(GestureProviderTest, ScrollUpdateValues) {
-  const int delta_x = 16;
-  const int delta_y = 84;
+  const float delta_x = 16;
+  const float delta_y = 84;
 
   const base::TimeTicks event_time = TimeTicks::Now();
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   // Move twice so that we get two ET_GESTURE_SCROLL_UPDATE events and can
   // compare the relative and absolute coordinates.
   event = ObtainMotionEvent(event_time + kOneMicrosecond,
@@ skipping 70 matching lines @@
     EXPECT_LE(gesture.details.scroll_y(), ((int)delta_y) + 1);
 
     // And that there has been no horizontal motion at all.
     EXPECT_EQ(0, gesture.details.scroll_x());
   }
 }
 
 // Generate a scroll gesture and verify that the resulting scroll begin event
 // has the expected hint values.
 TEST_F(GestureProviderTest, ScrollBeginValues) {
-  const int delta_x = 13;
-  const int delta_y = 89;
+  const float delta_x = 13;
+  const float delta_y = 89;
 
   const base::TimeTicks event_time = TimeTicks::Now();
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   // Move twice such that the first event isn't sufficient to start
   // scrolling on it's own.
   event = ObtainMotionEvent(event_time + kOneMicrosecond,
@@ skipping 142 matching lines @@
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_SCROLL_END, GetMostRecentGestureEventType());
   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
   EXPECT_FALSE(gesture_provider_->IsDoubleTapInProgress());
 }
 
 // Verify that the touch slop region is removed from the first scroll delta to
 // avoid a jump when starting to scroll.
 TEST_F(GestureProviderTest, TouchSlopRemovedFromScroll) {
-  const int scaled_touch_slop = GetTouchSlop();
-  const int scroll_delta = 5;
+  const float touch_slop = GetTouchSlop();
+  const float scroll_delta = 5;
 
   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 * 2,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX,
-                            kFakeCoordY + scaled_touch_slop + scroll_delta);
+                            kFakeCoordY + touch_slop + scroll_delta);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
   GestureEventData gesture = GetMostRecentGestureEvent();
   EXPECT_EQ(0, gesture.details.scroll_x());
   EXPECT_EQ(scroll_delta, gesture.details.scroll_y());
   EXPECT_EQ(1, gesture.details.touch_points());
 }
 
+// Verify that movement within the touch slop region does not generate a scroll,
+// and that the slop region is correct even when using fractional coordinates.
+TEST_F(GestureProviderTest, NoScrollWithinTouchSlop) {
+  const float touch_slop = GetTouchSlop();
+  const float scale_factor = 2.5f;
+  const int touch_slop_pixels = static_cast<int>(scale_factor * touch_slop);
+
+  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 * 2,
+                            MotionEvent::ACTION_MOVE,
+                            kFakeCoordX + touch_slop_pixels / scale_factor,
+                            kFakeCoordY);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+  EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
+
+  event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
+                            MotionEvent::ACTION_MOVE,
+                            kFakeCoordX,
+                            kFakeCoordY + touch_slop_pixels / scale_factor);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+  EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
+
+  event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
+                            MotionEvent::ACTION_MOVE,
+                            kFakeCoordX - touch_slop_pixels / scale_factor,
+                            kFakeCoordY);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+  EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
+
+  event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
+                            MotionEvent::ACTION_MOVE,
+                            kFakeCoordX,
+                            kFakeCoordY - touch_slop_pixels / scale_factor);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+  EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
+
+  event =
+      ObtainMotionEvent(event_time + kOneMicrosecond * 2,
+                        MotionEvent::ACTION_MOVE,
+                        kFakeCoordX,
+                        kFakeCoordY + (touch_slop_pixels + 1.f) / scale_factor);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+  EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
+}
+
 TEST_F(GestureProviderTest, NoDoubleTapWhenExplicitlyDisabled) {
   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
 
   base::TimeTicks event_time = base::TimeTicks::Now();
   MockMotionEvent event = ObtainMotionEvent(
       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(1U, GetReceivedGestureCount());
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
@@ skipping 212 matching lines @@
                             MotionEvent::ACTION_UP,
                             kFakeCoordX,
                             kFakeCoordY + 200);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_END));
 }
 
 // Verify that pinch zoom sends the proper event sequence.
 TEST_F(GestureProviderTest, PinchZoom) {
   base::TimeTicks event_time = base::TimeTicks::Now();
-  const int scaled_touch_slop = GetTouchSlop();
+  const float touch_slop = GetTouchSlop();
   int motion_event_id = 0;
 
   gesture_provider_->SetDoubleTapSupportForPageEnabled(false);
   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(true);
   gesture_provider_->SetMultiTouchSupportEnabled(true);
 
-  int secondary_coord_x = kFakeCoordX + 20 * scaled_touch_slop;
-  int secondary_coord_y = kFakeCoordY + 20 * scaled_touch_slop;
+  int secondary_coord_x = kFakeCoordX + 20 * touch_slop;
+  int secondary_coord_y = kFakeCoordY + 20 * touch_slop;
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   event.SetId(++motion_event_id);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 
   // Toggling double-tap support should not take effect until the next sequence.
   gesture_provider_->SetDoubleTapSupportForPageEnabled(true);
 
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_POINTER_DOWN,
                             kFakeCoordX,
                             kFakeCoordY,
                             secondary_coord_x,
                             secondary_coord_y);
   event.SetId(++motion_event_id);
 
   gesture_provider_->OnTouchEvent(event);
   EXPECT_EQ(1U, GetReceivedGestureCount());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 
-  secondary_coord_x += 5 * scaled_touch_slop;
-  secondary_coord_y += 5 * scaled_touch_slop;
+  secondary_coord_x += 5 * touch_slop;
+  secondary_coord_y += 5 * touch_slop;
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX,
                             kFakeCoordY,
                             secondary_coord_x,
                             secondary_coord_y);
   event.SetId(++motion_event_id);
 
   // Toggling double-tap support should not take effect until the next sequence.
   gesture_provider_->SetDoubleTapSupportForPageEnabled(false);
 
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_PINCH_BEGIN));
   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_UPDATE));
 
-  secondary_coord_x += 2 * scaled_touch_slop;
-  secondary_coord_y += 2 * scaled_touch_slop;
+  secondary_coord_x += 2 * touch_slop;
+  secondary_coord_y += 2 * touch_slop;
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX,
                             kFakeCoordY,
                             secondary_coord_x,
                             secondary_coord_y);
   event.SetId(++motion_event_id);
 
   // Toggling double-tap support should not take effect until the next sequence.
   gesture_provider_->SetDoubleTapSupportForPageEnabled(true);
@@ skipping 219 matching lines @@
 
   event = ObtainMotionEvent(event_time, MotionEvent::ACTION_CANCEL);
   event.pointer_count = 1;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEventType());
   EXPECT_EQ(12U, GetReceivedGestureCount());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 }
 
 }  // namespace ui