[Android] Use DIP coordinates with MotionEventAndroid

ui/events/gesture_detection/gesture_detector.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_detector.h"
 
 #include <cmath>
 
 #include "base/timer/timer.h"
 #include "ui/events/gesture_detection/motion_event.h"
 
 namespace ui {
 namespace {
 
+// Using a small epsilon when comparing slop distances allows pixel perfect
+// slop determination when using fractional DIP coordinates (assuming the slop
+// region and DPI scale are reasonably proportioned).
+const float kSlopEpsilon = .05f;
+
+// Minimum distance a scroll must have traveled from the last scroll/focal point
+// to trigger an |OnScroll| callback.
+const float kScrollEpsilon = .1f;
+
 // Constants used by TimeoutGestureHandler.
 enum TimeoutEvent {
   SHOW_PRESS = 0,
   LONG_PRESS,
   TAP,
   TIMEOUT_EVENT_COUNT
 };
 
 }  // namespace
 
 // Note: These constants were taken directly from the default (unscaled)
 // versions found in Android's ViewConfiguration.
 GestureDetector::Config::Config()
     : longpress_timeout(base::TimeDelta::FromMilliseconds(500)),
       showpress_timeout(base::TimeDelta::FromMilliseconds(180)),
       double_tap_timeout(base::TimeDelta::FromMilliseconds(300)),
-      scaled_touch_slop(8),
-      scaled_double_tap_slop(100),
-      scaled_minimum_fling_velocity(50),
-      scaled_maximum_fling_velocity(8000) {}
+      touch_slop(8),
+      double_tap_slop(100),
+      minimum_fling_velocity(50),
+      maximum_fling_velocity(8000) {}
 
 GestureDetector::Config::~Config() {}
 
 bool GestureDetector::SimpleGestureListener::OnDown(const MotionEvent& e) {
   return false;
 }
 
 void GestureDetector::SimpleGestureListener::OnShowPress(const MotionEvent& e) {
 }
 
@@ skipping 215 matching lines @@
         break;
 
       {
         const float scroll_x = last_focus_x_ - focus_x;
         const float scroll_y = last_focus_y_ - focus_y;
         if (is_double_tapping_) {
           // Give the move events of the double-tap.
           DCHECK(double_tap_listener_);
           handled |= double_tap_listener_->OnDoubleTapEvent(ev);
         } else if (always_in_tap_region_) {
-          const int delta_x = static_cast<int>(focus_x - down_focus_x_);
-          const int delta_y = static_cast<int>(focus_y - down_focus_y_);
-          int distance = (delta_x * delta_x) + (delta_y * delta_y);
-          if (distance > touch_slop_square_) {
+          const float delta_x = focus_x - down_focus_x_;
+          const float delta_y = focus_y - down_focus_y_;
+          const float distance_square = delta_x * delta_x + delta_y * delta_y;
+          if (distance_square > touch_slop_square_) {
             handled = listener_->OnScroll(
                 *current_down_event_, ev, scroll_x, scroll_y);
             last_focus_x_ = focus_x;
             last_focus_y_ = focus_y;
             always_in_tap_region_ = false;
             timeout_handler_->Stop();
           }
-          if (distance > double_tap_touch_slop_square_)
+          if (distance_square > double_tap_touch_slop_square_)
             always_in_bigger_tap_region_ = false;
-        } else if ((std::abs(scroll_x) >= 1) || (std::abs(scroll_y) >= 1)) {
+        } else if (std::abs(scroll_x) > kScrollEpsilon ||
+                   std::abs(scroll_y) > kScrollEpsilon) {
           handled =
               listener_->OnScroll(*current_down_event_, ev, scroll_x, scroll_y);
           last_focus_x_ = focus_x;
           last_focus_y_ = focus_y;
         }
       }
       break;
 
     case MotionEvent::ACTION_UP:
       still_down_ = false;
@@ skipping 39 matching lines @@
       Cancel();
       break;
   }
 
   return handled;
 }
 
 void GestureDetector::Init(const Config& config) {
   DCHECK(listener_);
 
-  const int touch_slop = config.scaled_touch_slop;
-  const int double_tap_touch_slop = touch_slop;
-  const int double_tap_slop = config.scaled_double_tap_slop;
-  min_fling_velocity_ = config.scaled_minimum_fling_velocity;
-  max_fling_velocity_ = config.scaled_maximum_fling_velocity;
+  const float touch_slop = config.touch_slop + kSlopEpsilon;
+  const float double_tap_touch_slop = touch_slop;
+  const float double_tap_slop = config.double_tap_slop + kSlopEpsilon;
   touch_slop_square_ = touch_slop * touch_slop;
   double_tap_touch_slop_square_ = double_tap_touch_slop * double_tap_touch_slop;
   double_tap_slop_square_ = double_tap_slop * double_tap_slop;
   double_tap_timeout_ = config.double_tap_timeout;
+  min_fling_velocity_ = config.minimum_fling_velocity;
+  max_fling_velocity_ = config.maximum_fling_velocity;
 }
 
 void GestureDetector::OnShowPressTimeout() {
   listener_->OnShowPress(*current_down_event_);
 }
 
 void GestureDetector::OnLongPressTimeout() {
   timeout_handler_->StopTimeout(TAP);
   defer_confirm_single_tap_ = false;
   in_longpress_ = listener_->OnLongPress(*current_down_event_);
@@ skipping 32 matching lines @@
     const MotionEvent& first_down,
     const MotionEvent& first_up,
     const MotionEvent& second_down) const {
   if (!always_in_bigger_tap_region_)
     return false;
 
   if (second_down.GetEventTime() - first_up.GetEventTime() >
       double_tap_timeout_)
     return false;
 
-  int delta_x = static_cast<int>(first_down.GetX() - second_down.GetX());
-  int delta_y = static_cast<int>(first_down.GetY() - second_down.GetY());
+  const float delta_x = first_down.GetX() - second_down.GetX();
+  const float delta_y = first_down.GetY() - second_down.GetY();
   return (delta_x * delta_x + delta_y * delta_y < double_tap_slop_square_);
 }
 
 }  // namespace ui