touch_disposition_gesture_filter_unittest.cc revision c5cede9ae108bb15f6b7a8aea21c7e1fefa2834c 
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, 0, base::TimeTicks(), 0, 0, 1);
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_BEGIN);
204  PushGesture(ET_GESTURE_SCROLL_BEGIN);
205  PressTouchPoint(1, 1);
206  EXPECT_FALSE(GesturesSent());
207  SendTouchNotConsumedAck();
208  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN),
209                            GetAndResetSentGestures()));
210
211  // Multiple gestures can be queued for a single event.
212  PushGesture(ET_SCROLL_FLING_START);
213  PushGesture(ET_SCROLL_FLING_CANCEL);
214  PushGesture(ET_GESTURE_END);
215  ReleaseTouchPoint();
216  EXPECT_FALSE(GesturesSent());
217  SendTouchNotConsumedAck();
218  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_START,
219                                     ET_SCROLL_FLING_CANCEL,
220                                     ET_GESTURE_END),
221                            GetAndResetSentGestures()));
222}
223
224TEST_F(TouchDispositionGestureFilterTest, BasicGesturesConsumed) {
225  // A consumed touch's gesture should not be sent.
226  PushGesture(ET_GESTURE_BEGIN);
227  PushGesture(ET_GESTURE_SCROLL_BEGIN);
228  PressTouchPoint(1, 1);
229  SendTouchConsumedAck();
230  EXPECT_FALSE(GesturesSent());
231
232  PushGesture(ET_GESTURE_SCROLL_UPDATE);
233  MoveTouchPoint(0, 2, 2);
234  SendTouchConsumedAck();
235  EXPECT_FALSE(GesturesSent());
236
237  PushGesture(ET_SCROLL_FLING_START);
238  PushGesture(ET_SCROLL_FLING_CANCEL);
239  PushGesture(ET_GESTURE_END);
240  ReleaseTouchPoint();
241  SendTouchConsumedAck();
242  EXPECT_FALSE(GesturesSent());
243}
244
245TEST_F(TouchDispositionGestureFilterTest, ConsumedThenNotConsumed) {
246  // A consumed touch's gesture should not be sent.
247  PushGesture(ET_GESTURE_SCROLL_BEGIN);
248  PressTouchPoint(1, 1);
249  SendTouchConsumedAck();
250  EXPECT_FALSE(GesturesSent());
251
252  // Even if the subsequent touch is not consumed, continue dropping gestures.
253  PushGesture(ET_GESTURE_SCROLL_UPDATE);
254  MoveTouchPoint(0, 2, 2);
255  SendTouchNotConsumedAck();
256  EXPECT_FALSE(GesturesSent());
257
258  // Even if the subsequent touch had no consumer, continue dropping gestures.
259  PushGesture(ET_SCROLL_FLING_START);
260  ReleaseTouchPoint();
261  SendTouchNotConsumedAck();
262  EXPECT_FALSE(GesturesSent());
263}
264
265TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenConsumed) {
266  // A not consumed touch's gesture should be sent.
267  PushGesture(ET_GESTURE_SCROLL_BEGIN);
268  PressTouchPoint(1, 1);
269  SendTouchNotConsumedAck();
270  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
271                            GetAndResetSentGestures()));
272
273  // A newly consumed gesture should not be sent.
274  PushGesture(ET_GESTURE_PINCH_BEGIN);
275  PressTouchPoint(10, 10);
276  SendTouchConsumedAck();
277  EXPECT_FALSE(GesturesSent());
278
279  // And subsequent non-consumed pinch updates should not be sent.
280  PushGesture(ET_GESTURE_SCROLL_UPDATE);
281  PushGesture(ET_GESTURE_PINCH_UPDATE);
282  MoveTouchPoint(0, 2, 2);
283  SendTouchNotConsumedAck();
284  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
285                            GetAndResetSentGestures()));
286
287  // End events dispatched only when their start events were.
288  PushGesture(ET_GESTURE_PINCH_END);
289  ReleaseTouchPoint();
290  SendTouchNotConsumedAck();
291  EXPECT_FALSE(GesturesSent());
292
293  PushGesture(ET_GESTURE_SCROLL_END);
294  ReleaseTouchPoint();
295  SendTouchConsumedAck();
296  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
297                            GetAndResetSentGestures()));
298}
299
300TEST_F(TouchDispositionGestureFilterTest, ScrollAlternatelyConsumed) {
301  // A consumed touch's gesture should not be sent.
302  PushGesture(ET_GESTURE_SCROLL_BEGIN);
303  PressTouchPoint(1, 1);
304  SendTouchNotConsumedAck();
305  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
306                            GetAndResetSentGestures()));
307
308  for (size_t i = 0; i < 3; ++i) {
309    PushGesture(ET_GESTURE_SCROLL_UPDATE);
310    MoveTouchPoint(0, 2, 2);
311    SendTouchConsumedAck();
312    EXPECT_FALSE(GesturesSent());
313
314    PushGesture(ET_GESTURE_SCROLL_UPDATE);
315    MoveTouchPoint(0, 3, 3);
316    SendTouchNotConsumedAck();
317    EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
318                              GetAndResetSentGestures()));
319  }
320
321  PushGesture(ET_GESTURE_SCROLL_END);
322  ReleaseTouchPoint();
323  SendTouchConsumedAck();
324  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
325                            GetAndResetSentGestures()));
326}
327
328TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenNoConsumer) {
329  // An unconsumed touch's gesture should be sent.
330  PushGesture(ET_GESTURE_SCROLL_BEGIN);
331  PressTouchPoint(1, 1);
332  SendTouchNotConsumedAck();
333  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
334                            GetAndResetSentGestures()));
335
336  // If the subsequent touch has no consumer (e.g., a secondary pointer is
337  // pressed but not on a touch handling rect), send the gesture.
338  PushGesture(ET_GESTURE_PINCH_BEGIN);
339  PressTouchPoint(2, 2);
340  SendTouchNotConsumedAck();
341  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
342                            GetAndResetSentGestures()));
343
344  // End events should be dispatched when their start events were, independent
345  // of the ack state.
346  PushGesture(ET_GESTURE_PINCH_END);
347  ReleaseTouchPoint();
348  SendTouchConsumedAck();
349  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
350                            GetAndResetSentGestures()));
351
352  PushGesture(ET_GESTURE_SCROLL_END);
353  ReleaseTouchPoint();
354  SendTouchConsumedAck();
355  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
356                            GetAndResetSentGestures()));
357}
358
359TEST_F(TouchDispositionGestureFilterTest, EndingEventsSent) {
360  PushGesture(ET_GESTURE_SCROLL_BEGIN);
361  PressTouchPoint(1, 1);
362  SendTouchNotConsumedAck();
363  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
364                            GetAndResetSentGestures()));
365
366  PushGesture(ET_GESTURE_PINCH_BEGIN);
367  PressTouchPoint(2, 2);
368  SendTouchNotConsumedAck();
369  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
370                            GetAndResetSentGestures()));
371
372  // Consuming the touchend event can't suppress the match end gesture.
373  PushGesture(ET_GESTURE_PINCH_END);
374  ReleaseTouchPoint();
375  SendTouchConsumedAck();
376  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
377                            GetAndResetSentGestures()));
378
379  // But other events in the same packet are still suppressed.
380  PushGesture(ET_GESTURE_SCROLL_UPDATE);
381  PushGesture(ET_GESTURE_SCROLL_END);
382  ReleaseTouchPoint();
383  SendTouchConsumedAck();
384  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
385                            GetAndResetSentGestures()));
386
387  // ET_GESTURE_SCROLL_END and ET_SCROLL_FLING_START behave the same in this
388  // regard.
389  PushGesture(ET_GESTURE_SCROLL_BEGIN);
390  PressTouchPoint(1, 1);
391  SendTouchNotConsumedAck();
392  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
393                            GetAndResetSentGestures()));
394
395  PushGesture(ET_SCROLL_FLING_START);
396  ReleaseTouchPoint();
397  SendTouchConsumedAck();
398  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_START),
399                            GetAndResetSentGestures()));
400}
401
402TEST_F(TouchDispositionGestureFilterTest, EndingEventsNotSent) {
403  // Consuming a begin event ensures no end events are sent.
404  PushGesture(ET_GESTURE_SCROLL_BEGIN);
405  PressTouchPoint(1, 1);
406  SendTouchConsumedAck();
407  EXPECT_FALSE(GesturesSent());
408
409  PushGesture(ET_GESTURE_PINCH_BEGIN);
410  PressTouchPoint(2, 2);
411  SendTouchNotConsumedAck();
412  EXPECT_FALSE(GesturesSent());
413
414  PushGesture(ET_GESTURE_PINCH_END);
415  ReleaseTouchPoint();
416  SendTouchNotConsumedAck();
417  EXPECT_FALSE(GesturesSent());
418
419  PushGesture(ET_GESTURE_SCROLL_END);
420  ReleaseTouchPoint();
421  SendTouchNotConsumedAck();
422  EXPECT_FALSE(GesturesSent());
423}
424
425TEST_F(TouchDispositionGestureFilterTest, UpdateEventsSuppressedPerEvent) {
426  PushGesture(ET_GESTURE_SCROLL_BEGIN);
427  PressTouchPoint(1, 1);
428  SendTouchNotConsumedAck();
429  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
430                            GetAndResetSentGestures()));
431
432  // Consuming a single scroll or pinch update should suppress only that event.
433  PushGesture(ET_GESTURE_SCROLL_UPDATE);
434  MoveTouchPoint(0, 2, 2);
435  SendTouchConsumedAck();
436  EXPECT_FALSE(GesturesSent());
437
438  PushGesture(ET_GESTURE_PINCH_BEGIN);
439  PressTouchPoint(2, 2);
440  SendTouchNotConsumedAck();
441  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
442                            GetAndResetSentGestures()));
443
444  PushGesture(ET_GESTURE_PINCH_UPDATE);
445  MoveTouchPoint(1, 2, 3);
446  SendTouchConsumedAck();
447  EXPECT_FALSE(GesturesSent());
448
449  // Subsequent updates should not be affected.
450  PushGesture(ET_GESTURE_SCROLL_UPDATE);
451  MoveTouchPoint(0, 4, 4);
452  SendTouchNotConsumedAck();
453  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
454                            GetAndResetSentGestures()));
455
456  PushGesture(ET_GESTURE_PINCH_UPDATE);
457  MoveTouchPoint(0, 4, 5);
458  SendTouchNotConsumedAck();
459  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_UPDATE),
460                            GetAndResetSentGestures()));
461
462  PushGesture(ET_GESTURE_PINCH_END);
463  ReleaseTouchPoint();
464  SendTouchConsumedAck();
465  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
466                            GetAndResetSentGestures()));
467
468  PushGesture(ET_GESTURE_SCROLL_END);
469  ReleaseTouchPoint();
470  SendTouchConsumedAck();
471  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
472                            GetAndResetSentGestures()));
473}
474
475TEST_F(TouchDispositionGestureFilterTest, UpdateEventsDependOnBeginEvents) {
476  PushGesture(ET_GESTURE_SCROLL_BEGIN);
477  PressTouchPoint(1, 1);
478  SendTouchConsumedAck();
479  EXPECT_FALSE(GesturesSent());
480
481  // Scroll and pinch gestures depend on the scroll begin gesture being
482  // dispatched.
483  PushGesture(ET_GESTURE_SCROLL_UPDATE);
484  MoveTouchPoint(0, 2, 2);
485  SendTouchNotConsumedAck();
486  EXPECT_FALSE(GesturesSent());
487
488  PushGesture(ET_GESTURE_PINCH_BEGIN);
489  PressTouchPoint(2, 2);
490  SendTouchNotConsumedAck();
491  EXPECT_FALSE(GesturesSent());
492
493  PushGesture(ET_GESTURE_PINCH_UPDATE);
494  MoveTouchPoint(1, 2, 3);
495  SendTouchConsumedAck();
496  EXPECT_FALSE(GesturesSent());
497
498  PushGesture(ET_GESTURE_PINCH_END);
499  ReleaseTouchPoint();
500  SendTouchNotConsumedAck();
501  EXPECT_FALSE(GesturesSent());
502
503  PushGesture(ET_GESTURE_SCROLL_END);
504  ReleaseTouchPoint();
505  SendTouchNotConsumedAck();
506  EXPECT_FALSE(GesturesSent());
507}
508
509TEST_F(TouchDispositionGestureFilterTest, MultipleTouchSequences) {
510  // Queue two touch-to-gestures sequences.
511  PushGesture(ET_GESTURE_TAP_DOWN);
512  PressTouchPoint(1, 1);
513  PushGesture(ET_GESTURE_TAP);
514  ReleaseTouchPoint();
515  PushGesture(ET_GESTURE_SCROLL_BEGIN);
516  PressTouchPoint(1, 1);
517  PushGesture(ET_GESTURE_SCROLL_END);
518  ReleaseTouchPoint();
519
520  // The first gesture sequence should not be allowed.
521  SendTouchConsumedAck();
522  SendTouchNotConsumedAck();
523  EXPECT_FALSE(GesturesSent());
524
525  // The subsequent sequence should "reset" allowance.
526  SendTouchNotConsumedAck();
527  SendTouchNotConsumedAck();
528  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
529                                     ET_GESTURE_SCROLL_END),
530                            GetAndResetSentGestures()));
531}
532
533TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnNewTouchSequence) {
534  // Simulate a fling.
535  PushGesture(ET_GESTURE_TAP_DOWN);
536  PushGesture(ET_GESTURE_SCROLL_BEGIN);
537  PressTouchPoint(1, 1);
538  SendTouchNotConsumedAck();
539  EXPECT_TRUE(GesturesMatch(
540      Gestures(
541          ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP_CANCEL, ET_GESTURE_SCROLL_BEGIN),
542      GetAndResetSentGestures()));
543  PushGesture(ET_SCROLL_FLING_START);
544  ReleaseTouchPoint();
545  SendTouchNotConsumedAck();
546  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_START),
547                            GetAndResetSentGestures()));
548
549  // A new touch seqeuence should cancel the outstanding fling.
550  PressTouchPoint(1, 1);
551  SendTouchNotConsumedAck();
552  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_CANCEL),
553                            GetAndResetSentGestures()));
554  ReleaseTouchPoint();
555  SendTouchNotConsumedAck();
556  EXPECT_FALSE(GesturesSent());
557}
558
559TEST_F(TouchDispositionGestureFilterTest, ScrollEndedOnNewTouchSequence) {
560  // Simulate a scroll.
561  PushGesture(ET_GESTURE_TAP_DOWN);
562  PushGesture(ET_GESTURE_SCROLL_BEGIN);
563  PressTouchPoint(1, 1);
564  SendTouchNotConsumedAck();
565  EXPECT_TRUE(GesturesMatch(
566      Gestures(
567          ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP_CANCEL, ET_GESTURE_SCROLL_BEGIN),
568      GetAndResetSentGestures()));
569  ReleaseTouchPoint();
570  SendTouchNotConsumedAck();
571
572  // A new touch seqeuence should end the outstanding scroll.
573  PressTouchPoint(1, 1);
574  SendTouchConsumedAck();
575  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
576                            GetAndResetSentGestures()));
577}
578
579TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnScrollBegin) {
580  // Simulate a fling sequence.
581  PushGesture(ET_GESTURE_TAP_DOWN);
582  PushGesture(ET_GESTURE_SCROLL_BEGIN);
583  PushGesture(ET_SCROLL_FLING_START);
584  PressTouchPoint(1, 1);
585  SendTouchNotConsumedAck();
586  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN,
587                                     ET_GESTURE_TAP_CANCEL,
588                                     ET_GESTURE_SCROLL_BEGIN,
589                                     ET_SCROLL_FLING_START),
590                            GetAndResetSentGestures()));
591
592  // The new fling should cancel the preceding one.
593  PushGesture(ET_GESTURE_SCROLL_BEGIN);
594  PushGesture(ET_SCROLL_FLING_START);
595  ReleaseTouchPoint();
596  SendTouchNotConsumedAck();
597  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_CANCEL,
598                                     ET_GESTURE_SCROLL_BEGIN,
599                                     ET_SCROLL_FLING_START),
600                            GetAndResetSentGestures()));
601}
602
603TEST_F(TouchDispositionGestureFilterTest, FlingNotCancelledIfGFCEventReceived) {
604  // Simulate a fling that is started then cancelled.
605  PushGesture(ET_GESTURE_SCROLL_BEGIN);
606  PressTouchPoint(1, 1);
607  SendTouchNotConsumedAck();
608  PushGesture(ET_SCROLL_FLING_START);
609  MoveTouchPoint(0, 1, 1);
610  SendTouchNotConsumedAck();
611  PushGesture(ET_SCROLL_FLING_CANCEL);
612  ReleaseTouchPoint();
613  SendTouchNotConsumedAck();
614  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
615                                     ET_SCROLL_FLING_START,
616                                     ET_SCROLL_FLING_CANCEL),
617                            GetAndResetSentGestures()));
618
619  // A new touch sequence will not inject a ET_SCROLL_FLING_CANCEL, as the fling
620  // has already been cancelled.
621  PressTouchPoint(1, 1);
622  SendTouchNotConsumedAck();
623  ReleaseTouchPoint();
624  SendTouchNotConsumedAck();
625  EXPECT_FALSE(GesturesSent());
626}
627
628TEST_F(TouchDispositionGestureFilterTest, TapCancelledWhenScrollBegins) {
629  PushGesture(ET_GESTURE_TAP_DOWN);
630  PressTouchPoint(1, 1);
631  SendTouchNotConsumedAck();
632  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
633                            GetAndResetSentGestures()));
634
635  // If the subsequent touch turns into a scroll, the tap should be cancelled.
636  PushGesture(ET_GESTURE_SCROLL_BEGIN);
637  MoveTouchPoint(0, 2, 2);
638  SendTouchNotConsumedAck();
639  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
640                                     ET_GESTURE_SCROLL_BEGIN),
641                            GetAndResetSentGestures()));
642}
643
644TEST_F(TouchDispositionGestureFilterTest, TapCancelledWhenTouchConsumed) {
645  PushGesture(ET_GESTURE_TAP_DOWN);
646  PressTouchPoint(1, 1);
647  SendTouchNotConsumedAck();
648  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
649                            GetAndResetSentGestures()));
650
651  // If the subsequent touch is consumed, the tap should be cancelled.
652  PushGesture(ET_GESTURE_SCROLL_BEGIN);
653  MoveTouchPoint(0, 2, 2);
654  SendTouchConsumedAck();
655  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL),
656                            GetAndResetSentGestures()));
657}
658
659TEST_F(TouchDispositionGestureFilterTest,
660       TapNotCancelledIfTapEndingEventReceived) {
661  PushGesture(ET_GESTURE_TAP_DOWN);
662  PressTouchPoint(1, 1);
663  PressTouchPoint(2, 2);
664  SendTouchNotConsumedAck();
665  SendTouchNotConsumedAck();
666  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
667                            GetAndResetSentGestures()));
668
669  PushGesture(ET_GESTURE_TAP);
670  ReleaseTouchPoint();
671  SendTouchNotConsumedAck();
672  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS,
673                                     ET_GESTURE_TAP),
674                            GetAndResetSentGestures()));
675
676  // The tap should not be cancelled as it was terminated by a |ET_GESTURE_TAP|.
677  ReleaseTouchPoint();
678  SendTouchConsumedAck();
679  EXPECT_FALSE(GesturesSent());
680}
681
682TEST_F(TouchDispositionGestureFilterTest, TimeoutGestures) {
683  // If the sequence is allowed, and there are no preceding gestures, the
684  // timeout gestures should be forwarded immediately.
685  PushGesture(ET_GESTURE_TAP_DOWN);
686  PressTouchPoint(1, 1);
687  SendTouchNotConsumedAck();
688  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
689                            GetAndResetSentGestures()));
690
691  SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
692  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS),
693                            GetAndResetSentGestures()));
694
695  SendTimeoutGesture(ET_GESTURE_LONG_PRESS);
696  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_LONG_PRESS),
697                            GetAndResetSentGestures()));
698
699  PushGesture(ET_GESTURE_LONG_TAP);
700  ReleaseTouchPoint();
701  SendTouchNotConsumedAck();
702  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
703                                     ET_GESTURE_LONG_TAP),
704                            GetAndResetSentGestures()));
705
706  // If the sequence is disallowed, and there are no preceding gestures, the
707  // timeout gestures should be dropped immediately.
708  PushGesture(ET_GESTURE_TAP_DOWN);
709  PressTouchPoint(1, 1);
710  SendTouchConsumedAck();
711  EXPECT_FALSE(GesturesSent());
712
713  SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
714  EXPECT_FALSE(GesturesSent());
715  ReleaseTouchPoint();
716  SendTouchNotConsumedAck();
717
718  // If the sequence has a pending ack, the timeout gestures should
719  // remain queued until the ack is received.
720  PushGesture(ET_GESTURE_TAP_DOWN);
721  PressTouchPoint(1, 1);
722  EXPECT_FALSE(GesturesSent());
723
724  SendTimeoutGesture(ET_GESTURE_LONG_PRESS);
725  EXPECT_FALSE(GesturesSent());
726
727  SendTouchNotConsumedAck();
728  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN,
729                                     ET_GESTURE_LONG_PRESS),
730                            GetAndResetSentGestures()));
731}
732
733TEST_F(TouchDispositionGestureFilterTest, SpuriousAcksIgnored) {
734  // Acks received when the queue is empty will be safely ignored.
735  ASSERT_TRUE(IsEmpty());
736  SendTouchConsumedAck();
737  EXPECT_FALSE(GesturesSent());
738
739  PushGesture(ET_GESTURE_SCROLL_BEGIN);
740  PressTouchPoint(1, 1);
741  PushGesture(ET_GESTURE_SCROLL_UPDATE);
742  MoveTouchPoint(0, 3,3);
743  SendTouchNotConsumedAck();
744  SendTouchNotConsumedAck();
745  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
746                                     ET_GESTURE_SCROLL_UPDATE),
747                            GetAndResetSentGestures()));
748
749  // Even if all packets have been dispatched, the filter may not be empty as
750  // there could be follow-up timeout events.  Spurious acks in such cases
751  // should also be safely ignored.
752  ASSERT_FALSE(IsEmpty());
753  SendTouchConsumedAck();
754  EXPECT_FALSE(GesturesSent());
755}
756
757TEST_F(TouchDispositionGestureFilterTest, PacketWithInvalidTypeIgnored) {
758  GestureEventDataPacket packet;
759  EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_TYPE,
760            SendGesturePacket(packet));
761  EXPECT_TRUE(IsEmpty());
762}
763
764TEST_F(TouchDispositionGestureFilterTest, PacketsWithInvalidOrderIgnored) {
765  EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_ORDER,
766            SendTimeoutGesture(ET_GESTURE_SHOW_PRESS));
767  EXPECT_TRUE(IsEmpty());
768}
769
770TEST_F(TouchDispositionGestureFilterTest, ConsumedTouchCancel) {
771  // An unconsumed touch's gesture should be sent.
772  PushGesture(ET_GESTURE_TAP_DOWN);
773  PressTouchPoint(1, 1);
774  EXPECT_FALSE(GesturesSent());
775  SendTouchNotConsumedAck();
776  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
777                            GetAndResetSentGestures()));
778
779  PushGesture(ET_GESTURE_TAP_CANCEL);
780  PushGesture(ET_GESTURE_SCROLL_END);
781  CancelTouchPoint();
782  EXPECT_FALSE(GesturesSent());
783  SendTouchConsumedAck();
784  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
785                                     ET_GESTURE_SCROLL_END),
786                            GetAndResetSentGestures()));
787}
788
789TEST_F(TouchDispositionGestureFilterTest, TimeoutEventAfterRelease) {
790  PressTouchPoint(1, 1);
791  SendTouchNotConsumedAck();
792  EXPECT_FALSE(GesturesSent());
793  PushGesture(ET_GESTURE_TAP_UNCONFIRMED);
794  ReleaseTouchPoint();
795  SendTouchNotConsumedAck();
796  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_UNCONFIRMED),
797                            GetAndResetSentGestures()));
798
799  SendTimeoutGesture(ET_GESTURE_TAP);
800  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP),
801                            GetAndResetSentGestures()));
802}
803
804TEST_F(TouchDispositionGestureFilterTest, ShowPressInsertedBeforeTap) {
805  PushGesture(ET_GESTURE_TAP_DOWN);
806  PressTouchPoint(1, 1);
807  SendTouchNotConsumedAck();
808  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
809                            GetAndResetSentGestures()));
810
811  SendTimeoutGesture(ET_GESTURE_TAP_UNCONFIRMED);
812  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_UNCONFIRMED),
813                            GetAndResetSentGestures()));
814
815  PushGesture(ET_GESTURE_TAP);
816  ReleaseTouchPoint();
817  SendTouchNotConsumedAck();
818  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS,
819                                     ET_GESTURE_TAP),
820                            GetAndResetSentGestures()));
821}
822
823TEST_F(TouchDispositionGestureFilterTest, ShowPressNotInsertedIfAlreadySent) {
824  PushGesture(ET_GESTURE_TAP_DOWN);
825  PressTouchPoint(1, 1);
826  SendTouchNotConsumedAck();
827  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
828                            GetAndResetSentGestures()));
829
830  SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
831  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS),
832                            GetAndResetSentGestures()));
833
834  PushGesture(ET_GESTURE_TAP);
835  ReleaseTouchPoint();
836  SendTouchNotConsumedAck();
837  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP),
838                            GetAndResetSentGestures()));
839}
840
841TEST_F(TouchDispositionGestureFilterTest, TapAndScrollCancelledOnTouchCancel) {
842  PushGesture(ET_GESTURE_TAP_DOWN);
843  PressTouchPoint(1, 1);
844  SendTouchNotConsumedAck();
845  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
846                            GetAndResetSentGestures()));
847
848  // A cancellation motion event should cancel the tap (though the TAP_CANCEL
849  // will not be dispatched until the following touch sequence).
850  CancelTouchPoint();
851  SendTouchNotConsumedAck();
852  EXPECT_FALSE(GesturesSent());
853
854  PushGesture(ET_GESTURE_SCROLL_BEGIN);
855  PressTouchPoint(1, 1);
856  SendTouchNotConsumedAck();
857  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
858                                     ET_GESTURE_SCROLL_BEGIN),
859                            GetAndResetSentGestures()));
860
861  // A cancellation motion event should end the scroll, even if the touch was
862  // consumed.
863  CancelTouchPoint();
864  SendTouchConsumedAck();
865  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
866                            GetAndResetSentGestures()));
867}
868
869TEST_F(TouchDispositionGestureFilterTest,
870       ConsumedScrollUpdateMakesFlingScrollEnd) {
871  // A consumed touch's gesture should not be sent.
872  PushGesture(ET_GESTURE_BEGIN);
873  PushGesture(ET_GESTURE_SCROLL_BEGIN);
874  PressTouchPoint(1, 1);
875  SendTouchNotConsumedAck();
876
877  EXPECT_TRUE(
878      GesturesMatch(Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN),
879                    GetAndResetSentGestures()));
880
881  PushGesture(ET_GESTURE_SCROLL_UPDATE);
882  MoveTouchPoint(0, 2, 2);
883  SendTouchConsumedAck();
884  EXPECT_FALSE(GesturesSent());
885
886  PushGesture(ET_SCROLL_FLING_START);
887  PushGesture(ET_SCROLL_FLING_CANCEL);
888  PushGesture(ET_GESTURE_END);
889  ReleaseTouchPoint();
890  SendTouchNotConsumedAck();
891  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_END, ET_GESTURE_SCROLL_END),
892                            GetAndResetSentGestures()));
893
894  PushGesture(ET_GESTURE_BEGIN);
895  PushGesture(ET_GESTURE_SCROLL_BEGIN);
896  PressTouchPoint(1, 1);
897  SendTouchNotConsumedAck();
898  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN),
899                            GetAndResetSentGestures()));
900}
901
902}  // namespace ui
903