touch_event_queue_unittest.cc revision 03b57e008b61dfcb1fbad3aea950ae0e001748b0 
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 "base/basictypes.h"
6#include "base/logging.h"
7#include "base/memory/scoped_ptr.h"
8#include "base/message_loop/message_loop.h"
9#include "content/browser/renderer_host/input/timeout_monitor.h"
10#include "content/browser/renderer_host/input/touch_event_queue.h"
11#include "content/common/input/synthetic_web_input_event_builders.h"
12#include "testing/gtest/include/gtest/gtest.h"
13#include "third_party/WebKit/public/web/WebInputEvent.h"
14
15using blink::WebGestureEvent;
16using blink::WebInputEvent;
17using blink::WebTouchEvent;
18using blink::WebTouchPoint;
19
20namespace content {
21namespace {
22
23const double kMinSecondsBetweenThrottledTouchmoves = 0.2;
24
25base::TimeDelta DefaultTouchTimeoutDelay() {
26  return base::TimeDelta::FromMilliseconds(1);
27}
28}  // namespace
29
30class TouchEventQueueTest : public testing::Test,
31                            public TouchEventQueueClient {
32 public:
33  TouchEventQueueTest()
34      : sent_event_count_(0),
35        acked_event_count_(0),
36        last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN),
37        slop_length_dips_(0),
38        slop_includes_boundary_(true),
39        touch_scrolling_mode_(TouchEventQueue::TOUCH_SCROLLING_MODE_DEFAULT) {}
40
41  virtual ~TouchEventQueueTest() {}
42
43  // testing::Test
44  virtual void SetUp() OVERRIDE { ResetQueueWithConfig(CreateConfig()); }
45
46  virtual void TearDown() OVERRIDE {
47    queue_.reset();
48  }
49
50  // TouchEventQueueClient
51  virtual void SendTouchEventImmediately(
52      const TouchEventWithLatencyInfo& event) OVERRIDE {
53    ++sent_event_count_;
54    last_sent_event_ = event.event;
55    if (sync_ack_result_)
56      SendTouchEventAck(*sync_ack_result_.Pass());
57  }
58
59  virtual void OnTouchEventAck(
60      const TouchEventWithLatencyInfo& event,
61      InputEventAckState ack_result) OVERRIDE {
62    ++acked_event_count_;
63    last_acked_event_ = event.event;
64    last_acked_event_state_ = ack_result;
65    if (followup_touch_event_) {
66      scoped_ptr<WebTouchEvent> followup_touch_event =
67          followup_touch_event_.Pass();
68      SendTouchEvent(*followup_touch_event);
69    }
70    if (followup_gesture_event_) {
71      scoped_ptr<WebGestureEvent> followup_gesture_event =
72          followup_gesture_event_.Pass();
73      queue_->OnGestureScrollEvent(
74          GestureEventWithLatencyInfo(*followup_gesture_event,
75                                      ui::LatencyInfo()));
76    }
77  }
78
79 protected:
80  TouchEventQueue::Config CreateConfig() {
81    TouchEventQueue::Config config;
82    config.touch_scrolling_mode = touch_scrolling_mode_;
83    config.touchmove_slop_suppression_length_dips = slop_length_dips_;
84    config.touchmove_slop_suppression_region_includes_boundary =
85        slop_includes_boundary_;
86    return config;
87  }
88
89  void SetTouchScrollingMode(TouchEventQueue::TouchScrollingMode mode) {
90    touch_scrolling_mode_ = mode;
91    ResetQueueWithConfig(CreateConfig());
92  }
93
94  void SetUpForTouchMoveSlopTesting(double slop_length_dips,
95                                    bool slop_includes_boundary) {
96    slop_length_dips_ = slop_length_dips;
97    slop_includes_boundary_ = slop_includes_boundary;
98    ResetQueueWithConfig(CreateConfig());
99  }
100
101  void SetUpForTimeoutTesting(base::TimeDelta timeout_delay) {
102    TouchEventQueue::Config config = CreateConfig();
103    config.touch_ack_timeout_delay = timeout_delay;
104    config.touch_ack_timeout_supported = true;
105    ResetQueueWithConfig(config);
106  }
107
108  void SendTouchEvent(const WebTouchEvent& event) {
109    queue_->QueueEvent(TouchEventWithLatencyInfo(event, ui::LatencyInfo()));
110  }
111
112  void SendGestureEvent(WebInputEvent::Type type) {
113    WebGestureEvent event;
114    event.type = type;
115    queue_->OnGestureScrollEvent(
116        GestureEventWithLatencyInfo(event, ui::LatencyInfo()));
117  }
118
119  void SendTouchEventAck(InputEventAckState ack_result) {
120    queue_->ProcessTouchAck(ack_result, ui::LatencyInfo());
121  }
122
123  void SendGestureEventAck(WebInputEvent::Type type,
124                           InputEventAckState ack_result) {
125    blink::WebGestureEvent gesture_event;
126    gesture_event.type = type;
127    GestureEventWithLatencyInfo event(gesture_event, ui::LatencyInfo());
128    queue_->OnGestureEventAck(event, ack_result);
129  }
130
131  void SetFollowupEvent(const WebTouchEvent& event) {
132    followup_touch_event_.reset(new WebTouchEvent(event));
133  }
134
135  void SetFollowupEvent(const WebGestureEvent& event) {
136    followup_gesture_event_.reset(new WebGestureEvent(event));
137  }
138
139  void SetSyncAckResult(InputEventAckState sync_ack_result) {
140    sync_ack_result_.reset(new InputEventAckState(sync_ack_result));
141  }
142
143  void PressTouchPoint(float x, float y) {
144    touch_event_.PressPoint(x, y);
145    SendTouchEvent();
146  }
147
148  void MoveTouchPoint(int index, float x, float y) {
149    touch_event_.MovePoint(index, x, y);
150    SendTouchEvent();
151  }
152
153  void MoveTouchPoints(int index0,
154                       float x0,
155                       float y0,
156                       int index1,
157                       float x1,
158                       float y1) {
159    touch_event_.MovePoint(index0, x0, y0);
160    touch_event_.MovePoint(index1, x1, y1);
161    SendTouchEvent();
162  }
163
164  void ReleaseTouchPoint(int index) {
165    touch_event_.ReleasePoint(index);
166    SendTouchEvent();
167  }
168
169  void CancelTouchPoint(int index) {
170    touch_event_.CancelPoint(index);
171    SendTouchEvent();
172  }
173
174  void AdvanceTouchTime(double seconds) {
175    touch_event_.timeStampSeconds += seconds;
176  }
177
178  void ResetTouchEvent() {
179    touch_event_ = SyntheticWebTouchEvent();
180  }
181
182  size_t GetAndResetAckedEventCount() {
183    size_t count = acked_event_count_;
184    acked_event_count_ = 0;
185    return count;
186  }
187
188  size_t GetAndResetSentEventCount() {
189    size_t count = sent_event_count_;
190    sent_event_count_ = 0;
191    return count;
192  }
193
194  bool IsPendingAckTouchStart() const {
195    return queue_->IsPendingAckTouchStart();
196  }
197
198  void OnHasTouchEventHandlers(bool has_handlers) {
199    queue_->OnHasTouchEventHandlers(has_handlers);
200  }
201
202  void SetAckTimeoutDisabled() { queue_->SetAckTimeoutEnabled(false); }
203
204  bool IsTimeoutEnabled() const { return queue_->ack_timeout_enabled(); }
205
206  bool IsTimeoutRunning() const { return queue_->IsTimeoutRunningForTesting(); }
207
208  bool HasPendingAsyncTouchMove() const {
209    return queue_->HasPendingAsyncTouchMoveForTesting();
210  }
211
212  size_t queued_event_count() const {
213    return queue_->size();
214  }
215
216  const WebTouchEvent& latest_event() const {
217    return queue_->GetLatestEventForTesting().event;
218  }
219
220  const WebTouchEvent& acked_event() const {
221    return last_acked_event_;
222  }
223
224  const WebTouchEvent& sent_event() const {
225    return last_sent_event_;
226  }
227
228  InputEventAckState acked_event_state() const {
229    return last_acked_event_state_;
230  }
231
232  static void RunTasksAndWait(base::TimeDelta delay) {
233    base::MessageLoop::current()->PostDelayedTask(
234        FROM_HERE, base::MessageLoop::QuitClosure(), delay);
235    base::MessageLoop::current()->Run();
236  }
237
238 private:
239  void SendTouchEvent() {
240    SendTouchEvent(touch_event_);
241    touch_event_.ResetPoints();
242  }
243
244  void ResetQueueWithConfig(const TouchEventQueue::Config& config) {
245    queue_.reset(new TouchEventQueue(this, config));
246    queue_->OnHasTouchEventHandlers(true);
247  }
248
249  scoped_ptr<TouchEventQueue> queue_;
250  size_t sent_event_count_;
251  size_t acked_event_count_;
252  WebTouchEvent last_sent_event_;
253  WebTouchEvent last_acked_event_;
254  InputEventAckState last_acked_event_state_;
255  SyntheticWebTouchEvent touch_event_;
256  scoped_ptr<WebTouchEvent> followup_touch_event_;
257  scoped_ptr<WebGestureEvent> followup_gesture_event_;
258  scoped_ptr<InputEventAckState> sync_ack_result_;
259  double slop_length_dips_;
260  bool slop_includes_boundary_;
261  TouchEventQueue::TouchScrollingMode touch_scrolling_mode_;
262  base::MessageLoopForUI message_loop_;
263};
264
265
266// Tests that touch-events are queued properly.
267TEST_F(TouchEventQueueTest, Basic) {
268  PressTouchPoint(1, 1);
269  EXPECT_EQ(1U, queued_event_count());
270  EXPECT_EQ(1U, GetAndResetSentEventCount());
271
272  // The second touch should not be sent since one is already in queue.
273  MoveTouchPoint(0, 5, 5);
274  EXPECT_EQ(2U, queued_event_count());
275  EXPECT_EQ(0U, GetAndResetSentEventCount());
276
277  // Receive an ACK for the first touch-event.
278  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
279  EXPECT_EQ(1U, queued_event_count());
280  EXPECT_EQ(1U, GetAndResetSentEventCount());
281  EXPECT_EQ(1U, GetAndResetAckedEventCount());
282  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
283  EXPECT_TRUE(acked_event().cancelable);
284
285  // Receive an ACK for the second touch-event.
286  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
287  EXPECT_EQ(0U, queued_event_count());
288  EXPECT_EQ(0U, GetAndResetSentEventCount());
289  EXPECT_EQ(1U, GetAndResetAckedEventCount());
290  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
291  EXPECT_TRUE(acked_event().cancelable);
292}
293
294// Tests that the touch-queue is emptied if a page stops listening for touch
295// events.
296TEST_F(TouchEventQueueTest, QueueFlushedWhenHandlersRemoved) {
297  OnHasTouchEventHandlers(true);
298  EXPECT_EQ(0U, queued_event_count());
299  EXPECT_EQ(0U, GetAndResetSentEventCount());
300
301  // Send a touch-press event.
302  PressTouchPoint(1, 1);
303  EXPECT_EQ(1U, GetAndResetSentEventCount());
304
305  ReleaseTouchPoint(0);
306
307  // Events will be queued until the first sent event is ack'ed.
308  for (int i = 5; i < 15; ++i) {
309    PressTouchPoint(1, 1);
310    MoveTouchPoint(0, i, i);
311    ReleaseTouchPoint(0);
312  }
313  EXPECT_EQ(32U, queued_event_count());
314  EXPECT_EQ(0U, GetAndResetSentEventCount());
315
316  // Receive an ACK for the first touch-event. One of the queued touch-event
317  // should be forwarded.
318  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
319  EXPECT_EQ(31U, queued_event_count());
320  EXPECT_EQ(1U, GetAndResetSentEventCount());
321  EXPECT_EQ(1U, GetAndResetAckedEventCount());
322  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
323
324  // Flush the queue. The touch-event queue should now be emptied, but none of
325  // the queued touch-events should be sent to the renderer.
326  OnHasTouchEventHandlers(false);
327  EXPECT_EQ(0U, queued_event_count());
328  EXPECT_EQ(0U, GetAndResetSentEventCount());
329  EXPECT_EQ(31U, GetAndResetAckedEventCount());
330}
331
332// Tests that addition of a touch handler during a touch sequence will not cause
333// the remaining sequence to be forwarded.
334TEST_F(TouchEventQueueTest, ActiveSequenceNotForwardedWhenHandlersAdded) {
335  OnHasTouchEventHandlers(false);
336
337  // Send a touch-press event while there is no handler.
338  PressTouchPoint(1, 1);
339  EXPECT_EQ(1U, GetAndResetAckedEventCount());
340  EXPECT_EQ(0U, GetAndResetSentEventCount());
341  EXPECT_EQ(0U, queued_event_count());
342
343  OnHasTouchEventHandlers(true);
344
345  // The remaining touch sequence should not be forwarded.
346  MoveTouchPoint(0, 5, 5);
347  ReleaseTouchPoint(0);
348  EXPECT_EQ(2U, GetAndResetAckedEventCount());
349  EXPECT_EQ(0U, GetAndResetSentEventCount());
350  EXPECT_EQ(0U, queued_event_count());
351
352  // A new touch sequence should resume forwarding.
353  PressTouchPoint(1, 1);
354  EXPECT_EQ(1U, queued_event_count());
355  EXPECT_EQ(1U, GetAndResetSentEventCount());
356}
357
358// Tests that removal of a touch handler during a touch sequence will prevent
359// the remaining sequence from being forwarded, even if another touch handler is
360// registered during the same touch sequence.
361TEST_F(TouchEventQueueTest, ActiveSequenceDroppedWhenHandlersRemoved) {
362  // Send a touch-press event.
363  PressTouchPoint(1, 1);
364  EXPECT_EQ(1U, GetAndResetSentEventCount());
365  EXPECT_EQ(1U, queued_event_count());
366
367  // Queue a touch-move event.
368  MoveTouchPoint(0, 5, 5);
369  EXPECT_EQ(2U, queued_event_count());
370  EXPECT_EQ(0U, GetAndResetAckedEventCount());
371  EXPECT_EQ(0U, GetAndResetSentEventCount());
372
373  // Touch handle deregistration should flush the queue.
374  OnHasTouchEventHandlers(false);
375  EXPECT_EQ(2U, GetAndResetAckedEventCount());
376  EXPECT_EQ(0U, queued_event_count());
377
378  // The ack should be ignored as the touch queue is now empty.
379  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
380  EXPECT_EQ(0U, GetAndResetAckedEventCount());
381  EXPECT_EQ(0U, queued_event_count());
382
383  // Events should be dropped while there is no touch handler.
384  MoveTouchPoint(0, 10, 10);
385  EXPECT_EQ(0U, queued_event_count());
386  EXPECT_EQ(1U, GetAndResetAckedEventCount());
387  EXPECT_EQ(0U, GetAndResetSentEventCount());
388
389  // Simulate touch handler registration in the middle of a touch sequence.
390  OnHasTouchEventHandlers(true);
391
392  // The touch end for the interrupted sequence should be dropped.
393  ReleaseTouchPoint(0);
394  EXPECT_EQ(0U, queued_event_count());
395  EXPECT_EQ(1U, GetAndResetAckedEventCount());
396  EXPECT_EQ(0U, GetAndResetSentEventCount());
397
398  // A new touch sequence should be forwarded properly.
399  PressTouchPoint(1, 1);
400  EXPECT_EQ(1U, queued_event_count());
401  EXPECT_EQ(1U, GetAndResetSentEventCount());
402}
403
404// Tests that touch-events are coalesced properly in the queue.
405TEST_F(TouchEventQueueTest, Coalesce) {
406  // Send a touch-press event.
407  PressTouchPoint(1, 1);
408  EXPECT_EQ(1U, GetAndResetSentEventCount());
409
410  // Send a few touch-move events, followed by a touch-release event. All the
411  // touch-move events should be coalesced into a single event.
412  for (int i = 5; i < 15; ++i)
413    MoveTouchPoint(0, i, i);
414
415  EXPECT_EQ(0U, GetAndResetSentEventCount());
416  ReleaseTouchPoint(0);
417  EXPECT_EQ(0U, GetAndResetSentEventCount());
418  EXPECT_EQ(3U, queued_event_count());
419
420  // ACK the press.  Coalesced touch-move events should be sent.
421  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
422  EXPECT_EQ(2U, queued_event_count());
423  EXPECT_EQ(1U, GetAndResetSentEventCount());
424  EXPECT_EQ(1U, GetAndResetAckedEventCount());
425  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
426  EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state());
427
428  // ACK the moves.
429  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
430  EXPECT_EQ(1U, queued_event_count());
431  EXPECT_EQ(1U, GetAndResetSentEventCount());
432  EXPECT_EQ(10U, GetAndResetAckedEventCount());
433  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
434
435  // ACK the release.
436  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
437  EXPECT_EQ(0U, queued_event_count());
438  EXPECT_EQ(0U, GetAndResetSentEventCount());
439  EXPECT_EQ(1U, GetAndResetAckedEventCount());
440  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type);
441}
442
443// Tests that an event that has already been sent but hasn't been ack'ed yet
444// doesn't get coalesced with newer events.
445TEST_F(TouchEventQueueTest, SentTouchEventDoesNotCoalesce) {
446  // Send a touch-press event.
447  PressTouchPoint(1, 1);
448  EXPECT_EQ(1U, GetAndResetSentEventCount());
449
450  // Send a few touch-move events, followed by a touch-release event. All the
451  // touch-move events should be coalesced into a single event.
452  for (int i = 5; i < 15; ++i)
453    MoveTouchPoint(0, i, i);
454
455  EXPECT_EQ(0U, GetAndResetSentEventCount());
456  EXPECT_EQ(2U, queued_event_count());
457
458  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
459  EXPECT_EQ(1U, GetAndResetSentEventCount());
460  EXPECT_EQ(1U, queued_event_count());
461
462  // The coalesced touch-move event has been sent to the renderer. Any new
463  // touch-move event should not be coalesced with the sent event.
464  MoveTouchPoint(0, 5, 5);
465  EXPECT_EQ(2U, queued_event_count());
466
467  MoveTouchPoint(0, 7, 7);
468  EXPECT_EQ(2U, queued_event_count());
469}
470
471// Tests that coalescing works correctly for multi-touch events.
472TEST_F(TouchEventQueueTest, MultiTouch) {
473  // Press the first finger.
474  PressTouchPoint(1, 1);
475  EXPECT_EQ(1U, GetAndResetSentEventCount());
476
477  // Move the finger.
478  MoveTouchPoint(0, 5, 5);
479  EXPECT_EQ(2U, queued_event_count());
480
481  // Now press a second finger.
482  PressTouchPoint(2, 2);
483  EXPECT_EQ(3U, queued_event_count());
484
485  // Move both fingers.
486  MoveTouchPoints(0, 10, 10, 1, 20, 20);
487  MoveTouchPoint(1, 20, 20);
488  EXPECT_EQ(4U, queued_event_count());
489
490  // Move only one finger now.
491  MoveTouchPoint(0, 15, 15);
492  EXPECT_EQ(4U, queued_event_count());
493
494  // Move the other finger.
495  MoveTouchPoint(1, 25, 25);
496  EXPECT_EQ(4U, queued_event_count());
497
498  // Make sure both fingers are marked as having been moved in the coalesced
499  // event.
500  const WebTouchEvent& event = latest_event();
501  EXPECT_EQ(WebTouchPoint::StateMoved, event.touches[0].state);
502  EXPECT_EQ(WebTouchPoint::StateMoved, event.touches[1].state);
503}
504
505// Tests that if a touch-event queue is destroyed in response to a touch-event
506// in the renderer, then there is no crash when the ACK for that touch-event
507// comes back.
508TEST_F(TouchEventQueueTest, AckAfterQueueFlushed) {
509  // Send some touch-events to the renderer.
510  PressTouchPoint(1, 1);
511  EXPECT_EQ(1U, GetAndResetSentEventCount());
512  EXPECT_EQ(1U, queued_event_count());
513
514  MoveTouchPoint(0, 10, 10);
515  EXPECT_EQ(0U, GetAndResetSentEventCount());
516  EXPECT_EQ(2U, queued_event_count());
517
518  // Receive an ACK for the press. This should cause the queued touch-move to
519  // be sent to the renderer.
520  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
521  EXPECT_EQ(1U, GetAndResetSentEventCount());
522  EXPECT_EQ(1U, queued_event_count());
523
524  OnHasTouchEventHandlers(false);
525  EXPECT_EQ(0U, GetAndResetSentEventCount());
526  EXPECT_EQ(0U, queued_event_count());
527
528  // Now receive an ACK for the move.
529  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
530  EXPECT_EQ(0U, GetAndResetSentEventCount());
531  EXPECT_EQ(0U, queued_event_count());
532}
533
534// Tests that touch-move events are not sent to the renderer if the preceding
535// touch-press event did not have a consumer (and consequently, did not hit the
536// main thread in the renderer). Also tests that all queued/coalesced touch
537// events are flushed immediately when the ACK for the touch-press comes back
538// with NO_CONSUMER status.
539TEST_F(TouchEventQueueTest, NoConsumer) {
540  // The first touch-press should reach the renderer.
541  PressTouchPoint(1, 1);
542  EXPECT_EQ(1U, GetAndResetSentEventCount());
543
544  // The second touch should not be sent since one is already in queue.
545  MoveTouchPoint(0, 5, 5);
546  EXPECT_EQ(0U, GetAndResetSentEventCount());
547  EXPECT_EQ(2U, queued_event_count());
548
549  // Receive an ACK for the first touch-event. This should release the queued
550  // touch-event, but it should not be sent to the renderer.
551  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
552  EXPECT_EQ(0U, queued_event_count());
553  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
554  EXPECT_EQ(2U, GetAndResetAckedEventCount());
555  EXPECT_EQ(0U, GetAndResetSentEventCount());
556
557  // Send a release event. This should not reach the renderer.
558  ReleaseTouchPoint(0);
559  EXPECT_EQ(0U, GetAndResetSentEventCount());
560  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type);
561  EXPECT_EQ(1U, GetAndResetAckedEventCount());
562
563  // Send a press-event, followed by move and release events, and another press
564  // event, before the ACK for the first press event comes back. All of the
565  // events should be queued first. After the NO_CONSUMER ack for the first
566  // touch-press, all events upto the second touch-press should be flushed.
567  PressTouchPoint(10, 10);
568  EXPECT_EQ(1U, GetAndResetSentEventCount());
569
570  MoveTouchPoint(0, 5, 5);
571  MoveTouchPoint(0, 6, 5);
572  ReleaseTouchPoint(0);
573
574  PressTouchPoint(6, 5);
575  EXPECT_EQ(0U, GetAndResetSentEventCount());
576  // The queue should hold the first sent touch-press event, the coalesced
577  // touch-move event, the touch-end event and the second touch-press event.
578  EXPECT_EQ(4U, queued_event_count());
579
580  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
581  EXPECT_EQ(1U, GetAndResetSentEventCount());
582  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type);
583  EXPECT_EQ(4U, GetAndResetAckedEventCount());
584  EXPECT_EQ(1U, queued_event_count());
585
586  // ACK the second press event as NO_CONSUMER too.
587  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
588  EXPECT_EQ(0U, GetAndResetSentEventCount());
589  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
590  EXPECT_EQ(1U, GetAndResetAckedEventCount());
591  EXPECT_EQ(0U, queued_event_count());
592
593  // Send a second press event. Even though the first touch press had
594  // NO_CONSUMER, this press event should reach the renderer.
595  PressTouchPoint(1, 1);
596  EXPECT_EQ(1U, GetAndResetSentEventCount());
597  EXPECT_EQ(1U, queued_event_count());
598  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
599  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
600  EXPECT_EQ(1U, GetAndResetAckedEventCount());
601}
602
603TEST_F(TouchEventQueueTest, ConsumerIgnoreMultiFinger) {
604  // Press two touch points and move them around a bit. The renderer consumes
605  // the events for the first touch point, but returns NO_CONSUMER_EXISTS for
606  // the second touch point.
607
608  PressTouchPoint(1, 1);
609  EXPECT_EQ(1U, GetAndResetSentEventCount());
610
611  MoveTouchPoint(0, 5, 5);
612
613  PressTouchPoint(10, 10);
614
615  MoveTouchPoint(0, 2, 2);
616
617  MoveTouchPoint(1, 4, 10);
618
619  MoveTouchPoints(0, 10, 10, 1, 20, 20);
620
621  // Since the first touch-press is still pending ACK, no other event should
622  // have been sent to the renderer.
623  EXPECT_EQ(0U, GetAndResetSentEventCount());
624  // The queue includes the two presses, the first touch-move of the first
625  // point, and a coalesced touch-move of both points.
626  EXPECT_EQ(4U, queued_event_count());
627
628  // ACK the first press as CONSUMED. This should cause the first touch-move of
629  // the first touch-point to be dispatched.
630  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
631  EXPECT_EQ(1U, GetAndResetSentEventCount());
632  EXPECT_EQ(3U, queued_event_count());
633
634  // ACK the first move as CONSUMED.
635  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
636  EXPECT_EQ(1U, GetAndResetSentEventCount());
637  EXPECT_EQ(2U, queued_event_count());
638
639  // ACK the second press as NO_CONSUMER_EXISTS. This will dequeue the coalesced
640  // touch-move event (which contains both touch points). Although the second
641  // touch-point does not need to be sent to the renderer, the first touch-point
642  // did move, and so the coalesced touch-event will be sent to the renderer.
643  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
644  EXPECT_EQ(1U, GetAndResetSentEventCount());
645  EXPECT_EQ(1U, queued_event_count());
646
647  // ACK the coalesced move as NOT_CONSUMED.
648  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
649  EXPECT_EQ(0U, GetAndResetSentEventCount());
650  EXPECT_EQ(0U, queued_event_count());
651
652  // Move just the second touch point. Because the first touch point did not
653  // move, this event should not reach the renderer.
654  MoveTouchPoint(1, 30, 30);
655  EXPECT_EQ(0U, GetAndResetSentEventCount());
656  EXPECT_EQ(0U, queued_event_count());
657
658  // Move just the first touch point. This should reach the renderer.
659  MoveTouchPoint(0, 10, 10);
660  EXPECT_EQ(1U, GetAndResetSentEventCount());
661  EXPECT_EQ(1U, queued_event_count());
662
663  // Move both fingers. This event should reach the renderer (after the ACK of
664  // the previous move event is received), because the first touch point did
665  // move.
666  MoveTouchPoints(0, 15, 15, 1, 25, 25);
667  EXPECT_EQ(0U, GetAndResetSentEventCount());
668
669  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
670  EXPECT_EQ(1U, GetAndResetSentEventCount());
671  EXPECT_EQ(1U, queued_event_count());
672
673  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
674  EXPECT_EQ(0U, GetAndResetSentEventCount());
675  EXPECT_EQ(0U, queued_event_count());
676
677  // Release the first finger. Then move the second finger around some, then
678  // press another finger. Once the release event is ACKed, the move events of
679  // the second finger should be immediately released to the view, and the
680  // touch-press event should be dispatched to the renderer.
681  ReleaseTouchPoint(0);
682  EXPECT_EQ(1U, GetAndResetSentEventCount());
683  EXPECT_EQ(1U, queued_event_count());
684
685  MoveTouchPoint(1, 40, 40);
686
687  MoveTouchPoint(1, 50, 50);
688
689  PressTouchPoint(1, 1);
690
691  MoveTouchPoint(1, 30, 30);
692  EXPECT_EQ(0U, GetAndResetSentEventCount());
693  EXPECT_EQ(4U, queued_event_count());
694
695  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
696  EXPECT_EQ(1U, GetAndResetSentEventCount());
697  EXPECT_EQ(2U, queued_event_count());
698  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
699
700  // ACK the press with NO_CONSUMED_EXISTS. This should release the queued
701  // touch-move events to the view.
702  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
703  EXPECT_EQ(0U, GetAndResetSentEventCount());
704  EXPECT_EQ(0U, queued_event_count());
705  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
706
707  ReleaseTouchPoint(2);
708  ReleaseTouchPoint(1);
709  EXPECT_EQ(0U, GetAndResetSentEventCount());
710  EXPECT_EQ(0U, queued_event_count());
711}
712
713// Tests that touch-event's enqueued via a touch ack are properly handled.
714TEST_F(TouchEventQueueTest, AckWithFollowupEvents) {
715  // Queue a touch down.
716  PressTouchPoint(1, 1);
717  EXPECT_EQ(1U, queued_event_count());
718  EXPECT_EQ(1U, GetAndResetSentEventCount());
719  EXPECT_EQ(0U, GetAndResetAckedEventCount());
720
721  // Create a touch event that will be queued synchronously by a touch ack.
722  // Note, this will be triggered by all subsequent touch acks.
723  WebTouchEvent followup_event;
724  followup_event.type = WebInputEvent::TouchStart;
725  followup_event.touchesLength = 1;
726  followup_event.touches[0].id = 1;
727  followup_event.touches[0].state = WebTouchPoint::StatePressed;
728  SetFollowupEvent(followup_event);
729
730  // Receive an ACK for the press. This should cause the followup touch-move to
731  // be sent to the renderer.
732  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
733  EXPECT_EQ(1U, queued_event_count());
734  EXPECT_EQ(1U, GetAndResetSentEventCount());
735  EXPECT_EQ(1U, GetAndResetAckedEventCount());
736  EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state());
737  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
738
739  // Queue another event.
740  MoveTouchPoint(0, 2, 2);
741  EXPECT_EQ(2U, queued_event_count());
742
743  // Receive an ACK for the touch-move followup event. This should cause the
744  // subsequent touch move event be sent to the renderer.
745  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
746  EXPECT_EQ(1U, queued_event_count());
747  EXPECT_EQ(1U, GetAndResetSentEventCount());
748  EXPECT_EQ(1U, GetAndResetAckedEventCount());
749}
750
751// Tests that touch-events can be synchronously ack'ed.
752TEST_F(TouchEventQueueTest, SynchronousAcks) {
753  // TouchStart
754  SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
755  PressTouchPoint(1, 1);
756  EXPECT_EQ(0U, queued_event_count());
757  EXPECT_EQ(1U, GetAndResetSentEventCount());
758  EXPECT_EQ(1U, GetAndResetAckedEventCount());
759
760  // TouchMove
761  SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
762  MoveTouchPoint(0, 2, 2);
763  EXPECT_EQ(0U, queued_event_count());
764  EXPECT_EQ(1U, GetAndResetSentEventCount());
765  EXPECT_EQ(1U, GetAndResetAckedEventCount());
766
767  // TouchEnd
768  SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
769  ReleaseTouchPoint(0);
770  EXPECT_EQ(0U, queued_event_count());
771  EXPECT_EQ(1U, GetAndResetSentEventCount());
772  EXPECT_EQ(1U, GetAndResetAckedEventCount());
773
774  // TouchCancel (first inserting a TouchStart so the TouchCancel will be sent)
775  PressTouchPoint(1, 1);
776  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
777  EXPECT_EQ(0U, queued_event_count());
778  EXPECT_EQ(1U, GetAndResetSentEventCount());
779  EXPECT_EQ(1U, GetAndResetAckedEventCount());
780
781  SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
782  CancelTouchPoint(0);
783  EXPECT_EQ(0U, queued_event_count());
784  EXPECT_EQ(1U, GetAndResetSentEventCount());
785  EXPECT_EQ(1U, GetAndResetAckedEventCount());
786}
787
788// Tests that followup events triggered by an immediate ack from
789// TouchEventQueue::QueueEvent() are properly handled.
790TEST_F(TouchEventQueueTest, ImmediateAckWithFollowupEvents) {
791  // Create a touch event that will be queued synchronously by a touch ack.
792  WebTouchEvent followup_event;
793  followup_event.type = WebInputEvent::TouchStart;
794  followup_event.touchesLength = 1;
795  followup_event.touches[0].id = 1;
796  followup_event.touches[0].state = WebTouchPoint::StatePressed;
797  SetFollowupEvent(followup_event);
798
799  // Now, enqueue a stationary touch that will not be forwarded.  This should be
800  // immediately ack'ed with "NO_CONSUMER_EXISTS".  The followup event should
801  // then be enqueued and immediately sent to the renderer.
802  WebTouchEvent stationary_event;
803  stationary_event.touchesLength = 1;
804  stationary_event.type = WebInputEvent::TouchMove;
805  stationary_event.touches[0].id = 1;
806  stationary_event.touches[0].state = WebTouchPoint::StateStationary;
807  SendTouchEvent(stationary_event);
808
809  EXPECT_EQ(1U, queued_event_count());
810  EXPECT_EQ(1U, GetAndResetSentEventCount());
811  EXPECT_EQ(1U, GetAndResetAckedEventCount());
812  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
813  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
814}
815
816// Tests basic TouchEvent forwarding suppression.
817TEST_F(TouchEventQueueTest, NoTouchBasic) {
818  // Disable TouchEvent forwarding.
819  OnHasTouchEventHandlers(false);
820  PressTouchPoint(30, 5);
821  EXPECT_EQ(0U, GetAndResetSentEventCount());
822  EXPECT_EQ(1U, GetAndResetAckedEventCount());
823
824  // TouchMove should not be sent to renderer.
825  MoveTouchPoint(0, 65, 10);
826  EXPECT_EQ(0U, GetAndResetSentEventCount());
827  EXPECT_EQ(1U, GetAndResetAckedEventCount());
828
829  // TouchEnd should not be sent to renderer.
830  ReleaseTouchPoint(0);
831  EXPECT_EQ(0U, GetAndResetSentEventCount());
832  EXPECT_EQ(1U, GetAndResetAckedEventCount());
833
834  // Enable TouchEvent forwarding.
835  OnHasTouchEventHandlers(true);
836
837  PressTouchPoint(80, 10);
838  EXPECT_EQ(1U, GetAndResetSentEventCount());
839  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
840  EXPECT_EQ(1U, GetAndResetAckedEventCount());
841
842  MoveTouchPoint(0, 80, 20);
843  EXPECT_EQ(1U, GetAndResetSentEventCount());
844  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
845  EXPECT_EQ(1U, GetAndResetAckedEventCount());
846
847  ReleaseTouchPoint(0);
848  EXPECT_EQ(1U, GetAndResetSentEventCount());
849  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
850  EXPECT_EQ(1U, GetAndResetAckedEventCount());
851}
852
853// Tests that no TouchEvents are sent to renderer during scrolling.
854TEST_F(TouchEventQueueTest, TouchCancelOnScroll) {
855  SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_TOUCHCANCEL);
856  // Queue a TouchStart.
857  PressTouchPoint(0, 1);
858  EXPECT_EQ(1U, GetAndResetSentEventCount());
859  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
860  EXPECT_EQ(1U, GetAndResetAckedEventCount());
861
862  MoveTouchPoint(0, 20, 5);
863  EXPECT_EQ(1U, queued_event_count());
864  EXPECT_EQ(1U, GetAndResetSentEventCount());
865
866  MoveTouchPoint(0, 30, 15);
867  EXPECT_EQ(2U, queued_event_count());
868  EXPECT_EQ(0U, GetAndResetSentEventCount());
869
870  // Queue another TouchStart.
871  PressTouchPoint(20, 20);
872  EXPECT_EQ(3U, queued_event_count());
873  EXPECT_EQ(0U, GetAndResetSentEventCount());
874  EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type);
875
876  WebGestureEvent followup_scroll;
877  followup_scroll.type = WebInputEvent::GestureScrollBegin;
878  SetFollowupEvent(followup_scroll);
879  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
880  EXPECT_EQ(1U, GetAndResetSentEventCount());
881  EXPECT_EQ(1U, GetAndResetAckedEventCount());
882  EXPECT_EQ(2U, queued_event_count());
883  EXPECT_TRUE(sent_event().cancelable);
884  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
885
886  // GestureScrollUpdate inserts a synthetic TouchCancel before the TouchStart.
887  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
888  SetFollowupEvent(followup_scroll);
889  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
890  EXPECT_EQ(1U, GetAndResetSentEventCount());
891  EXPECT_EQ(1U, GetAndResetAckedEventCount());
892  EXPECT_EQ(2U, queued_event_count());
893  EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
894  EXPECT_FALSE(sent_event().cancelable);
895  EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type);
896
897  // Acking the TouchCancel will result in dispatch of the next TouchStart.
898  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
899  // The synthetic TouchCancel should not reach client, only the TouchStart.
900  EXPECT_EQ(1U, GetAndResetAckedEventCount());
901  EXPECT_EQ(0U, GetAndResetSentEventCount());
902  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
903
904  // TouchMove should not be sent to the renderer.
905  MoveTouchPoint(0, 30, 5);
906  EXPECT_EQ(1U, GetAndResetAckedEventCount());
907  EXPECT_EQ(0U, GetAndResetSentEventCount());
908  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
909
910  // GestureScrollUpdates should not change affect touch forwarding.
911  SendGestureEvent(WebInputEvent::GestureScrollUpdate);
912
913  // TouchEnd should not be sent to the renderer.
914  ReleaseTouchPoint(0);
915  EXPECT_EQ(1U, GetAndResetAckedEventCount());
916  EXPECT_EQ(0U, GetAndResetSentEventCount());
917  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
918
919  ReleaseTouchPoint(0);
920  EXPECT_EQ(1U, GetAndResetAckedEventCount());
921  EXPECT_EQ(0U, GetAndResetSentEventCount());
922  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
923
924  // Touch events from a new gesture sequence should be forwarded normally.
925  PressTouchPoint(80, 10);
926  EXPECT_EQ(1U, GetAndResetSentEventCount());
927  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
928  EXPECT_EQ(1U, GetAndResetAckedEventCount());
929
930  MoveTouchPoint(0, 80, 20);
931  EXPECT_EQ(1U, GetAndResetSentEventCount());
932  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
933  EXPECT_EQ(1U, GetAndResetAckedEventCount());
934
935  ReleaseTouchPoint(0);
936  EXPECT_EQ(1U, GetAndResetSentEventCount());
937  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
938  EXPECT_EQ(1U, GetAndResetAckedEventCount());
939}
940
941// Tests that a scroll event will not insert a synthetic TouchCancel if there
942// was no consumer for the current touch sequence.
943TEST_F(TouchEventQueueTest, NoTouchCancelOnScrollIfNoConsumer) {
944  SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_TOUCHCANCEL);
945
946  // Queue a TouchStart.
947  PressTouchPoint(0, 1);
948  EXPECT_EQ(1U, GetAndResetSentEventCount());
949  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
950  EXPECT_EQ(1U, GetAndResetAckedEventCount());
951  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
952
953  // Queue a TouchMove that turns into a GestureScrollBegin.
954  WebGestureEvent followup_scroll;
955  followup_scroll.type = WebInputEvent::GestureScrollBegin;
956  SetFollowupEvent(followup_scroll);
957  MoveTouchPoint(0, 20, 5);
958
959  // The TouchMove has no consumer, and should be ack'ed immediately. However,
960  // *no* synthetic TouchCancel should be inserted as the touch sequence
961  // had no consumer.
962  EXPECT_EQ(0U, queued_event_count());
963  EXPECT_EQ(0U, GetAndResetSentEventCount());
964  EXPECT_EQ(1U, GetAndResetAckedEventCount());
965  EXPECT_EQ(0U, queued_event_count());
966  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
967
968  // Subsequent TouchMove's should not be sent to the renderer.
969  MoveTouchPoint(0, 30, 5);
970  EXPECT_EQ(1U, GetAndResetAckedEventCount());
971  EXPECT_EQ(0U, GetAndResetSentEventCount());
972  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
973
974  // TouchEnd should not be sent to the renderer.
975  ReleaseTouchPoint(0);
976  EXPECT_EQ(1U, GetAndResetAckedEventCount());
977  EXPECT_EQ(0U, GetAndResetSentEventCount());
978  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
979
980  // Touch events from a new gesture sequence should be forwarded normally.
981  PressTouchPoint(80, 10);
982  EXPECT_EQ(1U, GetAndResetSentEventCount());
983  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
984  EXPECT_EQ(1U, GetAndResetAckedEventCount());
985}
986
987// Tests that IsTouchStartPendingAck works correctly.
988TEST_F(TouchEventQueueTest, PendingStart) {
989
990  EXPECT_FALSE(IsPendingAckTouchStart());
991
992  // Send the touchstart for one point (#1).
993  PressTouchPoint(1, 1);
994  EXPECT_EQ(1U, queued_event_count());
995  EXPECT_TRUE(IsPendingAckTouchStart());
996
997  // Send a touchmove for that point (#2).
998  MoveTouchPoint(0, 5, 5);
999  EXPECT_EQ(2U, queued_event_count());
1000  EXPECT_TRUE(IsPendingAckTouchStart());
1001
1002  // Ack the touchstart (#1).
1003  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1004  EXPECT_EQ(1U, queued_event_count());
1005  EXPECT_FALSE(IsPendingAckTouchStart());
1006
1007  // Send a touchstart for another point (#3).
1008  PressTouchPoint(10, 10);
1009  EXPECT_EQ(2U, queued_event_count());
1010  EXPECT_FALSE(IsPendingAckTouchStart());
1011
1012  // Ack the touchmove (#2).
1013  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1014  EXPECT_EQ(1U, queued_event_count());
1015  EXPECT_TRUE(IsPendingAckTouchStart());
1016
1017  // Send a touchstart for a third point (#4).
1018  PressTouchPoint(15, 15);
1019  EXPECT_EQ(2U, queued_event_count());
1020  EXPECT_TRUE(IsPendingAckTouchStart());
1021
1022  // Ack the touchstart for the second point (#3).
1023  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1024  EXPECT_EQ(1U, queued_event_count());
1025  EXPECT_TRUE(IsPendingAckTouchStart());
1026
1027  // Ack the touchstart for the third point (#4).
1028  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1029  EXPECT_EQ(0U, queued_event_count());
1030  EXPECT_FALSE(IsPendingAckTouchStart());
1031}
1032
1033// Tests that the touch timeout is started when sending certain touch types.
1034TEST_F(TouchEventQueueTest, TouchTimeoutTypes) {
1035  SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1036
1037  // Sending a TouchStart will start the timeout.
1038  PressTouchPoint(0, 1);
1039  EXPECT_TRUE(IsTimeoutRunning());
1040  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1041  EXPECT_FALSE(IsTimeoutRunning());
1042
1043  // A TouchMove should start the timeout.
1044  MoveTouchPoint(0, 5, 5);
1045  EXPECT_TRUE(IsTimeoutRunning());
1046  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1047  EXPECT_FALSE(IsTimeoutRunning());
1048
1049  // A TouchEnd should not start the timeout.
1050  ReleaseTouchPoint(0);
1051  EXPECT_FALSE(IsTimeoutRunning());
1052  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1053  EXPECT_FALSE(IsTimeoutRunning());
1054
1055  // A TouchCancel should not start the timeout.
1056  PressTouchPoint(0, 1);
1057  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1058  ASSERT_FALSE(IsTimeoutRunning());
1059  CancelTouchPoint(0);
1060  EXPECT_FALSE(IsTimeoutRunning());
1061  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1062  EXPECT_FALSE(IsTimeoutRunning());
1063}
1064
1065// Tests that a delayed TouchEvent ack will trigger a TouchCancel timeout,
1066// disabling touch forwarding until the next TouchStart is received after
1067// the timeout events are ack'ed.
1068TEST_F(TouchEventQueueTest, TouchTimeoutBasic) {
1069  SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1070
1071  // Queue a TouchStart.
1072  GetAndResetSentEventCount();
1073  GetAndResetAckedEventCount();
1074  PressTouchPoint(0, 1);
1075  ASSERT_EQ(1U, GetAndResetSentEventCount());
1076  ASSERT_EQ(0U, GetAndResetAckedEventCount());
1077  EXPECT_TRUE(IsTimeoutRunning());
1078
1079  // Delay the ack.
1080  RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1081
1082  // The timeout should have fired, synthetically ack'ing the timed-out event.
1083  // TouchEvent forwarding is disabled until the ack is received for the
1084  // timed-out event and the future cancel event.
1085  EXPECT_FALSE(IsTimeoutRunning());
1086  EXPECT_EQ(0U, GetAndResetSentEventCount());
1087  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1088
1089  // Ack'ing the original event should trigger a cancel event.
1090  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1091  EXPECT_FALSE(IsTimeoutRunning());
1092  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1093  EXPECT_EQ(1U, GetAndResetSentEventCount());
1094  EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
1095  EXPECT_FALSE(sent_event().cancelable);
1096
1097  // Touch events should not be forwarded until we receive the cancel acks.
1098  MoveTouchPoint(0, 1, 1);
1099  ASSERT_EQ(0U, GetAndResetSentEventCount());
1100  ASSERT_EQ(1U, GetAndResetAckedEventCount());
1101
1102  ReleaseTouchPoint(0);
1103  ASSERT_EQ(0U, GetAndResetSentEventCount());
1104  ASSERT_EQ(1U, GetAndResetAckedEventCount());
1105
1106  // The synthetic TouchCancel ack should not reach the client, but should
1107  // resume touch forwarding.
1108  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1109  EXPECT_EQ(0U, GetAndResetSentEventCount());
1110  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1111
1112  // Subsequent events should be handled normally.
1113  PressTouchPoint(0, 1);
1114  EXPECT_EQ(1U, GetAndResetSentEventCount());
1115  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1116  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
1117  EXPECT_TRUE(sent_event().cancelable);
1118}
1119
1120// Tests that the timeout is never started if the renderer consumes
1121// a TouchEvent from the current touch sequence.
1122TEST_F(TouchEventQueueTest, NoTouchTimeoutIfRendererIsConsumingGesture) {
1123  SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1124
1125  // Queue a TouchStart.
1126  PressTouchPoint(0, 1);
1127  ASSERT_TRUE(IsTimeoutRunning());
1128
1129  // Mark the event as consumed. This should prevent the timeout from
1130  // being activated on subsequent TouchEvents in this gesture.
1131  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1132  EXPECT_FALSE(IsTimeoutRunning());
1133
1134  // A TouchMove should not start the timeout.
1135  MoveTouchPoint(0, 5, 5);
1136  EXPECT_FALSE(IsTimeoutRunning());
1137  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1138
1139  // A secondary TouchStart should not start the timeout.
1140  PressTouchPoint(1, 0);
1141  EXPECT_FALSE(IsTimeoutRunning());
1142  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1143
1144  // A TouchEnd should not start the timeout.
1145  ReleaseTouchPoint(1);
1146  EXPECT_FALSE(IsTimeoutRunning());
1147  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1148
1149  // A TouchCancel should not start the timeout.
1150  CancelTouchPoint(0);
1151  EXPECT_FALSE(IsTimeoutRunning());
1152}
1153
1154// Tests that the timeout is never started if the renderer consumes
1155// a TouchEvent from the current touch sequence.
1156TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledAfterTouchStart) {
1157  SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1158
1159  // Queue a TouchStart.
1160  PressTouchPoint(0, 1);
1161  ASSERT_TRUE(IsTimeoutRunning());
1162
1163  // Send the ack immediately. The timeout should not have fired.
1164  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1165  EXPECT_FALSE(IsTimeoutRunning());
1166  EXPECT_TRUE(IsTimeoutEnabled());
1167  EXPECT_EQ(1U, GetAndResetSentEventCount());
1168  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1169
1170  // Now explicitly disable the timeout.
1171  SetAckTimeoutDisabled();
1172  EXPECT_FALSE(IsTimeoutRunning());
1173  EXPECT_FALSE(IsTimeoutEnabled());
1174
1175  // A TouchMove should not start or trigger the timeout.
1176  MoveTouchPoint(0, 5, 5);
1177  EXPECT_FALSE(IsTimeoutRunning());
1178  EXPECT_EQ(1U, GetAndResetSentEventCount());
1179  RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1180  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1181}
1182
1183// Tests that the timeout is never started if the ack is synchronous.
1184TEST_F(TouchEventQueueTest, NoTouchTimeoutIfAckIsSynchronous) {
1185  SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1186
1187  // Queue a TouchStart.
1188  SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
1189  ASSERT_FALSE(IsTimeoutRunning());
1190  PressTouchPoint(0, 1);
1191  EXPECT_FALSE(IsTimeoutRunning());
1192}
1193
1194// Tests that the timeout is disabled if the touch handler disappears.
1195TEST_F(TouchEventQueueTest, NoTouchTimeoutIfTouchHandlerRemoved) {
1196  SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1197
1198  // Queue a TouchStart.
1199  PressTouchPoint(0, 1);
1200  ASSERT_TRUE(IsTimeoutRunning());
1201
1202  // Unload the touch handler.
1203  OnHasTouchEventHandlers(false);
1204  EXPECT_FALSE(IsTimeoutRunning());
1205}
1206
1207// Tests that the timeout does not fire if explicitly disabled while an event
1208// is in-flight.
1209TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledWhileTimerIsActive) {
1210  SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1211
1212  // Queue a TouchStart.
1213  PressTouchPoint(0, 1);
1214  ASSERT_TRUE(IsTimeoutRunning());
1215
1216  // Verify that disabling the timeout also turns off the timer.
1217  SetAckTimeoutDisabled();
1218  EXPECT_FALSE(IsTimeoutRunning());
1219  RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1220  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1221}
1222
1223// Tests that a TouchCancel timeout plays nice when the timed out touch stream
1224// turns into a scroll gesture sequence.
1225TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGesture) {
1226  SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1227
1228  // Queue a TouchStart.
1229  PressTouchPoint(0, 1);
1230  EXPECT_TRUE(IsTimeoutRunning());
1231  EXPECT_EQ(1U, GetAndResetSentEventCount());
1232
1233  // The cancelled sequence may turn into a scroll gesture.
1234  WebGestureEvent followup_scroll;
1235  followup_scroll.type = WebInputEvent::GestureScrollBegin;
1236  SetFollowupEvent(followup_scroll);
1237
1238  // Delay the ack.
1239  RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1240
1241  // The timeout should have fired, disabling touch forwarding until both acks
1242  // are received, acking the timed out event.
1243  EXPECT_FALSE(IsTimeoutRunning());
1244  EXPECT_EQ(0U, GetAndResetSentEventCount());
1245  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1246
1247  // Ack the original event, triggering a TouchCancel.
1248  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1249  EXPECT_FALSE(IsTimeoutRunning());
1250  EXPECT_EQ(1U, GetAndResetSentEventCount());
1251  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1252
1253  // Ack the cancel event.  Normally, this would resume touch forwarding,
1254  // but we're still within a scroll gesture so it remains disabled.
1255  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1256  EXPECT_FALSE(IsTimeoutRunning());
1257  EXPECT_EQ(0U, GetAndResetSentEventCount());
1258  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1259
1260  // Try to forward touch events for the current sequence.
1261  GetAndResetSentEventCount();
1262  GetAndResetAckedEventCount();
1263  MoveTouchPoint(0, 1, 1);
1264  ReleaseTouchPoint(0);
1265  EXPECT_FALSE(IsTimeoutRunning());
1266  EXPECT_EQ(0U, GetAndResetSentEventCount());
1267  EXPECT_EQ(2U, GetAndResetAckedEventCount());
1268
1269  // Now end the scroll sequence, resuming touch handling.
1270  SendGestureEvent(blink::WebInputEvent::GestureScrollEnd);
1271  PressTouchPoint(0, 1);
1272  EXPECT_TRUE(IsTimeoutRunning());
1273  EXPECT_EQ(1U, GetAndResetSentEventCount());
1274  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1275}
1276
1277// Tests that a TouchCancel timeout plays nice when the timed out touch stream
1278// turns into a scroll gesture sequence, but the original event acks are
1279// significantly delayed.
1280TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGestureAndDelayedAck) {
1281  SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1282
1283  // Queue a TouchStart.
1284  PressTouchPoint(0, 1);
1285  EXPECT_TRUE(IsTimeoutRunning());
1286  EXPECT_EQ(1U, GetAndResetSentEventCount());
1287
1288  // The cancelled sequence may turn into a scroll gesture.
1289  WebGestureEvent followup_scroll;
1290  followup_scroll.type = WebInputEvent::GestureScrollBegin;
1291  SetFollowupEvent(followup_scroll);
1292
1293  // Delay the ack.
1294  RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1295
1296  // The timeout should have fired, disabling touch forwarding until both acks
1297  // are received and acking the timed out event.
1298  EXPECT_FALSE(IsTimeoutRunning());
1299  EXPECT_EQ(0U, GetAndResetSentEventCount());
1300  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1301
1302  // Try to forward a touch event.
1303  GetAndResetSentEventCount();
1304  GetAndResetAckedEventCount();
1305  MoveTouchPoint(0, 1, 1);
1306  EXPECT_FALSE(IsTimeoutRunning());
1307  EXPECT_EQ(0U, GetAndResetSentEventCount());
1308  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1309
1310  // Now end the scroll sequence.  Events will not be forwarded until the two
1311  // outstanding touch acks are received.
1312  SendGestureEvent(blink::WebInputEvent::GestureScrollEnd);
1313  MoveTouchPoint(0, 2, 2);
1314  ReleaseTouchPoint(0);
1315  EXPECT_FALSE(IsTimeoutRunning());
1316  EXPECT_EQ(0U, GetAndResetSentEventCount());
1317  EXPECT_EQ(2U, GetAndResetAckedEventCount());
1318
1319  // Ack the original event, triggering a cancel.
1320  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1321  EXPECT_EQ(1U, GetAndResetSentEventCount());
1322  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1323
1324  // Ack the cancel event, resuming touch forwarding.
1325  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1326  EXPECT_EQ(0U, GetAndResetSentEventCount());
1327  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1328
1329  PressTouchPoint(0, 1);
1330  EXPECT_TRUE(IsTimeoutRunning());
1331  EXPECT_EQ(1U, GetAndResetSentEventCount());
1332}
1333
1334// Tests that a delayed TouchEvent ack will not trigger a TouchCancel timeout if
1335// the timed-out event had no consumer.
1336TEST_F(TouchEventQueueTest, NoCancelOnTouchTimeoutWithoutConsumer) {
1337  SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1338
1339  // Queue a TouchStart.
1340  PressTouchPoint(0, 1);
1341  ASSERT_EQ(1U, GetAndResetSentEventCount());
1342  ASSERT_EQ(0U, GetAndResetAckedEventCount());
1343  EXPECT_TRUE(IsTimeoutRunning());
1344
1345  // Delay the ack.
1346  RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1347
1348  // The timeout should have fired, synthetically ack'ing the timed out event.
1349  // TouchEvent forwarding is disabled until the original ack is received.
1350  EXPECT_FALSE(IsTimeoutRunning());
1351  EXPECT_EQ(0U, GetAndResetSentEventCount());
1352  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1353
1354  // Touch events should not be forwarded until we receive the original ack.
1355  MoveTouchPoint(0, 1, 1);
1356  ReleaseTouchPoint(0);
1357  ASSERT_EQ(0U, GetAndResetSentEventCount());
1358  ASSERT_EQ(2U, GetAndResetAckedEventCount());
1359
1360  // Ack'ing the original event should not trigger a cancel event, as the
1361  // TouchStart had no consumer.  However, it should re-enable touch forwarding.
1362  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1363  EXPECT_FALSE(IsTimeoutRunning());
1364  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1365  EXPECT_EQ(0U, GetAndResetSentEventCount());
1366
1367  // Subsequent events should be handled normally.
1368  PressTouchPoint(0, 1);
1369  EXPECT_EQ(1U, GetAndResetSentEventCount());
1370  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1371}
1372
1373// Tests that TouchMove's are dropped if within the boundary-inclusive slop
1374// suppression region for an unconsumed TouchStart.
1375TEST_F(TouchEventQueueTest, TouchMoveSuppressionIncludingSlopBoundary) {
1376  const double kSlopLengthDips = 10.;
1377  const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1378  const bool slop_includes_boundary = true;
1379  SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1380
1381  // Queue a TouchStart.
1382  PressTouchPoint(0, 0);
1383  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1384  ASSERT_EQ(1U, GetAndResetSentEventCount());
1385  ASSERT_EQ(1U, GetAndResetAckedEventCount());
1386
1387  // TouchMove's within the region should be suppressed.
1388  MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1389  EXPECT_EQ(0U, queued_event_count());
1390  EXPECT_EQ(0U, GetAndResetSentEventCount());
1391  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1392  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1393
1394  MoveTouchPoint(0, kHalfSlopLengthDips, 0);
1395  EXPECT_EQ(0U, queued_event_count());
1396  EXPECT_EQ(0U, GetAndResetSentEventCount());
1397  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1398  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1399
1400  MoveTouchPoint(0, -kHalfSlopLengthDips, 0);
1401  EXPECT_EQ(0U, queued_event_count());
1402  EXPECT_EQ(0U, GetAndResetSentEventCount());
1403  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1404  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1405
1406  MoveTouchPoint(0, -kSlopLengthDips, 0);
1407  EXPECT_EQ(0U, queued_event_count());
1408  EXPECT_EQ(0U, GetAndResetSentEventCount());
1409  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1410  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1411
1412  MoveTouchPoint(0, 0, kSlopLengthDips);
1413  EXPECT_EQ(0U, queued_event_count());
1414  EXPECT_EQ(0U, GetAndResetSentEventCount());
1415  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1416  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1417
1418  // As soon as a TouchMove exceeds the (Euclidean) distance, no more
1419  // TouchMove's should be suppressed.
1420  const double kFortyFiveDegreeSlopLengthXY =
1421      kSlopLengthDips * std::sqrt(2.) / 2.;
1422  MoveTouchPoint(0, kFortyFiveDegreeSlopLengthXY + .2,
1423                    kFortyFiveDegreeSlopLengthXY + .2);
1424  EXPECT_EQ(1U, queued_event_count());
1425  EXPECT_EQ(1U, GetAndResetSentEventCount());
1426  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1427  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1428  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1429
1430  // Even TouchMove's within the original slop region should now be forwarded.
1431  MoveTouchPoint(0, 0, 0);
1432  EXPECT_EQ(1U, queued_event_count());
1433  EXPECT_EQ(1U, GetAndResetSentEventCount());
1434  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1435  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1436  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1437
1438  // A new touch sequence should reset suppression.
1439  ReleaseTouchPoint(0);
1440  PressTouchPoint(0, 0);
1441  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1442  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1443  ASSERT_EQ(2U, GetAndResetSentEventCount());
1444  ASSERT_EQ(2U, GetAndResetAckedEventCount());
1445  ASSERT_EQ(0U, queued_event_count());
1446
1447  // The slop region is boundary-inclusive.
1448  MoveTouchPoint(0, kSlopLengthDips - 1., 0);
1449  EXPECT_EQ(0U, queued_event_count());
1450  EXPECT_EQ(0U, GetAndResetSentEventCount());
1451  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1452
1453  MoveTouchPoint(0, kSlopLengthDips, 0);
1454  EXPECT_EQ(0U, queued_event_count());
1455  EXPECT_EQ(0U, GetAndResetSentEventCount());
1456  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1457}
1458
1459// Tests that TouchMove's are dropped if within the boundary-exclusive slop
1460// suppression region for an unconsumed TouchStart.
1461TEST_F(TouchEventQueueTest, TouchMoveSuppressionExcludingSlopBoundary) {
1462  const double kSlopLengthDips = 10.;
1463  const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1464  const bool slop_includes_boundary = false;
1465  SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1466
1467  // Queue a TouchStart.
1468  PressTouchPoint(0, 0);
1469  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1470  ASSERT_EQ(1U, GetAndResetSentEventCount());
1471  ASSERT_EQ(1U, GetAndResetAckedEventCount());
1472
1473  // TouchMove's within the region should be suppressed.
1474  MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1475  EXPECT_EQ(0U, queued_event_count());
1476  EXPECT_EQ(0U, GetAndResetSentEventCount());
1477  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1478  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1479
1480  MoveTouchPoint(0, kSlopLengthDips - 0.2f, 0);
1481  EXPECT_EQ(0U, queued_event_count());
1482  EXPECT_EQ(0U, GetAndResetSentEventCount());
1483  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1484  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1485
1486  // As soon as a TouchMove reaches the (Euclidean) slop distance, no more
1487  // TouchMove's should be suppressed.
1488  MoveTouchPoint(0, kSlopLengthDips, 0);
1489  EXPECT_EQ(1U, queued_event_count());
1490  EXPECT_EQ(1U, GetAndResetSentEventCount());
1491  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1492  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1493  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1494
1495  MoveTouchPoint(0, kHalfSlopLengthDips, 0);
1496  EXPECT_EQ(1U, queued_event_count());
1497  EXPECT_EQ(1U, GetAndResetSentEventCount());
1498  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1499  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1500  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1501}
1502
1503// Tests that TouchMove's are not dropped within the slop suppression region if
1504// the touchstart was consumed.
1505TEST_F(TouchEventQueueTest, NoTouchMoveSuppressionAfterTouchConsumed) {
1506  const double kSlopLengthDips = 10.;
1507  const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1508  const bool slop_includes_boundary = true;
1509  SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1510
1511  // Queue a TouchStart.
1512  PressTouchPoint(0, 0);
1513  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1514  ASSERT_EQ(1U, GetAndResetSentEventCount());
1515  ASSERT_EQ(1U, GetAndResetAckedEventCount());
1516
1517  // TouchMove's within the region should not be suppressed, as a touch was
1518  // consumed.
1519  MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1520  EXPECT_EQ(1U, queued_event_count());
1521  EXPECT_EQ(1U, GetAndResetSentEventCount());
1522  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1523}
1524
1525// Tests that even very small TouchMove's are not suppressed when suppression is
1526// disabled.
1527TEST_F(TouchEventQueueTest, NoTouchMoveSuppressionIfDisabled) {
1528  // Queue a TouchStart.
1529  PressTouchPoint(0, 0);
1530  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1531  ASSERT_EQ(1U, GetAndResetSentEventCount());
1532  ASSERT_EQ(1U, GetAndResetAckedEventCount());
1533
1534  // Small TouchMove's should not be suppressed.
1535  MoveTouchPoint(0, 0.001f, 0.001f);
1536  EXPECT_EQ(1U, queued_event_count());
1537  EXPECT_EQ(1U, GetAndResetSentEventCount());
1538  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1539}
1540
1541// Tests that TouchMove's are not dropped due to incorrect handling of DPI
1542// scaling.
1543TEST_F(TouchEventQueueTest, TouchMoveSuppressionWithDIPScaling) {
1544  const float kSlopLengthPixels = 7.f;
1545  const float kDPIScale = 3.f;
1546  const bool slop_includes_boundary = true;
1547  SetUpForTouchMoveSlopTesting(kSlopLengthPixels / kDPIScale,
1548                               slop_includes_boundary);
1549
1550  // Queue a TouchStart.
1551  PressTouchPoint(0, 0);
1552  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1553  ASSERT_EQ(1U, GetAndResetSentEventCount());
1554  ASSERT_EQ(1U, GetAndResetAckedEventCount());
1555
1556  // TouchMove's along the slop boundary should be suppresed.
1557  MoveTouchPoint(0, 0, kSlopLengthPixels / kDPIScale);
1558  EXPECT_EQ(0U, queued_event_count());
1559  EXPECT_EQ(0U, GetAndResetSentEventCount());
1560  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1561
1562  // Reset the touch sequence.
1563  ReleaseTouchPoint(0);
1564  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1565  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1566  GetAndResetSentEventCount();
1567  GetAndResetAckedEventCount();
1568
1569  // Queue a TouchStart.
1570  PressTouchPoint(0, 0);
1571  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1572  ASSERT_EQ(1U, GetAndResetSentEventCount());
1573  ASSERT_EQ(1U, GetAndResetAckedEventCount());
1574
1575  // TouchMove's outside the region should not be suppressed.
1576  const float kPixelCoordOutsideSlopRegion = kSlopLengthPixels + 0.5f;
1577  MoveTouchPoint(0, 0, kPixelCoordOutsideSlopRegion / kDPIScale);
1578  EXPECT_EQ(1U, queued_event_count());
1579  EXPECT_EQ(1U, GetAndResetSentEventCount());
1580  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1581}
1582
1583// Tests that TouchMove's are not dropped if a secondary pointer is present
1584// during any movement.
1585TEST_F(TouchEventQueueTest, NoTouchMoveSuppressionAfterMultiTouch) {
1586  const double kSlopLengthDips = 10.;
1587  const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1588  const bool slop_includes_boundary = true;
1589  SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1590
1591  // Queue a TouchStart.
1592  PressTouchPoint(0, 0);
1593  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1594  ASSERT_EQ(1U, GetAndResetSentEventCount());
1595  ASSERT_EQ(1U, GetAndResetAckedEventCount());
1596
1597  // TouchMove's within the region should be suppressed.
1598  MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1599  EXPECT_EQ(0U, queued_event_count());
1600  EXPECT_EQ(0U, GetAndResetSentEventCount());
1601  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1602
1603  // Simulate a secondary pointer press.
1604  PressTouchPoint(kSlopLengthDips, 0);
1605  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1606  EXPECT_EQ(1U, GetAndResetSentEventCount());
1607  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1608
1609  // TouchMove with a secondary pointer should not be suppressed.
1610  MoveTouchPoint(1, kSlopLengthDips, 0);
1611  EXPECT_EQ(1U, queued_event_count());
1612  EXPECT_EQ(1U, GetAndResetSentEventCount());
1613  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1614  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1615
1616  // Release the secondary pointer.
1617  ReleaseTouchPoint(0);
1618  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1619  EXPECT_EQ(1U, GetAndResetSentEventCount());
1620  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1621
1622  // TouchMove's should not should be suppressed, even with the original
1623  // unmoved pointer.
1624  MoveTouchPoint(0, 0, 0);
1625  EXPECT_EQ(1U, queued_event_count());
1626  EXPECT_EQ(1U, GetAndResetSentEventCount());
1627  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1628}
1629
1630// Tests that secondary touch points can be forwarded even if the primary touch
1631// point had no consumer.
1632TEST_F(TouchEventQueueTest, SecondaryTouchForwardedAfterPrimaryHadNoConsumer) {
1633  // Queue a TouchStart.
1634  PressTouchPoint(0, 0);
1635  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1636  ASSERT_EQ(1U, GetAndResetSentEventCount());
1637  ASSERT_EQ(1U, GetAndResetAckedEventCount());
1638
1639  // Events should not be forwarded, as the point had no consumer.
1640  MoveTouchPoint(0, 0, 15);
1641  EXPECT_EQ(0U, queued_event_count());
1642  EXPECT_EQ(0U, GetAndResetSentEventCount());
1643  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1644
1645  // Simulate a secondary pointer press.
1646  PressTouchPoint(20, 0);
1647  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1648  EXPECT_EQ(1U, GetAndResetSentEventCount());
1649  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1650
1651  // TouchMove with a secondary pointer should not be suppressed.
1652  MoveTouchPoint(1, 25, 0);
1653  EXPECT_EQ(1U, queued_event_count());
1654  EXPECT_EQ(1U, GetAndResetSentEventCount());
1655  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1656  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1657}
1658
1659// Tests that no touch points will be forwarded after scrolling begins while no
1660// touch points have a consumer.
1661TEST_F(TouchEventQueueTest, NoForwardingAfterScrollWithNoTouchConsumers) {
1662  // Queue a TouchStart.
1663  PressTouchPoint(0, 0);
1664  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1665  ASSERT_EQ(1U, GetAndResetSentEventCount());
1666  ASSERT_EQ(1U, GetAndResetAckedEventCount());
1667
1668  WebGestureEvent followup_scroll;
1669  followup_scroll.type = WebInputEvent::GestureScrollBegin;
1670  SetFollowupEvent(followup_scroll);
1671  MoveTouchPoint(0, 20, 5);
1672  EXPECT_EQ(0U, GetAndResetSentEventCount());
1673  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1674  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
1675
1676  // The secondary pointer press should not be forwarded.
1677  PressTouchPoint(20, 0);
1678  EXPECT_EQ(0U, GetAndResetSentEventCount());
1679  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1680  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
1681
1682  // Neither should any further touchmoves be forwarded.
1683  MoveTouchPoint(1, 25, 0);
1684  EXPECT_EQ(0U, GetAndResetSentEventCount());
1685  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1686  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
1687}
1688
1689TEST_F(TouchEventQueueTest, SyncTouchMoveDoesntCancelTouchOnScroll) {
1690 SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_SYNC_TOUCHMOVE);
1691 // Queue a TouchStart.
1692 PressTouchPoint(0, 1);
1693 EXPECT_EQ(1U, GetAndResetSentEventCount());
1694 SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1695 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1696
1697 MoveTouchPoint(0, 20, 5);
1698 EXPECT_EQ(1U, queued_event_count());
1699 EXPECT_EQ(1U, GetAndResetSentEventCount());
1700
1701 // GestureScrollBegin doesn't insert a synthetic TouchCancel.
1702 WebGestureEvent followup_scroll;
1703 followup_scroll.type = WebInputEvent::GestureScrollBegin;
1704 SetFollowupEvent(followup_scroll);
1705 SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1706 EXPECT_EQ(0U, GetAndResetSentEventCount());
1707 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1708 EXPECT_EQ(0U, queued_event_count());
1709}
1710
1711TEST_F(TouchEventQueueTest, AsyncTouch) {
1712  SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
1713
1714  // Queue a TouchStart.
1715  PressTouchPoint(0, 1);
1716  EXPECT_EQ(1U, GetAndResetSentEventCount());
1717  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1718  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1719
1720  for (int i = 0; i < 3; ++i) {
1721   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1722                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1723
1724   MoveTouchPoint(0, 10, 5);
1725   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1726   EXPECT_FALSE(HasPendingAsyncTouchMove());
1727   EXPECT_TRUE(sent_event().cancelable);
1728   EXPECT_EQ(0U, queued_event_count());
1729   EXPECT_EQ(1U, GetAndResetSentEventCount());
1730
1731   // Consuming a scroll event will throttle subsequent touchmoves.
1732   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1733                       INPUT_EVENT_ACK_STATE_CONSUMED);
1734   MoveTouchPoint(0, 10, 5);
1735   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1736   EXPECT_TRUE(HasPendingAsyncTouchMove());
1737   EXPECT_EQ(0U, queued_event_count());
1738   EXPECT_EQ(0U, GetAndResetSentEventCount());
1739  }
1740}
1741
1742// Ensure that touchmove's are appropriately throttled during a typical
1743// scroll sequences that transitions between scrolls consumed and unconsumed.
1744TEST_F(TouchEventQueueTest, AsyncTouchThrottledAfterScroll) {
1745  SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
1746
1747  // Process a TouchStart
1748  PressTouchPoint(0, 1);
1749  EXPECT_EQ(1U, GetAndResetSentEventCount());
1750  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1751  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1752
1753  // Now send the first touch move and associated GestureScrollBegin.
1754  MoveTouchPoint(0, 0, 5);
1755  WebGestureEvent followup_scroll;
1756  followup_scroll.type = WebInputEvent::GestureScrollBegin;
1757  SetFollowupEvent(followup_scroll);
1758  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1759  EXPECT_EQ(1U, GetAndResetSentEventCount());
1760  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1761  SendGestureEventAck(WebInputEvent::GestureScrollBegin,
1762                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1763
1764  // Send the second touch move and associated GestureScrollUpdate, but don't
1765  // ACK the gesture event yet.
1766  MoveTouchPoint(0, 0, 50);
1767  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
1768  SetFollowupEvent(followup_scroll);
1769  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1770  EXPECT_EQ(1U, GetAndResetSentEventCount());
1771  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1772
1773  // Now queue a second touchmove and verify it's not (yet) dispatched.
1774  MoveTouchPoint(0, 0, 100);
1775  SetFollowupEvent(followup_scroll);
1776  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1777  EXPECT_TRUE(HasPendingAsyncTouchMove());
1778  EXPECT_EQ(0U, queued_event_count());
1779  EXPECT_EQ(0U, GetAndResetSentEventCount());
1780  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1781
1782  // Queuing the final touchend should flush the pending, async touchmove.
1783  ReleaseTouchPoint(0);
1784  followup_scroll.type = WebInputEvent::GestureScrollEnd;
1785  SetFollowupEvent(followup_scroll);
1786  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
1787  EXPECT_FALSE(HasPendingAsyncTouchMove());
1788  EXPECT_FALSE(sent_event().cancelable);
1789  EXPECT_EQ(1U, GetAndResetSentEventCount());
1790  EXPECT_EQ(2U, queued_event_count());
1791
1792  // Ack the flushed, async touchmove. The ack should not reach the client, but
1793  // it should trigger sending of the (now non-cancelable) touchend.
1794  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1795  EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
1796  EXPECT_FALSE(sent_event().cancelable);
1797  EXPECT_EQ(1U, GetAndResetSentEventCount());
1798  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1799  EXPECT_EQ(1U, queued_event_count());
1800
1801  // Ack the touchend.
1802  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1803  EXPECT_EQ(0U, queued_event_count());
1804  EXPECT_EQ(0U, GetAndResetSentEventCount());
1805  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1806
1807  // Now mark the scrolls as not consumed (which would cause future touchmoves
1808  // in the active sequence to be sent if there was one).
1809  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1810                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1811  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1812                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1813
1814  // Start a new touch sequence and verify that throttling has been reset.
1815  // Touch moves after the start of scrolling will again be throttled.
1816  PressTouchPoint(0, 0);
1817  EXPECT_EQ(1U, GetAndResetSentEventCount());
1818  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1819  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1820  MoveTouchPoint(0, 0, 5);
1821  followup_scroll.type = WebInputEvent::GestureScrollBegin;
1822  SetFollowupEvent(followup_scroll);
1823  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1824  EXPECT_EQ(1U, GetAndResetSentEventCount());
1825  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1826
1827  MoveTouchPoint(0, 0, 5);
1828  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
1829  SetFollowupEvent(followup_scroll);
1830  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1831  EXPECT_FALSE(HasPendingAsyncTouchMove());
1832  EXPECT_EQ(1U, GetAndResetSentEventCount());
1833  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1834
1835  MoveTouchPoint(0, 0, 10);
1836  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1837  EXPECT_TRUE(HasPendingAsyncTouchMove());
1838  EXPECT_EQ(0U, queued_event_count());
1839  EXPECT_EQ(0U, GetAndResetSentEventCount());
1840  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1841
1842  // As soon as a touchmove exceeds the outer slop region it will be forwarded
1843  // immediately.
1844  MoveTouchPoint(0, 0, 20);
1845  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1846  EXPECT_FALSE(HasPendingAsyncTouchMove());
1847  EXPECT_FALSE(sent_event().cancelable);
1848  EXPECT_EQ(0U, queued_event_count());
1849  EXPECT_EQ(1U, GetAndResetSentEventCount());
1850  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1851
1852  // Subsequent touchmove's should be deferred.
1853  MoveTouchPoint(0, 0, 25);
1854  EXPECT_TRUE(HasPendingAsyncTouchMove());
1855  EXPECT_EQ(0U, queued_event_count());
1856  EXPECT_EQ(0U, GetAndResetSentEventCount());
1857  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1858
1859  // The pending touchmove should be flushed with the the new touchmove if
1860  // sufficient time has passed.
1861  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
1862  MoveTouchPoint(0, 0, 15);
1863  EXPECT_FALSE(HasPendingAsyncTouchMove());
1864  EXPECT_FALSE(sent_event().cancelable);
1865  EXPECT_EQ(1U, queued_event_count());
1866  EXPECT_EQ(1U, GetAndResetSentEventCount());
1867  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1868  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1869  EXPECT_EQ(0U, queued_event_count());
1870  EXPECT_EQ(0U, GetAndResetSentEventCount());
1871  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1872
1873  // Non-touchmove events should always flush any pending touchmove events.
1874  MoveTouchPoint(0, 0, 25);
1875  EXPECT_TRUE(HasPendingAsyncTouchMove());
1876  EXPECT_EQ(0U, queued_event_count());
1877  EXPECT_EQ(0U, GetAndResetSentEventCount());
1878  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1879  PressTouchPoint(30, 30);
1880  EXPECT_FALSE(HasPendingAsyncTouchMove());
1881  EXPECT_FALSE(sent_event().cancelable);
1882  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
1883  EXPECT_EQ(1U, GetAndResetSentEventCount());
1884  EXPECT_EQ(2U, queued_event_count());
1885
1886  // Ack'ing the flushed, async touchmove will dispatch the touchstart. Note
1887  // that the flushed touchmove's ack will not reach the client (its
1888  // constituent events have already been ack'ed).
1889  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1890  EXPECT_FALSE(sent_event().cancelable);
1891  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
1892  EXPECT_EQ(1U, queued_event_count());
1893  EXPECT_EQ(1U, GetAndResetSentEventCount());
1894  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1895
1896  // Ack the touchstart.
1897  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1898  EXPECT_EQ(0U, queued_event_count());
1899  EXPECT_EQ(0U, GetAndResetSentEventCount());
1900  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1901
1902  // Send a secondary touchmove.
1903  MoveTouchPoint(1, 0, 25);
1904  EXPECT_TRUE(HasPendingAsyncTouchMove());
1905  EXPECT_EQ(0U, queued_event_count());
1906  EXPECT_EQ(0U, GetAndResetSentEventCount());
1907  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1908
1909  // An unconsumed scroll should resume synchronous touch handling.
1910  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1911                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1912
1913  // The pending touchmove should be coalesced with the next (now synchronous)
1914  // touchmove.
1915  MoveTouchPoint(0, 0, 25);
1916  EXPECT_TRUE(sent_event().cancelable);
1917  EXPECT_FALSE(HasPendingAsyncTouchMove());
1918  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
1919  EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[0].state);
1920  EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[1].state);
1921  EXPECT_EQ(1U, queued_event_count());
1922  EXPECT_EQ(1U, GetAndResetSentEventCount());
1923  EXPECT_EQ(0U, GetAndResetAckedEventCount());
1924
1925  // Subsequent touches will queue until the preceding, synchronous touches are
1926  // ack'ed.
1927  ReleaseTouchPoint(1);
1928  EXPECT_EQ(2U, queued_event_count());
1929  ReleaseTouchPoint(0);
1930  EXPECT_EQ(3U, queued_event_count());
1931  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1932  EXPECT_TRUE(sent_event().cancelable);
1933  EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
1934  EXPECT_EQ(2U, queued_event_count());
1935  EXPECT_EQ(1U, GetAndResetSentEventCount());
1936  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1937
1938  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1939  EXPECT_TRUE(sent_event().cancelable);
1940  EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
1941  EXPECT_EQ(1U, queued_event_count());
1942  EXPECT_EQ(1U, GetAndResetSentEventCount());
1943  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1944
1945  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1946  EXPECT_EQ(0U, queued_event_count());
1947  EXPECT_EQ(0U, GetAndResetSentEventCount());
1948  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1949}
1950
1951// Ensure that async touch dispatch and touch ack timeout interactions work
1952// appropriately.
1953TEST_F(TouchEventQueueTest, AsyncTouchWithAckTimeout) {
1954  SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
1955  SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1956
1957  // The touchstart should start the timeout.
1958  PressTouchPoint(0, 0);
1959  EXPECT_EQ(1U, GetAndResetSentEventCount());
1960  EXPECT_TRUE(IsTimeoutRunning());
1961  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1962  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1963  EXPECT_FALSE(IsTimeoutRunning());
1964
1965  // The start of a scroll gesture should trigger async touch event dispatch.
1966  MoveTouchPoint(0, 1, 1);
1967  EXPECT_EQ(1U, GetAndResetSentEventCount());
1968  EXPECT_TRUE(IsTimeoutRunning());
1969  WebGestureEvent followup_scroll;
1970  followup_scroll.type = WebInputEvent::GestureScrollBegin;
1971  SetFollowupEvent(followup_scroll);
1972  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1973  EXPECT_FALSE(IsTimeoutRunning());
1974  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1975
1976  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1977                      INPUT_EVENT_ACK_STATE_CONSUMED);
1978
1979  // An async touch should fire after the throttling interval has expired, but
1980  // it should not start the touch ack timeout.
1981  MoveTouchPoint(0, 5, 5);
1982  EXPECT_TRUE(HasPendingAsyncTouchMove());
1983  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1984
1985  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
1986  MoveTouchPoint(0, 5, 5);
1987  EXPECT_FALSE(IsTimeoutRunning());
1988  EXPECT_FALSE(HasPendingAsyncTouchMove());
1989  EXPECT_FALSE(sent_event().cancelable);
1990  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1991  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1992  EXPECT_EQ(1U, GetAndResetSentEventCount());
1993
1994  // An unconsumed scroll event will resume synchronous touchmoves, which are
1995  // subject to the ack timeout.
1996  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1997                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1998  MoveTouchPoint(0, 20, 5);
1999  EXPECT_TRUE(IsTimeoutRunning());
2000  EXPECT_TRUE(sent_event().cancelable);
2001  EXPECT_EQ(1U, GetAndResetSentEventCount());
2002
2003  // The timeout should fire, disabling touch forwarding until both acks are
2004  // received and acking the timed out event.
2005  RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
2006  EXPECT_FALSE(IsTimeoutRunning());
2007  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2008  EXPECT_EQ(0U, GetAndResetSentEventCount());
2009
2010  // Ack'ing the original event should trigger a cancel event.
2011  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2012  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2013  EXPECT_FALSE(sent_event().cancelable);
2014  EXPECT_EQ(0U, GetAndResetAckedEventCount());
2015  EXPECT_EQ(1U, GetAndResetSentEventCount());
2016
2017  // Subsequent touchmove's should not be forwarded, even as the scroll gesture
2018  // goes from unconsumed to consumed.
2019  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
2020                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2021  MoveTouchPoint(0, 20, 5);
2022  EXPECT_FALSE(HasPendingAsyncTouchMove());
2023  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2024  EXPECT_EQ(0U, GetAndResetSentEventCount());
2025
2026  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
2027                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2028  MoveTouchPoint(0, 25, 5);
2029  EXPECT_FALSE(HasPendingAsyncTouchMove());
2030  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2031  EXPECT_EQ(0U, GetAndResetSentEventCount());
2032}
2033
2034// Ensure that if the touch ack for an async touchmove triggers a follow-up
2035// touch event, that follow-up touch will be forwarded appropriately.
2036TEST_F(TouchEventQueueTest, AsyncTouchWithTouchCancelAfterAck) {
2037  SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
2038
2039  PressTouchPoint(0, 0);
2040  EXPECT_EQ(1U, GetAndResetSentEventCount());
2041  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2042  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2043
2044  // The start of a scroll gesture should trigger async touch event dispatch.
2045  MoveTouchPoint(0, 1, 1);
2046  EXPECT_EQ(1U, GetAndResetSentEventCount());
2047  WebGestureEvent followup_scroll;
2048  followup_scroll.type = WebInputEvent::GestureScrollBegin;
2049  SetFollowupEvent(followup_scroll);
2050  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2051  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2052  EXPECT_EQ(0U, queued_event_count());
2053
2054  SendGestureEvent(WebInputEvent::GestureScrollUpdate);
2055
2056  // The async touchmove should be ack'ed immediately, but not forwarded.
2057  // However, because the ack triggers a touchcancel, both the pending touch and
2058  // the queued touchcancel should be flushed.
2059  WebTouchEvent followup_cancel;
2060  followup_cancel.type = WebInputEvent::TouchCancel;
2061  followup_cancel.touchesLength = 1;
2062  followup_cancel.touches[0].state = WebTouchPoint::StateCancelled;
2063  SetFollowupEvent(followup_cancel);
2064  MoveTouchPoint(0, 5, 5);
2065  EXPECT_EQ(2U, queued_event_count());
2066  EXPECT_FALSE(sent_event().cancelable);
2067  EXPECT_FALSE(HasPendingAsyncTouchMove());
2068  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
2069  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
2070  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2071  EXPECT_EQ(1U, GetAndResetSentEventCount());
2072
2073  // The ack for the async touchmove should not reach the client, as it has
2074  // already been ack'ed.
2075  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2076  EXPECT_FALSE(sent_event().cancelable);
2077  EXPECT_EQ(1U, queued_event_count());
2078  EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
2079  EXPECT_EQ(0U, GetAndResetAckedEventCount());
2080  EXPECT_EQ(1U, GetAndResetSentEventCount());
2081
2082  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2083  EXPECT_EQ(0U, queued_event_count());
2084  EXPECT_EQ(WebInputEvent::TouchCancel, acked_event().type);
2085  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2086  EXPECT_EQ(0U, GetAndResetSentEventCount());
2087}
2088
2089// Ensure that the async touch is fully reset if the touch sequence restarts
2090// without properly terminating.
2091TEST_F(TouchEventQueueTest, AsyncTouchWithHardTouchStartReset) {
2092  SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
2093
2094  PressTouchPoint(0, 0);
2095  EXPECT_EQ(1U, GetAndResetSentEventCount());
2096  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2097  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2098
2099  // Trigger async touchmove dispatch.
2100  MoveTouchPoint(0, 1, 1);
2101  EXPECT_EQ(1U, GetAndResetSentEventCount());
2102  WebGestureEvent followup_scroll;
2103  followup_scroll.type = WebInputEvent::GestureScrollBegin;
2104  SetFollowupEvent(followup_scroll);
2105  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2106  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2107  EXPECT_EQ(0U, queued_event_count());
2108  SendGestureEvent(WebInputEvent::GestureScrollUpdate);
2109
2110  // The async touchmove should be immediately ack'ed but delivery is deferred.
2111  MoveTouchPoint(0, 2, 2);
2112  EXPECT_EQ(0U, GetAndResetSentEventCount());
2113  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2114  EXPECT_EQ(0U, queued_event_count());
2115  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
2116
2117  // The queue should be robust to hard touch restarts with a new touch
2118  // sequence. In this case, the deferred async touch should not be flushed
2119  // by the new touch sequence.
2120  SendGestureEvent(WebInputEvent::GestureScrollEnd);
2121  ResetTouchEvent();
2122
2123  PressTouchPoint(0, 0);
2124  EXPECT_EQ(1U, GetAndResetSentEventCount());
2125  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
2126  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2127  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2128}
2129
2130TEST_F(TouchEventQueueTest, TouchAbsorptionWithConsumedFirstMove) {
2131  SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
2132
2133  // Queue a TouchStart.
2134  PressTouchPoint(0, 1);
2135  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2136  EXPECT_EQ(0U, queued_event_count());
2137  EXPECT_EQ(1U, GetAndResetAckedEventCount());
2138
2139  MoveTouchPoint(0, 20, 5);
2140  SendGestureEvent(blink::WebInputEvent::GestureScrollBegin);
2141  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
2142  EXPECT_EQ(0U, queued_event_count());
2143  EXPECT_EQ(2U, GetAndResetSentEventCount());
2144
2145  // Even if the first touchmove event was consumed, subsequent unconsumed
2146  // touchmove events should trigger scrolling.
2147  MoveTouchPoint(0, 60, 5);
2148  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
2149  EXPECT_EQ(0U, queued_event_count());
2150  EXPECT_TRUE(sent_event().cancelable);
2151  EXPECT_EQ(1U, GetAndResetSentEventCount());
2152
2153  MoveTouchPoint(0, 20, 5);
2154  WebGestureEvent followup_scroll;
2155  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
2156  SetFollowupEvent(followup_scroll);
2157  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2158  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
2159                      INPUT_EVENT_ACK_STATE_CONSUMED);
2160  EXPECT_EQ(0U, queued_event_count());
2161  EXPECT_TRUE(sent_event().cancelable);
2162  EXPECT_EQ(1U, GetAndResetSentEventCount());
2163
2164  // Touch move event is throttled.
2165  MoveTouchPoint(0, 60, 5);
2166  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
2167  EXPECT_EQ(0U, queued_event_count());
2168  EXPECT_EQ(0U, GetAndResetSentEventCount());
2169}
2170
2171}  // namespace content
2172