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),
+    : tap_count_(0),
+      client_(client),
       filtered_gesture_provider_(ui::DefaultGestureProviderConfig(), this) {
   filtered_gesture_provider_.SetDoubleTapSupportForPlatformEnabled(false);
 }
 
 GestureProviderAura::~GestureProviderAura() {}
 
 bool GestureProviderAura::OnTouchEvent(const TouchEvent& event) {
   last_touch_event_flags_ = event.flags();
   bool pointer_id_is_active = false;
   for (size_t i = 0; i < pointer_state_.GetPointerCount(); ++i) {
     if (event.touch_id() != pointer_state_.GetPointerId(i))
       continue;
     pointer_id_is_active = true;
     break;
   }
 
   if (event.type() == ET_TOUCH_PRESSED && pointer_id_is_active) {
     // 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) {
+  const GestureEventDetails* details = &gesture.details;
+  scoped_ptr<GestureEventDetails> tap_details;

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

Do you have any other ideas on how to avoid constructing a new
GestureEventDetails when it isn't necessary?

Alternatively, do you think it would be better to just always construct a new
GestureEventDetails? This approach feels a little confusing.

[jdduke (slow), 2014/05/21 17:21:48]

Hmm, yeah, the details object is pretty small, might as well copy I guess?

[tdresser, 2014/05/21 18:47:49]

Done.

+
+  if (gesture.type == ET_GESTURE_TAP) {
+    if (previous_down_event_ && current_down_event_ &&
+        IsConsideredDoubleTap(
+            *previous_down_event_, previous_tap_time_, *current_down_event_)) {
+      tap_count_ = 1 + (tap_count_ % 3);
+    } else {
+      tap_count_ = 1;
+    }
+    tap_details.reset(new GestureEventDetails(ET_GESTURE_TAP, tap_count_, 0));
+    details = tap_details.get();
+    previous_tap_time_ = gesture.time;
+  } else if (gesture.type == ET_GESTURE_TAP_CANCEL) {
+    tap_count_ = 0;
+  }
+
   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,

[jdduke (slow), 2014/05/21 17:21:48]

Hmm, could we just store the previous_tap_event_? If we get another tap (without
an intervening tap cancel) that's sufficiently close within the appropriate time
window, shouldn't that be enough data to make the determination?

In that case, we could store a base::Optional<GestureEventDetails>
previous_tap_, and clear it when necessary? That would also store the
accumulated tap count for us.

[tdresser, 2014/05/21 18:47:49]

Done, with a scoped_ptr.

+    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