[Android] Use DIP coordinates with MotionEventAndroid

ui/events/gesture_detection/gesture_provider.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 <cmath>
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
@@ skipping 76 matching lines @@
   tap_details.set_bounding_box(
       gfx::RectF(event.GetTouchMajor(), event.GetTouchMajor()));
   return tap_details;
 }
 
 }  // namespace
 
 // GestureProvider:::Config
 
 GestureProvider::Config::Config()
-    : disable_click_delay(false), gesture_begin_end_types_enabled(false) {}
+    : display(gfx::Display::kInvalidDisplayID, gfx::Rect(1, 1)),
+      disable_click_delay(false),
+      gesture_begin_end_types_enabled(false) {}
 
 GestureProvider::Config::~Config() {}
 
 // GestureProvider::ScaleGestureListener
 
 class GestureProvider::ScaleGestureListenerImpl
     : public ScaleGestureDetector::ScaleGestureListener {
  public:
   ScaleGestureListenerImpl(const ScaleGestureDetector::Config& config,
-                           float device_scale_factor,
                            GestureProvider* provider)
       : scale_gesture_detector_(config, this),
         provider_(provider),
-        px_to_dp_(1.0f / device_scale_factor),
         ignore_multitouch_events_(false),
         pinch_event_sent_(false) {}
 
   bool OnTouchEvent(const MotionEvent& event) {
     // TODO: Need to deal with multi-touch transition.
     const bool in_scale_gesture = IsScaleGestureDetectionInProgress();
     bool handled = scale_gesture_detector_.OnTouchEvent(event);
     if (!in_scale_gesture &&
         (event.GetAction() == MotionEvent::ACTION_UP ||
          event.GetAction() == MotionEvent::ACTION_CANCEL)) {
@@ skipping 45 matching lines @@
     if (detector.InDoubleTapMode()) {
       // Relative changes in the double-tap scale factor computed by |detector|
       // diminish as the touch moves away from the original double-tap focus.
       // For historical reasons, Chrome has instead adopted a scale factor
       // computation that is invariant to the focal distance, where
       // the scale delta remains constant if the touch velocity is constant.
       float dy =
           (detector.GetCurrentSpanY() - detector.GetPreviousSpanY()) * 0.5f;
       scale = std::pow(scale > 1 ? 1.0f + kDoubleTapDragZoomSpeed
                                  : 1.0f - kDoubleTapDragZoomSpeed,
-                       std::abs(dy * px_to_dp_));
+                       std::abs(dy));
     }
     GestureEventDetails pinch_details(ET_GESTURE_PINCH_UPDATE, scale, 0);
     provider_->Send(CreateGesture(ET_GESTURE_PINCH_UPDATE,
                                   e.GetId(),
                                   detector.GetEventTime(),
                                   detector.GetFocusX(),
                                   detector.GetFocusY(),
                                   e.GetPointerCount(),
                                   pinch_details));
     return true;
@@ skipping 22 matching lines @@
 
  private:
   bool InDoubleTapMode() const {
     return scale_gesture_detector_.InDoubleTapMode();
   }
 
   ScaleGestureDetector scale_gesture_detector_;
 
   GestureProvider* const provider_;
 
-  // TODO(jdduke): Remove this when all MotionEvent's use DIPs.
-  const float px_to_dp_;
-
   // Completely silence multi-touch (pinch) scaling events. Used in WebView when
   // zoom support is turned off.
   bool ignore_multitouch_events_;
 
   // Whether any pinch zoom event has been sent to native.
   bool pinch_event_sent_;
 
   DISALLOW_COPY_AND_ASSIGN(ScaleGestureListenerImpl);
 };
 
 // GestureProvider::GestureListener
 
 class GestureProvider::GestureListenerImpl
     : public GestureDetector::GestureListener,
       public GestureDetector::DoubleTapListener {
  public:
   GestureListenerImpl(
+      const gfx::Display& display,
       const GestureDetector::Config& gesture_detector_config,
-      const SnapScrollController::Config& snap_scroll_controller_config,
       bool disable_click_delay,
       GestureProvider* provider)
       : gesture_detector_(gesture_detector_config, this, this),
-        snap_scroll_controller_(snap_scroll_controller_config),
+        snap_scroll_controller_(display),
         provider_(provider),
         disable_click_delay_(disable_click_delay),
-        scaled_touch_slop_(gesture_detector_config.scaled_touch_slop),
-        scaled_touch_slop_square_(scaled_touch_slop_ * scaled_touch_slop_),
+        touch_slop_(gesture_detector_config.touch_slop),
         double_tap_timeout_(gesture_detector_config.double_tap_timeout),
         ignore_single_tap_(false),
-        seen_first_scroll_event_(false),
-        last_raw_x_(0),
-        last_raw_y_(0),
-        accumulated_scroll_error_x_(0),
-        accumulated_scroll_error_y_(0) {}
+        seen_first_scroll_event_(false) {}
 
   virtual ~GestureListenerImpl() {}
 
   bool OnTouchEvent(const MotionEvent& e,
                     bool is_scale_gesture_detection_in_progress) {
     snap_scroll_controller_.SetSnapScrollingMode(
         e, is_scale_gesture_detection_in_progress);
 
     if (is_scale_gesture_detection_in_progress)
       SetIgnoreSingleTap(true);
 
     if (e.GetAction() == MotionEvent::ACTION_DOWN)
       gesture_detector_.set_is_longpress_enabled(true);
 
     return gesture_detector_.OnTouchEvent(e);
   }
 
   // GestureDetector::GestureListener implementation.
   virtual bool OnDown(const MotionEvent& e) OVERRIDE {
     current_down_time_ = e.GetEventTime();
     ignore_single_tap_ = false;
     seen_first_scroll_event_ = false;
-    last_raw_x_ = e.GetRawX();
-    last_raw_y_ = e.GetRawY();
-    accumulated_scroll_error_x_ = 0;
-    accumulated_scroll_error_y_ = 0;
 
     GestureEventDetails tap_details(ET_GESTURE_TAP_DOWN, 0, 0);
     tap_details.set_bounding_box(
         gfx::RectF(e.GetTouchMajor(), e.GetTouchMajor()));
     provider_->Send(CreateGesture(ET_GESTURE_TAP_DOWN, e, tap_details));
 
     // Return true to indicate that we want to handle touch.
     return true;
   }
 
   virtual bool OnScroll(const MotionEvent& e1,
                         const MotionEvent& e2,
                         float raw_distance_x,
                         float raw_distance_y) OVERRIDE {
     float distance_x = raw_distance_x;
     float distance_y = raw_distance_y;
     if (!seen_first_scroll_event_) {
       // Remove the touch slop region from the first scroll event to avoid a
       // jump.
       seen_first_scroll_event_ = true;
       double distance =
           std::sqrt(distance_x * distance_x + distance_y * distance_y);
       double epsilon = 1e-3;
       if (distance > epsilon) {
-        double ratio = std::max(0., distance - scaled_touch_slop_) / distance;
+        double ratio = std::max(0., distance - touch_slop_) / distance;
         distance_x *= ratio;
         distance_y *= ratio;
       }
     }
     snap_scroll_controller_.UpdateSnapScrollMode(distance_x, distance_y);
     if (snap_scroll_controller_.IsSnappingScrolls()) {
       if (snap_scroll_controller_.IsSnapHorizontal()) {
         distance_y = 0;
       } else {
         distance_x = 0;
       }
     }
 
-    last_raw_x_ = e2.GetRawX();
-    last_raw_y_ = e2.GetRawY();
     if (!provider_->IsScrollInProgress()) {
       // Note that scroll start hints are in distance traveled, where
       // scroll deltas are in the opposite direction.
       GestureEventDetails scroll_details(
           ET_GESTURE_SCROLL_BEGIN, -raw_distance_x, -raw_distance_y);
 
       // Use the co-ordinates from the touch down, as these co-ordinates are
       // used to determine which layer the scroll should affect.
       provider_->Send(CreateGesture(ET_GESTURE_SCROLL_BEGIN,
                                     e2.GetId(),
                                     e2.GetEventTime(),
                                     e1.GetX(),
                                     e1.GetY(),
                                     e2.GetPointerCount(),
                                     scroll_details));
     }
 
-    // distance_x and distance_y is the scrolling offset since last OnScroll.
-    // Because we are passing integers to Blink, this could introduce
-    // rounding errors. The rounding errors will accumulate overtime.
-    // To solve this, we should be adding back the rounding errors each time
-    // when we calculate the new offset.
-    // TODO(jdduke): Determine if we can simpy use floating point deltas, as
-    // WebGestureEvent also takes floating point deltas for GestureScrollUpdate.
-    int dx = (int)(distance_x + accumulated_scroll_error_x_);
-    int dy = (int)(distance_y + accumulated_scroll_error_y_);
-    accumulated_scroll_error_x_ += (distance_x - dx);
-    accumulated_scroll_error_y_ += (distance_y - dy);
-
-    if (dx || dy) {
-      GestureEventDetails scroll_details(ET_GESTURE_SCROLL_UPDATE, -dx, -dy);
+    if (distance_x || distance_y) {
+      GestureEventDetails scroll_details(
+          ET_GESTURE_SCROLL_UPDATE, -distance_x, -distance_y);
       provider_->Send(
           CreateGesture(ET_GESTURE_SCROLL_UPDATE, e2, scroll_details));
     }
 
     return true;
   }
 
   virtual bool OnFling(const MotionEvent& e1,
                        const MotionEvent& e2,
                        float velocity_x,
@@ skipping 13 matching lines @@
   virtual void OnShowPress(const MotionEvent& e) OVERRIDE {
     GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS, 0, 0);
     // TODO(jdduke): Expose minor axis length and rotation in |MotionEvent|.
     show_press_details.set_bounding_box(
         gfx::RectF(e.GetTouchMajor(), e.GetTouchMajor()));
     provider_->Send(
         CreateGesture(ET_GESTURE_SHOW_PRESS, e, show_press_details));
   }
 
   virtual bool OnSingleTapUp(const MotionEvent& e) OVERRIDE {
-    if (IsPointOutsideCurrentSlopRegion(e.GetRawX(), e.GetRawY())) {
-      ignore_single_tap_ = true;
-      return true;
-    }
     // This is a hack to address the issue where user hovers
     // over a link for longer than double_tap_timeout_, then
     // OnSingleTapConfirmed() is not triggered. But we still
     // want to trigger the tap event at UP. So we override
     // OnSingleTapUp() in this case. This assumes singleTapUp
     // gets always called before singleTapConfirmed.
     if (!ignore_single_tap_) {
       if (e.GetEventTime() - current_down_time_ > double_tap_timeout_) {
         return OnSingleTapConfirmed(e);
       } else if (!IsDoubleTapEnabled() || disable_click_delay_) {
@@ skipping 79 matching lines @@
     }
   }
 
   bool IsClickDelayDisabled() const { return disable_click_delay_; }
 
   bool IsDoubleTapInProgress() const {
     return gesture_detector_.is_double_tapping();
   }
 
  private:
-  bool IsPointOutsideCurrentSlopRegion(float x, float y) const {
-    return IsDistanceGreaterThanTouchSlop(last_raw_x_ - x, last_raw_y_ - y);
-  }
-
-  bool IsDistanceGreaterThanTouchSlop(float distance_x,
-                                      float distance_y) const {
-    return distance_x * distance_x + distance_y * distance_y >
-           scaled_touch_slop_square_;
-  }
-
   void SetIgnoreSingleTap(bool value) { ignore_single_tap_ = value; }
 
   bool IsDoubleTapEnabled() const {
     return gesture_detector_.has_doubletap_listener();
   }
 
   GestureDetector gesture_detector_;
   SnapScrollController snap_scroll_controller_;
 
   GestureProvider* const provider_;
 
   // Whether the click delay should always be disabled by sending clicks for
   // double-tap gestures.
   const bool disable_click_delay_;
 
-  const int scaled_touch_slop_;
-
-  // Cache of square of the scaled touch slop so we don't have to calculate it
-  // on every touch.
-  const int scaled_touch_slop_square_;
+  const float touch_slop_;
 
   const base::TimeDelta double_tap_timeout_;
 
   base::TimeTicks current_down_time_;
 
   // TODO(klobag): This is to avoid a bug in GestureDetector. With multi-touch,
   // always_in_tap_region_ is not reset. So when the last finger is up,
   // OnSingleTapUp() will be mistakenly fired.
   bool ignore_single_tap_;
 
   // Used to remove the touch slop from the initial scroll event in a scroll
   // gesture.
   bool seen_first_scroll_event_;
 
-  // Used to track the last rawX/Y coordinates for moves.  This gives absolute
-  // scroll distance.
-  // Useful for full screen tracking.
-  float last_raw_x_;
-  float last_raw_y_;
-
-  // Used to track the accumulated scroll error over time. This is used to
-  // remove the
-  // rounding error we introduced by passing integers to webkit.
-  float accumulated_scroll_error_x_;
-  float accumulated_scroll_error_y_;
-
   DISALLOW_COPY_AND_ASSIGN(GestureListenerImpl);
 };
 
 // GestureProvider
 
 GestureProvider::GestureProvider(const Config& config,
                                  GestureProviderClient* client)
     : client_(client),
       touch_scroll_in_progress_(false),
       pinch_in_progress_(false),
@@ skipping 64 matching lines @@
   return double_tap_support_for_page_ && double_tap_support_for_platform_;
 }
 
 bool GestureProvider::IsClickDelayDisabled() const {
   return gesture_listener_->IsClickDelayDisabled();
 }
 
 void GestureProvider::InitGestureDetectors(const Config& config) {
   TRACE_EVENT0("input", "GestureProvider::InitGestureDetectors");
   gesture_listener_.reset(
-      new GestureListenerImpl(config.gesture_detector_config,
-                              config.snap_scroll_controller_config,
+      new GestureListenerImpl(config.display,
+                              config.gesture_detector_config,
                               config.disable_click_delay,
                               this));
 
-  scale_gesture_listener_.reset(new ScaleGestureListenerImpl(
-      config.scale_gesture_detector_config,
-      config.snap_scroll_controller_config.device_scale_factor,
-      this));
+  scale_gesture_listener_.reset(
+      new ScaleGestureListenerImpl(config.scale_gesture_detector_config, this));
 
   UpdateDoubleTapDetectionSupport();
 }
 
 bool GestureProvider::CanHandle(const MotionEvent& event) const {
   return event.GetAction() == MotionEvent::ACTION_DOWN || current_down_event_;
 }
 
 void GestureProvider::Fling(const MotionEvent& event,
                             float velocity_x,
@@ skipping 152 matching lines @@
         Send(CreateGesture(ET_GESTURE_END, event));
       break;
     case MotionEvent::ACTION_DOWN:
     case MotionEvent::ACTION_POINTER_DOWN:
     case MotionEvent::ACTION_MOVE:
       break;
   }
 }
 
 }  //  namespace ui