Support tap_count in ui::GestureProvider.

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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/events/gesture_detection/gesture_detector.h"
 
 #include <cmath>
@@ skipping 46 matching lines @@
 GestureDetector::Config::~Config() {}
 
 bool GestureDetector::SimpleGestureListener::OnDown(const MotionEvent& e) {
   return false;
 }
 
 void GestureDetector::SimpleGestureListener::OnShowPress(const MotionEvent& e) {
 }
 
 bool GestureDetector::SimpleGestureListener::OnSingleTapUp(
-    const MotionEvent& e) {
+    const MotionEvent& e, int tap_count) {

[jdduke (slow), 2014/05/21 15:07:14]

Maybe tap_repeat_count? Hmm, but that's slightly ambiguous...

[tdresser, 2014/05/21 16:39:15]

We use tap_count throughout (GestureEventDetails, PlatformGestureEvent,
WebInputEvent...)

   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnLongPress(const MotionEvent& e) {
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnScroll(const MotionEvent& e1,
                                                       const MotionEvent& e2,
                                                       float distance_x,
@@ skipping 15 matching lines @@
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnTwoFingerTap(
     const MotionEvent& e1,
     const MotionEvent& e2) {
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnSingleTapConfirmed(
-    const MotionEvent& e) {
+    const MotionEvent& e, int tap_count) {
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnDoubleTap(const MotionEvent& e) {
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnDoubleTapEvent(
     const MotionEvent& e) {
   return false;
@@ skipping 66 matching lines @@
       defer_confirm_single_tap_(false),
       in_longpress_(false),
       always_in_tap_region_(false),
       always_in_bigger_tap_region_(false),
       two_finger_tap_allowed_for_gesture_(false),
       is_double_tapping_(false),
       last_focus_x_(0),
       last_focus_y_(0),
       down_focus_x_(0),
       down_focus_y_(0),
-  longpress_enabled_(true),
-  swipe_enabled_(false),
-  two_finger_tap_enabled_(false) {
+      longpress_enabled_(true),
+      swipe_enabled_(false),
+      two_finger_tap_enabled_(false),
+      tap_count_(0) {
   DCHECK(listener_);
   Init(config);
 }
 
 GestureDetector::~GestureDetector() {}
 
 bool GestureDetector::OnTouchEvent(const MotionEvent& ev) {
   const MotionEvent::Action action = ev.GetAction();
 
   velocity_tracker_.AddMovement(ev);
@@ skipping 117 matching lines @@
           handled |= double_tap_listener_->OnDoubleTapEvent(ev);
         } else {
           // This is a first tap.
           DCHECK(double_tap_timeout_ > base::TimeDelta());
           timeout_handler_->StartTimeout(TAP);
         }
       }
 
       down_focus_x_ = last_focus_x_ = focus_x;
       down_focus_y_ = last_focus_y_ = focus_y;
+      previous_down_event_ = current_down_event_.Pass();
       current_down_event_ = ev.Clone();
 
       secondary_pointer_down_event_.reset();
       always_in_tap_region_ = true;
       always_in_bigger_tap_region_ = true;
       still_down_ = true;
       in_longpress_ = false;
       defer_confirm_single_tap_ = false;
       two_finger_tap_allowed_for_gesture_ = two_finger_tap_enabled_;
 
@@ skipping 69 matching lines @@
       still_down_ = false;
       {
         if (is_double_tapping_) {
           // Finally, give the up event of the double-tap.
           DCHECK(double_tap_listener_);
           handled |= double_tap_listener_->OnDoubleTapEvent(ev);
         } else if (in_longpress_) {
           timeout_handler_->StopTimeout(TAP);
           in_longpress_ = false;
         } else if (always_in_tap_region_) {
-          handled = listener_->OnSingleTapUp(ev);
+          if (double_tap_listener_) {
+            tap_count_ = 1;
+          } else {
+            if (previous_down_event_ && previous_up_event_ &&
+                current_down_event_ &&
+                IsConsideredDoubleTap(*previous_down_event_,
+                                      *previous_up_event_,
+                                      *current_down_event_)) {
+              ++tap_count_;
+              // We only support up to triple tap. Further taps are also treated
+              // as triple taps.
+              tap_count_ = std::min(tap_count_, 3);

[jdduke (slow), 2014/05/21 15:07:14]

I'd prefer the GestureDetector not have any awareness of this restriction. 
Could we push this logic downstream?

[tdresser, 2014/05/21 16:39:15]

Done.

+            } else {
+              // As we're outside of the double tap range, reset the
+              // |tap_count_|.
+              tap_count_ = 1;
+            }
+          }
+          handled = listener_->OnSingleTapUp(ev, tap_count_);
           if (defer_confirm_single_tap_ && double_tap_listener_ != NULL) {
-            double_tap_listener_->OnSingleTapConfirmed(ev);
+            double_tap_listener_->OnSingleTapConfirmed(ev, 1);

[jdduke (slow), 2014/05/21 15:07:14]

Might as well just use |tap_count_| here instead of 1 for consistency.

[tdresser, 2014/05/21 16:39:15]

Done.

           }
         } else {
 
           // A fling must travel the minimum tap distance.
           const int pointer_id = ev.GetPointerId(0);
           velocity_tracker_.ComputeCurrentVelocity(1000, max_fling_velocity_);
           const float velocity_y = velocity_tracker_.GetYVelocity(pointer_id);
           const float velocity_x = velocity_tracker_.GetXVelocity(pointer_id);
 
           if ((std::abs(velocity_y) > min_fling_velocity_) ||
@@ skipping 74 matching lines @@
 void GestureDetector::OnLongPressTimeout() {
   timeout_handler_->StopTimeout(TAP);
   defer_confirm_single_tap_ = false;
   in_longpress_ = listener_->OnLongPress(*current_down_event_);
 }
 
 void GestureDetector::OnTapTimeout() {
   if (!double_tap_listener_)
     return;
   if (!still_down_)
-    double_tap_listener_->OnSingleTapConfirmed(*current_down_event_);
+    double_tap_listener_->OnSingleTapConfirmed(*current_down_event_, 1);
   else
     defer_confirm_single_tap_ = true;
 }
 
 void GestureDetector::Cancel() {
   timeout_handler_->Stop();
   velocity_tracker_.Clear();
   is_double_tapping_ = false;
   still_down_ = false;

[jdduke (slow), 2014/05/21 15:07:14]

We should probably reset tap_count_ both here and in |CancelTaps()|.  Actually,
I've been meaning to refactor these two methods, it appears we can implement
Cancel() in terms of CancelTaps(), so we'd have:

Cancel() {
  CancelTaps();
  velocity_tracker_.Clear();
  still_down_ = false;
}

[tdresser, 2014/05/21 16:39:15]

Done.

   always_in_tap_region_ = false;
   always_in_bigger_tap_region_ = false;
   defer_confirm_single_tap_ = false;
   in_longpress_ = false;
 }
 
 void GestureDetector::CancelTaps() {
   timeout_handler_->Stop();
   is_double_tapping_ = false;
   always_in_tap_region_ = false;
@@ skipping 12 matching lines @@
   if (second_down.GetEventTime() - first_up.GetEventTime() >
       double_tap_timeout_)
     return false;
 
   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