Validate that asynchronous touch acks are associated with the right event

The aura gesture recognizer currently only validates that synchronous touch
acks are associated with the right event. Now we also validate this for
asynchronous touch acks as well.

BUG=457669

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

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

6 files changed, 19 insertions, 58 deletions

diff --git a/ui/events/gestures/gesture_provider_aura.cc b/ui/events/gestures/gesture_provider_aura.cc
index 7742a58..bca63f2 100644
--- a/ui/events/gestures/gesture_provider_aura.cc
+++ b/ui/events/gestures/gesture_provider_aura.cc
@@ -18,9 +18,7 @@ GestureProviderAura::GestureProviderAura(GestureProviderAuraClient* client)
       filtered_gesture_provider_(
           GetGestureProviderConfig(GestureProviderConfigType::CURRENT_PLATFORM),
           this),
-      handling_event_(false),
-      last_unique_touch_event_id_(
-          std::numeric_limits<unsigned long long>::max()) {
+      handling_event_(false) {
   filtered_gesture_provider_.SetDoubleTapSupportForPlatformEnabled(false);
 }
 
@@ -30,8 +28,6 @@ bool GestureProviderAura::OnTouchEvent(TouchEvent* event) {
   if (!pointer_state_.OnTouch(*event))
     return false;
 
-  last_unique_touch_event_id_ = event->unique_event_id();
-
   auto result = filtered_gesture_provider_.OnTouchEvent(pointer_state_);
   if (!result.succeeded)
     return false;
@@ -41,20 +37,12 @@ bool GestureProviderAura::OnTouchEvent(TouchEvent* event) {
   return true;
 }
 
-void GestureProviderAura::OnAsyncTouchEventAck(bool event_consumed) {
-  DCHECK(pending_gestures_.empty());
-  DCHECK(!handling_event_);
-  base::AutoReset<bool> handling_event(&handling_event_, true);
-  filtered_gesture_provider_.OnAsyncTouchEventAck(event_consumed);
-}
-
-void GestureProviderAura::OnSyncTouchEventAck(const uint64 unique_event_id,
-                                              bool event_consumed) {
-  DCHECK_EQ(last_unique_touch_event_id_, unique_event_id);
+void GestureProviderAura::OnTouchEventAck(uint32 unique_event_id,
+                                          bool event_consumed) {
   DCHECK(pending_gestures_.empty());
   DCHECK(!handling_event_);
   base::AutoReset<bool> handling_event(&handling_event_, true);
-  filtered_gesture_provider_.OnSyncTouchEventAck(event_consumed);
+  filtered_gesture_provider_.OnTouchEventAck(unique_event_id, event_consumed);
 }
 
 void GestureProviderAura::OnGestureEvent(
diff --git a/ui/events/gestures/gesture_provider_aura.h b/ui/events/gestures/gesture_provider_aura.h
index bdb8a51..236a5ac 100644
--- a/ui/events/gestures/gesture_provider_aura.h
+++ b/ui/events/gestures/gesture_provider_aura.h
@@ -30,8 +30,7 @@ class EVENTS_EXPORT GestureProviderAura : public GestureProviderClient {
   ~GestureProviderAura() override;
 
   bool OnTouchEvent(TouchEvent* event);
-  void OnAsyncTouchEventAck(bool event_consumed);
-  void OnSyncTouchEventAck(const uint64 unique_event_id, bool event_consumed);
+  void OnTouchEventAck(uint32 unique_event_id, bool event_consumed);
   const MotionEventAura& pointer_state() { return pointer_state_; }
   ScopedVector<GestureEvent>* GetAndResetPendingGestures();
 
@@ -50,7 +49,6 @@ class EVENTS_EXPORT GestureProviderAura : public GestureProviderClient {
 
   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 0b2c424..fd7e544 100644
--- a/ui/events/gestures/gesture_recognizer.h
+++ b/ui/events/gestures/gesture_recognizer.h
@@ -33,15 +33,11 @@ class EVENTS_EXPORT GestureRecognizer {
                                             GestureConsumer* consumer) = 0;
 
   // Returns a list of zero or more GestureEvents. The caller is responsible for
-  // freeing the returned events. Acks the first gesture packet in the queue.
-  virtual Gestures* AckAsyncTouchEvent(ui::EventResult result,
-                                       GestureConsumer* consumer) = 0;
-
-  // Returns a list of zero or more GestureEvents. The caller is responsible for
-  // 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;
+  // freeing the returned events. Acks the gesture packet in the queue which
+  // matches with unique_event_id.
+  virtual Gestures* AckTouchEvent(uint32 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 61d4005..fe3de2c 100644
--- a/ui/events/gestures/gesture_recognizer_impl.cc
+++ b/ui/events/gestures/gesture_recognizer_impl.cc
@@ -238,27 +238,13 @@ bool GestureRecognizerImpl::ProcessTouchEventPreDispatch(
   return gesture_provider->OnTouchEvent(event);
 }
 
-// TODO(tdresser): we should take a unique_event_id here, and validate
-// that the correct event is being acked. See crbug.com/457669 for
-// details.
-GestureRecognizer::Gestures*
-GestureRecognizerImpl::AckAsyncTouchEvent(
+GestureRecognizer::Gestures* GestureRecognizerImpl::AckTouchEvent(
+    uint32 unique_event_id,
     ui::EventResult result,
     GestureConsumer* consumer) {
   GestureProviderAura* gesture_provider =
       GetGestureProviderForConsumer(consumer);
-  gesture_provider->OnAsyncTouchEventAck(result != ER_UNHANDLED);
-  return gesture_provider->GetAndResetPendingGestures();
-}
-
-GestureRecognizer::Gestures* GestureRecognizerImpl::AckSyncTouchEvent(
-    const uint64 unique_event_id,
-    ui::EventResult result,
-    GestureConsumer* consumer) {
-  GestureProviderAura* gesture_provider =
-      GetGestureProviderForConsumer(consumer);
-  gesture_provider->OnSyncTouchEventAck(unique_event_id,
-                                        result != ER_UNHANDLED);
+  gesture_provider->OnTouchEventAck(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 c59166d..febc672 100644
--- a/ui/events/gestures/gesture_recognizer_impl.h
+++ b/ui/events/gestures/gesture_recognizer_impl.h
@@ -61,12 +61,9 @@ class EVENTS_EXPORT GestureRecognizerImpl : public GestureRecognizer,
   bool ProcessTouchEventPreDispatch(TouchEvent* event,
                                     GestureConsumer* consumer) override;
 
-  Gestures* AckAsyncTouchEvent(ui::EventResult result,
-                               GestureConsumer* consumer) override;
-
-  Gestures* AckSyncTouchEvent(const uint64 unique_event_id,
-                              ui::EventResult result,
-                              GestureConsumer* consumer) override;
+  Gestures* AckTouchEvent(uint32 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 5d77e84..881a868 100644
--- a/ui/events/gestures/gesture_recognizer_impl_mac.cc
+++ b/ui/events/gestures/gesture_recognizer_impl_mac.cc
@@ -22,13 +22,9 @@ class GestureRecognizerImplMac : public GestureRecognizer {
     return false;
   }
 
-  Gestures* AckAsyncTouchEvent(ui::EventResult result,
-                               GestureConsumer* consumer) override {
-    return NULL;
-  }
-  Gestures* AckSyncTouchEvent(const uint64 unique_event_id,
-                              ui::EventResult result,
-                              GestureConsumer* consumer) override {
+  Gestures* AckTouchEvent(uint32 unique_event_id,
+                          ui::EventResult result,
+                          GestureConsumer* consumer) override {
     return NULL;
   }
   bool CleanupStateForConsumer(GestureConsumer* consumer) override {