Re-enable Eager Gesture Recognition on Aura

ui/aura/gestures/gesture_recognizer_unittest.cc

 // Copyright (c) 2012 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 "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 319 matching lines @@
   ui::EventType wait_until_event_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
  public:
   explicit QueueTouchEventDelegate(WindowEventDispatcher* dispatcher)
       : window_(NULL),
         dispatcher_(dispatcher),
-        queue_events_(true) {
+        queue_events_(true),
+        treat_next_event_as_invalid_(false) {
   }
   ~QueueTouchEventDelegate() override {
     while(!queue_.empty()) {
       delete queue_.front();
       queue_.pop();
     }
   }
 
   void OnTouchEvent(ui::TouchEvent* event) override {
+    event->DisableSynchronousHandling();
+    if (treat_next_event_as_invalid_) {
+      treat_next_event_as_invalid_ = false;
+      dispatcher_->IgnoreLastTouchEvent(window_);
+    }
     if (queue_events_) {
       queue_.push(new ui::TouchEvent(*event, window_, window_));
-      event->StopPropagation();
     }
   }
 
   void ReceivedAck() {
     ReceivedAckImpl(false);
   }
 
   void ReceivedAckPreventDefaulted() {
     ReceivedAckImpl(true);
   }
 
   void set_window(Window* w) { window_ = w; }
   void set_queue_events(bool queue) { queue_events_ = queue; }
+  void treat_next_event_as_invalid() {
+    treat_next_event_as_invalid_ = true;
+  }
 
  private:
   void ReceivedAckImpl(bool prevent_defaulted) {
     scoped_ptr<ui::TouchEvent> event(queue_.front());
     dispatcher_->ProcessedTouchEvent(event.get(), window_,
         prevent_defaulted ? ui::ER_HANDLED : ui::ER_UNHANDLED);
     queue_.pop();
   }
 
   std::queue<ui::TouchEvent*> queue_;
   Window* window_;
   WindowEventDispatcher* dispatcher_;
   bool queue_events_;
+  bool treat_next_event_as_invalid_;
 
   DISALLOW_COPY_AND_ASSIGN(QueueTouchEventDelegate);
 };
 
 // A delegate that ignores gesture events but keeps track of [synthetic] mouse
 // events.
 class GestureEventSynthDelegate : public TestWindowDelegate {
  public:
   GestureEventSynthDelegate()
       : mouse_enter_(false),
@@ skipping 3851 matching lines @@
   ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(65, 202),
                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_PINCH_UPDATE);
 }
 
 // Tests that delaying the ack of a touch release doesn't trigger a long press
 // gesture.
-TEST_F(GestureRecognizerTest, DISABLED_EagerGestureDetection) {
+TEST_F(GestureRecognizerTest, EagerGestureDetection) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
   delegate->Reset();
@@ skipping 12 matching lines @@
   delegate->Reset();
   // Wait until the long press event would fire (if we weren't eager).
   DelayByLongPressTimeout();
 
   // Ack the touch release.
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->tap());
   EXPECT_FALSE(delegate->long_press());
 }
 
-// This tests crbug.com/405519, in which events which the gesture detector
-// ignores cause future events to also be thrown away.
-TEST_F(GestureRecognizerTest, IgnoredEventsDontPreventFutureEvents) {
+// This tests crbug.com/405519, in which touch events which the gesture detector
+// ignores interfere with gesture recognition.
+TEST_F(GestureRecognizerTest, IgnoredEventsDontBreakGestureRecognition) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 3;
   gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
@@ skipping 12 matching lines @@
       ui::ET_TOUCH_MOVED, gfx::Point(65, 201), kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
   delegate->ReceivedAck();
 
   EXPECT_3_EVENTS(delegate->events(),
                   ui::ET_GESTURE_TAP_CANCEL,
                   ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE);
 
   delegate->Reset();
+
+  // Send a valid event, but don't ack it.
   ui::TouchEvent move2(
       ui::ET_TOUCH_MOVED, gfx::Point(65, 202), kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
+  EXPECT_0_EVENTS(delegate->events());
 
   // Send a touchmove event at the same location as the previous touchmove
   // event. This shouldn't do anything.
   ui::TouchEvent move3(
       ui::ET_TOUCH_MOVED, gfx::Point(65, 202), kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&move3);
 
+  // Ack the previous valid event. The intermediary invalid event shouldn't
+  // interfere.
   delegate->ReceivedAck();
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
 }
 
+// Tests that an event found invalid after gesture recognition has
+// taken place can't cause out of order acks.
+TEST_F(GestureRecognizerTest, IgnoredEventsAfterGRDontCauseOutOfOrderAcks) {
+  scoped_ptr<QueueTouchEventDelegate> delegate(
+      new QueueTouchEventDelegate(host()->dispatcher()));
+  TimedEvents tes;
+  const int kWindowWidth = 300;
+  const int kWindowHeight = 400;
+  const int kTouchId1 = 3;
+  gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, root_window()));
+  delegate->set_window(window.get());
+
+  // Start a scroll gesture.
+  ui::TouchEvent press1(
+      ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), kTouchId1, tes.Now());
+  DispatchEventUsingWindowDispatcher(&press1);
+  delegate->ReceivedAck();
+
+  ui::TouchEvent move1(
+      ui::ET_TOUCH_MOVED, gfx::Point(100, 100), kTouchId1, tes.Now());
+  DispatchEventUsingWindowDispatcher(&move1);
+  delegate->ReceivedAck();
+
+  delegate->Reset();
+  // Dispatch an invalid touch move, which should be ignored.
+  delegate->treat_next_event_as_invalid();
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(200, 200), kTouchId1,
+                       tes.Now());
+  DispatchEventUsingWindowDispatcher(&move2);
+  EXPECT_0_EVENTS(delegate->events());
+
+  // Dispatch a valid touch move, but don't ack it.
+  ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(300, 300), kTouchId1,
+                       tes.Now());
+  DispatchEventUsingWindowDispatcher(&move3);
+
+  // Dispatch two invalid touch moves, which should be ignored.
+  delegate->treat_next_event_as_invalid();
+  ui::TouchEvent move4(
+      ui::ET_TOUCH_MOVED, gfx::Point(400, 400), kTouchId1, tes.Now());
+  DispatchEventUsingWindowDispatcher(&move4);
+
+  delegate->treat_next_event_as_invalid();
+  ui::TouchEvent move5(
+      ui::ET_TOUCH_MOVED, gfx::Point(500, 500), kTouchId1, tes.Now());
+  DispatchEventUsingWindowDispatcher(&move5);
+
+  EXPECT_0_EVENTS(delegate->events());
+  EXPECT_EQ(100, delegate->bounding_box().x());
+  // Ack the valid touch, and ensure the most recent gesture event
+  // used its co-ordinates.
+  delegate->ReceivedAck();
+  EXPECT_EQ(300, delegate->bounding_box().x());
+  EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
+}
+
 }  // namespace test
 }  // namespace aura