Re-enable Eager Gesture Recognition on Aura

This enables eager gesture recognition on Aura for the unified gesture
detector.

The previous attempt at enabling eager gesture recognition
(crrev.com/393953012) failed.
See crbug.com/408594 for details.

See https://codereview.chromium.org/551373006/ for some additional history.

BUG=332418
TEST=GestureRecognizerTest.{*,EagerGestureDetection}
Also manually tested on Cros and Windows.

Review URL: https://codereview.chromium.org/680413006

Cr-Commit-Position: refs/heads/master@{#307548}

6 files changed, 47 insertions, 32 deletions

diff --git a/ui/events/gestures/gesture_provider_aura.cc b/ui/events/gestures/gesture_provider_aura.cc
index 10f7ab1..ad66092 100644
--- a/ui/events/gestures/gesture_provider_aura.cc
+++ b/ui/events/gestures/gesture_provider_aura.cc
@@ -16,13 +16,16 @@ 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;
 
@@ -52,11 +55,21 @@ bool GestureProviderAura::OnTouchEvent(const TouchEvent& 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();
 }
 
diff --git a/ui/events/gestures/gesture_provider_aura.h b/ui/events/gestures/gesture_provider_aura.h
index daf853d..25769d6 100644
--- a/ui/events/gestures/gesture_provider_aura.h
+++ b/ui/events/gestures/gesture_provider_aura.h
@@ -30,7 +30,8 @@ class EVENTS_EXPORT GestureProviderAura : public GestureProviderClient {
   ~GestureProviderAura() override;
 
   bool OnTouchEvent(const TouchEvent& event);
-  void OnTouchEventAck(bool event_consumed);
+  void OnAsyncTouchEventAck(bool event_consumed);
+  void OnSyncTouchEventAck(const uint64 unique_event_id, bool event_consumed);
   const MotionEventAura& pointer_state() { return pointer_state_; }
   ScopedVector<GestureEvent>* GetAndResetPendingGestures();
 
@@ -50,6 +51,7 @@ class EVENTS_EXPORT GestureProviderAura : public GestureProviderClient {
   ui::LatencyInfo last_touch_event_latency_info_;
   bool handling_event_;
   ScopedVector<GestureEvent> pending_gestures_;
+  uint64 last_unique_touch_event_id_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureProviderAura);
 };
diff --git a/ui/events/gestures/gesture_recognizer.h b/ui/events/gestures/gesture_recognizer.h
index 5dc5834..f062177 100644
--- a/ui/events/gestures/gesture_recognizer.h
+++ b/ui/events/gestures/gesture_recognizer.h
@@ -28,21 +28,22 @@ class EVENTS_EXPORT GestureRecognizer {
   virtual ~GestureRecognizer() {}
 
   // Invoked before event dispatch. If the event is invalid given the current
-  // touch sequence, marks it as handled.
+  // touch sequence, returns false.
   virtual bool ProcessTouchEventPreDispatch(const TouchEvent& event,
                                             GestureConsumer* consumer) = 0;
+
   // Returns a list of zero or more GestureEvents. The caller is responsible for
-  // freeing the returned events. Called synchronously after event dispatch.
-  virtual Gestures* ProcessTouchEventPostDispatch(
+  // freeing the returned events. Acks the first gesture packet in the queue.
+  virtual Gestures* AckAsyncTouchEvent(
       const TouchEvent& event,
       ui::EventResult result,
       GestureConsumer* consumer) = 0;
+
   // Returns a list of zero or more GestureEvents. The caller is responsible for
-  // freeing the returned events. Called when a touch event receives an
-  // asynchronous ack.
-  virtual Gestures* ProcessTouchEventOnAsyncAck(const TouchEvent& event,
-                                                ui::EventResult result,
-                                                GestureConsumer* consumer) = 0;
+  // freeing the returned events. Acks the last gesture packet in the queue.
+  virtual Gestures* AckSyncTouchEvent(const uint64 unique_event_id,
+                                      ui::EventResult result,
+                                      GestureConsumer* consumer) = 0;
 
   // This is called when the consumer is destroyed. So this should cleanup any
   // internal state maintained for |consumer|. Returns true iff there was
diff --git a/ui/events/gestures/gesture_recognizer_impl.cc b/ui/events/gestures/gesture_recognizer_impl.cc
index ae5f89e..950bec9 100644
--- a/ui/events/gestures/gesture_recognizer_impl.cc
+++ b/ui/events/gestures/gesture_recognizer_impl.cc
@@ -249,25 +249,24 @@ bool GestureRecognizerImpl::ProcessTouchEventPreDispatch(
 }
 
 GestureRecognizer::Gestures*
-GestureRecognizerImpl::ProcessTouchEventPostDispatch(
+GestureRecognizerImpl::AckAsyncTouchEvent(
     const TouchEvent& event,
     ui::EventResult result,
     GestureConsumer* consumer) {
   GestureProviderAura* gesture_provider =
       GetGestureProviderForConsumer(consumer);
-  gesture_provider->OnTouchEventAck(result != ER_UNHANDLED);
+  gesture_provider->OnAsyncTouchEventAck(result != ER_UNHANDLED);
   return gesture_provider->GetAndResetPendingGestures();
 }
 
-GestureRecognizer::Gestures* GestureRecognizerImpl::ProcessTouchEventOnAsyncAck(
-    const TouchEvent& event,
+GestureRecognizer::Gestures* GestureRecognizerImpl::AckSyncTouchEvent(
+    const uint64 unique_event_id,
     ui::EventResult result,
     GestureConsumer* consumer) {
-  if (result & ui::ER_CONSUMED)
-    return NULL;
   GestureProviderAura* gesture_provider =
       GetGestureProviderForConsumer(consumer);
-  gesture_provider->OnTouchEventAck(result != ER_UNHANDLED);
+  gesture_provider->OnSyncTouchEventAck(unique_event_id,
+                                        result != ER_UNHANDLED);
   return gesture_provider->GetAndResetPendingGestures();
 }
 
diff --git a/ui/events/gestures/gesture_recognizer_impl.h b/ui/events/gestures/gesture_recognizer_impl.h
index 7cc7a42..39598be 100644
--- a/ui/events/gestures/gesture_recognizer_impl.h
+++ b/ui/events/gestures/gesture_recognizer_impl.h
@@ -60,13 +60,13 @@ class EVENTS_EXPORT GestureRecognizerImpl : public GestureRecognizer,
   bool ProcessTouchEventPreDispatch(const TouchEvent& event,
                                     GestureConsumer* consumer) override;
 
-  Gestures* ProcessTouchEventPostDispatch(const TouchEvent& event,
-                                          ui::EventResult result,
-                                          GestureConsumer* consumer) override;
+  Gestures* AckAsyncTouchEvent(const TouchEvent& event,
+                               ui::EventResult result,
+                               GestureConsumer* consumer) override;
 
-  Gestures* ProcessTouchEventOnAsyncAck(const TouchEvent& event,
-                                        ui::EventResult result,
-                                        GestureConsumer* consumer) override;
+  Gestures* AckSyncTouchEvent(const uint64 unique_event_id,
+                              ui::EventResult result,
+                              GestureConsumer* consumer) override;
 
   bool CleanupStateForConsumer(GestureConsumer* consumer) override;
   void AddGestureEventHelper(GestureEventHelper* helper) override;
diff --git a/ui/events/gestures/gesture_recognizer_impl_mac.cc b/ui/events/gestures/gesture_recognizer_impl_mac.cc
index a0d4ba4..8a9fe34 100644
--- a/ui/events/gestures/gesture_recognizer_impl_mac.cc
+++ b/ui/events/gestures/gesture_recognizer_impl_mac.cc
@@ -22,16 +22,16 @@ class GestureRecognizerImplMac : public GestureRecognizer {
     return false;
   }
 
-  Gestures* ProcessTouchEventPostDispatch(const TouchEvent& event,
-                                          ui::EventResult result,
-                                          GestureConsumer* consumer) override {
+  Gestures* AckAsyncTouchEvent(const TouchEvent& event,
+                               ui::EventResult result,
+                               GestureConsumer* consumer) override {
     return NULL;
   }
-  Gestures* ProcessTouchEventOnAsyncAck(const TouchEvent& event,
-                                        ui::EventResult result,
-                                        GestureConsumer* consumer) override {
+  Gestures* AckSyncTouchEvent(const uint64 unique_event_id,
+                              ui::EventResult result,
+                              GestureConsumer* consumer) override {
     return NULL;
-  };
+  }
   bool CleanupStateForConsumer(GestureConsumer* consumer) override {
     return false;
   }