Support tap_count in ui::GestureProvider.

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 83 matching lines @@
   return CreateGesture(type,
                        event.GetId(),
                        event.GetEventTime(),
                        event.GetX(),
                        event.GetY(),
                        event.GetPointerCount(),
                        GetBoundingBox(event));
 }
 
 GestureEventDetails CreateTapGestureDetails(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.
-  GestureEventDetails tap_details(type, 1, 0);
+                                            const MotionEvent& event,
+                                            int tap_count) {
+  DCHECK(type != ET_GESTURE_DOUBLE_TAP || tap_count == 1);
+  DCHECK_GT(tap_count, 0);
+  DCHECK_LE(tap_count, 3);
+  GestureEventDetails tap_details(type, tap_count, 0);
   return tap_details;
 }
 
 }  // namespace
 
 // GestureProvider:::Config
 
 GestureProvider::Config::Config()
     : display(gfx::Display::kInvalidDisplayID, gfx::Rect(1, 1)),
       disable_click_delay(false),
@@ skipping 280 matching lines @@
                                   two_finger_tap_details));
     return true;
   }
 
   virtual void OnShowPress(const MotionEvent& e) OVERRIDE {
     GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS, 0, 0);
     provider_->Send(
         CreateGesture(ET_GESTURE_SHOW_PRESS, e, show_press_details));
   }
 
-  virtual bool OnSingleTapUp(const MotionEvent& e) OVERRIDE {
+  virtual 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_ > double_tap_timeout_) {
-        return OnSingleTapConfirmed(e);
+        return OnSingleTapConfirmed(e, tap_count);
       } else if (!IsDoubleTapEnabled() || disable_click_delay_) {
         // If double-tap has been disabled, there is no need to wait
         // for the double-tap timeout.
-        return OnSingleTapConfirmed(e);
+        return OnSingleTapConfirmed(e, tap_count);
       } else {
         // Notify Blink about this tapUp event anyway, when none of the above
         // conditions applied.
         provider_->Send(CreateGesture(
             ET_GESTURE_TAP_UNCONFIRMED,
             e,
-            CreateTapGestureDetails(ET_GESTURE_TAP_UNCONFIRMED, e)));
+            CreateTapGestureDetails(ET_GESTURE_TAP_UNCONFIRMED, e, tap_count)));
       }
     }
 
     return provider_->SendLongTapIfNecessary(e);
   }
 
   // GestureDetector::DoubleTapListener implementation.
-  virtual bool OnSingleTapConfirmed(const MotionEvent& e) OVERRIDE {
+  virtual bool OnSingleTapConfirmed(const MotionEvent& e,
+                                    int tap_count) 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;
 
-    provider_->Send(CreateGesture(
-        ET_GESTURE_TAP, e, CreateTapGestureDetails(ET_GESTURE_TAP, e)));
+    provider_->Send(
+        CreateGesture(ET_GESTURE_TAP,
+                      e,
+                      CreateTapGestureDetails(ET_GESTURE_TAP, e, tap_count)));
     return true;
   }
 
   virtual bool OnDoubleTap(const MotionEvent& e) OVERRIDE { return false; }
 
   virtual 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 (!provider_->IsPinchInProgress() &&
             !provider_->IsScrollInProgress()) {
-          provider_->Send(
-              CreateGesture(ET_GESTURE_DOUBLE_TAP,
-                            e,
-                            CreateTapGestureDetails(ET_GESTURE_DOUBLE_TAP, e)));
+          // Tap count is set to 1 for ET_GESTURE_DOUBLE_TAP, in order to be
+          // consistent with double tap behavior on a mobile viewport. See
+          // crbug.com/234986 for context.
+          provider_->Send(CreateGesture(
+              ET_GESTURE_DOUBLE_TAP,
+              e,
+              CreateTapGestureDetails(ET_GESTURE_DOUBLE_TAP, e, 1)));
           return true;
         }
         break;
       default:
         break;
     }
     return false;
   }
 
   virtual bool OnLongPress(const MotionEvent& e) OVERRIDE {
@@ skipping 298 matching lines @@
   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);
   scale_gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
 }
 
 }  //  namespace ui