src/content/browser/renderer_host/input/input_router_impl_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <math.h>
   6
   7 #include "base/basictypes.h"
   8 #include "base/command_line.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "content/browser/renderer_host/input/gesture_event_queue.h"
  12 #include "content/browser/renderer_host/input/input_router_client.h"
  13 #include "content/browser/renderer_host/input/input_router_impl.h"
  14 #include "content/browser/renderer_host/input/mock_input_ack_handler.h"
  15 #include "content/browser/renderer_host/input/mock_input_router_client.h"
  16 #include "content/common/content_constants_internal.h"
  17 #include "content/common/edit_command.h"
  18 #include "content/common/input/synthetic_web_input_event_builders.h"
  19 #include "content/common/input/touch_action.h"
  20 #include "content/common/input/web_input_event_traits.h"
  21 #include "content/common/input_messages.h"
  22 #include "content/common/view_messages.h"
  23 #include "content/public/common/content_switches.h"
  24 #include "content/public/test/mock_render_process_host.h"
  25 #include "content/public/test/test_browser_context.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27 #include "ui/events/keycodes/keyboard_codes.h"
  28
  29 #if defined(USE_AURA)
  30 #include "content/browser/renderer_host/ui_events_helper.h"
  31 #include "ui/events/event.h"
  32 #endif
  33
  34 using base::TimeDelta;
  35 using blink::WebGestureDevice;
  36 using blink::WebGestureEvent;
  37 using blink::WebKeyboardEvent;
  38 using blink::WebInputEvent;
  39 using blink::WebMouseEvent;
  40 using blink::WebMouseWheelEvent;
  41 using blink::WebTouchEvent;
  42 using blink::WebTouchPoint;
  43
  44 namespace content {
  45
  46 namespace {
  47
  48 const WebInputEvent* GetInputEventFromMessage(const IPC::Message& message) {
  49   PickleIterator iter(message);
  50   const char* data;
  51   int data_length;
  52   if (!message.ReadData(&iter, &data, &data_length))
  53     return NULL;
  54   return reinterpret_cast<const WebInputEvent*>(data);
  55 }
  56
  57 WebInputEvent& GetEventWithType(WebInputEvent::Type type) {
  58   WebInputEvent* event = NULL;
  59   if (WebInputEvent::isMouseEventType(type)) {
  60     static WebMouseEvent mouse;
  61     event = &mouse;
  62   } else if (WebInputEvent::isTouchEventType(type)) {
  63     static WebTouchEvent touch;
  64     event = &touch;
  65   } else if (WebInputEvent::isKeyboardEventType(type)) {
  66     static WebKeyboardEvent key;
  67     event = &key;
  68   } else if (WebInputEvent::isGestureEventType(type)) {
  69     static WebGestureEvent gesture;
  70     event = &gesture;
  71   } else if (type == WebInputEvent::MouseWheel) {
  72     static WebMouseWheelEvent wheel;
  73     event = &wheel;
  74   }
  75   CHECK(event);
  76   event->type = type;
  77   return *event;
  78 }
  79
  80 bool GetIsShortcutFromHandleInputEventMessage(const IPC::Message* msg) {
  81   InputMsg_HandleInputEvent::Schema::Param param;
  82   InputMsg_HandleInputEvent::Read(msg, &param);
  83   return param.c;
  84 }
  85
  86 template<typename MSG_T, typename ARG_T1>
  87 void ExpectIPCMessageWithArg1(const IPC::Message* msg, const ARG_T1& arg1) {
  88   ASSERT_EQ(MSG_T::ID, msg->type());
  89   typename MSG_T::Schema::Param param;
  90   ASSERT_TRUE(MSG_T::Read(msg, &param));
  91   EXPECT_EQ(arg1, param.a);
  92 }
  93
  94 template<typename MSG_T, typename ARG_T1, typename ARG_T2>
  95 void ExpectIPCMessageWithArg2(const IPC::Message* msg,
  96                               const ARG_T1& arg1,
  97                               const ARG_T2& arg2) {
  98   ASSERT_EQ(MSG_T::ID, msg->type());
  99   typename MSG_T::Schema::Param param;
 100   ASSERT_TRUE(MSG_T::Read(msg, &param));
 101   EXPECT_EQ(arg1, param.a);
 102   EXPECT_EQ(arg2, param.b);
 103 }
 104
 105 #if defined(USE_AURA)
 106 bool TouchEventsAreEquivalent(const ui::TouchEvent& first,
 107                               const ui::TouchEvent& second) {
 108   if (first.type() != second.type())
 109     return false;
 110   if (first.location() != second.location())
 111     return false;
 112   if (first.touch_id() != second.touch_id())
 113     return false;
 114   if (second.time_stamp().InSeconds() != first.time_stamp().InSeconds())
 115     return false;
 116   return true;
 117 }
 118
 119 bool EventListIsSubset(const ScopedVector<ui::TouchEvent>& subset,
 120                        const ScopedVector<ui::TouchEvent>& set) {
 121   if (subset.size() > set.size())
 122     return false;
 123   for (size_t i = 0; i < subset.size(); ++i) {
 124     const ui::TouchEvent* first = subset[i];
 125     const ui::TouchEvent* second = set[i];
 126     bool equivalent = TouchEventsAreEquivalent(*first, *second);
 127     if (!equivalent)
 128       return false;
 129   }
 130
 131   return true;
 132 }
 133 #endif  // defined(USE_AURA)
 134
 135 // Expected function used for converting pinch scales to deltaY values.
 136 float PinchScaleToWheelDelta(float scale) {
 137   return 100.0 * log(scale);
 138 }
 139
 140 }  // namespace
 141
 142 class InputRouterImplTest : public testing::Test {
 143  public:
 144   InputRouterImplTest() {}
 145   virtual ~InputRouterImplTest() {}
 146
 147  protected:
 148   // testing::Test
 149   virtual void SetUp() OVERRIDE {
 150     browser_context_.reset(new TestBrowserContext());
 151     process_.reset(new MockRenderProcessHost(browser_context_.get()));
 152     client_.reset(new MockInputRouterClient());
 153     ack_handler_.reset(new MockInputAckHandler());
 154     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 155     command_line->AppendSwitch(switches::kValidateInputEventStream);
 156     input_router_.reset(new InputRouterImpl(process_.get(),
 157                                             client_.get(),
 158                                             ack_handler_.get(),
 159                                             MSG_ROUTING_NONE,
 160                                             config_));
 161     client_->set_input_router(input_router());
 162     ack_handler_->set_input_router(input_router());
 163   }
 164
 165   virtual void TearDown() OVERRIDE {
 166     // Process all pending tasks to avoid leaks.
 167     base::MessageLoop::current()->RunUntilIdle();
 168
 169     input_router_.reset();
 170     client_.reset();
 171     process_.reset();
 172     browser_context_.reset();
 173   }
 174
 175   void SetUpForTouchAckTimeoutTest(int timeout_ms) {
 176     config_.touch_config.touch_ack_timeout_delay =
 177         base::TimeDelta::FromMilliseconds(timeout_ms);
 178     config_.touch_config.touch_ack_timeout_supported = true;
 179     TearDown();
 180     SetUp();
 181   }
 182
 183   void SimulateKeyboardEvent(WebInputEvent::Type type, bool is_shortcut) {
 184     WebKeyboardEvent event = SyntheticWebKeyboardEventBuilder::Build(type);
 185     NativeWebKeyboardEvent native_event;
 186     memcpy(&native_event, &event, sizeof(event));
 187     input_router_->SendKeyboardEvent(
 188         native_event,
 189         ui::LatencyInfo(),
 190         is_shortcut);
 191   }
 192
 193   void SimulateWheelEvent(float dX, float dY, int modifiers, bool precise) {
 194     input_router_->SendWheelEvent(MouseWheelEventWithLatencyInfo(
 195         SyntheticWebMouseWheelEventBuilder::Build(dX, dY, modifiers, precise),
 196         ui::LatencyInfo()));
 197   }
 198
 199   void SimulateMouseEvent(WebInputEvent::Type type, int x, int y) {
 200     input_router_->SendMouseEvent(MouseEventWithLatencyInfo(
 201         SyntheticWebMouseEventBuilder::Build(type, x, y, 0),
 202         ui::LatencyInfo()));
 203   }
 204
 205   void SimulateWheelEventWithPhase(WebMouseWheelEvent::Phase phase) {
 206     input_router_->SendWheelEvent(MouseWheelEventWithLatencyInfo(
 207         SyntheticWebMouseWheelEventBuilder::Build(phase), ui::LatencyInfo()));
 208   }
 209
 210   void SimulateGestureEvent(const WebGestureEvent& gesture) {
 211     input_router_->SendGestureEvent(
 212         GestureEventWithLatencyInfo(gesture, ui::LatencyInfo()));
 213   }
 214
 215   void SimulateGestureEvent(WebInputEvent::Type type,
 216                             WebGestureDevice sourceDevice) {
 217     SimulateGestureEvent(
 218         SyntheticWebGestureEventBuilder::Build(type, sourceDevice));
 219   }
 220
 221   void SimulateGestureScrollUpdateEvent(float dX, float dY, int modifiers) {
 222     SimulateGestureEvent(
 223         SyntheticWebGestureEventBuilder::BuildScrollUpdate(dX, dY, modifiers));
 224   }
 225
 226   void SimulateGesturePinchUpdateEvent(float scale,
 227                                        float anchorX,
 228                                        float anchorY,
 229                                        int modifiers,
 230                                        WebGestureDevice sourceDevice) {
 231     SimulateGestureEvent(SyntheticWebGestureEventBuilder::BuildPinchUpdate(
 232         scale, anchorX, anchorY, modifiers, sourceDevice));
 233   }
 234
 235   void SimulateGestureFlingStartEvent(float velocityX,
 236                                       float velocityY,
 237                                       WebGestureDevice sourceDevice) {
 238     SimulateGestureEvent(
 239         SyntheticWebGestureEventBuilder::BuildFling(velocityX,
 240                                                     velocityY,
 241                                                     sourceDevice));
 242   }
 243
 244   void SetTouchTimestamp(base::TimeDelta timestamp) {
 245     touch_event_.SetTimestamp(timestamp);
 246   }
 247
 248   void SendTouchEvent() {
 249     input_router_->SendTouchEvent(
 250         TouchEventWithLatencyInfo(touch_event_, ui::LatencyInfo()));
 251     touch_event_.ResetPoints();
 252   }
 253
 254   int PressTouchPoint(int x, int y) {
 255     return touch_event_.PressPoint(x, y);
 256   }
 257
 258   void MoveTouchPoint(int index, int x, int y) {
 259     touch_event_.MovePoint(index, x, y);
 260   }
 261
 262   void ReleaseTouchPoint(int index) {
 263     touch_event_.ReleasePoint(index);
 264   }
 265
 266   void CancelTouchPoint(int index) {
 267     touch_event_.CancelPoint(index);
 268   }
 269
 270   void SendInputEventACK(blink::WebInputEvent::Type type,
 271                          InputEventAckState ack_result) {
 272     InputHostMsg_HandleInputEvent_ACK_Params ack;
 273     ack.type = type;
 274     ack.state = ack_result;
 275     input_router_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
 276   }
 277
 278   InputRouterImpl* input_router() const {
 279     return input_router_.get();
 280   }
 281
 282   bool TouchEventQueueEmpty() const {
 283     return input_router()->touch_event_queue_.empty();
 284   }
 285
 286   bool TouchEventTimeoutEnabled() const {
 287     return input_router()->touch_event_queue_.IsAckTimeoutEnabled();
 288   }
 289
 290   void Flush() const {
 291     return input_router_->Flush();
 292   }
 293
 294   size_t GetAndResetDidFlushCount() {
 295     return client_->GetAndResetDidFlushCount();
 296   }
 297
 298   bool HasPendingEvents() const {
 299     return input_router_->HasPendingEvents();
 300   }
 301
 302   void OnHasTouchEventHandlers(bool has_handlers) {
 303     input_router_->OnMessageReceived(
 304         ViewHostMsg_HasTouchEventHandlers(0, has_handlers));
 305   }
 306
 307   void OnSetTouchAction(content::TouchAction touch_action) {
 308     input_router_->OnMessageReceived(
 309         InputHostMsg_SetTouchAction(0, touch_action));
 310   }
 311
 312   size_t GetSentMessageCountAndResetSink() {
 313     size_t count = process_->sink().message_count();
 314     process_->sink().ClearMessages();
 315     return count;
 316   }
 317
 318   static void RunTasksAndWait(base::TimeDelta delay) {
 319     base::MessageLoop::current()->PostDelayedTask(
 320         FROM_HERE, base::MessageLoop::QuitClosure(), delay);
 321     base::MessageLoop::current()->Run();
 322   }
 323
 324   InputRouterImpl::Config config_;
 325   scoped_ptr<MockRenderProcessHost> process_;
 326   scoped_ptr<MockInputRouterClient> client_;
 327   scoped_ptr<MockInputAckHandler> ack_handler_;
 328   scoped_ptr<InputRouterImpl> input_router_;
 329
 330  private:
 331   base::MessageLoopForUI message_loop_;
 332   SyntheticWebTouchEvent touch_event_;
 333
 334   scoped_ptr<TestBrowserContext> browser_context_;
 335 };
 336
 337 TEST_F(InputRouterImplTest, CoalescesRangeSelection) {
 338   input_router_->SendInput(scoped_ptr<IPC::Message>(
 339       new InputMsg_SelectRange(0, gfx::Point(1, 2), gfx::Point(3, 4))));
 340   ExpectIPCMessageWithArg2<InputMsg_SelectRange>(
 341       process_->sink().GetMessageAt(0),
 342       gfx::Point(1, 2),
 343       gfx::Point(3, 4));
 344   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 345
 346   // Send two more messages without acking.
 347   input_router_->SendInput(scoped_ptr<IPC::Message>(
 348       new InputMsg_SelectRange(0, gfx::Point(5, 6), gfx::Point(7, 8))));
 349   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 350
 351   input_router_->SendInput(scoped_ptr<IPC::Message>(
 352       new InputMsg_SelectRange(0, gfx::Point(9, 10), gfx::Point(11, 12))));
 353   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 354
 355   // Now ack the first message.
 356   {
 357     scoped_ptr<IPC::Message> response(new ViewHostMsg_SelectRange_ACK(0));
 358     input_router_->OnMessageReceived(*response);
 359   }
 360
 361   // Verify that the two messages are coalesced into one message.
 362   ExpectIPCMessageWithArg2<InputMsg_SelectRange>(
 363       process_->sink().GetMessageAt(0),
 364       gfx::Point(9, 10),
 365       gfx::Point(11, 12));
 366   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 367
 368   // Acking the coalesced msg should not send any more msg.
 369   {
 370     scoped_ptr<IPC::Message> response(new ViewHostMsg_SelectRange_ACK(0));
 371     input_router_->OnMessageReceived(*response);
 372   }
 373   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 374 }
 375
 376 TEST_F(InputRouterImplTest, CoalescesCaretMove) {
 377   input_router_->SendInput(
 378       scoped_ptr<IPC::Message>(new InputMsg_MoveCaret(0, gfx::Point(1, 2))));
 379   ExpectIPCMessageWithArg1<InputMsg_MoveCaret>(
 380       process_->sink().GetMessageAt(0), gfx::Point(1, 2));
 381   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 382
 383   // Send two more messages without acking.
 384   input_router_->SendInput(
 385       scoped_ptr<IPC::Message>(new InputMsg_MoveCaret(0, gfx::Point(5, 6))));
 386   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 387
 388   input_router_->SendInput(
 389       scoped_ptr<IPC::Message>(new InputMsg_MoveCaret(0, gfx::Point(9, 10))));
 390   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 391
 392   // Now ack the first message.
 393   {
 394     scoped_ptr<IPC::Message> response(new ViewHostMsg_MoveCaret_ACK(0));
 395     input_router_->OnMessageReceived(*response);
 396   }
 397
 398   // Verify that the two messages are coalesced into one message.
 399   ExpectIPCMessageWithArg1<InputMsg_MoveCaret>(
 400       process_->sink().GetMessageAt(0), gfx::Point(9, 10));
 401   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 402
 403   // Acking the coalesced msg should not send any more msg.
 404   {
 405     scoped_ptr<IPC::Message> response(new ViewHostMsg_MoveCaret_ACK(0));
 406     input_router_->OnMessageReceived(*response);
 407   }
 408   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 409 }
 410
 411 TEST_F(InputRouterImplTest, HandledInputEvent) {
 412   client_->set_filter_state(INPUT_EVENT_ACK_STATE_CONSUMED);
 413
 414   // Simulate a keyboard event.
 415   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 416
 417   // Make sure no input event is sent to the renderer.
 418   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 419
 420   // OnKeyboardEventAck should be triggered without actual ack.
 421   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 422
 423   // As the event was acked already, keyboard event queue should be
 424   // empty.
 425   ASSERT_EQ(NULL, input_router_->GetLastKeyboardEvent());
 426 }
 427
 428 TEST_F(InputRouterImplTest, ClientCanceledKeyboardEvent) {
 429   client_->set_filter_state(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 430
 431   // Simulate a keyboard event that has no consumer.
 432   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 433
 434   // Make sure no input event is sent to the renderer.
 435   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 436   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 437
 438
 439   // Simulate a keyboard event that should be dropped.
 440   client_->set_filter_state(INPUT_EVENT_ACK_STATE_UNKNOWN);
 441   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 442
 443   // Make sure no input event is sent to the renderer, and no ack is sent.
 444   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 445   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 446 }
 447
 448 TEST_F(InputRouterImplTest, ShortcutKeyboardEvent) {
 449   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, true);
 450   EXPECT_TRUE(GetIsShortcutFromHandleInputEventMessage(
 451       process_->sink().GetMessageAt(0)));
 452
 453   process_->sink().ClearMessages();
 454
 455   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 456   EXPECT_FALSE(GetIsShortcutFromHandleInputEventMessage(
 457       process_->sink().GetMessageAt(0)));
 458 }
 459
 460 TEST_F(InputRouterImplTest, NoncorrespondingKeyEvents) {
 461   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 462
 463   SendInputEventACK(WebInputEvent::KeyUp,
 464                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 465   EXPECT_TRUE(ack_handler_->unexpected_event_ack_called());
 466 }
 467
 468 // Tests ported from RenderWidgetHostTest --------------------------------------
 469
 470 TEST_F(InputRouterImplTest, HandleKeyEventsWeSent) {
 471   // Simulate a keyboard event.
 472   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 473   ASSERT_TRUE(input_router_->GetLastKeyboardEvent());
 474   EXPECT_EQ(WebInputEvent::RawKeyDown,
 475             input_router_->GetLastKeyboardEvent()->type);
 476
 477   // Make sure we sent the input event to the renderer.
 478   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 479                   InputMsg_HandleInputEvent::ID));
 480   process_->sink().ClearMessages();
 481
 482   // Send the simulated response from the renderer back.
 483   SendInputEventACK(WebInputEvent::RawKeyDown,
 484                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 485   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 486   EXPECT_EQ(WebInputEvent::RawKeyDown,
 487             ack_handler_->acked_keyboard_event().type);
 488 }
 489
 490 TEST_F(InputRouterImplTest, IgnoreKeyEventsWeDidntSend) {
 491   // Send a simulated, unrequested key response. We should ignore this.
 492   SendInputEventACK(WebInputEvent::RawKeyDown,
 493                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 494
 495   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 496 }
 497
 498 TEST_F(InputRouterImplTest, CoalescesWheelEvents) {
 499   // Simulate wheel events.
 500   SimulateWheelEvent(0, -5, 0, false);  // sent directly
 501   SimulateWheelEvent(0, -10, 0, false);  // enqueued
 502   SimulateWheelEvent(8, -6, 0, false);  // coalesced into previous event
 503   SimulateWheelEvent(9, -7, 1, false);  // enqueued, different modifiers
 504   SimulateWheelEvent(0, -10, 0, false);  // enqueued, different modifiers
 505   // Explicitly verify that PhaseEnd isn't coalesced to avoid bugs like
 506   // https://crbug.com/154740.
 507   SimulateWheelEventWithPhase(WebMouseWheelEvent::PhaseEnded);  // enqueued
 508
 509   // Check that only the first event was sent.
 510   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 511                   InputMsg_HandleInputEvent::ID));
 512   const WebInputEvent* input_event =
 513       GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
 514   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
 515   const WebMouseWheelEvent* wheel_event =
 516       static_cast<const WebMouseWheelEvent*>(input_event);
 517   EXPECT_EQ(0, wheel_event->deltaX);
 518   EXPECT_EQ(-5, wheel_event->deltaY);
 519   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 520
 521   // Check that the ACK sends the second message immediately.
 522   SendInputEventACK(WebInputEvent::MouseWheel,
 523                     INPUT_EVENT_ACK_STATE_CONSUMED);
 524   // The coalesced events can queue up a delayed ack
 525   // so that additional input events can be processed before
 526   // we turn off coalescing.
 527   base::MessageLoop::current()->RunUntilIdle();
 528   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 529   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 530           InputMsg_HandleInputEvent::ID));
 531   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
 532   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
 533   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
 534   EXPECT_EQ(8, wheel_event->deltaX);
 535   EXPECT_EQ(-10 + -6, wheel_event->deltaY);  // coalesced
 536   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 537
 538   // Ack the second event (which had the third coalesced into it).
 539   SendInputEventACK(WebInputEvent::MouseWheel,
 540                     INPUT_EVENT_ACK_STATE_CONSUMED);
 541   base::MessageLoop::current()->RunUntilIdle();
 542   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 543   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 544                   InputMsg_HandleInputEvent::ID));
 545   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
 546   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
 547   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
 548   EXPECT_EQ(9, wheel_event->deltaX);
 549   EXPECT_EQ(-7, wheel_event->deltaY);
 550   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 551
 552   // Ack the fourth event.
 553   SendInputEventACK(WebInputEvent::MouseWheel,
 554                     INPUT_EVENT_ACK_STATE_CONSUMED);
 555   base::MessageLoop::current()->RunUntilIdle();
 556   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 557   EXPECT_TRUE(
 558       process_->sink().GetUniqueMessageMatching(InputMsg_HandleInputEvent::ID));
 559   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
 560   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
 561   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
 562   EXPECT_EQ(0, wheel_event->deltaX);
 563   EXPECT_EQ(-10, wheel_event->deltaY);
 564   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 565
 566   // Ack the fifth event.
 567   SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED);
 568   base::MessageLoop::current()->RunUntilIdle();
 569   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 570   EXPECT_TRUE(
 571       process_->sink().GetUniqueMessageMatching(InputMsg_HandleInputEvent::ID));
 572   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
 573   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
 574   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
 575   EXPECT_EQ(0, wheel_event->deltaX);
 576   EXPECT_EQ(0, wheel_event->deltaY);
 577   EXPECT_EQ(WebMouseWheelEvent::PhaseEnded, wheel_event->phase);
 578   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 579
 580   // After the final ack, the queue should be empty.
 581   SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED);
 582   base::MessageLoop::current()->RunUntilIdle();
 583   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 584   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 585 }
 586
 587 // Tests that touch-events are queued properly.
 588 TEST_F(InputRouterImplTest, TouchEventQueue) {
 589   OnHasTouchEventHandlers(true);
 590
 591   PressTouchPoint(1, 1);
 592   SendTouchEvent();
 593   EXPECT_TRUE(client_->GetAndResetFilterEventCalled());
 594   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 595   EXPECT_FALSE(TouchEventQueueEmpty());
 596
 597   // The second touch should not be sent since one is already in queue.
 598   MoveTouchPoint(0, 5, 5);
 599   SendTouchEvent();
 600   EXPECT_FALSE(client_->GetAndResetFilterEventCalled());
 601   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 602   EXPECT_FALSE(TouchEventQueueEmpty());
 603
 604   // Receive an ACK for the first touch-event.
 605   SendInputEventACK(WebInputEvent::TouchStart,
 606                     INPUT_EVENT_ACK_STATE_CONSUMED);
 607   EXPECT_FALSE(TouchEventQueueEmpty());
 608   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 609   EXPECT_EQ(WebInputEvent::TouchStart,
 610             ack_handler_->acked_touch_event().event.type);
 611   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 612
 613   SendInputEventACK(WebInputEvent::TouchMove,
 614                     INPUT_EVENT_ACK_STATE_CONSUMED);
 615   EXPECT_TRUE(TouchEventQueueEmpty());
 616   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 617   EXPECT_EQ(WebInputEvent::TouchMove,
 618             ack_handler_->acked_touch_event().event.type);
 619   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 620 }
 621
 622 // Tests that the touch-queue is emptied after a page stops listening for touch
 623 // events and the outstanding ack is received.
 624 TEST_F(InputRouterImplTest, TouchEventQueueFlush) {
 625   OnHasTouchEventHandlers(true);
 626   EXPECT_TRUE(client_->has_touch_handler());
 627   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 628   EXPECT_TRUE(TouchEventQueueEmpty());
 629
 630   EXPECT_TRUE(input_router_->ShouldForwardTouchEvent());
 631
 632   // Send a touch-press event.
 633   PressTouchPoint(1, 1);
 634   SendTouchEvent();
 635   MoveTouchPoint(0, 2, 2);
 636   MoveTouchPoint(0, 3, 3);
 637   EXPECT_FALSE(TouchEventQueueEmpty());
 638   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 639
 640   // The page stops listening for touch-events. Note that flushing is deferred
 641   // until the outstanding ack is received.
 642   OnHasTouchEventHandlers(false);
 643   EXPECT_FALSE(client_->has_touch_handler());
 644   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 645   EXPECT_FALSE(TouchEventQueueEmpty());
 646   EXPECT_TRUE(input_router_->ShouldForwardTouchEvent());
 647
 648   // After the ack, the touch-event queue should be empty, and none of the
 649   // flushed touch-events should have been sent to the renderer.
 650   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
 651   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 652   EXPECT_TRUE(TouchEventQueueEmpty());
 653   EXPECT_FALSE(input_router_->ShouldForwardTouchEvent());
 654 }
 655
 656 #if defined(USE_AURA)
 657 // Tests that the acked events have correct state. (ui::Events are used only on
 658 // windows and aura)
 659 TEST_F(InputRouterImplTest, AckedTouchEventState) {
 660   input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
 661   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 662   EXPECT_TRUE(TouchEventQueueEmpty());
 663   EXPECT_TRUE(input_router_->ShouldForwardTouchEvent());
 664
 665   // Send a bunch of events, and make sure the ACKed events are correct.
 666   ScopedVector<ui::TouchEvent> expected_events;
 667
 668   // Use a custom timestamp for all the events to test that the acked events
 669   // have the same timestamp;
 670   base::TimeDelta timestamp = base::Time::NowFromSystemTime() - base::Time();
 671   timestamp -= base::TimeDelta::FromSeconds(600);
 672
 673   // Press the first finger.
 674   PressTouchPoint(1, 1);
 675   SetTouchTimestamp(timestamp);
 676   SendTouchEvent();
 677   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 678   expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
 679       gfx::Point(1, 1), 0, timestamp));
 680
 681   // Move the finger.
 682   timestamp += base::TimeDelta::FromSeconds(10);
 683   MoveTouchPoint(0, 500, 500);
 684   SetTouchTimestamp(timestamp);
 685   SendTouchEvent();
 686   EXPECT_FALSE(TouchEventQueueEmpty());
 687   expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED,
 688       gfx::Point(500, 500), 0, timestamp));
 689
 690   // Now press a second finger.
 691   timestamp += base::TimeDelta::FromSeconds(10);
 692   PressTouchPoint(2, 2);
 693   SetTouchTimestamp(timestamp);
 694   SendTouchEvent();
 695   EXPECT_FALSE(TouchEventQueueEmpty());
 696   expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
 697       gfx::Point(2, 2), 1, timestamp));
 698
 699   // Move both fingers.
 700   timestamp += base::TimeDelta::FromSeconds(10);
 701   MoveTouchPoint(0, 10, 10);
 702   MoveTouchPoint(1, 20, 20);
 703   SetTouchTimestamp(timestamp);
 704   SendTouchEvent();
 705   EXPECT_FALSE(TouchEventQueueEmpty());
 706   expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED,
 707       gfx::Point(10, 10), 0, timestamp));
 708   expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED,
 709       gfx::Point(20, 20), 1, timestamp));
 710
 711   // Receive the ACKs and make sure the generated events from the acked events
 712   // are correct.
 713   WebInputEvent::Type acks[] = { WebInputEvent::TouchStart,
 714                                  WebInputEvent::TouchMove,
 715                                  WebInputEvent::TouchStart,
 716                                  WebInputEvent::TouchMove };
 717
 718   TouchEventCoordinateSystem coordinate_system = LOCAL_COORDINATES;
 719 #if !defined(OS_WIN)
 720   coordinate_system = SCREEN_COORDINATES;
 721 #endif
 722   for (size_t i = 0; i < arraysize(acks); ++i) {
 723     SendInputEventACK(acks[i],
 724                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 725     EXPECT_EQ(acks[i], ack_handler_->acked_touch_event().event.type);
 726     ScopedVector<ui::TouchEvent> acked;
 727
 728     MakeUITouchEventsFromWebTouchEvents(
 729         ack_handler_->acked_touch_event(), &acked, coordinate_system);
 730     bool success = EventListIsSubset(acked, expected_events);
 731     EXPECT_TRUE(success) << "Failed on step: " << i;
 732     if (!success)
 733       break;
 734     expected_events.erase(expected_events.begin(),
 735                           expected_events.begin() + acked.size());
 736   }
 737
 738   EXPECT_TRUE(TouchEventQueueEmpty());
 739   EXPECT_EQ(0U, expected_events.size());
 740 }
 741 #endif  // defined(USE_AURA)
 742
 743 TEST_F(InputRouterImplTest, UnhandledWheelEvent) {
 744   // Simulate wheel events.
 745   SimulateWheelEvent(0, -5, 0, false);  // sent directly
 746   SimulateWheelEvent(0, -10, 0, false);  // enqueued
 747
 748   // Check that only the first event was sent.
 749   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 750                   InputMsg_HandleInputEvent::ID));
 751   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 752
 753   // Indicate that the wheel event was unhandled.
 754   SendInputEventACK(WebInputEvent::MouseWheel,
 755                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 756
 757   // Check that the correct unhandled wheel event was received.
 758   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 759   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_handler_->ack_state());
 760   EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -5);
 761
 762   // Check that the second event was sent.
 763   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 764                   InputMsg_HandleInputEvent::ID));
 765   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 766
 767   // Check that the correct unhandled wheel event was received.
 768   EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -5);
 769 }
 770
 771 TEST_F(InputRouterImplTest, TouchTypesIgnoringAck) {
 772   OnHasTouchEventHandlers(true);
 773   // Only acks for TouchCancel should always be ignored.
 774   ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
 775       GetEventWithType(WebInputEvent::TouchStart)));
 776   ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
 777       GetEventWithType(WebInputEvent::TouchMove)));
 778   ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
 779       GetEventWithType(WebInputEvent::TouchEnd)));
 780
 781   // Precede the TouchCancel with an appropriate TouchStart;
 782   PressTouchPoint(1, 1);
 783   SendTouchEvent();
 784   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
 785   ASSERT_EQ(1U, GetSentMessageCountAndResetSink());
 786   ASSERT_EQ(1U, ack_handler_->GetAndResetAckCount());
 787   ASSERT_EQ(0, client_->in_flight_event_count());
 788
 789   // The TouchCancel ack is always ignored.
 790   CancelTouchPoint(0);
 791   SendTouchEvent();
 792   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 793   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 794   EXPECT_EQ(0, client_->in_flight_event_count());
 795   EXPECT_FALSE(HasPendingEvents());
 796   SendInputEventACK(WebInputEvent::TouchCancel,
 797                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 798   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 799   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 800   EXPECT_FALSE(HasPendingEvents());
 801 }
 802
 803 TEST_F(InputRouterImplTest, GestureTypesIgnoringAck) {
 804   // We test every gesture type, ensuring that the stream of gestures is valid.
 805   const int kEventTypesLength = 29;
 806   WebInputEvent::Type eventTypes[kEventTypesLength] = {
 807       WebInputEvent::GestureTapDown,
 808       WebInputEvent::GestureShowPress,
 809       WebInputEvent::GestureTapCancel,
 810       WebInputEvent::GestureScrollBegin,
 811       WebInputEvent::GestureFlingStart,
 812       WebInputEvent::GestureFlingCancel,
 813       WebInputEvent::GestureTapDown,
 814       WebInputEvent::GestureTap,
 815       WebInputEvent::GestureTapDown,
 816       WebInputEvent::GestureLongPress,
 817       WebInputEvent::GestureTapCancel,
 818       WebInputEvent::GestureLongTap,
 819       WebInputEvent::GestureTapDown,
 820       WebInputEvent::GestureTapUnconfirmed,
 821       WebInputEvent::GestureTapCancel,
 822       WebInputEvent::GestureTapDown,
 823       WebInputEvent::GestureDoubleTap,
 824       WebInputEvent::GestureTapDown,
 825       WebInputEvent::GestureTapCancel,
 826       WebInputEvent::GestureTwoFingerTap,
 827       WebInputEvent::GestureTapDown,
 828       WebInputEvent::GestureTapCancel,
 829       WebInputEvent::GestureScrollBegin,
 830       WebInputEvent::GestureScrollUpdate,
 831       WebInputEvent::GestureScrollUpdateWithoutPropagation,
 832       WebInputEvent::GesturePinchBegin,
 833       WebInputEvent::GesturePinchUpdate,
 834       WebInputEvent::GesturePinchEnd,
 835       WebInputEvent::GestureScrollEnd};
 836   for (int i = 0; i < kEventTypesLength; ++i) {
 837     WebInputEvent::Type type = eventTypes[i];
 838     if (!WebInputEventTraits::IgnoresAckDisposition(GetEventWithType(type))) {
 839       SimulateGestureEvent(type, blink::WebGestureDeviceTouchscreen);
 840       EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 841       EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 842       EXPECT_EQ(1, client_->in_flight_event_count());
 843       EXPECT_TRUE(HasPendingEvents());
 844
 845       SendInputEventACK(type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 846       EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 847       EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 848       EXPECT_EQ(0, client_->in_flight_event_count());
 849       EXPECT_FALSE(HasPendingEvents());
 850       continue;
 851     }
 852
 853     SimulateGestureEvent(type, blink::WebGestureDeviceTouchscreen);
 854     EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 855     EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 856     EXPECT_EQ(0, client_->in_flight_event_count());
 857     EXPECT_FALSE(HasPendingEvents());
 858   }
 859 }
 860
 861 TEST_F(InputRouterImplTest, MouseTypesIgnoringAck) {
 862   int start_type = static_cast<int>(WebInputEvent::MouseDown);
 863   int end_type = static_cast<int>(WebInputEvent::ContextMenu);
 864   ASSERT_LT(start_type, end_type);
 865   for (int i = start_type; i <= end_type; ++i) {
 866     WebInputEvent::Type type = static_cast<WebInputEvent::Type>(i);
 867     int expected_in_flight_event_count =
 868         WebInputEventTraits::IgnoresAckDisposition(GetEventWithType(type)) ? 0
 869                                                                            : 1;
 870
 871     // Note: Mouse event acks are never forwarded to the ack handler, so the key
 872     // result here is that ignored ack types don't affect the in-flight count.
 873     SimulateMouseEvent(type, 0, 0);
 874     EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 875     EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 876     EXPECT_EQ(expected_in_flight_event_count, client_->in_flight_event_count());
 877     if (expected_in_flight_event_count) {
 878       SendInputEventACK(type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 879       EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 880       EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 881       EXPECT_EQ(0, client_->in_flight_event_count());
 882     }
 883   }
 884 }
 885
 886 // Guard against breaking changes to the list of ignored event ack types in
 887 // |WebInputEventTraits::IgnoresAckDisposition|.
 888 TEST_F(InputRouterImplTest, RequiredEventAckTypes) {
 889   const WebInputEvent::Type kRequiredEventAckTypes[] = {
 890     WebInputEvent::MouseMove,
 891     WebInputEvent::MouseWheel,
 892     WebInputEvent::RawKeyDown,
 893     WebInputEvent::KeyDown,
 894     WebInputEvent::KeyUp,
 895     WebInputEvent::Char,
 896     WebInputEvent::GestureScrollUpdate,
 897     WebInputEvent::GestureFlingStart,
 898     WebInputEvent::GestureFlingCancel,
 899     WebInputEvent::GesturePinchUpdate,
 900     WebInputEvent::TouchStart,
 901     WebInputEvent::TouchMove
 902   };
 903   for (size_t i = 0; i < arraysize(kRequiredEventAckTypes); ++i) {
 904     const WebInputEvent::Type required_ack_type = kRequiredEventAckTypes[i];
 905     EXPECT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
 906         GetEventWithType(required_ack_type)));
 907   }
 908 }
 909
 910 // Test that GestureShowPress, GestureTapDown and GestureTapCancel events don't
 911 // wait for ACKs.
 912 TEST_F(InputRouterImplTest, GestureTypesIgnoringAckInterleaved) {
 913   // Interleave a few events that do and do not ignore acks, ensuring that
 914   // ack-ignoring events aren't dispatched until all prior events which observe
 915   // their ack disposition have been dispatched.
 916
 917   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 918                        blink::WebGestureDeviceTouchscreen);
 919   ASSERT_EQ(1U, GetSentMessageCountAndResetSink());
 920   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 921   EXPECT_EQ(0, client_->in_flight_event_count());
 922
 923   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
 924                        blink::WebGestureDeviceTouchscreen);
 925   ASSERT_EQ(1U, GetSentMessageCountAndResetSink());
 926   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 927   EXPECT_EQ(1, client_->in_flight_event_count());
 928
 929   SimulateGestureEvent(WebInputEvent::GestureTapDown,
 930                        blink::WebGestureDeviceTouchscreen);
 931   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 932   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 933   EXPECT_EQ(1, client_->in_flight_event_count());
 934
 935   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
 936                        blink::WebGestureDeviceTouchscreen);
 937   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 938   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 939
 940   SimulateGestureEvent(WebInputEvent::GestureShowPress,
 941                        blink::WebGestureDeviceTouchscreen);
 942   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 943   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 944
 945   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
 946                        blink::WebGestureDeviceTouchscreen);
 947   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 948   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 949
 950   SimulateGestureEvent(WebInputEvent::GestureTapCancel,
 951                        blink::WebGestureDeviceTouchscreen);
 952   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 953   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 954
 955   // Now ack each ack-respecting event. Ack-ignoring events should not be
 956   // dispatched until all prior events which observe ack disposition have been
 957   // fired, at which point they should be sent immediately.  They should also
 958   // have no effect on the in-flight event count.
 959   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 960                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 961   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
 962   EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
 963   EXPECT_EQ(1, client_->in_flight_event_count());
 964
 965   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 966                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 967   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
 968   EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
 969   EXPECT_EQ(1, client_->in_flight_event_count());
 970
 971   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 972                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 973   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 974   EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
 975   EXPECT_EQ(0, client_->in_flight_event_count());
 976 }
 977
 978 // Test that GestureShowPress events don't get out of order due to
 979 // ignoring their acks.
 980 TEST_F(InputRouterImplTest, GestureShowPressIsInOrder) {
 981   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 982                        blink::WebGestureDeviceTouchscreen);
 983   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 984   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 985
 986
 987   // GesturePinchBegin ignores its ack.
 988   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
 989                        blink::WebGestureDeviceTouchscreen);
 990   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 991   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 992
 993   // GesturePinchUpdate waits for an ack.
 994   // This also verifies that GesturePinchUpdates for touchscreen are sent
 995   // to the renderer (in contrast to the TrackpadPinchUpdate test).
 996   SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
 997                        blink::WebGestureDeviceTouchscreen);
 998   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 999   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1000
1001   SimulateGestureEvent(WebInputEvent::GestureShowPress,
1002                        blink::WebGestureDeviceTouchscreen);
1003   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1004   // The ShowPress, though it ignores ack, is still stuck in the queue
1005   // behind the PinchUpdate which requires an ack.
1006   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1007
1008   SimulateGestureEvent(WebInputEvent::GestureShowPress,
1009                        blink::WebGestureDeviceTouchscreen);
1010   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1011   // ShowPress has entered the queue.
1012   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1013
1014   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
1015                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1016   // Now that the Tap has been ACKed, the ShowPress events should receive
1017   // synthetic acks, and fire immediately.
1018   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
1019   EXPECT_EQ(3U, ack_handler_->GetAndResetAckCount());
1020 }
1021
1022 // Test that touch ack timeout behavior is properly toggled by view update flags
1023 // and allowed touch actions.
1024 TEST_F(InputRouterImplTest, TouchAckTimeoutConfigured) {
1025   const int timeout_ms = 1;
1026   SetUpForTouchAckTimeoutTest(timeout_ms);
1027   ASSERT_TRUE(TouchEventTimeoutEnabled());
1028
1029   // Verify that the touch ack timeout fires upon the delayed ack.
1030   PressTouchPoint(1, 1);
1031   SendTouchEvent();
1032   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1033   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1034   RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1));
1035
1036   // The timed-out event should have been ack'ed.
1037   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1038   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1039
1040   // Ack'ing the timed-out event should fire a TouchCancel.
1041   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1042   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1043   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1044
1045   // The remainder of the touch sequence should be dropped.
1046   ReleaseTouchPoint(0);
1047   SendTouchEvent();
1048   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1049   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1050   ASSERT_TRUE(TouchEventTimeoutEnabled());
1051
1052   // A fixed page scale or mobile viewport should disable the touch timeout.
1053   input_router()->OnViewUpdated(InputRouter::FIXED_PAGE_SCALE);
1054   EXPECT_FALSE(TouchEventTimeoutEnabled());
1055
1056   input_router()->OnViewUpdated(InputRouter::VIEW_FLAGS_NONE);
1057   EXPECT_TRUE(TouchEventTimeoutEnabled());
1058
1059   input_router()->OnViewUpdated(InputRouter::MOBILE_VIEWPORT);
1060   EXPECT_FALSE(TouchEventTimeoutEnabled());
1061
1062   input_router()->OnViewUpdated(InputRouter::MOBILE_VIEWPORT |
1063                                 InputRouter::FIXED_PAGE_SCALE);
1064   EXPECT_FALSE(TouchEventTimeoutEnabled());
1065
1066   input_router()->OnViewUpdated(InputRouter::VIEW_FLAGS_NONE);
1067   EXPECT_TRUE(TouchEventTimeoutEnabled());
1068
1069   // TOUCH_ACTION_NONE (and no other touch-action) should disable the timeout.
1070   OnHasTouchEventHandlers(true);
1071   PressTouchPoint(1, 1);
1072   SendTouchEvent();
1073   OnSetTouchAction(TOUCH_ACTION_PAN_Y);
1074   EXPECT_TRUE(TouchEventTimeoutEnabled());
1075   ReleaseTouchPoint(0);
1076   SendTouchEvent();
1077   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1078   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1079
1080   PressTouchPoint(1, 1);
1081   SendTouchEvent();
1082   OnSetTouchAction(TOUCH_ACTION_NONE);
1083   EXPECT_FALSE(TouchEventTimeoutEnabled());
1084   ReleaseTouchPoint(0);
1085   SendTouchEvent();
1086   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1087   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1088
1089   // As the touch-action is reset by a new touch sequence, the timeout behavior
1090   // should be restored.
1091   PressTouchPoint(1, 1);
1092   SendTouchEvent();
1093   EXPECT_TRUE(TouchEventTimeoutEnabled());
1094 }
1095
1096 // Test that a touch sequenced preceded by TOUCH_ACTION_NONE is not affected by
1097 // the touch timeout.
1098 TEST_F(InputRouterImplTest,
1099        TouchAckTimeoutDisabledForTouchSequenceAfterTouchActionNone) {
1100   const int timeout_ms = 1;
1101   SetUpForTouchAckTimeoutTest(timeout_ms);
1102   ASSERT_TRUE(TouchEventTimeoutEnabled());
1103   OnHasTouchEventHandlers(true);
1104
1105   // Start a touch sequence.
1106   PressTouchPoint(1, 1);
1107   SendTouchEvent();
1108   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1109
1110   // TOUCH_ACTION_NONE should disable the timeout.
1111   OnSetTouchAction(TOUCH_ACTION_NONE);
1112   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1113   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1114   EXPECT_FALSE(TouchEventTimeoutEnabled());
1115
1116   MoveTouchPoint(0, 1, 1);
1117   SendTouchEvent();
1118   EXPECT_FALSE(TouchEventTimeoutEnabled());
1119   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1120
1121   // Delay the move ack. The timeout should not fire.
1122   RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1));
1123   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1124   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1125   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1126   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1127
1128   // End the touch sequence.
1129   ReleaseTouchPoint(0);
1130   SendTouchEvent();
1131   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1132   EXPECT_FALSE(TouchEventTimeoutEnabled());
1133   ack_handler_->GetAndResetAckCount();
1134   GetSentMessageCountAndResetSink();
1135
1136   // Start another touch sequence.  This should restore the touch timeout.
1137   PressTouchPoint(1, 1);
1138   SendTouchEvent();
1139   EXPECT_TRUE(TouchEventTimeoutEnabled());
1140   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1141   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1142
1143   // Wait for the touch ack timeout to fire.
1144   RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1));
1145   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1146 }
1147
1148 // Test that TouchActionFilter::ResetTouchAction is called before the
1149 // first touch event for a touch sequence reaches the renderer.
1150 TEST_F(InputRouterImplTest, TouchActionResetBeforeEventReachesRenderer) {
1151   OnHasTouchEventHandlers(true);
1152
1153   // Sequence 1.
1154   PressTouchPoint(1, 1);
1155   SendTouchEvent();
1156   OnSetTouchAction(TOUCH_ACTION_NONE);
1157   MoveTouchPoint(0, 50, 50);
1158   SendTouchEvent();
1159   ReleaseTouchPoint(0);
1160   SendTouchEvent();
1161
1162   // Sequence 2.
1163   PressTouchPoint(1, 1);
1164   SendTouchEvent();
1165   MoveTouchPoint(0, 50, 50);
1166   SendTouchEvent();
1167   ReleaseTouchPoint(0);
1168   SendTouchEvent();
1169
1170   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1171   SendInputEventACK(WebInputEvent::TouchMove, INPUT_EVENT_ACK_STATE_CONSUMED);
1172
1173   // Ensure touch action is still none, as the next touch start hasn't been
1174   // acked yet. ScrollBegin and ScrollEnd don't require acks.
1175   EXPECT_EQ(3U, GetSentMessageCountAndResetSink());
1176   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1177                        blink::WebGestureDeviceTouchscreen);
1178   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1179   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1180                        blink::WebGestureDeviceTouchscreen);
1181   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1182
1183   // This allows the next touch sequence to start.
1184   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1185
1186   // Ensure touch action has been set to auto, as a new touch sequence has
1187   // started.
1188   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1189   SendInputEventACK(WebInputEvent::TouchMove, INPUT_EVENT_ACK_STATE_CONSUMED);
1190   EXPECT_EQ(3U, GetSentMessageCountAndResetSink());
1191   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1192                        blink::WebGestureDeviceTouchscreen);
1193   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1194   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1195                        blink::WebGestureDeviceTouchscreen);
1196   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1197   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1198 }
1199
1200 // Test that TouchActionFilter::ResetTouchAction is called when a new touch
1201 // sequence has no consumer.
1202 TEST_F(InputRouterImplTest, TouchActionResetWhenTouchHasNoConsumer) {
1203   OnHasTouchEventHandlers(true);
1204
1205   // Sequence 1.
1206   PressTouchPoint(1, 1);
1207   SendTouchEvent();
1208   MoveTouchPoint(0, 50, 50);
1209   SendTouchEvent();
1210   OnSetTouchAction(TOUCH_ACTION_NONE);
1211   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1212   SendInputEventACK(WebInputEvent::TouchMove, INPUT_EVENT_ACK_STATE_CONSUMED);
1213
1214   ReleaseTouchPoint(0);
1215   SendTouchEvent();
1216
1217   // Sequence 2
1218   PressTouchPoint(1, 1);
1219   SendTouchEvent();
1220   MoveTouchPoint(0, 50, 50);
1221   SendTouchEvent();
1222   ReleaseTouchPoint(0);
1223   SendTouchEvent();
1224
1225   // Ensure we have touch-action:none. ScrollBegin and ScrollEnd don't require
1226   // acks.
1227   EXPECT_EQ(3U, GetSentMessageCountAndResetSink());
1228   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1229                        blink::WebGestureDeviceTouchscreen);
1230   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1231   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1232                        blink::WebGestureDeviceTouchscreen);
1233   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1234
1235   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1236   SendInputEventACK(WebInputEvent::TouchStart,
1237                     INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1238
1239   // Ensure touch action has been set to auto, as the touch had no consumer.
1240   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1241   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1242                        blink::WebGestureDeviceTouchscreen);
1243   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1244   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1245                        blink::WebGestureDeviceTouchscreen);
1246   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1247 }
1248
1249 // Test that TouchActionFilter::ResetTouchAction is called when the touch
1250 // handler is removed.
1251 TEST_F(InputRouterImplTest, TouchActionResetWhenTouchHandlerRemoved) {
1252   // Touch sequence with touch handler.
1253   OnHasTouchEventHandlers(true);
1254   PressTouchPoint(1, 1);
1255   SendTouchEvent();
1256   MoveTouchPoint(0, 50, 50);
1257   SendTouchEvent();
1258   OnSetTouchAction(TOUCH_ACTION_NONE);
1259   ReleaseTouchPoint(0);
1260   SendTouchEvent();
1261   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1262
1263   // Ensure we have touch-action:none, suppressing scroll events.
1264   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1265   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1266   SendInputEventACK(WebInputEvent::TouchMove,
1267                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1268   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1269   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1270                        blink::WebGestureDeviceTouchscreen);
1271   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1272
1273   SendInputEventACK(WebInputEvent::TouchEnd,
1274                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1275   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1276                        blink::WebGestureDeviceTouchscreen);
1277   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1278
1279   // Sequence without a touch handler. Note that in this case, the view may not
1280   // necessarily forward touches to the router (as no touch handler exists).
1281   OnHasTouchEventHandlers(false);
1282
1283   // Ensure touch action has been set to auto, as the touch handler has been
1284   // removed.
1285   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1286                        blink::WebGestureDeviceTouchscreen);
1287   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1288   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1289                        blink::WebGestureDeviceTouchscreen);
1290   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1291 }
1292
1293 // Test that the double tap gesture depends on the touch action of the first
1294 // tap.
1295 TEST_F(InputRouterImplTest, DoubleTapGestureDependsOnFirstTap) {
1296   OnHasTouchEventHandlers(true);
1297
1298   // Sequence 1.
1299   PressTouchPoint(1, 1);
1300   SendTouchEvent();
1301   OnSetTouchAction(TOUCH_ACTION_NONE);
1302   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1303
1304   ReleaseTouchPoint(0);
1305   SendTouchEvent();
1306
1307   // Sequence 2
1308   PressTouchPoint(1, 1);
1309   SendTouchEvent();
1310
1311   // First tap.
1312   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
1313   SimulateGestureEvent(WebInputEvent::GestureTapDown,
1314                        blink::WebGestureDeviceTouchscreen);
1315   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1316
1317   // The GestureTapUnconfirmed is converted into a tap, as the touch action is
1318   // none.
1319   SimulateGestureEvent(WebInputEvent::GestureTapUnconfirmed,
1320                        blink::WebGestureDeviceTouchscreen);
1321   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1322   // This test will become invalid if GestureTap stops requiring an ack.
1323   ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
1324       GetEventWithType(WebInputEvent::GestureTap)));
1325   EXPECT_EQ(2, client_->in_flight_event_count());
1326   SendInputEventACK(WebInputEvent::GestureTap,
1327                     INPUT_EVENT_ACK_STATE_CONSUMED);
1328   EXPECT_EQ(1, client_->in_flight_event_count());
1329
1330   // This tap gesture is dropped, since the GestureTapUnconfirmed was turned
1331   // into a tap.
1332   SimulateGestureEvent(WebInputEvent::GestureTap,
1333                        blink::WebGestureDeviceTouchscreen);
1334   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1335
1336   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1337   SendInputEventACK(WebInputEvent::TouchStart,
1338                     INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1339
1340   // Second Tap.
1341   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1342   SimulateGestureEvent(WebInputEvent::GestureTapDown,
1343                        blink::WebGestureDeviceTouchscreen);
1344   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1345
1346   // Although the touch-action is now auto, the double tap still won't be
1347   // dispatched, because the first tap occured when the touch-action was none.
1348   SimulateGestureEvent(WebInputEvent::GestureDoubleTap,
1349                        blink::WebGestureDeviceTouchscreen);
1350   // This test will become invalid if GestureDoubleTap stops requiring an ack.
1351   ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
1352       GetEventWithType(WebInputEvent::GestureDoubleTap)));
1353   EXPECT_EQ(1, client_->in_flight_event_count());
1354   SendInputEventACK(WebInputEvent::GestureTap, INPUT_EVENT_ACK_STATE_CONSUMED);
1355   EXPECT_EQ(0, client_->in_flight_event_count());
1356 }
1357
1358 // Test that the router will call the client's |DidFlush| after all events have
1359 // been dispatched following a call to |Flush|.
1360 TEST_F(InputRouterImplTest, InputFlush) {
1361   EXPECT_FALSE(HasPendingEvents());
1362
1363   // Flushing an empty router should immediately trigger DidFlush.
1364   Flush();
1365   EXPECT_EQ(1U, GetAndResetDidFlushCount());
1366   EXPECT_FALSE(HasPendingEvents());
1367
1368   // Queue a TouchStart.
1369   OnHasTouchEventHandlers(true);
1370   PressTouchPoint(1, 1);
1371   SendTouchEvent();
1372   EXPECT_TRUE(HasPendingEvents());
1373
1374   // DidFlush should be called only after the event is ack'ed.
1375   Flush();
1376   EXPECT_EQ(0U, GetAndResetDidFlushCount());
1377   SendInputEventACK(WebInputEvent::TouchStart,
1378                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1379   EXPECT_EQ(1U, GetAndResetDidFlushCount());
1380
1381   // Ensure different types of enqueued events will prevent the DidFlush call
1382   // until all such events have been fully dispatched.
1383   MoveTouchPoint(0, 50, 50);
1384   SendTouchEvent();
1385   ASSERT_TRUE(HasPendingEvents());
1386   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1387                        blink::WebGestureDeviceTouchscreen);
1388   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1389                        blink::WebGestureDeviceTouchscreen);
1390   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
1391                        blink::WebGestureDeviceTouchscreen);
1392   SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
1393                        blink::WebGestureDeviceTouchscreen);
1394   Flush();
1395   EXPECT_EQ(0U, GetAndResetDidFlushCount());
1396
1397   // Repeated flush calls should have no effect.
1398   Flush();
1399   EXPECT_EQ(0U, GetAndResetDidFlushCount());
1400
1401   // There are still pending gestures.
1402   SendInputEventACK(WebInputEvent::TouchMove,
1403                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1404   EXPECT_EQ(0U, GetAndResetDidFlushCount());
1405   EXPECT_TRUE(HasPendingEvents());
1406
1407   // One more gesture to go.
1408   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
1409                     INPUT_EVENT_ACK_STATE_CONSUMED);
1410   EXPECT_EQ(0U, GetAndResetDidFlushCount());
1411   EXPECT_TRUE(HasPendingEvents());
1412
1413   // The final ack'ed gesture should trigger the DidFlush.
1414   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
1415                     INPUT_EVENT_ACK_STATE_CONSUMED);
1416   EXPECT_EQ(1U, GetAndResetDidFlushCount());
1417   EXPECT_FALSE(HasPendingEvents());
1418 }
1419
1420 // Test that GesturePinchUpdate is handled specially for trackpad
1421 TEST_F(InputRouterImplTest, TouchpadPinchUpdate) {
1422   // GesturePinchUpdate for trackpad sends synthetic wheel events.
1423   // Note that the Touchscreen case is verified as NOT doing this as
1424   // part of the ShowPressIsInOrder test.
1425
1426   SimulateGesturePinchUpdateEvent(
1427       1.5f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1428
1429   // Verify we actually sent a special wheel event to the renderer.
1430   const WebInputEvent* input_event =
1431       GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1432   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1433   const WebMouseWheelEvent* wheel_event =
1434       static_cast<const WebMouseWheelEvent*>(input_event);
1435   EXPECT_EQ(20, wheel_event->x);
1436   EXPECT_EQ(25, wheel_event->y);
1437   EXPECT_EQ(20, wheel_event->globalX);
1438   EXPECT_EQ(25, wheel_event->globalY);
1439   EXPECT_EQ(20, wheel_event->windowX);
1440   EXPECT_EQ(25, wheel_event->windowY);
1441   EXPECT_EQ(PinchScaleToWheelDelta(1.5), wheel_event->deltaY);
1442   EXPECT_EQ(0, wheel_event->deltaX);
1443   EXPECT_EQ(1, wheel_event->hasPreciseScrollingDeltas);
1444   EXPECT_EQ(1, wheel_event->wheelTicksY);
1445   EXPECT_EQ(0, wheel_event->wheelTicksX);
1446   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1447
1448   // Indicate that the wheel event was unhandled.
1449   SendInputEventACK(WebInputEvent::MouseWheel,
1450                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1451
1452   // Check that the correct unhandled pinch event was received.
1453   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1454   ASSERT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1455   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_handler_->ack_state());
1456   EXPECT_EQ(1.5f, ack_handler_->acked_gesture_event().data.pinchUpdate.scale);
1457   EXPECT_EQ(0, client_->in_flight_event_count());
1458
1459   // Second a second pinch event.
1460   SimulateGesturePinchUpdateEvent(
1461       0.3f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1462   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1463   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1464   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
1465   EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(0.3f), wheel_event->deltaY);
1466   EXPECT_EQ(1, wheel_event->hasPreciseScrollingDeltas);
1467   EXPECT_EQ(-1, wheel_event->wheelTicksY);
1468   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1469
1470   // Indicate that the wheel event was handled this time.
1471   SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED);
1472
1473   // Check that the correct HANDLED pinch event was received.
1474   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1475   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1476   EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, ack_handler_->ack_state());
1477   EXPECT_FLOAT_EQ(0.3f,
1478                   ack_handler_->acked_gesture_event().data.pinchUpdate.scale);
1479 }
1480
1481 // Test that touchpad pinch events are coalesced property, with their synthetic
1482 // wheel events getting the right ACKs.
1483 TEST_F(InputRouterImplTest, TouchpadPinchCoalescing) {
1484   // Send the first pinch.
1485   SimulateGesturePinchUpdateEvent(
1486       1.5f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1487
1488   // Verify we sent the wheel event to the renderer.
1489   const WebInputEvent* input_event =
1490       GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1491   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1492   const WebMouseWheelEvent* wheel_event =
1493       static_cast<const WebMouseWheelEvent*>(input_event);
1494   EXPECT_EQ(PinchScaleToWheelDelta(1.5f), wheel_event->deltaY);
1495   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1496   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1497   EXPECT_EQ(1, client_->in_flight_event_count());
1498
1499   // Send a second pinch, this should be queued in the GestureEventQueue.
1500   SimulateGesturePinchUpdateEvent(
1501       1.6f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1502   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1503   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1504
1505   // Send a third pinch, this should be coalesced into the second in the
1506   // GestureEventQueue.
1507   SimulateGesturePinchUpdateEvent(
1508       1.7f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1509   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1510   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1511
1512   // Indicate that the first wheel event was unhandled and verify the ACK.
1513   SendInputEventACK(WebInputEvent::MouseWheel,
1514                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1515   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1516   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1517   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_handler_->ack_state());
1518   EXPECT_EQ(1.5f, ack_handler_->acked_gesture_event().data.pinchUpdate.scale);
1519
1520   // Verify a second wheel event was sent representing the 2nd and 3rd pinch
1521   // events.
1522   EXPECT_EQ(1, client_->in_flight_event_count());
1523   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1524   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1525   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
1526   EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(1.6f * 1.7f),
1527                   PinchScaleToWheelDelta(1.6f) + PinchScaleToWheelDelta(1.7f));
1528   EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(1.6f * 1.7f), wheel_event->deltaY);
1529   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1530   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1531
1532   // Indicate that the second wheel event was handled and verify the ACK.
1533   SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED);
1534   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1535   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1536   EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, ack_handler_->ack_state());
1537   EXPECT_FLOAT_EQ(1.6f * 1.7f,
1538                   ack_handler_->acked_gesture_event().data.pinchUpdate.scale);
1539 }
1540
1541 // Test interleaving pinch and wheel events.
1542 TEST_F(InputRouterImplTest, TouchpadPinchAndWheel) {
1543   // Simulate queued wheel and pinch events events.
1544   // Note that in practice interleaving pinch and wheel events should be rare
1545   // (eg. requires the use of a mouse and trackpad at the same time).
1546
1547   // Use the control modifier to match the synthetic wheel events so that
1548   // they're elligble for coalescing.
1549   int mod = WebInputEvent::ControlKey;
1550
1551   // Event 1: sent directly.
1552   SimulateWheelEvent(0, -5, mod, true);
1553   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1554
1555   // Event 2: enqueued in InputRouter.
1556   SimulateWheelEvent(0, -10, mod, true);
1557   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1558
1559   // Event 3: enqueued in InputRouter, not coalesced into #2.
1560   SimulateGesturePinchUpdateEvent(
1561       1.5f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1562   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1563
1564   // Event 4: enqueued in GestureEventQueue.
1565   SimulateGesturePinchUpdateEvent(
1566       1.2f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1567   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1568
1569   // Event 5: coalesced into wheel event for #3.
1570   SimulateWheelEvent(2, 0, mod, true);
1571   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1572
1573   // Send ack for #1.
1574   SendInputEventACK(WebInputEvent::MouseWheel,
1575                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1576   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1577   EXPECT_EQ(WebInputEvent::MouseWheel, ack_handler_->ack_event_type());
1578
1579   // Verify we sent #2.
1580   ASSERT_EQ(1U, process_->sink().message_count());
1581   const WebInputEvent* input_event =
1582       GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1583   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1584   const WebMouseWheelEvent* wheel_event =
1585       static_cast<const WebMouseWheelEvent*>(input_event);
1586   EXPECT_EQ(0, wheel_event->deltaX);
1587   EXPECT_EQ(-10, wheel_event->deltaY);
1588   EXPECT_EQ(mod, wheel_event->modifiers);
1589   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1590
1591   // Send ack for #2.
1592   SendInputEventACK(WebInputEvent::MouseWheel,
1593                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1594   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1595   EXPECT_EQ(WebInputEvent::MouseWheel, ack_handler_->ack_event_type());
1596
1597   // Verify we sent #3 (with #5 coalesced in).
1598   ASSERT_EQ(1U, process_->sink().message_count());
1599   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1600   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1601   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
1602   EXPECT_EQ(2, wheel_event->deltaX);
1603   EXPECT_EQ(PinchScaleToWheelDelta(1.5f), wheel_event->deltaY);
1604   EXPECT_EQ(mod, wheel_event->modifiers);
1605   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1606
1607   // Send ack for #3.
1608   SendInputEventACK(WebInputEvent::MouseWheel,
1609                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1610   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1611   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1612
1613   // Verify we sent #4.
1614   ASSERT_EQ(1U, process_->sink().message_count());
1615   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1616   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1617   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
1618   EXPECT_EQ(0, wheel_event->deltaX);
1619   EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(1.2f), wheel_event->deltaY);
1620   EXPECT_EQ(mod, wheel_event->modifiers);
1621   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1622
1623   // Send ack for #4.
1624   SendInputEventACK(WebInputEvent::MouseWheel,
1625                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1626   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1627   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1628 }
1629
1630 // Test proper handling of touchpad Gesture{Pinch,Scroll}Update sequences.
1631 TEST_F(InputRouterImplTest, TouchpadPinchAndScrollUpdate) {
1632   // The first scroll should be sent immediately.
1633   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1634                        blink::WebGestureDeviceTouchpad);
1635   ASSERT_EQ(1U, GetSentMessageCountAndResetSink());
1636   EXPECT_EQ(1, client_->in_flight_event_count());
1637
1638   // Subsequent scroll and pinch events should remain queued, coalescing as
1639   // more trackpad events arrive.
1640   SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
1641                        blink::WebGestureDeviceTouchpad);
1642   ASSERT_EQ(0U, GetSentMessageCountAndResetSink());
1643   EXPECT_EQ(1, client_->in_flight_event_count());
1644
1645   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1646                        blink::WebGestureDeviceTouchpad);
1647   ASSERT_EQ(0U, GetSentMessageCountAndResetSink());
1648   EXPECT_EQ(1, client_->in_flight_event_count());
1649
1650   SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
1651                        blink::WebGestureDeviceTouchpad);
1652   ASSERT_EQ(0U, GetSentMessageCountAndResetSink());
1653   EXPECT_EQ(1, client_->in_flight_event_count());
1654
1655   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1656                        blink::WebGestureDeviceTouchpad);
1657   ASSERT_EQ(0U, GetSentMessageCountAndResetSink());
1658   EXPECT_EQ(1, client_->in_flight_event_count());
1659
1660   // Ack'ing the first scroll should trigger both the coalesced scroll and the
1661   // coalesced pinch events (which is sent to the renderer as a wheel event).
1662   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
1663                     INPUT_EVENT_ACK_STATE_CONSUMED);
1664   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1665   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
1666   EXPECT_EQ(2, client_->in_flight_event_count());
1667
1668   // Ack the second scroll.
1669   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
1670                     INPUT_EVENT_ACK_STATE_CONSUMED);
1671   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1672   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1673   EXPECT_EQ(1, client_->in_flight_event_count());
1674
1675   // Ack the wheel event.
1676   SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED);
1677   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1678   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1679   EXPECT_EQ(0, client_->in_flight_event_count());
1680 }
1681
1682 // Test proper routing of overscroll notifications received either from
1683 // event acks or from |DidOverscroll| IPC messages.
1684 TEST_F(InputRouterImplTest, OverscrollDispatch) {
1685   DidOverscrollParams overscroll;
1686   overscroll.accumulated_overscroll = gfx::Vector2dF(-14, 14);
1687   overscroll.latest_overscroll_delta = gfx::Vector2dF(-7, 0);
1688   overscroll.current_fling_velocity = gfx::Vector2dF(-1, 0);
1689
1690   input_router_->OnMessageReceived(InputHostMsg_DidOverscroll(0, overscroll));
1691   DidOverscrollParams client_overscroll = client_->GetAndResetOverscroll();
1692   EXPECT_EQ(overscroll.accumulated_overscroll,
1693             client_overscroll.accumulated_overscroll);
1694   EXPECT_EQ(overscroll.latest_overscroll_delta,
1695             client_overscroll.latest_overscroll_delta);
1696   EXPECT_EQ(overscroll.current_fling_velocity,
1697             client_overscroll.current_fling_velocity);
1698
1699   DidOverscrollParams wheel_overscroll;
1700   wheel_overscroll.accumulated_overscroll = gfx::Vector2dF(7, -7);
1701   wheel_overscroll.latest_overscroll_delta = gfx::Vector2dF(3, 0);
1702   wheel_overscroll.current_fling_velocity = gfx::Vector2dF(1, 0);
1703
1704   SimulateWheelEvent(3, 0, 0, false);
1705   InputHostMsg_HandleInputEvent_ACK_Params ack;
1706   ack.type = WebInputEvent::MouseWheel;
1707   ack.state = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1708   ack.overscroll.reset(new DidOverscrollParams(wheel_overscroll));
1709   input_router_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
1710
1711   client_overscroll = client_->GetAndResetOverscroll();
1712   EXPECT_EQ(wheel_overscroll.accumulated_overscroll,
1713             client_overscroll.accumulated_overscroll);
1714   EXPECT_EQ(wheel_overscroll.latest_overscroll_delta,
1715             client_overscroll.latest_overscroll_delta);
1716   EXPECT_EQ(wheel_overscroll.current_fling_velocity,
1717             client_overscroll.current_fling_velocity);
1718 }
1719
1720 }  // namespace content