[Android] Support double-tap selection

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/trace_event/trace_event.h"
@@ skipping 386 matching lines @@
                        e2.GetFlags()));
     return true;
   }
 
   void OnShowPress(const MotionEvent& e) override {
     GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS);
     show_press_event_sent_ = true;
     Send(CreateGesture(show_press_details, e));
   }
 
-  bool OnSingleTapUp(const MotionEvent& e) override {
+  bool OnSingleTapUp(const MotionEvent& e, int tap_count) override {
     // 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_ >
           config_.gesture_detector_config.double_tap_timeout) {
-        return OnSingleTapConfirmed(e);
+        return OnSingleTapImpl(e, tap_count);
       } else if (!IsDoubleTapEnabled()) {
         // If double-tap has been disabled, there is no need to wait
         // for the double-tap timeout.
-        return OnSingleTapConfirmed(e);
+        return OnSingleTapImpl(e, tap_count);
       } else {
         // Notify Blink about this tapUp event anyway, when none of the above
         // conditions applied.
-        Send(CreateTapGesture(ET_GESTURE_TAP_UNCONFIRMED, e));
+        Send(CreateTapGesture(ET_GESTURE_TAP_UNCONFIRMED, e, 1));
       }
     }
 
     if (e.GetAction() == MotionEvent::ACTION_UP &&
         !current_longpress_time_.is_null() &&
         !IsScaleGestureDetectionInProgress()) {
       GestureEventDetails long_tap_details(ET_GESTURE_LONG_TAP);
       Send(CreateGesture(long_tap_details, e));
       return true;
     }
 
     return false;
   }
 
   // DoubleTapListener implementation.
   bool OnSingleTapConfirmed(const MotionEvent& e) override {
-    // Long taps in the edges of the screen have their events delayed by
-    // ContentViewHolder for tab swipe operations. As a consequence of the delay
-    // this method might be called after receiving the up event.
-    // These corner cases should be ignored.
-    if (ignore_single_tap_)
-      return true;
-
-    ignore_single_tap_ = true;
-
-    Send(CreateTapGesture(ET_GESTURE_TAP, e));
-    return true;
+    return OnSingleTapImpl(e, 1);
   }
 
   bool OnDoubleTap(const MotionEvent& e) override {
     return scale_gesture_detector_.OnDoubleTap(e);
   }
 
   bool OnDoubleTapEvent(const MotionEvent& e) override {
     switch (e.GetAction()) {
       case MotionEvent::ACTION_DOWN:
         gesture_detector_.set_longpress_enabled(false);
         break;
 
       case MotionEvent::ACTION_UP:
         if (!IsPinchInProgress() && !IsScrollInProgress()) {
-          Send(CreateTapGesture(ET_GESTURE_DOUBLE_TAP, e));
+          Send(CreateTapGesture(ET_GESTURE_DOUBLE_TAP, e, 1));
           return true;
         }
         break;
 
       default:
         break;
     }
     return false;
   }
 
   void OnLongPress(const MotionEvent& e) override {
     DCHECK(!IsDoubleTapInProgress());
     SetIgnoreSingleTap(true);
     GestureEventDetails long_press_details(ET_GESTURE_LONG_PRESS);
     Send(CreateGesture(long_press_details, e));
   }
 
   GestureEventData CreateGesture(const GestureEventDetails& details,
                                  int motion_event_id,
                                  MotionEvent::ToolType primary_tool_type,
                                  base::TimeTicks time,
                                  float x,
                                  float y,
                                  float raw_x,
                                  float raw_y,
                                  size_t touch_point_count,
                                  const gfx::RectF& bounding_box,
-                                 int flags) {
+                                 int flags) const {
     return GestureEventData(details,
                             motion_event_id,
                             primary_tool_type,
                             time,
                             x,
                             y,
                             raw_x,
                             raw_y,
                             touch_point_count,
                             bounding_box,
                             flags);
   }
 
   GestureEventData CreateGesture(EventType type,
                                  int motion_event_id,
                                  MotionEvent::ToolType primary_tool_type,
                                  base::TimeTicks time,
                                  float x,
                                  float y,
                                  float raw_x,
                                  float raw_y,
                                  size_t touch_point_count,
                                  const gfx::RectF& bounding_box,
-                                 int flags) {
+                                 int flags) const {
     return GestureEventData(GestureEventDetails(type),
                             motion_event_id,
                             primary_tool_type,
                             time,
                             x,
                             y,
                             raw_x,
                             raw_y,
                             touch_point_count,
                             bounding_box,
                             flags);
   }
 
   GestureEventData CreateGesture(const GestureEventDetails& details,
-                                 const MotionEvent& event) {
+                                 const MotionEvent& event) const {
     return GestureEventData(details,
                             event.GetPointerId(),
                             event.GetToolType(),
                             event.GetEventTime(),
                             event.GetX(),
                             event.GetY(),
                             event.GetRawX(),
                             event.GetRawY(),
                             event.GetPointerCount(),
                             GetBoundingBox(event, details.type()),
                             event.GetFlags());
   }
 
-  GestureEventData CreateGesture(EventType type, const MotionEvent& event) {
+  GestureEventData CreateGesture(EventType type,
+                                 const MotionEvent& event) const {
     return CreateGesture(GestureEventDetails(type), event);
   }
 
-  GestureEventData CreateTapGesture(EventType type, const MotionEvent& event) {
-    // Set the tap count to 1 even for ET_GESTURE_DOUBLE_TAP, in order to be
-    // consistent with double tap behavior on a mobile viewport. See
-    // crbug.com/234986 for context.
+  GestureEventData CreateTapGesture(EventType type,
+                                    const MotionEvent& event,
+                                    int tap_count) const {
+    DCHECK_GE(tap_count, 0);
     GestureEventDetails details(type);
-    details.set_tap_count(1);
+    details.set_tap_count(tap_count);
     return CreateGesture(details, event);
   }
 
-  gfx::RectF GetBoundingBox(const MotionEvent& event, EventType type) {
+  gfx::RectF GetBoundingBox(const MotionEvent& event, EventType type) const {
     // Can't use gfx::RectF::Union, as it ignores touches with a radius of 0.
     float left = std::numeric_limits<float>::max();
     float top = std::numeric_limits<float>::max();
     float right = -std::numeric_limits<float>::max();
     float bottom = -std::numeric_limits<float>::max();
     for (size_t i = 0; i < event.GetPointerCount(); ++i) {
       float x, y, diameter;
       // Only for the show press and tap events, the bounding box is calculated
       // based on the touch start point and the maximum diameter before the
       // show press event is sent.
@@ skipping 34 matching lines @@
   bool IsDoubleTapInProgress() const {
     return gesture_detector_.is_double_tapping() ||
            (IsScaleGestureDetectionInProgress() && InDoubleTapMode());
   }
 
   bool IsScrollInProgress() const { return scroll_event_sent_; }
 
   bool IsPinchInProgress() const { return pinch_event_sent_; }
 
  private:
+  bool OnSingleTapImpl(const MotionEvent& e, int tap_count) {
+    // Long taps in the edges of the screen have their events delayed by
+    // ContentViewHolder for tab swipe operations. As a consequence of the delay
+    // this method might be called after receiving the up event.
+    // These corner cases should be ignored.
+    if (ignore_single_tap_)
+      return true;
+
+    ignore_single_tap_ = true;
+
+    Send(CreateTapGesture(ET_GESTURE_TAP, e, tap_count));
+    return true;
+  }
+
   bool IsScaleGestureDetectionInProgress() const {
     return scale_gesture_detector_.IsInProgress();
   }
 
   bool InDoubleTapMode() const {
     return scale_gesture_detector_.InDoubleTapMode();
   }
 
   bool IsDoubleTapEnabled() const {
     return gesture_detector_.has_doubletap_listener();
@@ skipping 195 matching lines @@
   // null'ing of the listener until the sequence has ended.
   if (current_down_event_)
     return;
 
   const bool double_tap_enabled =
       double_tap_support_for_page_ && double_tap_support_for_platform_;
   gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
 }
 
 }  //  namespace ui