Make tapDown async.

content/browser/renderer_host/input/immediate_input_router_unittest.cc

Index: content/browser/renderer_host/input/immediate_input_router_unittest.cc
diff --git a/content/browser/renderer_host/input/immediate_input_router_unittest.cc b/content/browser/renderer_host/input/immediate_input_router_unittest.cc
index b464bc06e279f55505aeb2426329f4f00730daec..e18cfe601166c6cf2478a9763ba04fae298adef8 100644
--- a/content/browser/renderer_host/input/immediate_input_router_unittest.cc
+++ b/content/browser/renderer_host/input/immediate_input_router_unittest.cc
@@ -889,9 +889,8 @@ TEST_F(ImmediateInputRouterTest, DeferredGestureTapDown) {
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_EQ(1U, GestureEventLastQueueEventSize());
-  EXPECT_EQ(WebInputEvent::GestureTapDown,
-            GestureEventLastQueueEvent().type);
+  // The tap down event will have escaped the queue, since they're asynch.
+  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
 }
 
 // Test that GestureTapDown events are sent immediately on GestureTap.
@@ -906,8 +905,9 @@ TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownSentOnTap) {
 
   SimulateGestureEvent(WebInputEvent::GestureTap,
                        WebGestureEvent::Touchscreen);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_EQ(2U, GestureEventLastQueueEventSize());
+
+  EXPECT_EQ(2U, process_->sink().message_count());
+  EXPECT_EQ(1U, GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureTap,
             GestureEventLastQueueEvent().type);
 
@@ -921,7 +921,7 @@ TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownSentOnTap) {
             client_->immediately_sent_gesture_event().event.type);
 
   // If the deferral timer incorrectly fired, it sent an extra message.
-  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(2U, process_->sink().message_count());
 }
 
 // Test that only a single GestureTapDown event is sent when tap occurs after
@@ -943,17 +943,118 @@ TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownOnlyOnce) {
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(1U, process_->sink().message_count());
+  // The tap down events will have escaped the queue, since they're asynch.
+  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
+
+  // Now send the tap gesture and verify we didn't get an extra TapDown.
+  SimulateGestureEvent(WebInputEvent::GestureTap,
+                       WebGestureEvent::Touchscreen);
+  EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, GestureEventLastQueueEventSize());
-  EXPECT_EQ(WebInputEvent::GestureTapDown,
+  EXPECT_EQ(WebInputEvent::GestureTap,
             GestureEventLastQueueEvent().type);
+}
+
+// Test that GestureTapDown events don't wait for ACKs.

[jdduke (slow), 2013/09/30 15:42:56]

Could you file a bug that GestureEventFilter tests should be factored out from
ImmediateInputRouterTest? And link to that bug in a comment above the first GEF
test here? Thanks.

[tdresser, 2013/09/30 18:05:03]

Done.

+TEST_F(ImmediateInputRouterTest, GestureTapDownIsAsynch) {
+  // Set some sort of short deferral timeout
+  set_maximum_tap_gap_time_ms(5);
+
+  SimulateGestureEvent(WebInputEvent::GestureTapDown,
+                       WebGestureEvent::Touchscreen);
+  EXPECT_EQ(0U, process_->sink().message_count());
+  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
+
+  // Wait for tap deferral to end.
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
+      TimeDelta::FromMilliseconds(10));
+  base::MessageLoop::current()->Run();
+
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
+
+  SimulateGestureEvent(WebInputEvent::GestureTapDown,
+                       WebGestureEvent::Touchscreen);
+
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
+
+  // Wait for tap deferral to end.
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
+      TimeDelta::FromMilliseconds(10));
+  base::MessageLoop::current()->Run();
+
+  SimulateGestureEvent(WebInputEvent::GestureTapDown,
+                       WebGestureEvent::Touchscreen);
+
+  EXPECT_EQ(2U, process_->sink().message_count());
+  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
+
+  // Wait for tap deferral to end.
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
+      TimeDelta::FromMilliseconds(10));
+  base::MessageLoop::current()->Run();
+
+  EXPECT_EQ(3U, process_->sink().message_count());
+  // The tap down events will have escaped the queue, since they're asynch.
+  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
+}
+
+// Test that GestureTapDown events don't get out of order due to asynchronicity.
+TEST_F(ImmediateInputRouterTest, GestureTapDownIsInOrder) {
+  // Set some sort of short deferral timeout
+  set_maximum_tap_gap_time_ms(5);
 
-  // Now send the tap gesture and verify we didn't get an extra TapDown.
   SimulateGestureEvent(WebInputEvent::GestureTap,
                        WebGestureEvent::Touchscreen);
+
+  SimulateGestureEvent(WebInputEvent::GestureTapDown,
+                       WebGestureEvent::Touchscreen);
+  EXPECT_EQ(1U, process_->sink().message_count());
+  // TapDown is deferred, hasn't entered the queue yet.
+  EXPECT_EQ(1U, GestureEventLastQueueEventSize());
+
+  // Wait long enough for the first timeout and verify it fired.
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
+      TimeDelta::FromMilliseconds(10));
+  base::MessageLoop::current()->Run();
+
   EXPECT_EQ(1U, process_->sink().message_count());
+  // The TapDown, though asynchronous, is still stuck in the queue
+  // behind the synchronous Tap.
   EXPECT_EQ(2U, GestureEventLastQueueEventSize());
-  EXPECT_EQ(WebInputEvent::GestureTap,
-            GestureEventLastQueueEvent().type);
+
+  SimulateGestureEvent(WebInputEvent::GestureTapDown,
+                       WebGestureEvent::Touchscreen);
+  EXPECT_EQ(1U, process_->sink().message_count());
+  // TapDown is deferred, hasn't entered the queue yet.
+  EXPECT_EQ(2U, GestureEventLastQueueEventSize());
+
+  // Wait long enough for the second timeout and verify it fired.
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
+      TimeDelta::FromMilliseconds(10));
+  base::MessageLoop::current()->Run();
+
+  EXPECT_EQ(1U, process_->sink().message_count());
+  // TapDown has entered the queue.
+  EXPECT_EQ(3U, GestureEventLastQueueEventSize());
+
+  SendInputEventACK(WebInputEvent::GestureTap,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  // Now that the Tap has been ACKed, the TapDowns should fire immediately.
+  EXPECT_EQ(3U, process_->sink().message_count());
+  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
 }
 
 // Test that scroll events during the deferral interval drop the GestureTapDown.
@@ -1027,12 +1128,12 @@ TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownTapCancel) {
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_EQ(1U, GestureEventLastQueueEventSize());
+  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
 
   SimulateGestureEvent(WebInputEvent::GestureTapCancel,
                        WebGestureEvent::Touchscreen);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_EQ(2U, GestureEventLastQueueEventSize());
+  EXPECT_EQ(2U, process_->sink().message_count());
+  EXPECT_EQ(1U, GestureEventLastQueueEventSize());
 }
 
 // Test that a GestureScrollEnd | GestureFlingStart are deferred during the