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