content/browser/renderer_host/input/input_router_impl_unittest.cc

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