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
34using base::TimeDelta;
35using blink::WebGestureDevice;
36using blink::WebGestureEvent;
37using blink::WebKeyboardEvent;
38using blink::WebInputEvent;
39using blink::WebMouseEvent;
40using blink::WebMouseWheelEvent;
41using blink::WebTouchEvent;
42using blink::WebTouchPoint;
43
44namespace content {
45
46namespace {
47
48const 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
57WebInputEvent& 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
80bool GetIsShortcutFromHandleInputEventMessage(const IPC::Message* msg) {
81  InputMsg_HandleInputEvent::Schema::Param param;
82  InputMsg_HandleInputEvent::Read(msg, &param);
83  return param.c;
84}
85
86template<typename MSG_T, typename ARG_T1>
87void 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
94template<typename MSG_T, typename ARG_T1, typename ARG_T2>
95void 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)
106bool 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
119bool 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.
136float PinchScaleToWheelDelta(float scale) {
137  return 100.0 * log(scale);
138}
139
140}  // namespace
141
142class 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
337TEST_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
376TEST_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
411TEST_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
428TEST_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
448TEST_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
460TEST_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
470TEST_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
490TEST_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
498TEST_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.
588TEST_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.
624TEST_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)
659TEST_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
743TEST_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
771TEST_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
803TEST_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
861TEST_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|.
888TEST_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.
912TEST_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.
980TEST_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.
1024TEST_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.
1098TEST_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.
1150TEST_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.
1202TEST_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.
1251TEST_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.
1295TEST_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|.
1360TEST_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
1421TEST_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.
1483TEST_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.
1542TEST_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.
1631TEST_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.
1684TEST_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