Support tap_count in ui::GestureProvider.

ui/events/gestures/gesture_provider_aura.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/gestures/gesture_provider_aura.h"
 
 #include "base/logging.h"
 #include "ui/events/event.h"
 #include "ui/events/gesture_detection/gesture_config_helper.h"
 #include "ui/events/gesture_detection/gesture_event_data.h"
+#include "ui/events/gestures/gesture_configuration.h"
 
 namespace ui {
 
 GestureProviderAura::GestureProviderAura(GestureProviderAuraClient* client)
     : client_(client),
       filtered_gesture_provider_(ui::DefaultGestureProviderConfig(), this) {
   filtered_gesture_provider_.SetDoubleTapSupportForPlatformEnabled(false);
 }
 
 GestureProviderAura::~GestureProviderAura() {}
@@ skipping 12 matching lines @@
     // Ignore touch press events if we already believe the pointer is down.
     return false;
   } else if (event.type() != ET_TOUCH_PRESSED && !pointer_id_is_active) {
     // We could have an active touch stream transfered to us, resulting in touch
     // move or touch up events without associated touch down events. Ignore
     // them.
     return false;
   }
 
   pointer_state_.OnTouch(event);
+
+  if (pointer_state_.GetAction() == MotionEvent::ACTION_DOWN) {
+    previous_down_event_ = current_down_event_.Pass();
+    current_down_event_ = pointer_state_.Clone();
+  }
+
   bool result = filtered_gesture_provider_.OnTouchEvent(pointer_state_);
   pointer_state_.CleanupRemovedTouchPoints(event);
   return result;
 }
 
 void GestureProviderAura::OnTouchEventAck(bool event_consumed) {
   filtered_gesture_provider_.OnTouchEventAck(event_consumed);
 }
 
 void GestureProviderAura::OnGestureEvent(
     const GestureEventData& gesture) {
+  GestureEventDetails details = gesture.details;
+
+  int tap_count = 1;
+  if (gesture.type == ET_GESTURE_TAP) {
+    if (previous_down_event_ && current_down_event_ &&
+        IsConsideredDoubleTap(

[jdduke (slow), 2014/05/21 19:00:30]

The reason I suggested just caching the tap details was to prevent cloning
previous/current down events.  Why do we need the down events if we know the
previous tap position, the previous tap time, and that no intervening tap cancel
has occurred?

[tdresser, 2014/05/21 19:50:43]

I hesitated because it does change the behavior (We previously looked at down
locations, not up).

I think you're right that it's fine though. Done.

+            *previous_down_event_, previous_tap_->time, *current_down_event_)) {
+      tap_count = 1 + (previous_tap_->details.tap_count() % 3);
+    }
+    details = GestureEventDetails(ET_GESTURE_TAP, tap_count, 0);
+    previous_tap_.reset(new GestureEventData(gesture));
+    previous_tap_->details = details;
+  } else if (gesture.type == ET_GESTURE_TAP_CANCEL) {
+    previous_tap_.reset();
+  }
+
   ui::GestureEvent event(gesture.type,
                          gesture.x,
                          gesture.y,
                          last_touch_event_flags_,
                          gesture.time - base::TimeTicks(),
-                         gesture.details,
+                         details,
                          // ui::GestureEvent stores a bitfield indicating the
                          // ids of active touch points. This is currently only
                          // used when one finger is down, and will eventually
                          // be cleaned up. See crbug.com/366707.
                          1 << gesture.motion_event_id);
   client_->OnGestureEvent(&event);
 }
 
+bool GestureProviderAura::IsConsideredDoubleTap(
+    const MotionEvent& previous_down,
+    const base::TimeTicks previous_tap_time,
+    const MotionEvent& current_down) const {
+  if (current_down.GetEventTime() - previous_tap_time >
+      base::TimeDelta::FromMilliseconds(
+          ui::GestureConfiguration::max_seconds_between_double_click() *
+          1000)) {
+    return false;
+  }
+
+  double double_tap_slop_square =
+      GestureConfiguration::max_distance_between_taps_for_double_tap();
+  double_tap_slop_square *= double_tap_slop_square;
+  const float delta_x = previous_down.GetX() - current_down.GetX();
+  const float delta_y = previous_down.GetY() - current_down.GetY();
+  return (delta_x * delta_x + delta_y * delta_y < double_tap_slop_square);
+}
+
 }  // namespace content