Make tapDown async.

content/browser/renderer_host/input/immediate_input_router_unittest.cc

 // Copyright 2013 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/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/renderer_host/input/gesture_event_filter.h"
 #include "content/browser/renderer_host/input/immediate_input_router.h"
 #include "content/browser/renderer_host/input/input_router_client.h"
@@ skipping 347 matching lines @@
 }
 
 TEST_F(ImmediateInputRouterTest, IgnoreKeyEventsWeDidntSend) {
   // Send a simulated, unrequested key response. We should ignore this.
   SendInputEventACK(WebInputEvent::RawKeyDown,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   ack_handler_->ExpectAckCalled(0);
 }
 
+// GestureEventFilter tests should be factored out of
+// ImmediateInputRouterTest. See crbug.com/301807.
 TEST_F(ImmediateInputRouterTest, CoalescesWheelEvents) {
   // Simulate wheel events.
   SimulateWheelEvent(0, -5, 0, false);  // sent directly
   SimulateWheelEvent(0, -10, 0, false);  // enqueued
   SimulateWheelEvent(8, -6, 0, false);  // coalesced into previous event
   SimulateWheelEvent(9, -7, 1, false);  // enqueued, different modifiers
 
   // Check that only the first event was sent.
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
@@ skipping 504 matching lines @@
   EXPECT_EQ(0U, GestureEventLastQueueEventSize());
 
   // Wait long enough for first timeout and see if 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());
-  EXPECT_EQ(1U, GestureEventLastQueueEventSize());
-  EXPECT_EQ(WebInputEvent::GestureTapDown,
-            GestureEventLastQueueEvent().type);
+  // The tap down event will have escaped the queue, since they're async.
+  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
 }
 
 // Test that GestureTapDown events are sent immediately on GestureTap.
 TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownSentOnTap) {
   // 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());
 
   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);
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::MessageLoop::QuitClosure(),
       TimeDelta::FromMilliseconds(10));
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(WebInputEvent::GestureTapDown,
             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
 // the timeout.
 TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownOnlyOnce) {
   // 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 long enough for the 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());
-  EXPECT_EQ(1U, GestureEventLastQueueEventSize());
-  EXPECT_EQ(WebInputEvent::GestureTapDown,
-            GestureEventLastQueueEvent().type);
+  // The tap down events will have escaped the queue, since they're async.
+  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(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);
 }
 
+// Test that GestureTapDown events don't wait for ACKs.
+TEST_F(ImmediateInputRouterTest, GestureTapDownIsAsync) {
+  // 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 async.
+  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);
+
+  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());
+
+  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.
 TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownAnulledOnScroll) {
   // 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());
 
@@ skipping 51 matching lines @@
   EXPECT_EQ(0U, process_->sink().message_count());
   EXPECT_EQ(0U, GestureEventLastQueueEventSize());
 
   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(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
 // debounce interval, that Scrolls are not and that the deferred events are
 // sent after that timer fires.
 TEST_F(ImmediateInputRouterTest, DebounceDefersFollowingGestureEvents) {
   set_debounce_interval_time_ms(3);
 
   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
                        WebGestureEvent::Touchscreen);
@@ skipping 888 matching lines @@
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   ReleaseTouchPoint(0);
   SendTouchEvent();
   EXPECT_EQ(1U, process_->sink().message_count());
   process_->sink().ClearMessages();
   SendInputEventACK(WebInputEvent::TouchEnd,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 }
 }  // namespace content