Events ignoring ack disposition receive synthetic acks.

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 111 matching lines @@
     scoped_ptr<IPC::Message> response(
         new InputHostMsg_HandleInputEvent_ACK(0, type, ack_result,
                                               ui::LatencyInfo()));
     input_router_->OnMessageReceived(*response);
   }
 
   ImmediateInputRouter* input_router() const {
     return static_cast<ImmediateInputRouter*>(input_router_.get());
   }
 
+  size_t GestureEventQueueSize() {
+    return input_router()->gesture_event_filter_->
+        coalesced_gesture_events_.size();
+  }
+
   bool no_touch_to_renderer() {
     return input_router()->touch_event_queue_->no_touch_to_renderer();
   }
 
   bool TouchEventQueueEmpty() const {
     return input_router()->touch_event_queue_->empty();
   }
 
   size_t GetSentMessageCountAndResetSink() {
     size_t count = process_->sink().message_count();
@@ skipping 409 matching lines @@
 
   // Check that the second event was sent.
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
                   InputMsg_HandleInputEvent::ID));
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Check that the correct unhandled wheel event was received.
   EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -5);
 }
 
+// Test that GestureShowPress, GestureTapDown and GestureTapCancel events don't
+// wait for ACKs.
+TEST_F(ImmediateInputRouterTest, GestureTypesIgnoringAck) {
+  // The show press, tap down and tap cancel events will be acked immediately,
+  // since they ignore ack disposition.
+  SimulateGestureEvent(WebInputEvent::GestureShowPress,
+                       WebGestureEvent::Touchscreen);
+  EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(0U, GestureEventQueueSize());

[jdduke (slow), 2013/11/07 23:12:52]

You can just delete all the "GestureEventQueueSize()" queries here, we have
enough coverage between Sent and Ack'ed counts to check for the correct
behavior.

[tdresser, 2013/11/08 16:20:34]

Done.

+  EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
+
+  SimulateGestureEvent(WebInputEvent::GestureTapDown,
+                       WebGestureEvent::Touchscreen);
+  EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(0U, GestureEventQueueSize());
+  EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
+
+  SimulateGestureEvent(WebInputEvent::GestureTapCancel,
+                       WebGestureEvent::Touchscreen);
+  EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(0U, GestureEventQueueSize());
+  EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
+
+  // Interleave a few events that do and do not ignore acks, ensuring that
+  // ack-ignoring events aren't dispatched until all prior events which observe
+  // their ack disposition have been dispatched.
+  SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
+                       WebGestureEvent::Touchpad);
+  ASSERT_EQ(1U, GetSentMessageCountAndResetSink());
+  ASSERT_EQ(1U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+
+  SimulateGestureEvent(WebInputEvent::GestureTapDown,
+                       WebGestureEvent::Touchscreen);
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(2U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+
+  SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
+                       WebGestureEvent::Touchpad);
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(3U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+
+  SimulateGestureEvent(WebInputEvent::GestureShowPress,
+                       WebGestureEvent::Touchscreen);
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(4U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+
+  SimulateGestureEvent(WebInputEvent::GesturePinchEnd,
+                       WebGestureEvent::Touchpad);
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(5U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+
+  SimulateGestureEvent(WebInputEvent::GestureTapCancel,
+                       WebGestureEvent::Touchscreen);
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(6U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+
+  // Now ack each event. Ack-ignoring events should not be dispatched until all
+  // prior events which observe ack disposition have been fired, at which
+  // point they should be sent immediately.
+  SendInputEventACK(WebInputEvent::GesturePinchBegin,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(4U, GestureEventQueueSize());
+  EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
+
+  // For events which ignore ack disposition, non-synthetic acks are ignored.
+  SendInputEventACK(WebInputEvent::GestureTapDown,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(4U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+
+  SendInputEventACK(WebInputEvent::GesturePinchUpdate,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(2U, GestureEventQueueSize());
+  EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
+
+  // For events which ignore ack disposition, non-synthetic acks are ignored.
+  SendInputEventACK(WebInputEvent::GestureShowPress,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(2U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+
+  SendInputEventACK(WebInputEvent::GesturePinchEnd,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(0U, GestureEventQueueSize());
+  EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
+
+  // For events which ignore ack disposition, non-synthetic acks are ignored.
+  SendInputEventACK(WebInputEvent::GestureTapCancel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(0U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+}
+
+// Test that GestureShowPress events don't get out of order due to
+// ignoring their acks.
+TEST_F(ImmediateInputRouterTest, GestureShowPressIsInOrder) {
+  SimulateGestureEvent(WebInputEvent::GestureTap,
+                       WebGestureEvent::Touchscreen);
+
+  EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(1U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+
+  SimulateGestureEvent(WebInputEvent::GestureShowPress,
+                       WebGestureEvent::Touchscreen);
+
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  // The ShowPress, though it ignores ack, is still stuck in the queue
+  // behind the Tap which requires an ack.
+  EXPECT_EQ(2U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+
+  SimulateGestureEvent(WebInputEvent::GestureShowPress,
+                       WebGestureEvent::Touchscreen);
+
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  // ShowPress has entered the queue.
+  EXPECT_EQ(3U, GestureEventQueueSize());
+  EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
+
+  SendInputEventACK(WebInputEvent::GestureTap,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  // Now that the Tap has been ACKed, the ShowPress events should receive
+  // synthetics acks, and fire immediately.
+  EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
+  EXPECT_EQ(0U, GestureEventQueueSize());
+  EXPECT_EQ(3U, ack_handler_->GetAndResetAckCount());
+}
+
 }  // namespace content