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   ~InputRouterImplTest() override {}
 146
 147  protected:
 148   // testing::Test
 149   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   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 InputHostMsg_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 InputHostMsg_SelectRange_ACK(0));
 371     input_router_->OnMessageReceived(*response);
 372   }
 373   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 374 }
 375
 376 TEST_F(InputRouterImplTest, CoalescesMoveRangeSelectionExtent) {
 377   input_router_->SendInput(scoped_ptr<IPC::Message>(
 378       new InputMsg_MoveRangeSelectionExtent(0, gfx::Point(1, 2))));
 379   ExpectIPCMessageWithArg1<InputMsg_MoveRangeSelectionExtent>(
 380       process_->sink().GetMessageAt(0),
 381       gfx::Point(1, 2));
 382   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 383
 384   // Send two more messages without acking.
 385   input_router_->SendInput(scoped_ptr<IPC::Message>(
 386       new InputMsg_MoveRangeSelectionExtent(0, gfx::Point(3, 4))));
 387   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 388
 389   input_router_->SendInput(scoped_ptr<IPC::Message>(
 390       new InputMsg_MoveRangeSelectionExtent(0, gfx::Point(5, 6))));
 391   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 392
 393   // Now ack the first message.
 394   {
 395     scoped_ptr<IPC::Message> response(
 396         new InputHostMsg_MoveRangeSelectionExtent_ACK(0));
 397     input_router_->OnMessageReceived(*response);
 398   }
 399
 400   // Verify that the two messages are coalesced into one message.
 401   ExpectIPCMessageWithArg1<InputMsg_MoveRangeSelectionExtent>(
 402       process_->sink().GetMessageAt(0),
 403       gfx::Point(5, 6));
 404   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 405
 406   // Acking the coalesced msg should not send any more msg.
 407   {
 408     scoped_ptr<IPC::Message> response(
 409         new InputHostMsg_MoveRangeSelectionExtent_ACK(0));
 410     input_router_->OnMessageReceived(*response);
 411   }
 412   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 413 }
 414
 415 TEST_F(InputRouterImplTest, InterleaveSelectRangeAndMoveRangeSelectionExtent) {
 416   // Send first message: SelectRange.
 417   input_router_->SendInput(scoped_ptr<IPC::Message>(
 418       new InputMsg_SelectRange(0, gfx::Point(1, 2), gfx::Point(3, 4))));
 419   ExpectIPCMessageWithArg2<InputMsg_SelectRange>(
 420       process_->sink().GetMessageAt(0),
 421       gfx::Point(1, 2),
 422       gfx::Point(3, 4));
 423   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 424
 425   // Send second message: MoveRangeSelectionExtent.
 426   input_router_->SendInput(scoped_ptr<IPC::Message>(
 427       new InputMsg_MoveRangeSelectionExtent(0, gfx::Point(5, 6))));
 428   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 429
 430   // Send third message: SelectRange.
 431   input_router_->SendInput(scoped_ptr<IPC::Message>(
 432       new InputMsg_SelectRange(0, gfx::Point(7, 8), gfx::Point(9, 10))));
 433   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 434
 435   // Ack the messages and verify that they're not coalesced and that they're in
 436   // correct order.
 437
 438   // Ack the first message.
 439   {
 440     scoped_ptr<IPC::Message> response(
 441         new InputHostMsg_SelectRange_ACK(0));
 442     input_router_->OnMessageReceived(*response);
 443   }
 444
 445   ExpectIPCMessageWithArg1<InputMsg_MoveRangeSelectionExtent>(
 446       process_->sink().GetMessageAt(0),
 447       gfx::Point(5, 6));
 448   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 449
 450   // Ack the second message.
 451   {
 452     scoped_ptr<IPC::Message> response(
 453         new InputHostMsg_MoveRangeSelectionExtent_ACK(0));
 454     input_router_->OnMessageReceived(*response);
 455   }
 456
 457   ExpectIPCMessageWithArg2<InputMsg_SelectRange>(
 458       process_->sink().GetMessageAt(0),
 459       gfx::Point(7, 8),
 460       gfx::Point(9, 10));
 461   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 462
 463   // Ack the third message.
 464   {
 465     scoped_ptr<IPC::Message> response(
 466         new InputHostMsg_SelectRange_ACK(0));
 467     input_router_->OnMessageReceived(*response);
 468   }
 469   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 470 }
 471
 472 TEST_F(InputRouterImplTest,
 473        CoalescesInterleavedSelectRangeAndMoveRangeSelectionExtent) {
 474   // Send interleaved SelectRange and MoveRangeSelectionExtent messages. They
 475   // should be coalesced as shown by the arrows.
 476   //  > SelectRange
 477   //    MoveRangeSelectionExtent
 478   //    MoveRangeSelectionExtent
 479   //  > MoveRangeSelectionExtent
 480   //    SelectRange
 481   //  > SelectRange
 482   //  > MoveRangeSelectionExtent
 483
 484   input_router_->SendInput(scoped_ptr<IPC::Message>(
 485       new InputMsg_SelectRange(0, gfx::Point(1, 2), gfx::Point(3, 4))));
 486   ExpectIPCMessageWithArg2<InputMsg_SelectRange>(
 487       process_->sink().GetMessageAt(0),
 488       gfx::Point(1, 2),
 489       gfx::Point(3, 4));
 490   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 491
 492   input_router_->SendInput(scoped_ptr<IPC::Message>(
 493       new InputMsg_MoveRangeSelectionExtent(0, gfx::Point(5, 6))));
 494   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 495
 496   input_router_->SendInput(scoped_ptr<IPC::Message>(
 497       new InputMsg_MoveRangeSelectionExtent(0, gfx::Point(7, 8))));
 498   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 499
 500   input_router_->SendInput(scoped_ptr<IPC::Message>(
 501       new InputMsg_MoveRangeSelectionExtent(0, gfx::Point(9, 10))));
 502   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 503
 504   input_router_->SendInput(scoped_ptr<IPC::Message>(
 505       new InputMsg_SelectRange(0, gfx::Point(11, 12), gfx::Point(13, 14))));
 506   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 507
 508   input_router_->SendInput(scoped_ptr<IPC::Message>(
 509       new InputMsg_SelectRange(0, gfx::Point(15, 16), gfx::Point(17, 18))));
 510   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 511
 512   input_router_->SendInput(scoped_ptr<IPC::Message>(
 513       new InputMsg_MoveRangeSelectionExtent(0, gfx::Point(19, 20))));
 514   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 515
 516   // Ack the first message.
 517   {
 518     scoped_ptr<IPC::Message> response(
 519         new InputHostMsg_SelectRange_ACK(0));
 520     input_router_->OnMessageReceived(*response);
 521   }
 522
 523   // Verify that the three MoveRangeSelectionExtent messages are coalesced into
 524   // one message.
 525   ExpectIPCMessageWithArg1<InputMsg_MoveRangeSelectionExtent>(
 526       process_->sink().GetMessageAt(0),
 527       gfx::Point(9, 10));
 528   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 529
 530   // Ack the second message.
 531   {
 532     scoped_ptr<IPC::Message> response(
 533         new InputHostMsg_MoveRangeSelectionExtent_ACK(0));
 534     input_router_->OnMessageReceived(*response);
 535   }
 536
 537   // Verify that the two SelectRange messages are coalesced into one message.
 538   ExpectIPCMessageWithArg2<InputMsg_SelectRange>(
 539       process_->sink().GetMessageAt(0),
 540       gfx::Point(15, 16),
 541       gfx::Point(17, 18));
 542   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 543
 544   // Ack the third message.
 545   {
 546     scoped_ptr<IPC::Message> response(
 547         new InputHostMsg_SelectRange_ACK(0));
 548     input_router_->OnMessageReceived(*response);
 549   }
 550
 551   // Verify the fourth message.
 552   ExpectIPCMessageWithArg1<InputMsg_MoveRangeSelectionExtent>(
 553       process_->sink().GetMessageAt(0),
 554       gfx::Point(19, 20));
 555   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 556
 557   // Ack the fourth message.
 558   {
 559     scoped_ptr<IPC::Message> response(
 560         new InputHostMsg_MoveRangeSelectionExtent_ACK(0));
 561     input_router_->OnMessageReceived(*response);
 562   }
 563   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 564 }
 565
 566 TEST_F(InputRouterImplTest, CoalescesCaretMove) {
 567   input_router_->SendInput(
 568       scoped_ptr<IPC::Message>(new InputMsg_MoveCaret(0, gfx::Point(1, 2))));
 569   ExpectIPCMessageWithArg1<InputMsg_MoveCaret>(
 570       process_->sink().GetMessageAt(0), gfx::Point(1, 2));
 571   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 572
 573   // Send two more messages without acking.
 574   input_router_->SendInput(
 575       scoped_ptr<IPC::Message>(new InputMsg_MoveCaret(0, gfx::Point(5, 6))));
 576   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 577
 578   input_router_->SendInput(
 579       scoped_ptr<IPC::Message>(new InputMsg_MoveCaret(0, gfx::Point(9, 10))));
 580   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 581
 582   // Now ack the first message.
 583   {
 584     scoped_ptr<IPC::Message> response(new InputHostMsg_MoveCaret_ACK(0));
 585     input_router_->OnMessageReceived(*response);
 586   }
 587
 588   // Verify that the two messages are coalesced into one message.
 589   ExpectIPCMessageWithArg1<InputMsg_MoveCaret>(
 590       process_->sink().GetMessageAt(0), gfx::Point(9, 10));
 591   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 592
 593   // Acking the coalesced msg should not send any more msg.
 594   {
 595     scoped_ptr<IPC::Message> response(new InputHostMsg_MoveCaret_ACK(0));
 596     input_router_->OnMessageReceived(*response);
 597   }
 598   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 599 }
 600
 601 TEST_F(InputRouterImplTest, HandledInputEvent) {
 602   client_->set_filter_state(INPUT_EVENT_ACK_STATE_CONSUMED);
 603
 604   // Simulate a keyboard event.
 605   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 606
 607   // Make sure no input event is sent to the renderer.
 608   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 609
 610   // OnKeyboardEventAck should be triggered without actual ack.
 611   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 612
 613   // As the event was acked already, keyboard event queue should be
 614   // empty.
 615   ASSERT_EQ(NULL, input_router_->GetLastKeyboardEvent());
 616 }
 617
 618 TEST_F(InputRouterImplTest, ClientCanceledKeyboardEvent) {
 619   client_->set_filter_state(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 620
 621   // Simulate a keyboard event that has no consumer.
 622   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 623
 624   // Make sure no input event is sent to the renderer.
 625   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 626   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 627
 628
 629   // Simulate a keyboard event that should be dropped.
 630   client_->set_filter_state(INPUT_EVENT_ACK_STATE_UNKNOWN);
 631   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 632
 633   // Make sure no input event is sent to the renderer, and no ack is sent.
 634   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 635   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 636 }
 637
 638 TEST_F(InputRouterImplTest, ShortcutKeyboardEvent) {
 639   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, true);
 640   EXPECT_TRUE(GetIsShortcutFromHandleInputEventMessage(
 641       process_->sink().GetMessageAt(0)));
 642
 643   process_->sink().ClearMessages();
 644
 645   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 646   EXPECT_FALSE(GetIsShortcutFromHandleInputEventMessage(
 647       process_->sink().GetMessageAt(0)));
 648 }
 649
 650 TEST_F(InputRouterImplTest, NoncorrespondingKeyEvents) {
 651   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 652
 653   SendInputEventACK(WebInputEvent::KeyUp,
 654                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 655   EXPECT_TRUE(ack_handler_->unexpected_event_ack_called());
 656 }
 657
 658 // Tests ported from RenderWidgetHostTest --------------------------------------
 659
 660 TEST_F(InputRouterImplTest, HandleKeyEventsWeSent) {
 661   // Simulate a keyboard event.
 662   SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false);
 663   ASSERT_TRUE(input_router_->GetLastKeyboardEvent());
 664   EXPECT_EQ(WebInputEvent::RawKeyDown,
 665             input_router_->GetLastKeyboardEvent()->type);
 666
 667   // Make sure we sent the input event to the renderer.
 668   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 669                   InputMsg_HandleInputEvent::ID));
 670   process_->sink().ClearMessages();
 671
 672   // Send the simulated response from the renderer back.
 673   SendInputEventACK(WebInputEvent::RawKeyDown,
 674                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 675   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 676   EXPECT_EQ(WebInputEvent::RawKeyDown,
 677             ack_handler_->acked_keyboard_event().type);
 678 }
 679
 680 TEST_F(InputRouterImplTest, IgnoreKeyEventsWeDidntSend) {
 681   // Send a simulated, unrequested key response. We should ignore this.
 682   SendInputEventACK(WebInputEvent::RawKeyDown,
 683                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 684
 685   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 686 }
 687
 688 TEST_F(InputRouterImplTest, CoalescesWheelEvents) {
 689   // Simulate wheel events.
 690   SimulateWheelEvent(0, -5, 0, false);  // sent directly
 691   SimulateWheelEvent(0, -10, 0, false);  // enqueued
 692   SimulateWheelEvent(8, -6, 0, false);  // coalesced into previous event
 693   SimulateWheelEvent(9, -7, 1, false);  // enqueued, different modifiers
 694   SimulateWheelEvent(0, -10, 0, false);  // enqueued, different modifiers
 695   // Explicitly verify that PhaseEnd isn't coalesced to avoid bugs like
 696   // https://crbug.com/154740.
 697   SimulateWheelEventWithPhase(WebMouseWheelEvent::PhaseEnded);  // enqueued
 698
 699   // Check that only the first event was sent.
 700   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 701                   InputMsg_HandleInputEvent::ID));
 702   const WebInputEvent* input_event =
 703       GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
 704   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
 705   const WebMouseWheelEvent* wheel_event =
 706       static_cast<const WebMouseWheelEvent*>(input_event);
 707   EXPECT_EQ(0, wheel_event->deltaX);
 708   EXPECT_EQ(-5, wheel_event->deltaY);
 709   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 710
 711   // Check that the ACK sends the second message immediately.
 712   SendInputEventACK(WebInputEvent::MouseWheel,
 713                     INPUT_EVENT_ACK_STATE_CONSUMED);
 714   // The coalesced events can queue up a delayed ack
 715   // so that additional input events can be processed before
 716   // we turn off coalescing.
 717   base::MessageLoop::current()->RunUntilIdle();
 718   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 719   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 720           InputMsg_HandleInputEvent::ID));
 721   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
 722   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
 723   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
 724   EXPECT_EQ(8, wheel_event->deltaX);
 725   EXPECT_EQ(-10 + -6, wheel_event->deltaY);  // coalesced
 726   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 727
 728   // Ack the second event (which had the third coalesced into it).
 729   SendInputEventACK(WebInputEvent::MouseWheel,
 730                     INPUT_EVENT_ACK_STATE_CONSUMED);
 731   base::MessageLoop::current()->RunUntilIdle();
 732   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 733   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 734                   InputMsg_HandleInputEvent::ID));
 735   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
 736   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
 737   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
 738   EXPECT_EQ(9, wheel_event->deltaX);
 739   EXPECT_EQ(-7, wheel_event->deltaY);
 740   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 741
 742   // Ack the fourth event.
 743   SendInputEventACK(WebInputEvent::MouseWheel,
 744                     INPUT_EVENT_ACK_STATE_CONSUMED);
 745   base::MessageLoop::current()->RunUntilIdle();
 746   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 747   EXPECT_TRUE(
 748       process_->sink().GetUniqueMessageMatching(InputMsg_HandleInputEvent::ID));
 749   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
 750   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
 751   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
 752   EXPECT_EQ(0, wheel_event->deltaX);
 753   EXPECT_EQ(-10, wheel_event->deltaY);
 754   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 755
 756   // Ack the fifth event.
 757   SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED);
 758   base::MessageLoop::current()->RunUntilIdle();
 759   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 760   EXPECT_TRUE(
 761       process_->sink().GetUniqueMessageMatching(InputMsg_HandleInputEvent::ID));
 762   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
 763   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
 764   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
 765   EXPECT_EQ(0, wheel_event->deltaX);
 766   EXPECT_EQ(0, wheel_event->deltaY);
 767   EXPECT_EQ(WebMouseWheelEvent::PhaseEnded, wheel_event->phase);
 768   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 769
 770   // After the final ack, the queue should be empty.
 771   SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED);
 772   base::MessageLoop::current()->RunUntilIdle();
 773   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 774   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 775 }
 776
 777 // Tests that touch-events are queued properly.
 778 TEST_F(InputRouterImplTest, TouchEventQueue) {
 779   OnHasTouchEventHandlers(true);
 780
 781   PressTouchPoint(1, 1);
 782   SendTouchEvent();
 783   EXPECT_TRUE(client_->GetAndResetFilterEventCalled());
 784   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 785   EXPECT_FALSE(TouchEventQueueEmpty());
 786
 787   // The second touch should not be sent since one is already in queue.
 788   MoveTouchPoint(0, 5, 5);
 789   SendTouchEvent();
 790   EXPECT_FALSE(client_->GetAndResetFilterEventCalled());
 791   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 792   EXPECT_FALSE(TouchEventQueueEmpty());
 793
 794   // Receive an ACK for the first touch-event.
 795   SendInputEventACK(WebInputEvent::TouchStart,
 796                     INPUT_EVENT_ACK_STATE_CONSUMED);
 797   EXPECT_FALSE(TouchEventQueueEmpty());
 798   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 799   EXPECT_EQ(WebInputEvent::TouchStart,
 800             ack_handler_->acked_touch_event().event.type);
 801   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 802
 803   SendInputEventACK(WebInputEvent::TouchMove,
 804                     INPUT_EVENT_ACK_STATE_CONSUMED);
 805   EXPECT_TRUE(TouchEventQueueEmpty());
 806   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 807   EXPECT_EQ(WebInputEvent::TouchMove,
 808             ack_handler_->acked_touch_event().event.type);
 809   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 810 }
 811
 812 // Tests that the touch-queue is emptied after a page stops listening for touch
 813 // events and the outstanding ack is received.
 814 TEST_F(InputRouterImplTest, TouchEventQueueFlush) {
 815   OnHasTouchEventHandlers(true);
 816   EXPECT_TRUE(client_->has_touch_handler());
 817   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 818   EXPECT_TRUE(TouchEventQueueEmpty());
 819
 820   EXPECT_TRUE(input_router_->ShouldForwardTouchEvent());
 821
 822   // Send a touch-press event.
 823   PressTouchPoint(1, 1);
 824   SendTouchEvent();
 825   MoveTouchPoint(0, 2, 2);
 826   MoveTouchPoint(0, 3, 3);
 827   EXPECT_FALSE(TouchEventQueueEmpty());
 828   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 829
 830   // The page stops listening for touch-events. Note that flushing is deferred
 831   // until the outstanding ack is received.
 832   OnHasTouchEventHandlers(false);
 833   EXPECT_FALSE(client_->has_touch_handler());
 834   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 835   EXPECT_FALSE(TouchEventQueueEmpty());
 836   EXPECT_TRUE(input_router_->ShouldForwardTouchEvent());
 837
 838   // After the ack, the touch-event queue should be empty, and none of the
 839   // flushed touch-events should have been sent to the renderer.
 840   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
 841   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 842   EXPECT_TRUE(TouchEventQueueEmpty());
 843   EXPECT_FALSE(input_router_->ShouldForwardTouchEvent());
 844 }
 845
 846 #if defined(USE_AURA)
 847 // Tests that the acked events have correct state. (ui::Events are used only on
 848 // windows and aura)
 849 TEST_F(InputRouterImplTest, AckedTouchEventState) {
 850   input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
 851   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 852   EXPECT_TRUE(TouchEventQueueEmpty());
 853   EXPECT_TRUE(input_router_->ShouldForwardTouchEvent());
 854
 855   // Send a bunch of events, and make sure the ACKed events are correct.
 856   ScopedVector<ui::TouchEvent> expected_events;
 857
 858   // Use a custom timestamp for all the events to test that the acked events
 859   // have the same timestamp;
 860   base::TimeDelta timestamp = base::Time::NowFromSystemTime() - base::Time();
 861   timestamp -= base::TimeDelta::FromSeconds(600);
 862
 863   // Press the first finger.
 864   PressTouchPoint(1, 1);
 865   SetTouchTimestamp(timestamp);
 866   SendTouchEvent();
 867   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 868   expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
 869       gfx::Point(1, 1), 0, timestamp));
 870
 871   // Move the finger.
 872   timestamp += base::TimeDelta::FromSeconds(10);
 873   MoveTouchPoint(0, 500, 500);
 874   SetTouchTimestamp(timestamp);
 875   SendTouchEvent();
 876   EXPECT_FALSE(TouchEventQueueEmpty());
 877   expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED,
 878       gfx::Point(500, 500), 0, timestamp));
 879
 880   // Now press a second finger.
 881   timestamp += base::TimeDelta::FromSeconds(10);
 882   PressTouchPoint(2, 2);
 883   SetTouchTimestamp(timestamp);
 884   SendTouchEvent();
 885   EXPECT_FALSE(TouchEventQueueEmpty());
 886   expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
 887       gfx::Point(2, 2), 1, timestamp));
 888
 889   // Move both fingers.
 890   timestamp += base::TimeDelta::FromSeconds(10);
 891   MoveTouchPoint(0, 10, 10);
 892   MoveTouchPoint(1, 20, 20);
 893   SetTouchTimestamp(timestamp);
 894   SendTouchEvent();
 895   EXPECT_FALSE(TouchEventQueueEmpty());
 896   expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED,
 897       gfx::Point(10, 10), 0, timestamp));
 898   expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED,
 899       gfx::Point(20, 20), 1, timestamp));
 900
 901   // Receive the ACKs and make sure the generated events from the acked events
 902   // are correct.
 903   WebInputEvent::Type acks[] = { WebInputEvent::TouchStart,
 904                                  WebInputEvent::TouchMove,
 905                                  WebInputEvent::TouchStart,
 906                                  WebInputEvent::TouchMove };
 907
 908   TouchEventCoordinateSystem coordinate_system = LOCAL_COORDINATES;
 909 #if !defined(OS_WIN)
 910   coordinate_system = SCREEN_COORDINATES;
 911 #endif
 912   for (size_t i = 0; i < arraysize(acks); ++i) {
 913     SendInputEventACK(acks[i],
 914                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 915     EXPECT_EQ(acks[i], ack_handler_->acked_touch_event().event.type);
 916     ScopedVector<ui::TouchEvent> acked;
 917
 918     MakeUITouchEventsFromWebTouchEvents(
 919         ack_handler_->acked_touch_event(), &acked, coordinate_system);
 920     bool success = EventListIsSubset(acked, expected_events);
 921     EXPECT_TRUE(success) << "Failed on step: " << i;
 922     if (!success)
 923       break;
 924     expected_events.erase(expected_events.begin(),
 925                           expected_events.begin() + acked.size());
 926   }
 927
 928   EXPECT_TRUE(TouchEventQueueEmpty());
 929   EXPECT_EQ(0U, expected_events.size());
 930 }
 931 #endif  // defined(USE_AURA)
 932
 933 TEST_F(InputRouterImplTest, UnhandledWheelEvent) {
 934   // Simulate wheel events.
 935   SimulateWheelEvent(0, -5, 0, false);  // sent directly
 936   SimulateWheelEvent(0, -10, 0, false);  // enqueued
 937
 938   // Check that only the first event was sent.
 939   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 940                   InputMsg_HandleInputEvent::ID));
 941   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 942
 943   // Indicate that the wheel event was unhandled.
 944   SendInputEventACK(WebInputEvent::MouseWheel,
 945                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 946
 947   // Check that the correct unhandled wheel event was received.
 948   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 949   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_handler_->ack_state());
 950   EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -5);
 951
 952   // Check that the second event was sent.
 953   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
 954                   InputMsg_HandleInputEvent::ID));
 955   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 956
 957   // Check that the correct unhandled wheel event was received.
 958   EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -5);
 959 }
 960
 961 TEST_F(InputRouterImplTest, TouchTypesIgnoringAck) {
 962   OnHasTouchEventHandlers(true);
 963   // Only acks for TouchCancel should always be ignored.
 964   ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
 965       GetEventWithType(WebInputEvent::TouchStart)));
 966   ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
 967       GetEventWithType(WebInputEvent::TouchMove)));
 968   ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
 969       GetEventWithType(WebInputEvent::TouchEnd)));
 970
 971   // Precede the TouchCancel with an appropriate TouchStart;
 972   PressTouchPoint(1, 1);
 973   SendTouchEvent();
 974   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
 975   ASSERT_EQ(1U, GetSentMessageCountAndResetSink());
 976   ASSERT_EQ(1U, ack_handler_->GetAndResetAckCount());
 977   ASSERT_EQ(0, client_->in_flight_event_count());
 978
 979   // The TouchCancel ack is always ignored.
 980   CancelTouchPoint(0);
 981   SendTouchEvent();
 982   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 983   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 984   EXPECT_EQ(0, client_->in_flight_event_count());
 985   EXPECT_FALSE(HasPendingEvents());
 986   SendInputEventACK(WebInputEvent::TouchCancel,
 987                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 988   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 989   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 990   EXPECT_FALSE(HasPendingEvents());
 991 }
 992
 993 TEST_F(InputRouterImplTest, GestureTypesIgnoringAck) {
 994   // We test every gesture type, ensuring that the stream of gestures is valid.
 995   const int kEventTypesLength = 29;
 996   WebInputEvent::Type eventTypes[kEventTypesLength] = {
 997       WebInputEvent::GestureTapDown,
 998       WebInputEvent::GestureShowPress,
 999       WebInputEvent::GestureTapCancel,
1000       WebInputEvent::GestureScrollBegin,
1001       WebInputEvent::GestureFlingStart,
1002       WebInputEvent::GestureFlingCancel,
1003       WebInputEvent::GestureTapDown,
1004       WebInputEvent::GestureTap,
1005       WebInputEvent::GestureTapDown,
1006       WebInputEvent::GestureLongPress,
1007       WebInputEvent::GestureTapCancel,
1008       WebInputEvent::GestureLongTap,
1009       WebInputEvent::GestureTapDown,
1010       WebInputEvent::GestureTapUnconfirmed,
1011       WebInputEvent::GestureTapCancel,
1012       WebInputEvent::GestureTapDown,
1013       WebInputEvent::GestureDoubleTap,
1014       WebInputEvent::GestureTapDown,
1015       WebInputEvent::GestureTapCancel,
1016       WebInputEvent::GestureTwoFingerTap,
1017       WebInputEvent::GestureTapDown,
1018       WebInputEvent::GestureTapCancel,
1019       WebInputEvent::GestureScrollBegin,
1020       WebInputEvent::GestureScrollUpdate,
1021       WebInputEvent::GestureScrollUpdateWithoutPropagation,
1022       WebInputEvent::GesturePinchBegin,
1023       WebInputEvent::GesturePinchUpdate,
1024       WebInputEvent::GesturePinchEnd,
1025       WebInputEvent::GestureScrollEnd};
1026   for (int i = 0; i < kEventTypesLength; ++i) {
1027     WebInputEvent::Type type = eventTypes[i];
1028     if (!WebInputEventTraits::IgnoresAckDisposition(GetEventWithType(type))) {
1029       SimulateGestureEvent(type, blink::WebGestureDeviceTouchscreen);
1030       EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1031       EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1032       EXPECT_EQ(1, client_->in_flight_event_count());
1033       EXPECT_TRUE(HasPendingEvents());
1034
1035       SendInputEventACK(type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1036       EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1037       EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1038       EXPECT_EQ(0, client_->in_flight_event_count());
1039       EXPECT_FALSE(HasPendingEvents());
1040       continue;
1041     }
1042
1043     SimulateGestureEvent(type, blink::WebGestureDeviceTouchscreen);
1044     EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1045     EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1046     EXPECT_EQ(0, client_->in_flight_event_count());
1047     EXPECT_FALSE(HasPendingEvents());
1048   }
1049 }
1050
1051 TEST_F(InputRouterImplTest, MouseTypesIgnoringAck) {
1052   int start_type = static_cast<int>(WebInputEvent::MouseDown);
1053   int end_type = static_cast<int>(WebInputEvent::ContextMenu);
1054   ASSERT_LT(start_type, end_type);
1055   for (int i = start_type; i <= end_type; ++i) {
1056     WebInputEvent::Type type = static_cast<WebInputEvent::Type>(i);
1057     int expected_in_flight_event_count =
1058         WebInputEventTraits::IgnoresAckDisposition(GetEventWithType(type)) ? 0
1059                                                                            : 1;
1060
1061     // Note: Mouse event acks are never forwarded to the ack handler, so the key
1062     // result here is that ignored ack types don't affect the in-flight count.
1063     SimulateMouseEvent(type, 0, 0);
1064     EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1065     EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1066     EXPECT_EQ(expected_in_flight_event_count, client_->in_flight_event_count());
1067     if (expected_in_flight_event_count) {
1068       SendInputEventACK(type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1069       EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1070       EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1071       EXPECT_EQ(0, client_->in_flight_event_count());
1072     }
1073   }
1074 }
1075
1076 // Guard against breaking changes to the list of ignored event ack types in
1077 // |WebInputEventTraits::IgnoresAckDisposition|.
1078 TEST_F(InputRouterImplTest, RequiredEventAckTypes) {
1079   const WebInputEvent::Type kRequiredEventAckTypes[] = {
1080     WebInputEvent::MouseMove,
1081     WebInputEvent::MouseWheel,
1082     WebInputEvent::RawKeyDown,
1083     WebInputEvent::KeyDown,
1084     WebInputEvent::KeyUp,
1085     WebInputEvent::Char,
1086     WebInputEvent::GestureScrollUpdate,
1087     WebInputEvent::GestureFlingStart,
1088     WebInputEvent::GestureFlingCancel,
1089     WebInputEvent::GesturePinchUpdate,
1090     WebInputEvent::TouchStart,
1091     WebInputEvent::TouchMove
1092   };
1093   for (size_t i = 0; i < arraysize(kRequiredEventAckTypes); ++i) {
1094     const WebInputEvent::Type required_ack_type = kRequiredEventAckTypes[i];
1095     EXPECT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
1096         GetEventWithType(required_ack_type)));
1097   }
1098 }
1099
1100 // Test that GestureShowPress, GestureTapDown and GestureTapCancel events don't
1101 // wait for ACKs.
1102 TEST_F(InputRouterImplTest, GestureTypesIgnoringAckInterleaved) {
1103   // Interleave a few events that do and do not ignore acks, ensuring that
1104   // ack-ignoring events aren't dispatched until all prior events which observe
1105   // their ack disposition have been dispatched.
1106
1107   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1108                        blink::WebGestureDeviceTouchscreen);
1109   ASSERT_EQ(1U, GetSentMessageCountAndResetSink());
1110   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1111   EXPECT_EQ(0, client_->in_flight_event_count());
1112
1113   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1114                        blink::WebGestureDeviceTouchscreen);
1115   ASSERT_EQ(1U, GetSentMessageCountAndResetSink());
1116   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1117   EXPECT_EQ(1, client_->in_flight_event_count());
1118
1119   SimulateGestureEvent(WebInputEvent::GestureTapDown,
1120                        blink::WebGestureDeviceTouchscreen);
1121   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1122   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1123   EXPECT_EQ(1, client_->in_flight_event_count());
1124
1125   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1126                        blink::WebGestureDeviceTouchscreen);
1127   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1128   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1129
1130   SimulateGestureEvent(WebInputEvent::GestureShowPress,
1131                        blink::WebGestureDeviceTouchscreen);
1132   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1133   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1134
1135   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1136                        blink::WebGestureDeviceTouchscreen);
1137   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1138   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1139
1140   SimulateGestureEvent(WebInputEvent::GestureTapCancel,
1141                        blink::WebGestureDeviceTouchscreen);
1142   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1143   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1144
1145   // Now ack each ack-respecting event. Ack-ignoring events should not be
1146   // dispatched until all prior events which observe ack disposition have been
1147   // fired, at which point they should be sent immediately.  They should also
1148   // have no effect on the in-flight event count.
1149   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
1150                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1151   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
1152   EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
1153   EXPECT_EQ(1, client_->in_flight_event_count());
1154
1155   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
1156                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1157   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
1158   EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
1159   EXPECT_EQ(1, client_->in_flight_event_count());
1160
1161   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
1162                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1163   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1164   EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
1165   EXPECT_EQ(0, client_->in_flight_event_count());
1166 }
1167
1168 // Test that GestureShowPress events don't get out of order due to
1169 // ignoring their acks.
1170 TEST_F(InputRouterImplTest, GestureShowPressIsInOrder) {
1171   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1172                        blink::WebGestureDeviceTouchscreen);
1173   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1174   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1175
1176
1177   // GesturePinchBegin ignores its ack.
1178   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
1179                        blink::WebGestureDeviceTouchscreen);
1180   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1181   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1182
1183   // GesturePinchUpdate waits for an ack.
1184   // This also verifies that GesturePinchUpdates for touchscreen are sent
1185   // to the renderer (in contrast to the TrackpadPinchUpdate test).
1186   SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
1187                        blink::WebGestureDeviceTouchscreen);
1188   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1189   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1190
1191   SimulateGestureEvent(WebInputEvent::GestureShowPress,
1192                        blink::WebGestureDeviceTouchscreen);
1193   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1194   // The ShowPress, though it ignores ack, is still stuck in the queue
1195   // behind the PinchUpdate which requires an ack.
1196   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1197
1198   SimulateGestureEvent(WebInputEvent::GestureShowPress,
1199                        blink::WebGestureDeviceTouchscreen);
1200   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1201   // ShowPress has entered the queue.
1202   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1203
1204   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
1205                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1206   // Now that the Tap has been ACKed, the ShowPress events should receive
1207   // synthetic acks, and fire immediately.
1208   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
1209   EXPECT_EQ(3U, ack_handler_->GetAndResetAckCount());
1210 }
1211
1212 // Test that touch ack timeout behavior is properly toggled by view update flags
1213 // and allowed touch actions.
1214 TEST_F(InputRouterImplTest, TouchAckTimeoutConfigured) {
1215   const int timeout_ms = 1;
1216   SetUpForTouchAckTimeoutTest(timeout_ms);
1217   ASSERT_TRUE(TouchEventTimeoutEnabled());
1218
1219   // Verify that the touch ack timeout fires upon the delayed ack.
1220   PressTouchPoint(1, 1);
1221   SendTouchEvent();
1222   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1223   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1224   RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1));
1225
1226   // The timed-out event should have been ack'ed.
1227   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1228   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1229
1230   // Ack'ing the timed-out event should fire a TouchCancel.
1231   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1232   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1233   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1234
1235   // The remainder of the touch sequence should be dropped.
1236   ReleaseTouchPoint(0);
1237   SendTouchEvent();
1238   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1239   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1240   ASSERT_TRUE(TouchEventTimeoutEnabled());
1241
1242   // A fixed page scale or mobile viewport should disable the touch timeout.
1243   input_router()->OnViewUpdated(InputRouter::FIXED_PAGE_SCALE);
1244   EXPECT_FALSE(TouchEventTimeoutEnabled());
1245
1246   input_router()->OnViewUpdated(InputRouter::VIEW_FLAGS_NONE);
1247   EXPECT_TRUE(TouchEventTimeoutEnabled());
1248
1249   input_router()->OnViewUpdated(InputRouter::MOBILE_VIEWPORT);
1250   EXPECT_FALSE(TouchEventTimeoutEnabled());
1251
1252   input_router()->OnViewUpdated(InputRouter::MOBILE_VIEWPORT |
1253                                 InputRouter::FIXED_PAGE_SCALE);
1254   EXPECT_FALSE(TouchEventTimeoutEnabled());
1255
1256   input_router()->OnViewUpdated(InputRouter::VIEW_FLAGS_NONE);
1257   EXPECT_TRUE(TouchEventTimeoutEnabled());
1258
1259   // TOUCH_ACTION_NONE (and no other touch-action) should disable the timeout.
1260   OnHasTouchEventHandlers(true);
1261   PressTouchPoint(1, 1);
1262   SendTouchEvent();
1263   OnSetTouchAction(TOUCH_ACTION_PAN_Y);
1264   EXPECT_TRUE(TouchEventTimeoutEnabled());
1265   ReleaseTouchPoint(0);
1266   SendTouchEvent();
1267   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1268   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1269
1270   PressTouchPoint(1, 1);
1271   SendTouchEvent();
1272   OnSetTouchAction(TOUCH_ACTION_NONE);
1273   EXPECT_FALSE(TouchEventTimeoutEnabled());
1274   ReleaseTouchPoint(0);
1275   SendTouchEvent();
1276   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1277   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1278
1279   // As the touch-action is reset by a new touch sequence, the timeout behavior
1280   // should be restored.
1281   PressTouchPoint(1, 1);
1282   SendTouchEvent();
1283   EXPECT_TRUE(TouchEventTimeoutEnabled());
1284 }
1285
1286 // Test that a touch sequenced preceded by TOUCH_ACTION_NONE is not affected by
1287 // the touch timeout.
1288 TEST_F(InputRouterImplTest,
1289        TouchAckTimeoutDisabledForTouchSequenceAfterTouchActionNone) {
1290   const int timeout_ms = 1;
1291   SetUpForTouchAckTimeoutTest(timeout_ms);
1292   ASSERT_TRUE(TouchEventTimeoutEnabled());
1293   OnHasTouchEventHandlers(true);
1294
1295   // Start a touch sequence.
1296   PressTouchPoint(1, 1);
1297   SendTouchEvent();
1298   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1299
1300   // TOUCH_ACTION_NONE should disable the timeout.
1301   OnSetTouchAction(TOUCH_ACTION_NONE);
1302   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1303   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1304   EXPECT_FALSE(TouchEventTimeoutEnabled());
1305
1306   MoveTouchPoint(0, 1, 1);
1307   SendTouchEvent();
1308   EXPECT_FALSE(TouchEventTimeoutEnabled());
1309   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1310
1311   // Delay the move ack. The timeout should not fire.
1312   RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1));
1313   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1314   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1315   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1316   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1317
1318   // End the touch sequence.
1319   ReleaseTouchPoint(0);
1320   SendTouchEvent();
1321   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1322   EXPECT_FALSE(TouchEventTimeoutEnabled());
1323   ack_handler_->GetAndResetAckCount();
1324   GetSentMessageCountAndResetSink();
1325
1326   // Start another touch sequence.  This should restore the touch timeout.
1327   PressTouchPoint(1, 1);
1328   SendTouchEvent();
1329   EXPECT_TRUE(TouchEventTimeoutEnabled());
1330   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1331   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1332
1333   // Wait for the touch ack timeout to fire.
1334   RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1));
1335   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1336 }
1337
1338 // Test that TouchActionFilter::ResetTouchAction is called before the
1339 // first touch event for a touch sequence reaches the renderer.
1340 TEST_F(InputRouterImplTest, TouchActionResetBeforeEventReachesRenderer) {
1341   OnHasTouchEventHandlers(true);
1342
1343   // Sequence 1.
1344   PressTouchPoint(1, 1);
1345   SendTouchEvent();
1346   OnSetTouchAction(TOUCH_ACTION_NONE);
1347   MoveTouchPoint(0, 50, 50);
1348   SendTouchEvent();
1349   ReleaseTouchPoint(0);
1350   SendTouchEvent();
1351
1352   // Sequence 2.
1353   PressTouchPoint(1, 1);
1354   SendTouchEvent();
1355   MoveTouchPoint(0, 50, 50);
1356   SendTouchEvent();
1357   ReleaseTouchPoint(0);
1358   SendTouchEvent();
1359
1360   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1361   SendInputEventACK(WebInputEvent::TouchMove, INPUT_EVENT_ACK_STATE_CONSUMED);
1362
1363   // Ensure touch action is still none, as the next touch start hasn't been
1364   // acked yet. ScrollBegin and ScrollEnd don't require acks.
1365   EXPECT_EQ(3U, GetSentMessageCountAndResetSink());
1366   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1367                        blink::WebGestureDeviceTouchscreen);
1368   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1369   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1370                        blink::WebGestureDeviceTouchscreen);
1371   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1372
1373   // This allows the next touch sequence to start.
1374   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1375
1376   // Ensure touch action has been set to auto, as a new touch sequence has
1377   // started.
1378   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1379   SendInputEventACK(WebInputEvent::TouchMove, INPUT_EVENT_ACK_STATE_CONSUMED);
1380   EXPECT_EQ(3U, GetSentMessageCountAndResetSink());
1381   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1382                        blink::WebGestureDeviceTouchscreen);
1383   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1384   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1385                        blink::WebGestureDeviceTouchscreen);
1386   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1387   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1388 }
1389
1390 // Test that TouchActionFilter::ResetTouchAction is called when a new touch
1391 // sequence has no consumer.
1392 TEST_F(InputRouterImplTest, TouchActionResetWhenTouchHasNoConsumer) {
1393   OnHasTouchEventHandlers(true);
1394
1395   // Sequence 1.
1396   PressTouchPoint(1, 1);
1397   SendTouchEvent();
1398   MoveTouchPoint(0, 50, 50);
1399   SendTouchEvent();
1400   OnSetTouchAction(TOUCH_ACTION_NONE);
1401   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1402   SendInputEventACK(WebInputEvent::TouchMove, INPUT_EVENT_ACK_STATE_CONSUMED);
1403
1404   ReleaseTouchPoint(0);
1405   SendTouchEvent();
1406
1407   // Sequence 2
1408   PressTouchPoint(1, 1);
1409   SendTouchEvent();
1410   MoveTouchPoint(0, 50, 50);
1411   SendTouchEvent();
1412   ReleaseTouchPoint(0);
1413   SendTouchEvent();
1414
1415   // Ensure we have touch-action:none. ScrollBegin and ScrollEnd don't require
1416   // acks.
1417   EXPECT_EQ(3U, GetSentMessageCountAndResetSink());
1418   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1419                        blink::WebGestureDeviceTouchscreen);
1420   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1421   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1422                        blink::WebGestureDeviceTouchscreen);
1423   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1424
1425   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1426   SendInputEventACK(WebInputEvent::TouchStart,
1427                     INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1428
1429   // Ensure touch action has been set to auto, as the touch had no consumer.
1430   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1431   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1432                        blink::WebGestureDeviceTouchscreen);
1433   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1434   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1435                        blink::WebGestureDeviceTouchscreen);
1436   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1437 }
1438
1439 // Test that TouchActionFilter::ResetTouchAction is called when the touch
1440 // handler is removed.
1441 TEST_F(InputRouterImplTest, TouchActionResetWhenTouchHandlerRemoved) {
1442   // Touch sequence with touch handler.
1443   OnHasTouchEventHandlers(true);
1444   PressTouchPoint(1, 1);
1445   SendTouchEvent();
1446   MoveTouchPoint(0, 50, 50);
1447   SendTouchEvent();
1448   OnSetTouchAction(TOUCH_ACTION_NONE);
1449   ReleaseTouchPoint(0);
1450   SendTouchEvent();
1451   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1452
1453   // Ensure we have touch-action:none, suppressing scroll events.
1454   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1455   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1456   SendInputEventACK(WebInputEvent::TouchMove,
1457                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1458   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1459   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1460                        blink::WebGestureDeviceTouchscreen);
1461   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1462
1463   SendInputEventACK(WebInputEvent::TouchEnd,
1464                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1465   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1466                        blink::WebGestureDeviceTouchscreen);
1467   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1468
1469   // Sequence without a touch handler. Note that in this case, the view may not
1470   // necessarily forward touches to the router (as no touch handler exists).
1471   OnHasTouchEventHandlers(false);
1472
1473   // Ensure touch action has been set to auto, as the touch handler has been
1474   // removed.
1475   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1476                        blink::WebGestureDeviceTouchscreen);
1477   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1478   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1479                        blink::WebGestureDeviceTouchscreen);
1480   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1481 }
1482
1483 // Test that the double tap gesture depends on the touch action of the first
1484 // tap.
1485 TEST_F(InputRouterImplTest, DoubleTapGestureDependsOnFirstTap) {
1486   OnHasTouchEventHandlers(true);
1487
1488   // Sequence 1.
1489   PressTouchPoint(1, 1);
1490   SendTouchEvent();
1491   OnSetTouchAction(TOUCH_ACTION_NONE);
1492   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
1493
1494   ReleaseTouchPoint(0);
1495   SendTouchEvent();
1496
1497   // Sequence 2
1498   PressTouchPoint(1, 1);
1499   SendTouchEvent();
1500
1501   // First tap.
1502   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
1503   SimulateGestureEvent(WebInputEvent::GestureTapDown,
1504                        blink::WebGestureDeviceTouchscreen);
1505   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1506
1507   // The GestureTapUnconfirmed is converted into a tap, as the touch action is
1508   // none.
1509   SimulateGestureEvent(WebInputEvent::GestureTapUnconfirmed,
1510                        blink::WebGestureDeviceTouchscreen);
1511   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1512   // This test will become invalid if GestureTap stops requiring an ack.
1513   ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
1514       GetEventWithType(WebInputEvent::GestureTap)));
1515   EXPECT_EQ(2, client_->in_flight_event_count());
1516   SendInputEventACK(WebInputEvent::GestureTap,
1517                     INPUT_EVENT_ACK_STATE_CONSUMED);
1518   EXPECT_EQ(1, client_->in_flight_event_count());
1519
1520   // This tap gesture is dropped, since the GestureTapUnconfirmed was turned
1521   // into a tap.
1522   SimulateGestureEvent(WebInputEvent::GestureTap,
1523                        blink::WebGestureDeviceTouchscreen);
1524   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1525
1526   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
1527   SendInputEventACK(WebInputEvent::TouchStart,
1528                     INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1529
1530   // Second Tap.
1531   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1532   SimulateGestureEvent(WebInputEvent::GestureTapDown,
1533                        blink::WebGestureDeviceTouchscreen);
1534   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1535
1536   // Although the touch-action is now auto, the double tap still won't be
1537   // dispatched, because the first tap occured when the touch-action was none.
1538   SimulateGestureEvent(WebInputEvent::GestureDoubleTap,
1539                        blink::WebGestureDeviceTouchscreen);
1540   // This test will become invalid if GestureDoubleTap stops requiring an ack.
1541   ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
1542       GetEventWithType(WebInputEvent::GestureDoubleTap)));
1543   EXPECT_EQ(1, client_->in_flight_event_count());
1544   SendInputEventACK(WebInputEvent::GestureTap, INPUT_EVENT_ACK_STATE_CONSUMED);
1545   EXPECT_EQ(0, client_->in_flight_event_count());
1546 }
1547
1548 // Test that the router will call the client's |DidFlush| after all events have
1549 // been dispatched following a call to |Flush|.
1550 TEST_F(InputRouterImplTest, InputFlush) {
1551   EXPECT_FALSE(HasPendingEvents());
1552
1553   // Flushing an empty router should immediately trigger DidFlush.
1554   Flush();
1555   EXPECT_EQ(1U, GetAndResetDidFlushCount());
1556   EXPECT_FALSE(HasPendingEvents());
1557
1558   // Queue a TouchStart.
1559   OnHasTouchEventHandlers(true);
1560   PressTouchPoint(1, 1);
1561   SendTouchEvent();
1562   EXPECT_TRUE(HasPendingEvents());
1563
1564   // DidFlush should be called only after the event is ack'ed.
1565   Flush();
1566   EXPECT_EQ(0U, GetAndResetDidFlushCount());
1567   SendInputEventACK(WebInputEvent::TouchStart,
1568                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1569   EXPECT_EQ(1U, GetAndResetDidFlushCount());
1570
1571   // Ensure different types of enqueued events will prevent the DidFlush call
1572   // until all such events have been fully dispatched.
1573   MoveTouchPoint(0, 50, 50);
1574   SendTouchEvent();
1575   ASSERT_TRUE(HasPendingEvents());
1576   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
1577                        blink::WebGestureDeviceTouchscreen);
1578   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1579                        blink::WebGestureDeviceTouchscreen);
1580   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
1581                        blink::WebGestureDeviceTouchscreen);
1582   SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
1583                        blink::WebGestureDeviceTouchscreen);
1584   Flush();
1585   EXPECT_EQ(0U, GetAndResetDidFlushCount());
1586
1587   // Repeated flush calls should have no effect.
1588   Flush();
1589   EXPECT_EQ(0U, GetAndResetDidFlushCount());
1590
1591   // There are still pending gestures.
1592   SendInputEventACK(WebInputEvent::TouchMove,
1593                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1594   EXPECT_EQ(0U, GetAndResetDidFlushCount());
1595   EXPECT_TRUE(HasPendingEvents());
1596
1597   // One more gesture to go.
1598   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
1599                     INPUT_EVENT_ACK_STATE_CONSUMED);
1600   EXPECT_EQ(0U, GetAndResetDidFlushCount());
1601   EXPECT_TRUE(HasPendingEvents());
1602
1603   // The final ack'ed gesture should trigger the DidFlush.
1604   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
1605                     INPUT_EVENT_ACK_STATE_CONSUMED);
1606   EXPECT_EQ(1U, GetAndResetDidFlushCount());
1607   EXPECT_FALSE(HasPendingEvents());
1608 }
1609
1610 // Test that GesturePinchUpdate is handled specially for trackpad
1611 TEST_F(InputRouterImplTest, TouchpadPinchUpdate) {
1612   // GesturePinchUpdate for trackpad sends synthetic wheel events.
1613   // Note that the Touchscreen case is verified as NOT doing this as
1614   // part of the ShowPressIsInOrder test.
1615
1616   SimulateGesturePinchUpdateEvent(
1617       1.5f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1618
1619   // Verify we actually sent a special wheel event to the renderer.
1620   const WebInputEvent* input_event =
1621       GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1622   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1623   const WebMouseWheelEvent* wheel_event =
1624       static_cast<const WebMouseWheelEvent*>(input_event);
1625   EXPECT_EQ(20, wheel_event->x);
1626   EXPECT_EQ(25, wheel_event->y);
1627   EXPECT_EQ(20, wheel_event->globalX);
1628   EXPECT_EQ(25, wheel_event->globalY);
1629   EXPECT_EQ(20, wheel_event->windowX);
1630   EXPECT_EQ(25, wheel_event->windowY);
1631   EXPECT_EQ(PinchScaleToWheelDelta(1.5), wheel_event->deltaY);
1632   EXPECT_EQ(0, wheel_event->deltaX);
1633   EXPECT_EQ(1, wheel_event->hasPreciseScrollingDeltas);
1634   EXPECT_EQ(1, wheel_event->wheelTicksY);
1635   EXPECT_EQ(0, wheel_event->wheelTicksX);
1636   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1637
1638   // Indicate that the wheel event was unhandled.
1639   SendInputEventACK(WebInputEvent::MouseWheel,
1640                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1641
1642   // Check that the correct unhandled pinch event was received.
1643   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1644   ASSERT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1645   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_handler_->ack_state());
1646   EXPECT_EQ(1.5f, ack_handler_->acked_gesture_event().data.pinchUpdate.scale);
1647   EXPECT_EQ(0, client_->in_flight_event_count());
1648
1649   // Second a second pinch event.
1650   SimulateGesturePinchUpdateEvent(
1651       0.3f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1652   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1653   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1654   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
1655   EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(0.3f), wheel_event->deltaY);
1656   EXPECT_EQ(1, wheel_event->hasPreciseScrollingDeltas);
1657   EXPECT_EQ(-1, wheel_event->wheelTicksY);
1658   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1659
1660   // Indicate that the wheel event was handled this time.
1661   SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED);
1662
1663   // Check that the correct HANDLED pinch event was received.
1664   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1665   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1666   EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, ack_handler_->ack_state());
1667   EXPECT_FLOAT_EQ(0.3f,
1668                   ack_handler_->acked_gesture_event().data.pinchUpdate.scale);
1669 }
1670
1671 // Test that touchpad pinch events are coalesced property, with their synthetic
1672 // wheel events getting the right ACKs.
1673 TEST_F(InputRouterImplTest, TouchpadPinchCoalescing) {
1674   // Send the first pinch.
1675   SimulateGesturePinchUpdateEvent(
1676       1.5f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1677
1678   // Verify we sent the wheel event to the renderer.
1679   const WebInputEvent* input_event =
1680       GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1681   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1682   const WebMouseWheelEvent* wheel_event =
1683       static_cast<const WebMouseWheelEvent*>(input_event);
1684   EXPECT_EQ(PinchScaleToWheelDelta(1.5f), wheel_event->deltaY);
1685   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1686   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1687   EXPECT_EQ(1, client_->in_flight_event_count());
1688
1689   // Send a second pinch, this should be queued in the GestureEventQueue.
1690   SimulateGesturePinchUpdateEvent(
1691       1.6f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1692   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1693   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1694
1695   // Send a third pinch, this should be coalesced into the second in the
1696   // GestureEventQueue.
1697   SimulateGesturePinchUpdateEvent(
1698       1.7f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1699   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1700   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1701
1702   // Indicate that the first wheel event was unhandled and verify the ACK.
1703   SendInputEventACK(WebInputEvent::MouseWheel,
1704                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1705   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1706   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1707   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_handler_->ack_state());
1708   EXPECT_EQ(1.5f, ack_handler_->acked_gesture_event().data.pinchUpdate.scale);
1709
1710   // Verify a second wheel event was sent representing the 2nd and 3rd pinch
1711   // events.
1712   EXPECT_EQ(1, client_->in_flight_event_count());
1713   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1714   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1715   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
1716   EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(1.6f * 1.7f),
1717                   PinchScaleToWheelDelta(1.6f) + PinchScaleToWheelDelta(1.7f));
1718   EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(1.6f * 1.7f), wheel_event->deltaY);
1719   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1720   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
1721
1722   // Indicate that the second wheel event was handled and verify the ACK.
1723   SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED);
1724   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1725   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1726   EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, ack_handler_->ack_state());
1727   EXPECT_FLOAT_EQ(1.6f * 1.7f,
1728                   ack_handler_->acked_gesture_event().data.pinchUpdate.scale);
1729 }
1730
1731 // Test interleaving pinch and wheel events.
1732 TEST_F(InputRouterImplTest, TouchpadPinchAndWheel) {
1733   // Simulate queued wheel and pinch events events.
1734   // Note that in practice interleaving pinch and wheel events should be rare
1735   // (eg. requires the use of a mouse and trackpad at the same time).
1736
1737   // Use the control modifier to match the synthetic wheel events so that
1738   // they're elligble for coalescing.
1739   int mod = WebInputEvent::ControlKey;
1740
1741   // Event 1: sent directly.
1742   SimulateWheelEvent(0, -5, mod, true);
1743   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1744
1745   // Event 2: enqueued in InputRouter.
1746   SimulateWheelEvent(0, -10, mod, true);
1747   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1748
1749   // Event 3: enqueued in InputRouter, not coalesced into #2.
1750   SimulateGesturePinchUpdateEvent(
1751       1.5f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1752   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1753
1754   // Event 4: enqueued in GestureEventQueue.
1755   SimulateGesturePinchUpdateEvent(
1756       1.2f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
1757   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1758
1759   // Event 5: coalesced into wheel event for #3.
1760   SimulateWheelEvent(2, 0, mod, true);
1761   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1762
1763   // Send ack for #1.
1764   SendInputEventACK(WebInputEvent::MouseWheel,
1765                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1766   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1767   EXPECT_EQ(WebInputEvent::MouseWheel, ack_handler_->ack_event_type());
1768
1769   // Verify we sent #2.
1770   ASSERT_EQ(1U, process_->sink().message_count());
1771   const WebInputEvent* input_event =
1772       GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1773   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1774   const WebMouseWheelEvent* wheel_event =
1775       static_cast<const WebMouseWheelEvent*>(input_event);
1776   EXPECT_EQ(0, wheel_event->deltaX);
1777   EXPECT_EQ(-10, wheel_event->deltaY);
1778   EXPECT_EQ(mod, wheel_event->modifiers);
1779   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1780
1781   // Send ack for #2.
1782   SendInputEventACK(WebInputEvent::MouseWheel,
1783                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1784   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1785   EXPECT_EQ(WebInputEvent::MouseWheel, ack_handler_->ack_event_type());
1786
1787   // Verify we sent #3 (with #5 coalesced in).
1788   ASSERT_EQ(1U, process_->sink().message_count());
1789   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1790   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1791   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
1792   EXPECT_EQ(2, wheel_event->deltaX);
1793   EXPECT_EQ(PinchScaleToWheelDelta(1.5f), wheel_event->deltaY);
1794   EXPECT_EQ(mod, wheel_event->modifiers);
1795   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1796
1797   // Send ack for #3.
1798   SendInputEventACK(WebInputEvent::MouseWheel,
1799                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1800   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1801   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1802
1803   // Verify we sent #4.
1804   ASSERT_EQ(1U, process_->sink().message_count());
1805   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
1806   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
1807   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
1808   EXPECT_EQ(0, wheel_event->deltaX);
1809   EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(1.2f), wheel_event->deltaY);
1810   EXPECT_EQ(mod, wheel_event->modifiers);
1811   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
1812
1813   // Send ack for #4.
1814   SendInputEventACK(WebInputEvent::MouseWheel,
1815                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1816   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1817   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
1818 }
1819
1820 // Test proper handling of touchpad Gesture{Pinch,Scroll}Update sequences.
1821 TEST_F(InputRouterImplTest, TouchpadPinchAndScrollUpdate) {
1822   // The first scroll should be sent immediately.
1823   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1824                        blink::WebGestureDeviceTouchpad);
1825   ASSERT_EQ(1U, GetSentMessageCountAndResetSink());
1826   EXPECT_EQ(1, client_->in_flight_event_count());
1827
1828   // Subsequent scroll and pinch events should remain queued, coalescing as
1829   // more trackpad events arrive.
1830   SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
1831                        blink::WebGestureDeviceTouchpad);
1832   ASSERT_EQ(0U, GetSentMessageCountAndResetSink());
1833   EXPECT_EQ(1, client_->in_flight_event_count());
1834
1835   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1836                        blink::WebGestureDeviceTouchpad);
1837   ASSERT_EQ(0U, GetSentMessageCountAndResetSink());
1838   EXPECT_EQ(1, client_->in_flight_event_count());
1839
1840   SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
1841                        blink::WebGestureDeviceTouchpad);
1842   ASSERT_EQ(0U, GetSentMessageCountAndResetSink());
1843   EXPECT_EQ(1, client_->in_flight_event_count());
1844
1845   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1846                        blink::WebGestureDeviceTouchpad);
1847   ASSERT_EQ(0U, GetSentMessageCountAndResetSink());
1848   EXPECT_EQ(1, client_->in_flight_event_count());
1849
1850   // Ack'ing the first scroll should trigger both the coalesced scroll and the
1851   // coalesced pinch events (which is sent to the renderer as a wheel event).
1852   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
1853                     INPUT_EVENT_ACK_STATE_CONSUMED);
1854   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1855   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
1856   EXPECT_EQ(2, client_->in_flight_event_count());
1857
1858   // Ack the second scroll.
1859   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
1860                     INPUT_EVENT_ACK_STATE_CONSUMED);
1861   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1862   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1863   EXPECT_EQ(1, client_->in_flight_event_count());
1864
1865   // Ack the wheel event.
1866   SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED);
1867   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
1868   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
1869   EXPECT_EQ(0, client_->in_flight_event_count());
1870 }
1871
1872 // Test proper routing of overscroll notifications received either from
1873 // event acks or from |DidOverscroll| IPC messages.
1874 TEST_F(InputRouterImplTest, OverscrollDispatch) {
1875   DidOverscrollParams overscroll;
1876   overscroll.accumulated_overscroll = gfx::Vector2dF(-14, 14);
1877   overscroll.latest_overscroll_delta = gfx::Vector2dF(-7, 0);
1878   overscroll.current_fling_velocity = gfx::Vector2dF(-1, 0);
1879
1880   input_router_->OnMessageReceived(InputHostMsg_DidOverscroll(0, overscroll));
1881   DidOverscrollParams client_overscroll = client_->GetAndResetOverscroll();
1882   EXPECT_EQ(overscroll.accumulated_overscroll,
1883             client_overscroll.accumulated_overscroll);
1884   EXPECT_EQ(overscroll.latest_overscroll_delta,
1885             client_overscroll.latest_overscroll_delta);
1886   EXPECT_EQ(overscroll.current_fling_velocity,
1887             client_overscroll.current_fling_velocity);
1888
1889   DidOverscrollParams wheel_overscroll;
1890   wheel_overscroll.accumulated_overscroll = gfx::Vector2dF(7, -7);
1891   wheel_overscroll.latest_overscroll_delta = gfx::Vector2dF(3, 0);
1892   wheel_overscroll.current_fling_velocity = gfx::Vector2dF(1, 0);
1893
1894   SimulateWheelEvent(3, 0, 0, false);
1895   InputHostMsg_HandleInputEvent_ACK_Params ack;
1896   ack.type = WebInputEvent::MouseWheel;
1897   ack.state = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1898   ack.overscroll.reset(new DidOverscrollParams(wheel_overscroll));
1899   input_router_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
1900
1901   client_overscroll = client_->GetAndResetOverscroll();
1902   EXPECT_EQ(wheel_overscroll.accumulated_overscroll,
1903             client_overscroll.accumulated_overscroll);
1904   EXPECT_EQ(wheel_overscroll.latest_overscroll_delta,
1905             client_overscroll.latest_overscroll_delta);
1906   EXPECT_EQ(wheel_overscroll.current_fling_velocity,
1907             client_overscroll.current_fling_velocity);
1908 }
1909
1910 }  // namespace content