Defer synthetic gesture completions until events have been flushed

content/browser/renderer_host/input/input_router_impl_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/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/renderer_host/input/gesture_event_queue.h"
 #include "content/browser/renderer_host/input/input_router_client.h"
@@ skipping 106 matching lines @@
   // testing::Test
   virtual void SetUp() OVERRIDE {
     browser_context_.reset(new TestBrowserContext());
     process_.reset(new MockRenderProcessHost(browser_context_.get()));
     client_.reset(new MockInputRouterClient());
     ack_handler_.reset(new MockInputAckHandler());
     CommandLine* command_line = CommandLine::ForCurrentProcess();
     command_line->AppendSwitch(switches::kValidateInputEventStream);
     input_router_.reset(new InputRouterImpl(
         process_.get(), client_.get(), ack_handler_.get(), MSG_ROUTING_NONE));
-    input_router_->gesture_event_queue_->set_debounce_enabled_for_testing(
+    input_router_->gesture_event_queue_.set_debounce_enabled_for_testing(
         false);
     client_->set_input_router(input_router());
     ack_handler_->set_input_router(input_router());
   }
 
   virtual void TearDown() OVERRIDE {
     // Process all pending tasks to avoid leaks.
     base::MessageLoop::current()->RunUntilIdle();
 
     input_router_.reset();
@@ skipping 120 matching lines @@
         new InputHostMsg_HandleInputEvent_ACK(0, type, ack_result,
                                               ui::LatencyInfo()));
     input_router_->OnMessageReceived(*response);
   }
 
   InputRouterImpl* input_router() const {
     return input_router_.get();
   }
 
   bool TouchEventQueueEmpty() const {
-    return input_router()->touch_event_queue_->empty();
+    return input_router()->touch_event_queue_.empty();
   }
 
   bool TouchEventTimeoutEnabled() const {
-    return input_router()->touch_event_queue_->ack_timeout_enabled();
+    return input_router()->touch_event_queue_.ack_timeout_enabled();
+  }
+
+  void Flush() const {
+    return input_router_->Flush();
+  }
+
+  size_t GetAndResetDidFlushCount() {
+    return client_->GetAndResetDidFlushCount();
+  }
+
+  bool HasPendingEvents() const {
+    return input_router_->HasPendingEvents();
   }
 
   void OnHasTouchEventHandlers(bool has_handlers) {
     input_router_->OnMessageReceived(
         ViewHostMsg_HasTouchEventHandlers(0, has_handlers));
   }
 
   void OnSetTouchAction(content::TouchAction touch_action) {
     input_router_->OnMessageReceived(
         InputHostMsg_SetTouchAction(0, touch_action));
@@ skipping 458 matching lines @@
                         INPUT_EVENT_ACK_STATE_CONSUMED);
       ASSERT_EQ(1U, GetSentMessageCountAndResetSink());
       ASSERT_EQ(1U, ack_handler_->GetAndResetAckCount());
       ASSERT_EQ(0, client_->in_flight_event_count());
     }
 
     SimulateTouchEvent(type);
     EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
     EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
     EXPECT_EQ(0, client_->in_flight_event_count());
+    EXPECT_FALSE(HasPendingEvents());
     SendInputEventACK(type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
     EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+    EXPECT_FALSE(HasPendingEvents());
   }
 }
 
 TEST_F(InputRouterImplTest, GestureTypesIgnoringAck) {
   // We test every gesture type, ensuring that the stream of gestures is valid.
   const int kEventTypesLength = 29;
   WebInputEvent::Type eventTypes[kEventTypesLength] = {
       WebInputEvent::GestureTapDown,
       WebInputEvent::GestureShowPress,
       WebInputEvent::GestureTapCancel,
@@ skipping 23 matching lines @@
       WebInputEvent::GesturePinchUpdate,
       WebInputEvent::GesturePinchEnd,
       WebInputEvent::GestureScrollEnd};
   for (int i = 0; i < kEventTypesLength; ++i) {
     WebInputEvent::Type type = eventTypes[i];
     if (!WebInputEventTraits::IgnoresAckDisposition(type)) {
       SimulateGestureEvent(type, WebGestureEvent::Touchscreen);
       EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
       EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
       EXPECT_EQ(1, client_->in_flight_event_count());
+      EXPECT_TRUE(HasPendingEvents());
 
       SendInputEventACK(type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
       EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
       EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
       EXPECT_EQ(0, client_->in_flight_event_count());
+      EXPECT_FALSE(HasPendingEvents());
       continue;
     }
 
     SimulateGestureEvent(type, WebGestureEvent::Touchscreen);
     EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
     EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
     EXPECT_EQ(0, client_->in_flight_event_count());
+    EXPECT_FALSE(HasPendingEvents());
     SendInputEventACK(type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
     EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+    EXPECT_FALSE(HasPendingEvents());
   }
 }
 
 TEST_F(InputRouterImplTest, MouseTypesIgnoringAck) {
   int start_type = static_cast<int>(WebInputEvent::MouseDown);
   int end_type = static_cast<int>(WebInputEvent::ContextMenu);
   ASSERT_LT(start_type, end_type);
   for (int i = start_type; i <= end_type; ++i) {
     WebInputEvent::Type type = static_cast<WebInputEvent::Type>(i);
     int expected_in_flight_event_count =
@@ skipping 470 matching lines @@
   // Although the touch-action is now auto, the double tap still won't be
   // dispatched, because the first tap occured when the touch-action was none.
   SimulateGestureEvent(WebInputEvent::GestureDoubleTap,
                        WebGestureEvent::Touchscreen);
   // This test will become invalid if GestureDoubleTap stops requiring an ack.
   DCHECK(!WebInputEventTraits::IgnoresAckDisposition(
       WebInputEvent::GestureDoubleTap));
   EXPECT_EQ(0, client_->in_flight_event_count());
 }
 
+// Test that the router will call the client's |DidFlush| after all events have
+// been dispatched following a call to |Flush|.
+TEST_F(InputRouterImplTest, InputFlush) {
+  EXPECT_FALSE(HasPendingEvents());
+
+  // Flushing an empty router should immediately trigger DidFlush.
+  Flush();
+  EXPECT_EQ(1U, GetAndResetDidFlushCount());
+  EXPECT_FALSE(HasPendingEvents());
+
+  // Queue a TouchStart.
+  OnHasTouchEventHandlers(true);
+  PressTouchPoint(1, 1);
+  SendTouchEvent();
+  EXPECT_TRUE(HasPendingEvents());
+
+  // DidFlush should be called only after the event is ack'ed.
+  Flush();
+  EXPECT_EQ(0U, GetAndResetDidFlushCount());
+  SendInputEventACK(WebInputEvent::TouchStart,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(1U, GetAndResetDidFlushCount());
+
+  // Ensure different types of enqueued events will prevent the DidFlush call
+  // until all such events have been fully dispatched.
+  MoveTouchPoint(0, 50, 50);
+  SendTouchEvent();
+  ASSERT_TRUE(HasPendingEvents());
+  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
+                       WebGestureEvent::Touchscreen);
+  SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
+                       WebGestureEvent::Touchscreen);
+  Flush();
+  EXPECT_EQ(0U, GetAndResetDidFlushCount());
+
+  // Repeated flush calls should have no effect.
+  Flush();
+  EXPECT_EQ(0U, GetAndResetDidFlushCount());
+
+  // There are still pending gestures.
+  SendInputEventACK(WebInputEvent::TouchMove,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(0U, GetAndResetDidFlushCount());
+  EXPECT_TRUE(HasPendingEvents());
+
+  // One more gesture to go.
+  SendInputEventACK(WebInputEvent::GestureScrollBegin,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, GetAndResetDidFlushCount());
+  EXPECT_TRUE(HasPendingEvents());
+
+  // The final ack'ed gesture should trigger the DidFlush.
+  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(1U, GetAndResetDidFlushCount());
+  EXPECT_FALSE(HasPendingEvents());
+}
+
 // Test that GesturePinchUpdate is handled specially for trackpad
 TEST_F(InputRouterImplTest, TrackpadPinchUpdate) {
   // For now Trackpad PinchUpdate events are just immediately ACKed
   // as unconsumed without going to the renderer.
   // TODO(rbyers): Update for wheel event behavior - crbug.com/289887.
   // Note that the Touchscreen case is verified as NOT doing this as
   // part of the ShowPressIsInOrder test.
   SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
                        WebGestureEvent::Touchpad);
   ASSERT_EQ(0U, GetSentMessageCountAndResetSink());
@@ skipping 44 matching lines @@
 
   // Ack the second scroll.
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(0, client_->in_flight_event_count());
 }
 
 }  // namespace content