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