Re-enable Eager Gesture Recognition on Aura

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/auto_reset.h"
 #include "base/logging.h"
 #include "ui/events/event.h"
 #include "ui/events/gesture_detection/gesture_configuration.h"
 #include "ui/events/gesture_detection/gesture_event_data.h"
 #include "ui/events/gesture_detection/gesture_provider_config_helper.h"
 
 namespace ui {
 
 GestureProviderAura::GestureProviderAura(GestureProviderAuraClient* client)
     : client_(client),
       filtered_gesture_provider_(DefaultGestureProviderConfig(), this),
-      handling_event_(false) {
+      handling_event_(false),
+      last_unique_touch_event_id_(
+          std::numeric_limits<unsigned long long>::max()) {
   filtered_gesture_provider_.SetDoubleTapSupportForPlatformEnabled(false);
 }
 
 GestureProviderAura::~GestureProviderAura() {}
 
 bool GestureProviderAura::OnTouchEvent(const TouchEvent& event) {
+  last_unique_touch_event_id_ = event.unique_event_id();
   int index = pointer_state_.FindPointerIndexOfId(event.touch_id());
   bool pointer_id_is_active = index != -1;
 
   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;
   }
 
   // If this is a touchmove event, and it isn't different from the last
   // event, ignore it.
   if (event.type() == ET_TOUCH_MOVED &&
       event.x() == pointer_state_.GetX(index) &&
       event.y() == pointer_state_.GetY(index)) {
     return false;
   }
 
   last_touch_event_latency_info_ = *event.latency();
   pointer_state_.OnTouch(event);
 
   bool result = filtered_gesture_provider_.OnTouchEvent(pointer_state_);
   pointer_state_.CleanupRemovedTouchPoints(event);
   return result;
 }
 
-void GestureProviderAura::OnTouchEventAck(bool event_consumed) {
+void GestureProviderAura::OnAsyncTouchEventAck(bool event_consumed) {
   DCHECK(pending_gestures_.empty());
   DCHECK(!handling_event_);
   base::AutoReset<bool> handling_event(&handling_event_, true);
-  filtered_gesture_provider_.OnTouchEventAck(event_consumed);
+  filtered_gesture_provider_.OnAsyncTouchEventAck(event_consumed);
   last_touch_event_latency_info_.Clear();
 }
 
+void GestureProviderAura::OnSyncTouchEventAck(const uint64 unique_event_id,
+                                              bool event_consumed) {
+  DCHECK_EQ(last_unique_touch_event_id_, unique_event_id);
+  DCHECK(pending_gestures_.empty());
+  DCHECK(!handling_event_);
+  base::AutoReset<bool> handling_event(&handling_event_, true);
+  filtered_gesture_provider_.OnSyncTouchEventAck(event_consumed);
+  last_touch_event_latency_info_.Clear();
+}
+
 void GestureProviderAura::OnGestureEvent(
     const GestureEventData& gesture) {
   GestureEventDetails details = gesture.details;
   details.set_oldest_touch_id(gesture.motion_event_id);
 
   if (gesture.type() == ET_GESTURE_TAP) {
     int tap_count = 1;
     if (previous_tap_ && IsConsideredDoubleTap(*previous_tap_, gesture))
       tap_count = 1 + (previous_tap_->details.tap_count() % 3);
     details.set_tap_count(tap_count);
@@ skipping 57 matching lines @@
   float double_tap_slop_square =
       GestureConfiguration::GetInstance()
           ->max_distance_between_taps_for_double_tap();
   double_tap_slop_square *= double_tap_slop_square;
   const float delta_x = previous_tap.x - current_tap.x;
   const float delta_y = previous_tap.y - current_tap.y;
   return (delta_x * delta_x + delta_y * delta_y < double_tap_slop_square);
 }
 
 }  // namespace content