touch_disposition_gesture_filter_unittest.cc revision effb81e5f8246d0db0270817048dc992db66e9fb 
1// Copyright 2014 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/memory/scoped_ptr.h"
7#include "testing/gtest/include/gtest/gtest.h"
8#include "ui/events/gesture_detection/mock_motion_event.h"
9#include "ui/events/gesture_detection/touch_disposition_gesture_filter.h"
10
11namespace ui {
12
13class TouchDispositionGestureFilterTest
14    : public testing::Test,
15      public TouchDispositionGestureFilterClient {
16 public:
17  TouchDispositionGestureFilterTest() : sent_gesture_count_(0) {}
18  virtual ~TouchDispositionGestureFilterTest() {}
19
20  // testing::Test
21  virtual void SetUp() OVERRIDE {
22    queue_.reset(new TouchDispositionGestureFilter(this));
23  }
24
25  virtual void TearDown() OVERRIDE {
26    queue_.reset();
27  }
28
29  // TouchDispositionGestureFilterClient
30  virtual void ForwardGestureEvent(const GestureEventData& event) OVERRIDE {
31    ++sent_gesture_count_;
32    sent_gestures_.push_back(event.type);
33  }
34
35 protected:
36  typedef std::vector<EventType> GestureList;
37
38  ::testing::AssertionResult GesturesMatch(const GestureList& expected,
39                                           const GestureList& actual) {
40    if (expected.size() != actual.size()) {
41      return ::testing::AssertionFailure()
42          << "actual.size(" << actual.size()
43          << ") != expected.size(" << expected.size() << ")";
44    }
45
46    for (size_t i = 0; i < expected.size(); ++i) {
47      if (expected[i] != actual[i]) {
48        return ::testing::AssertionFailure()
49            << "actual[" << i << "] ("
50            << actual[i]
51            << ") != expected[" << i << "] ("
52            << expected[i] << ")";
53      }
54    }
55
56    return ::testing::AssertionSuccess();
57  }
58
59  GestureList Gestures(EventType type) {
60    return GestureList(1, type);
61  }
62
63  GestureList Gestures(EventType type0, EventType type1) {
64    GestureList gestures(2);
65    gestures[0] = type0;
66    gestures[1] = type1;
67    return gestures;
68  }
69
70  GestureList Gestures(EventType type0,
71                       EventType type1,
72                       EventType type2) {
73    GestureList gestures(3);
74    gestures[0] = type0;
75    gestures[1] = type1;
76    gestures[2] = type2;
77    return gestures;
78  }
79
80  GestureList Gestures(EventType type0,
81                       EventType type1,
82                       EventType type2,
83                       EventType type3) {
84    GestureList gestures(4);
85    gestures[0] = type0;
86    gestures[1] = type1;
87    gestures[2] = type2;
88    gestures[3] = type3;
89    return gestures;
90  }
91
92  void SendTouchGestures() {
93    GestureEventDataPacket gesture_packet;
94    std::swap(gesture_packet, pending_gesture_packet_);
95    EXPECT_EQ(TouchDispositionGestureFilter::SUCCESS,
96              SendTouchGestures(touch_event_, gesture_packet));
97  }
98
99  TouchDispositionGestureFilter::PacketResult
100  SendTouchGestures(const MotionEvent& touch,
101                    const GestureEventDataPacket& packet) {
102    GestureEventDataPacket touch_packet =
103        GestureEventDataPacket::FromTouch(touch);
104    for (size_t i = 0; i < packet.gesture_count(); ++i)
105      touch_packet.Push(packet.gesture(i));
106    return queue_->OnGesturePacket(touch_packet);
107  }
108
109  TouchDispositionGestureFilter::PacketResult
110  SendTimeoutGesture(EventType type) {
111    return queue_->OnGesturePacket(
112        GestureEventDataPacket::FromTouchTimeout(CreateGesture(type)));
113  }
114
115  TouchDispositionGestureFilter::PacketResult
116  SendGesturePacket(const GestureEventDataPacket& packet) {
117    return queue_->OnGesturePacket(packet);
118  }
119
120  void SendTouchEventAck(bool event_consumed) {
121    queue_->OnTouchEventAck(event_consumed);
122  }
123
124  void SendTouchConsumedAck() {
125    SendTouchEventAck(true);
126  }
127
128  void SendTouchNotConsumedAck() {
129    SendTouchEventAck(false);
130  }
131
132  void PushGesture(EventType type) {
133    pending_gesture_packet_.Push(CreateGesture(type));
134  }
135
136  void PressTouchPoint(int x, int y) {
137    touch_event_.PressPoint(x, y);
138    SendTouchGestures();
139  }
140
141  void MoveTouchPoint(size_t index, int x, int y) {
142    touch_event_.MovePoint(index, x, y);
143    SendTouchGestures();
144  }
145
146  void ReleaseTouchPoint() {
147    touch_event_.ReleasePoint();
148    SendTouchGestures();
149  }
150
151  void CancelTouchPoint() {
152    touch_event_.CancelPoint();
153    SendTouchGestures();
154  }
155
156  bool GesturesSent() const {
157    return !sent_gestures_.empty();
158  }
159
160  bool IsEmpty() const {
161    return queue_->IsEmpty();
162  }
163
164  GestureList GetAndResetSentGestures() {
165    GestureList sent_gestures;
166    sent_gestures.swap(sent_gestures_);
167    return sent_gestures;
168  }
169
170  static GestureEventData CreateGesture(EventType type) {
171    return GestureEventData(type, base::TimeTicks(), 0, 0);
172  }
173
174 private:
175  scoped_ptr<TouchDispositionGestureFilter> queue_;
176  MockMotionEvent touch_event_;
177  GestureEventDataPacket pending_gesture_packet_;
178  size_t sent_gesture_count_;
179  GestureList sent_gestures_;
180};
181
182TEST_F(TouchDispositionGestureFilterTest, BasicNoGestures) {
183  PressTouchPoint(1, 1);
184  EXPECT_FALSE(GesturesSent());
185
186  MoveTouchPoint(0, 2, 2);
187  EXPECT_FALSE(GesturesSent());
188
189  // No gestures should be dispatched by the ack, as the queued packets
190  // contained no gestures.
191  SendTouchConsumedAck();
192  EXPECT_FALSE(GesturesSent());
193
194  // Release the touch gesture.
195  ReleaseTouchPoint();
196  SendTouchConsumedAck();
197  SendTouchConsumedAck();
198  EXPECT_FALSE(GesturesSent());
199}
200
201TEST_F(TouchDispositionGestureFilterTest, BasicGestures) {
202  // An unconsumed touch's gesture should be sent.
203  PushGesture(ET_GESTURE_SCROLL_BEGIN);
204  PressTouchPoint(1, 1);
205  EXPECT_FALSE(GesturesSent());
206  SendTouchNotConsumedAck();
207  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
208                            GetAndResetSentGestures()));
209
210  // Multiple gestures can be queued for a single event.
211  PushGesture(ET_SCROLL_FLING_START);
212  PushGesture(ET_SCROLL_FLING_CANCEL);
213  ReleaseTouchPoint();
214  EXPECT_FALSE(GesturesSent());
215  SendTouchNotConsumedAck();
216  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_START,
217                                     ET_SCROLL_FLING_CANCEL),
218                            GetAndResetSentGestures()));
219}
220
221TEST_F(TouchDispositionGestureFilterTest, BasicGesturesConsumed) {
222  // A consumed touch's gesture should not be sent.
223  PushGesture(ET_GESTURE_SCROLL_BEGIN);
224  PressTouchPoint(1, 1);
225  SendTouchConsumedAck();
226  EXPECT_FALSE(GesturesSent());
227
228  PushGesture(ET_SCROLL_FLING_START);
229  PushGesture(ET_SCROLL_FLING_CANCEL);
230  ReleaseTouchPoint();
231  SendTouchConsumedAck();
232  EXPECT_FALSE(GesturesSent());
233}
234
235TEST_F(TouchDispositionGestureFilterTest, ConsumedThenNotConsumed) {
236  // A consumed touch's gesture should not be sent.
237  PushGesture(ET_GESTURE_SCROLL_BEGIN);
238  PressTouchPoint(1, 1);
239  SendTouchConsumedAck();
240  EXPECT_FALSE(GesturesSent());
241
242  // Even if the subsequent touch is not consumed, continue dropping gestures.
243  PushGesture(ET_GESTURE_SCROLL_UPDATE);
244  MoveTouchPoint(0, 2, 2);
245  SendTouchNotConsumedAck();
246  EXPECT_FALSE(GesturesSent());
247
248  // Even if the subsequent touch had no consumer, continue dropping gestures.
249  PushGesture(ET_SCROLL_FLING_START);
250  ReleaseTouchPoint();
251  SendTouchNotConsumedAck();
252  EXPECT_FALSE(GesturesSent());
253}
254
255TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenConsumed) {
256  // A not consumed touch's gesture should be sent.
257  PushGesture(ET_GESTURE_SCROLL_BEGIN);
258  PressTouchPoint(1, 1);
259  SendTouchNotConsumedAck();
260  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
261                            GetAndResetSentGestures()));
262
263  // A newly consumed gesture should not be sent.
264  PushGesture(ET_GESTURE_PINCH_BEGIN);
265  PressTouchPoint(10, 10);
266  SendTouchConsumedAck();
267  EXPECT_FALSE(GesturesSent());
268
269  // And subsequent non-consumed pinch updates should not be sent.
270  PushGesture(ET_GESTURE_SCROLL_UPDATE);
271  PushGesture(ET_GESTURE_PINCH_UPDATE);
272  MoveTouchPoint(0, 2, 2);
273  SendTouchNotConsumedAck();
274  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
275                            GetAndResetSentGestures()));
276
277  // End events dispatched only when their start events were.
278  PushGesture(ET_GESTURE_PINCH_END);
279  ReleaseTouchPoint();
280  SendTouchNotConsumedAck();
281  EXPECT_FALSE(GesturesSent());
282
283  PushGesture(ET_GESTURE_SCROLL_END);
284  ReleaseTouchPoint();
285  SendTouchConsumedAck();
286  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
287                            GetAndResetSentGestures()));
288}
289
290TEST_F(TouchDispositionGestureFilterTest, ScrollAlternatelyConsumed) {
291  // A consumed touch's gesture should not be sent.
292  PushGesture(ET_GESTURE_SCROLL_BEGIN);
293  PressTouchPoint(1, 1);
294  SendTouchNotConsumedAck();
295  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
296                            GetAndResetSentGestures()));
297
298  for (size_t i = 0; i < 3; ++i) {
299    PushGesture(ET_GESTURE_SCROLL_UPDATE);
300    MoveTouchPoint(0, 2, 2);
301    SendTouchConsumedAck();
302    EXPECT_FALSE(GesturesSent());
303
304    PushGesture(ET_GESTURE_SCROLL_UPDATE);
305    MoveTouchPoint(0, 3, 3);
306    SendTouchNotConsumedAck();
307    EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
308                              GetAndResetSentGestures()));
309  }
310
311  PushGesture(ET_GESTURE_SCROLL_END);
312  ReleaseTouchPoint();
313  SendTouchConsumedAck();
314  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
315                            GetAndResetSentGestures()));
316}
317
318TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenNoConsumer) {
319  // An unconsumed touch's gesture should be sent.
320  PushGesture(ET_GESTURE_SCROLL_BEGIN);
321  PressTouchPoint(1, 1);
322  SendTouchNotConsumedAck();
323  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
324                            GetAndResetSentGestures()));
325
326  // If the subsequent touch has no consumer (e.g., a secondary pointer is
327  // pressed but not on a touch handling rect), send the gesture.
328  PushGesture(ET_GESTURE_PINCH_BEGIN);
329  PressTouchPoint(2, 2);
330  SendTouchNotConsumedAck();
331  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
332                            GetAndResetSentGestures()));
333
334  // End events should be dispatched when their start events were, independent
335  // of the ack state.
336  PushGesture(ET_GESTURE_PINCH_END);
337  ReleaseTouchPoint();
338  SendTouchConsumedAck();
339  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
340                            GetAndResetSentGestures()));
341
342  PushGesture(ET_GESTURE_SCROLL_END);
343  ReleaseTouchPoint();
344  SendTouchConsumedAck();
345  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
346                            GetAndResetSentGestures()));
347}
348
349TEST_F(TouchDispositionGestureFilterTest, EndingEventsSent) {
350  PushGesture(ET_GESTURE_SCROLL_BEGIN);
351  PressTouchPoint(1, 1);
352  SendTouchNotConsumedAck();
353  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
354                            GetAndResetSentGestures()));
355
356  PushGesture(ET_GESTURE_PINCH_BEGIN);
357  PressTouchPoint(2, 2);
358  SendTouchNotConsumedAck();
359  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
360                            GetAndResetSentGestures()));
361
362  // Consuming the touchend event can't suppress the match end gesture.
363  PushGesture(ET_GESTURE_PINCH_END);
364  ReleaseTouchPoint();
365  SendTouchConsumedAck();
366  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
367                            GetAndResetSentGestures()));
368
369  // But other events in the same packet are still suppressed.
370  PushGesture(ET_GESTURE_SCROLL_UPDATE);
371  PushGesture(ET_GESTURE_SCROLL_END);
372  ReleaseTouchPoint();
373  SendTouchConsumedAck();
374  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
375                            GetAndResetSentGestures()));
376
377  // ET_GESTURE_SCROLL_END and ET_SCROLL_FLING_START behave the same in this
378  // regard.
379  PushGesture(ET_GESTURE_SCROLL_BEGIN);
380  PressTouchPoint(1, 1);
381  SendTouchNotConsumedAck();
382  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
383                            GetAndResetSentGestures()));
384
385  PushGesture(ET_SCROLL_FLING_START);
386  ReleaseTouchPoint();
387  SendTouchConsumedAck();
388  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_START),
389                            GetAndResetSentGestures()));
390}
391
392TEST_F(TouchDispositionGestureFilterTest, EndingEventsNotSent) {
393  // Consuming a begin event ensures no end events are sent.
394  PushGesture(ET_GESTURE_SCROLL_BEGIN);
395  PressTouchPoint(1, 1);
396  SendTouchConsumedAck();
397  EXPECT_FALSE(GesturesSent());
398
399  PushGesture(ET_GESTURE_PINCH_BEGIN);
400  PressTouchPoint(2, 2);
401  SendTouchNotConsumedAck();
402  EXPECT_FALSE(GesturesSent());
403
404  PushGesture(ET_GESTURE_PINCH_END);
405  ReleaseTouchPoint();
406  SendTouchNotConsumedAck();
407  EXPECT_FALSE(GesturesSent());
408
409  PushGesture(ET_GESTURE_SCROLL_END);
410  ReleaseTouchPoint();
411  SendTouchNotConsumedAck();
412  EXPECT_FALSE(GesturesSent());
413}
414
415TEST_F(TouchDispositionGestureFilterTest, UpdateEventsSuppressedPerEvent) {
416  PushGesture(ET_GESTURE_SCROLL_BEGIN);
417  PressTouchPoint(1, 1);
418  SendTouchNotConsumedAck();
419  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
420                            GetAndResetSentGestures()));
421
422  // Consuming a single scroll or pinch update should suppress only that event.
423  PushGesture(ET_GESTURE_SCROLL_UPDATE);
424  MoveTouchPoint(0, 2, 2);
425  SendTouchConsumedAck();
426  EXPECT_FALSE(GesturesSent());
427
428  PushGesture(ET_GESTURE_PINCH_BEGIN);
429  PressTouchPoint(2, 2);
430  SendTouchNotConsumedAck();
431  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
432                            GetAndResetSentGestures()));
433
434  PushGesture(ET_GESTURE_PINCH_UPDATE);
435  MoveTouchPoint(1, 2, 3);
436  SendTouchConsumedAck();
437  EXPECT_FALSE(GesturesSent());
438
439  // Subsequent updates should not be affected.
440  PushGesture(ET_GESTURE_SCROLL_UPDATE);
441  MoveTouchPoint(0, 4, 4);
442  SendTouchNotConsumedAck();
443  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
444                            GetAndResetSentGestures()));
445
446  PushGesture(ET_GESTURE_PINCH_UPDATE);
447  MoveTouchPoint(0, 4, 5);
448  SendTouchNotConsumedAck();
449  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_UPDATE),
450                            GetAndResetSentGestures()));
451
452  PushGesture(ET_GESTURE_PINCH_END);
453  ReleaseTouchPoint();
454  SendTouchConsumedAck();
455  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
456                            GetAndResetSentGestures()));
457
458  PushGesture(ET_GESTURE_SCROLL_END);
459  ReleaseTouchPoint();
460  SendTouchConsumedAck();
461  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
462                            GetAndResetSentGestures()));
463}
464
465TEST_F(TouchDispositionGestureFilterTest, UpdateEventsDependOnBeginEvents) {
466  PushGesture(ET_GESTURE_SCROLL_BEGIN);
467  PressTouchPoint(1, 1);
468  SendTouchConsumedAck();
469  EXPECT_FALSE(GesturesSent());
470
471  // Scroll and pinch gestures depend on the scroll begin gesture being
472  // dispatched.
473  PushGesture(ET_GESTURE_SCROLL_UPDATE);
474  MoveTouchPoint(0, 2, 2);
475  SendTouchNotConsumedAck();
476  EXPECT_FALSE(GesturesSent());
477
478  PushGesture(ET_GESTURE_PINCH_BEGIN);
479  PressTouchPoint(2, 2);
480  SendTouchNotConsumedAck();
481  EXPECT_FALSE(GesturesSent());
482
483  PushGesture(ET_GESTURE_PINCH_UPDATE);
484  MoveTouchPoint(1, 2, 3);
485  SendTouchConsumedAck();
486  EXPECT_FALSE(GesturesSent());
487
488  PushGesture(ET_GESTURE_PINCH_END);
489  ReleaseTouchPoint();
490  SendTouchNotConsumedAck();
491  EXPECT_FALSE(GesturesSent());
492
493  PushGesture(ET_GESTURE_SCROLL_END);
494  ReleaseTouchPoint();
495  SendTouchNotConsumedAck();
496  EXPECT_FALSE(GesturesSent());
497}
498
499TEST_F(TouchDispositionGestureFilterTest, MultipleTouchSequences) {
500  // Queue two touch-to-gestures sequences.
501  PushGesture(ET_GESTURE_TAP_DOWN);
502  PressTouchPoint(1, 1);
503  PushGesture(ET_GESTURE_TAP);
504  ReleaseTouchPoint();
505  PushGesture(ET_GESTURE_SCROLL_BEGIN);
506  PressTouchPoint(1, 1);
507  PushGesture(ET_GESTURE_SCROLL_END);
508  ReleaseTouchPoint();
509
510  // The first gesture sequence should not be allowed.
511  SendTouchConsumedAck();
512  SendTouchNotConsumedAck();
513  EXPECT_FALSE(GesturesSent());
514
515  // The subsequent sequence should "reset" allowance.
516  SendTouchNotConsumedAck();
517  SendTouchNotConsumedAck();
518  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
519                                     ET_GESTURE_SCROLL_END),
520                            GetAndResetSentGestures()));
521}
522
523TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnNewTouchSequence) {
524  // Simulate a fling.
525  PushGesture(ET_GESTURE_SCROLL_BEGIN);
526  PressTouchPoint(1, 1);
527  SendTouchNotConsumedAck();
528  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
529                            GetAndResetSentGestures()));
530  PushGesture(ET_SCROLL_FLING_START);
531  ReleaseTouchPoint();
532  SendTouchNotConsumedAck();
533  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_START),
534                            GetAndResetSentGestures()));
535
536  // A new touch seqeuence should cancel the outstanding fling.
537  PressTouchPoint(1, 1);
538  SendTouchNotConsumedAck();
539  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_CANCEL),
540                            GetAndResetSentGestures()));
541  ReleaseTouchPoint();
542  SendTouchNotConsumedAck();
543  EXPECT_FALSE(GesturesSent());
544}
545
546TEST_F(TouchDispositionGestureFilterTest, ScrollEndedOnNewTouchSequence) {
547  // Simulate a scroll.
548  PushGesture(ET_GESTURE_SCROLL_BEGIN);
549  PressTouchPoint(1, 1);
550  SendTouchNotConsumedAck();
551  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
552                            GetAndResetSentGestures()));
553  ReleaseTouchPoint();
554  SendTouchNotConsumedAck();
555
556  // A new touch seqeuence should end the outstanding scroll.
557  PressTouchPoint(1, 1);
558  SendTouchConsumedAck();
559  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
560                            GetAndResetSentGestures()));
561}
562
563TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnScrollBegin) {
564  // Simulate a fling sequence.
565  PushGesture(ET_GESTURE_SCROLL_BEGIN);
566  PushGesture(ET_SCROLL_FLING_START);
567  PressTouchPoint(1, 1);
568  SendTouchNotConsumedAck();
569  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
570                                     ET_SCROLL_FLING_START),
571                            GetAndResetSentGestures()));
572
573  // The new fling should cancel the preceding one.
574  PushGesture(ET_GESTURE_SCROLL_BEGIN);
575  PushGesture(ET_SCROLL_FLING_START);
576  ReleaseTouchPoint();
577  SendTouchNotConsumedAck();
578  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_CANCEL,
579                                     ET_GESTURE_SCROLL_BEGIN,
580                                     ET_SCROLL_FLING_START),
581                            GetAndResetSentGestures()));
582}
583
584TEST_F(TouchDispositionGestureFilterTest, FlingNotCancelledIfGFCEventReceived) {
585  // Simulate a fling that is started then cancelled.
586  PushGesture(ET_GESTURE_SCROLL_BEGIN);
587  PressTouchPoint(1, 1);
588  SendTouchNotConsumedAck();
589  PushGesture(ET_SCROLL_FLING_START);
590  MoveTouchPoint(0, 1, 1);
591  SendTouchNotConsumedAck();
592  PushGesture(ET_SCROLL_FLING_CANCEL);
593  ReleaseTouchPoint();
594  SendTouchNotConsumedAck();
595  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
596                                     ET_SCROLL_FLING_START,
597                                     ET_SCROLL_FLING_CANCEL),
598                            GetAndResetSentGestures()));
599
600  // A new touch sequence will not inject a ET_SCROLL_FLING_CANCEL, as the fling
601  // has already been cancelled.
602  PressTouchPoint(1, 1);
603  SendTouchNotConsumedAck();
604  ReleaseTouchPoint();
605  SendTouchNotConsumedAck();
606  EXPECT_FALSE(GesturesSent());
607}
608
609TEST_F(TouchDispositionGestureFilterTest, TapCancelledWhenScrollBegins) {
610  PushGesture(ET_GESTURE_TAP_DOWN);
611  PressTouchPoint(1, 1);
612  SendTouchNotConsumedAck();
613  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
614                            GetAndResetSentGestures()));
615
616  // If the subsequent touch turns into a scroll, the tap should be cancelled.
617  PushGesture(ET_GESTURE_SCROLL_BEGIN);
618  MoveTouchPoint(0, 2, 2);
619  SendTouchNotConsumedAck();
620  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
621                                     ET_GESTURE_SCROLL_BEGIN),
622                            GetAndResetSentGestures()));
623}
624
625TEST_F(TouchDispositionGestureFilterTest, TapCancelledWhenTouchConsumed) {
626  PushGesture(ET_GESTURE_TAP_DOWN);
627  PressTouchPoint(1, 1);
628  SendTouchNotConsumedAck();
629  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
630                            GetAndResetSentGestures()));
631
632  // If the subsequent touch is consumed, the tap should be cancelled.
633  PushGesture(ET_GESTURE_SCROLL_BEGIN);
634  MoveTouchPoint(0, 2, 2);
635  SendTouchConsumedAck();
636  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL),
637                            GetAndResetSentGestures()));
638}
639
640TEST_F(TouchDispositionGestureFilterTest,
641       TapNotCancelledIfTapEndingEventReceived) {
642  PushGesture(ET_GESTURE_TAP_DOWN);
643  PressTouchPoint(1, 1);
644  PressTouchPoint(2, 2);
645  SendTouchNotConsumedAck();
646  SendTouchNotConsumedAck();
647  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
648                            GetAndResetSentGestures()));
649
650  PushGesture(ET_GESTURE_TAP);
651  ReleaseTouchPoint();
652  SendTouchNotConsumedAck();
653  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP),
654                            GetAndResetSentGestures()));
655
656  // The tap should not be cancelled as it was terminated by a |ET_GESTURE_TAP|.
657  ReleaseTouchPoint();
658  SendTouchConsumedAck();
659  EXPECT_FALSE(GesturesSent());
660}
661
662TEST_F(TouchDispositionGestureFilterTest, TimeoutGestures) {
663  // If the sequence is allowed, and there are no preceding gestures, the
664  // timeout gestures should be forwarded immediately.
665  PressTouchPoint(1, 1);
666  SendTouchNotConsumedAck();
667  EXPECT_FALSE(GesturesSent());
668
669  SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
670  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS),
671                            GetAndResetSentGestures()));
672
673  SendTimeoutGesture(ET_GESTURE_LONG_PRESS);
674  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_LONG_PRESS),
675                            GetAndResetSentGestures()));
676
677  ReleaseTouchPoint();
678  SendTouchNotConsumedAck();
679
680  // If the sequence is disallowed, and there are no preceding gestures, the
681  // timeout gestures should be dropped immediately.
682  PressTouchPoint(1, 1);
683  SendTouchConsumedAck();
684  EXPECT_FALSE(GesturesSent());
685
686  SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
687  EXPECT_FALSE(GesturesSent());
688  ReleaseTouchPoint();
689  SendTouchNotConsumedAck();
690
691  // If the sequence has a pending ack, the timeout gestures should
692  // remain queued until the ack is received.
693  PressTouchPoint(1, 1);
694  EXPECT_FALSE(GesturesSent());
695
696  SendTimeoutGesture(ET_GESTURE_LONG_PRESS);
697  EXPECT_FALSE(GesturesSent());
698
699  SendTouchNotConsumedAck();
700  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_LONG_PRESS),
701                            GetAndResetSentGestures()));
702}
703
704TEST_F(TouchDispositionGestureFilterTest, SpuriousAcksIgnored) {
705  // Acks received when the queue is empty will be safely ignored.
706  ASSERT_TRUE(IsEmpty());
707  SendTouchConsumedAck();
708  EXPECT_FALSE(GesturesSent());
709
710  PushGesture(ET_GESTURE_SCROLL_BEGIN);
711  PressTouchPoint(1, 1);
712  PushGesture(ET_GESTURE_SCROLL_UPDATE);
713  MoveTouchPoint(0, 3,3);
714  SendTouchNotConsumedAck();
715  SendTouchNotConsumedAck();
716  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
717                                     ET_GESTURE_SCROLL_UPDATE),
718                            GetAndResetSentGestures()));
719
720  // Even if all packets have been dispatched, the filter may not be empty as
721  // there could be follow-up timeout events.  Spurious acks in such cases
722  // should also be safely ignored.
723  ASSERT_FALSE(IsEmpty());
724  SendTouchConsumedAck();
725  EXPECT_FALSE(GesturesSent());
726}
727
728TEST_F(TouchDispositionGestureFilterTest, PacketWithInvalidTypeIgnored) {
729  GestureEventDataPacket packet;
730  EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_TYPE,
731            SendGesturePacket(packet));
732  EXPECT_TRUE(IsEmpty());
733}
734
735TEST_F(TouchDispositionGestureFilterTest, PacketsWithInvalidOrderIgnored) {
736  EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_ORDER,
737            SendTimeoutGesture(ET_GESTURE_SHOW_PRESS));
738  EXPECT_TRUE(IsEmpty());
739}
740
741TEST_F(TouchDispositionGestureFilterTest, ConsumedTouchCancel) {
742  // An unconsumed touch's gesture should be sent.
743  PushGesture(ET_GESTURE_TAP_DOWN);
744  PressTouchPoint(1, 1);
745  EXPECT_FALSE(GesturesSent());
746  SendTouchNotConsumedAck();
747  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
748                            GetAndResetSentGestures()));
749
750  PushGesture(ET_GESTURE_TAP_CANCEL);
751  PushGesture(ET_GESTURE_SCROLL_END);
752  CancelTouchPoint();
753  EXPECT_FALSE(GesturesSent());
754  SendTouchConsumedAck();
755  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
756                                     ET_GESTURE_SCROLL_END),
757                            GetAndResetSentGestures()));
758}
759
760TEST_F(TouchDispositionGestureFilterTest, TimeoutEventAfterRelease) {
761  PressTouchPoint(1, 1);
762  SendTouchNotConsumedAck();
763  EXPECT_FALSE(GesturesSent());
764  PushGesture(ET_GESTURE_TAP_UNCONFIRMED);
765  ReleaseTouchPoint();
766  SendTouchNotConsumedAck();
767  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_UNCONFIRMED),
768                            GetAndResetSentGestures()));
769
770  SendTimeoutGesture(ET_GESTURE_TAP);
771  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP),
772                            GetAndResetSentGestures()));
773}
774
775}  // namespace ui
776