Provided batched input delivery with a BufferedInputRouter

content/browser/renderer_host/input/buffered_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 "content/browser/renderer_host/input/buffered_input_router.h"
+#include "content/browser/renderer_host/input/input_router_unittest.h"
+#include "content/common/input/event_packet.h"
+#include "content/common/input/input_event_utils.h"
+#include "content/common/input_messages.h"
+#include "content/common/view_messages.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using WebKit::WebGestureEvent;
+using WebKit::WebInputEvent;
+using WebKit::WebMouseEvent;
+using WebKit::WebMouseWheelEvent;
+using WebKit::WebTouchEvent;
+using WebKit::WebTouchPoint;
+
+namespace content {
+
+class BufferedInputRouterTest : public InputRouterTest {
+ public:
+  BufferedInputRouterTest()
+      : sync_flush_ack_(false),
+        sync_flush_state_(INPUT_EVENT_UNHANDLED) {}
+  virtual ~BufferedInputRouterTest() {}
+
+ protected:
+  // InputRouterTest
+  virtual scoped_ptr<InputRouter> CreateInputRouter(RenderProcessHost* process,
+                                                    InputRouterClient* client,
+                                                    int routing_id) OVERRIDE {
+    return scoped_ptr<InputRouter>(
+        new BufferedInputRouter(process, client, routing_id));
+  }
+
+  // IPC::Listener
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+    if (!sync_flush_ack_)
+      return false;
+
+    SendEventPacketACK(message, sync_flush_state_);
+    return true;
+  }
+
+  bool FinishFlush(InputEventState ack_state) {
+    if (!process_->sink().message_count())
+      return false;
+    IPC::Message message(*process_->sink().GetMessageAt(0));
+    process_->sink().ClearMessages();
+    SendEventPacketACK(message, ack_state);
+    return true;
+  }
+
+  void SendEventPacketACK(const IPC::Message& message,
+                          InputEventState ack_state) {
+    EventPacket packet;
+    ASSERT_TRUE(CrackEventPacketMessage(message, &packet));
+
+    for (size_t i = 0; i < packet.events.size(); ++i)
+      packet.events[i].state = ack_state;
+
+    input_router_->OnMessageReceived(
+        InputHostMsg_HandleEventPacket_ACK(0, packet));
+  }
+
+  void CheckShouldSignalDelayedPacket() {
+    buffered_input_router()->CheckShouldSignalDelayedPacket();
+  }
+
+  void SetSyncFlushAck(bool sync, InputEventState state) {
+    sync_flush_ack_ = sync;
+    sync_flush_state_ = state;
+  }
+
+  size_t QueuedEventCount() const {
+    return buffered_input_router()->input_queue_->QueuedEventCount();
+  }
+
+  bool IsFlushTimeoutRunning() const {
+    return buffered_input_router()->delayed_packet_timer_.IsRunning();
+  }
+
+  BufferedInputRouter* buffered_input_router() const {
+    return static_cast<BufferedInputRouter*>(input_router_.get());
+  }
+
+private:
+  bool sync_flush_ack_;
+  InputEventState sync_flush_state_;
+};
+
+TEST_F(BufferedInputRouterTest, InputEventsProperlyQueued) {
+  EXPECT_TRUE(input_router_->SendInput(new InputMsg_Redo(MSG_ROUTING_NONE)));
+  EXPECT_EQ(1U, QueuedEventCount());
+
+  EXPECT_TRUE(input_router_->SendInput(new InputMsg_Cut(MSG_ROUTING_NONE)));
+  EXPECT_EQ(2U, QueuedEventCount());
+
+  EXPECT_TRUE(input_router_->SendInput(new InputMsg_Copy(MSG_ROUTING_NONE)));
+  EXPECT_EQ(3U, QueuedEventCount());
+
+  EXPECT_TRUE(input_router_->SendInput(new InputMsg_Paste(MSG_ROUTING_NONE)));
+  EXPECT_EQ(4U, QueuedEventCount());
+
+#ifdef NDEBUG
+  // Non-input messages not queued (this will DCHECK).
+  EXPECT_FALSE(input_router_->SendInput(
+      new ViewMsg_ChangeResizeRect(MSG_ROUTING_NONE, gfx::Rect())));
+  EXPECT_EQ(4U, QueuedEventCount());
+#endif
+}
+
+#define SCOPED_EXPECT(CALL, MESSAGE) { SCOPED_TRACE(MESSAGE); CALL; }
+
+TEST_F(BufferedInputRouterTest, ClientOnSendEventCalled) {
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_EQ(1U, QueuedEventCount());
+
+  SimulateWheelEvent(5, 0, 0, false);
+  EXPECT_EQ(2U, QueuedEventCount());
+
+  SimulateMouseMove(5, 0, 0);
+  EXPECT_EQ(3U, QueuedEventCount());
+
+  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
+                       WebGestureEvent::Touchpad);
+  EXPECT_EQ(4U, QueuedEventCount());
+
+  SimulateTouchEvent(1, 1);
+  EXPECT_EQ(5U, QueuedEventCount());
+}
+
+TEST_F(BufferedInputRouterTest, ClientOnSendEventHonored) {
+  client_->set_allow_send_event(false);
+
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_EQ(0U, QueuedEventCount());
+
+  SimulateWheelEvent(5, 0, 0, false);
+  EXPECT_EQ(0U, QueuedEventCount());
+
+  SimulateMouseMove(5, 0, 0);
+  EXPECT_EQ(0U, QueuedEventCount());
+
+  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
+                       WebGestureEvent::Touchpad);
+  EXPECT_EQ(0U, QueuedEventCount());
+
+  SimulateTouchEvent(1, 1);
+  EXPECT_EQ(0U, QueuedEventCount());
+}
+
+TEST_F(BufferedInputRouterTest, FlightCountIncrementedOnDeliver) {
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_EQ(0, client_->in_flight_event_count());
+
+  input_router_->Flush();
+  EXPECT_EQ(1, client_->in_flight_event_count());
+}
+
+TEST_F(BufferedInputRouterTest, FlightCountNotIncrementedOnSyncAck) {
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_EQ(0, client_->in_flight_event_count());
+
+  SetSyncFlushAck(true, INPUT_EVENT_IMPL_THREAD_ABSORBED);
+  input_router_->Flush();
+  EXPECT_EQ(0, client_->in_flight_event_count());
+}
+
+TEST_F(BufferedInputRouterTest, FlightCountDecrementedOnAck) {
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_EQ(0, client_->in_flight_event_count());
+
+  input_router_->Flush();
+  EXPECT_EQ(1, client_->in_flight_event_count());
+
+  // The in-flight count should continue until the flush has finished.
+  ASSERT_TRUE(FinishFlush(INPUT_EVENT_IMPL_THREAD_COULD_NOT_DELIVER));
+  EXPECT_EQ(1, client_->in_flight_event_count());
+
+  ASSERT_TRUE(FinishFlush(INPUT_EVENT_IMPL_THREAD_ABSORBED));
+  EXPECT_EQ(0, client_->in_flight_event_count());
+}
+
+TEST_F(BufferedInputRouterTest, FilteredEventsNeverQueued) {
+  // Event should not be queued, but should be ack'ed.
+  client_->set_filter_state(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  SCOPED_EXPECT(client_->ExpectAckCalled(1), "AckCalled");
+  EXPECT_EQ(0U, QueuedEventCount());
+  ASSERT_EQ(NULL, input_router_->GetLastKeyboardEvent());
+
+  // Event should not be queued, but should be ack'ed.
+  client_->set_filter_state(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  SCOPED_EXPECT(client_->ExpectAckCalled(1), "AckCalled");
+  EXPECT_EQ(0U, QueuedEventCount());
+  ASSERT_EQ(NULL, input_router_->GetLastKeyboardEvent());
+
+  // |INPUT_EVENT_ACK_STATE_UNKNOWN| should drop the event without ack'ing.
+  client_->set_filter_state(INPUT_EVENT_ACK_STATE_UNKNOWN);
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  SCOPED_EXPECT(client_->ExpectAckCalled(0), "AckNotCalled");
+  EXPECT_EQ(0U, QueuedEventCount());
+  ASSERT_EQ(NULL, input_router_->GetLastKeyboardEvent());
+
+  // Event should be queued.
+  client_->set_filter_state(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  SCOPED_EXPECT(client_->ExpectAckCalled(0), "AckNotCalled");
+  EXPECT_EQ(1U, QueuedEventCount());
+}
+
+TEST_F(BufferedInputRouterTest, FollowupEventsInjected) {
+  // Enable a followup gesture event.
+  WebGestureEvent followup_event;
+  followup_event.type = WebInputEvent::GestureScrollBegin;
+  followup_event.data.scrollUpdate.deltaX = 10;
+  client_->set_followup_touch_event(make_scoped_ptr(
+      new GestureEventWithLatencyInfo(followup_event, ui::LatencyInfo())));
+
+  // Create an initial packet of { Touch, Key } and start flushing.
+  SimulateTouchEvent(1, 1);
+  EXPECT_EQ(1U, QueuedEventCount());
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_EQ(2U, QueuedEventCount());
+  input_router_->Flush();
+
+  // Followup only triggered when event handled.
+  ASSERT_TRUE(FinishFlush(INPUT_EVENT_IMPL_THREAD_COULD_NOT_DELIVER));
+  SCOPED_EXPECT(client_->ExpectDidFlushCalled(false), "DidFlushNotCalled");
+  EXPECT_EQ(2U, QueuedEventCount());
+
+  // Ack the touch event.
+  EventPacket packet;
+  ASSERT_EQ(1U, process_->sink().message_count());
+  ASSERT_TRUE(CrackEventPacketMessage(*process_->sink().GetMessageAt(0),
+                                      &packet));
+  process_->sink().ClearMessages();
+  packet.events[0].state = INPUT_EVENT_IMPL_THREAD_ABSORBED;
+  packet.events[1].state = INPUT_EVENT_IMPL_THREAD_COULD_NOT_DELIVER;
+  input_router_->OnMessageReceived(
+      InputHostMsg_HandleEventPacket_ACK(0, packet));
+
+  // Ack'ing the touch event will triggered the followup gesture event.
+  // However, the flush is not complete until the followup event is ack'ed.
+  SCOPED_EXPECT(client_->ExpectDidFlushCalled(false), "DidFlushNotCalled");
+  SCOPED_EXPECT(client_->ExpectSendCalled(true), "SendGestureCalled");
+  EXPECT_EQ(followup_event.type, client_->sent_gesture_event().event.type);
+  EXPECT_EQ(2U, QueuedEventCount());
+
+  // Our packet is now { Gesture, Key }.
+  EventPacket followup_packet;
+  ASSERT_EQ(1U, process_->sink().message_count());
+  ASSERT_TRUE(CrackEventPacketMessage(*process_->sink().GetMessageAt(0),
+                                      &followup_packet));
+  ui::LatencyInfo latency;
+  const WebInputEvent* web_event = NULL;
+  ASSERT_TRUE(CrackWebInputEventMessage(followup_packet.events[0].message,
+                                        &web_event,
+                                        &latency,
+                                        NULL));
+  EXPECT_EQ(followup_event.type, web_event->type);
+  ASSERT_TRUE(CrackWebInputEventMessage(followup_packet.events[1].message,
+                                        &web_event,
+                                        &latency,
+                                        NULL));
+  EXPECT_EQ(WebInputEvent::RawKeyDown, web_event->type);
+
+  // Complete the flush; the gesture should have been ack'ed.
+  ASSERT_TRUE(FinishFlush(INPUT_EVENT_IMPL_THREAD_ABSORBED));
+  SCOPED_EXPECT(client_->ExpectDidFlushCalled(true), "DidFlushCalled");
+  EXPECT_EQ(followup_event.type, client_->acked_gesture_event().type);
+  EXPECT_EQ(0U, QueuedEventCount());
+}
+
+TEST_F(BufferedInputRouterTest, FlushRequestedOnQueue) {
+  // The first queued event should trigger a flush request.
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_EQ(1U, QueuedEventCount());
+  SCOPED_EXPECT(client_->ExpectNeedsFlushCalled(true), "SetNeedsFlushCalled");
+
+  // Subsequently queued events will not trigger another flush request.
+  SimulateWheelEvent(5, 0, 0, false);
+  EXPECT_EQ(2U, QueuedEventCount());
+  SCOPED_EXPECT(client_->ExpectNeedsFlushCalled(false), "SetNeedsFlushCalled");
+}
+
+TEST_F(BufferedInputRouterTest, FlushTriggersTimeout) {
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_FALSE(IsFlushTimeoutRunning());
+
+  input_router_->Flush();
+  EXPECT_TRUE(IsFlushTimeoutRunning());
+  SCOPED_EXPECT(client_->ExpectDidFlushCalled(false), "DidFlushNotCalled");
+}
+
+TEST_F(BufferedInputRouterTest, SyncFlushDoesntTriggerTimeout) {
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_FALSE(IsFlushTimeoutRunning());
+  SetSyncFlushAck(true, INPUT_EVENT_IMPL_THREAD_ABSORBED);
+
+  input_router_->Flush();
+  EXPECT_FALSE(IsFlushTimeoutRunning());
+  SCOPED_EXPECT(client_->ExpectDidFlushCalled(true), "DidFlushCalled");
+}
+
+TEST_F(BufferedInputRouterTest, DidFlushStopsTimeout) {
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_FALSE(IsFlushTimeoutRunning());
+  input_router_->Flush();
+  EXPECT_TRUE(IsFlushTimeoutRunning());
+
+  ASSERT_TRUE(FinishFlush(INPUT_EVENT_IMPL_THREAD_ABSORBED));
+  SCOPED_EXPECT(client_->ExpectDidFlushCalled(true), "DidFlushCalled");
+  EXPECT_FALSE(IsFlushTimeoutRunning());
+}
+
+TEST_F(BufferedInputRouterTest, TimeoutSignalsDidFlush) {
+  base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10);
+  buffered_input_router()->set_delayed_packet_timeout_ms(timeout);
+
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_EQ(1U, QueuedEventCount());
+  input_router_->Flush();
+  EXPECT_TRUE(IsFlushTimeoutRunning());
+
+  // The delayed signal should trigger a DidFlush, but the queue keeps flushing.
+  base::PlatformThread::Sleep(timeout * 2);
+  CheckShouldSignalDelayedPacket();
+  SCOPED_EXPECT(client_->ExpectDidFlushCalled(true), "DidFlushCalled");
+  EXPECT_EQ(1U, QueuedEventCount());
+  EXPECT_FALSE(IsFlushTimeoutRunning());
+}
+
+TEST_F(BufferedInputRouterTest, HasQueuedGestureEvents) {
+  EXPECT_FALSE(input_router_->HasQueuedGestureEvents());
+  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
+                       WebGestureEvent::Touchpad);
+  EXPECT_TRUE(input_router_->HasQueuedGestureEvents());
+
+  // Only an ack'ed gesture should clear it from the queue.
+  input_router_->Flush();
+  ASSERT_TRUE(FinishFlush(INPUT_EVENT_IMPL_THREAD_COULD_NOT_DELIVER));
+  EXPECT_TRUE(input_router_->HasQueuedGestureEvents());
+
+  ASSERT_TRUE(FinishFlush(INPUT_EVENT_IMPL_THREAD_ABSORBED));
+  EXPECT_FALSE(input_router_->HasQueuedGestureEvents());
+}
+
+TEST_F(BufferedInputRouterTest, GetLastKeyboardEvent) {
+  EXPECT_EQ(NULL, input_router_->GetLastKeyboardEvent());
+
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  EXPECT_EQ(WebInputEvent::RawKeyDown,
+            input_router_->GetLastKeyboardEvent()->type);
+
+  // Queueing another key event does not effect the "last" event.
+  SimulateKeyboardEvent(WebInputEvent::KeyUp);
+  EXPECT_EQ(WebInputEvent::RawKeyDown,
+            input_router_->GetLastKeyboardEvent()->type);
+
+  input_router_->Flush();
+
+  // Ack'ing the first event should make the second event the "last" event.
+  EventPacket packet;
+  ASSERT_TRUE(CrackEventPacketMessage(*process_->sink().GetMessageAt(0),
+                                      &packet));
+  process_->sink().ClearMessages();
+  packet.events[0].state = INPUT_EVENT_IMPL_THREAD_ABSORBED;
+  packet.events[1].state = INPUT_EVENT_IMPL_THREAD_COULD_NOT_DELIVER;
+  input_router_->OnMessageReceived(
+      InputHostMsg_HandleEventPacket_ACK(0, packet));
+  EXPECT_EQ(WebInputEvent::KeyUp,
+            input_router_->GetLastKeyboardEvent()->type);
+
+  // A key event queued during a flush becomes "last" upon flush completion.
+  SimulateKeyboardEvent(WebInputEvent::Char);
+  ASSERT_TRUE(FinishFlush(INPUT_EVENT_IMPL_THREAD_ABSORBED));
+  EXPECT_EQ(WebInputEvent::Char,
+            input_router_->GetLastKeyboardEvent()->type);
+
+  // An empty queue should produce a null "last" event.
+  input_router_->Flush();
+  ASSERT_TRUE(FinishFlush(INPUT_EVENT_IMPL_THREAD_ABSORBED));
+  EXPECT_EQ(NULL, input_router_->GetLastKeyboardEvent());
+}
+
+TEST_F(BufferedInputRouterTest, UnexpectedAck) {
+  ASSERT_FALSE(client_->unexpected_event_ack_called());
+  input_router_->OnMessageReceived(
+      InputHostMsg_HandleEventPacket_ACK(0, EventPacket()));
+  EXPECT_TRUE(client_->unexpected_event_ack_called());
+}
+
+TEST_F(BufferedInputRouterTest, BadAck) {
+  SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
+  input_router_->Flush();
+
+  ASSERT_FALSE(client_->unexpected_event_ack_called());
+  EventPacket packet;
+  input_router_->OnMessageReceived(
+      InputHostMsg_HandleEventPacket_ACK(0, EventPacket()));
+  EXPECT_TRUE(client_->unexpected_event_ack_called());
+}
+
+}  // namespace content