touch_disposition_gesture_filter_unittest.cc revision 010d83a9304c5a91596085d917d248abff47903a 
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()
18      : cancel_after_next_gesture_(false), sent_gesture_count_(0) {}
19  virtual ~TouchDispositionGestureFilterTest() {}
20
21  // testing::Test
22  virtual void SetUp() OVERRIDE {
23    queue_.reset(new TouchDispositionGestureFilter(this));
24  }
25
26  virtual void TearDown() OVERRIDE {
27    queue_.reset();
28  }
29
30  // TouchDispositionGestureFilterClient
31  virtual void ForwardGestureEvent(const GestureEventData& event) OVERRIDE {
32    ++sent_gesture_count_;
33    last_sent_gesture_time_ = event.time;
34    sent_gestures_.push_back(event.type);
35    if (cancel_after_next_gesture_) {
36      CancelTouchPoint();
37      SendTouchNotConsumedAck();
38      cancel_after_next_gesture_ = false;
39    }
40  }
41
42 protected:
43  typedef std::vector<EventType> GestureList;
44
45  ::testing::AssertionResult GesturesMatch(const GestureList& expected,
46                                           const GestureList& actual) {
47    if (expected.size() != actual.size()) {
48      return ::testing::AssertionFailure()
49          << "actual.size(" << actual.size()
50          << ") != expected.size(" << expected.size() << ")";
51    }
52
53    for (size_t i = 0; i < expected.size(); ++i) {
54      if (expected[i] != actual[i]) {
55        return ::testing::AssertionFailure()
56            << "actual[" << i << "] ("
57            << actual[i]
58            << ") != expected[" << i << "] ("
59            << expected[i] << ")";
60      }
61    }
62
63    return ::testing::AssertionSuccess();
64  }
65
66  GestureList Gestures(EventType type) {
67    return GestureList(1, type);
68  }
69
70  GestureList Gestures(EventType type0, EventType type1) {
71    GestureList gestures(2);
72    gestures[0] = type0;
73    gestures[1] = type1;
74    return gestures;
75  }
76
77  GestureList Gestures(EventType type0,
78                       EventType type1,
79                       EventType type2) {
80    GestureList gestures(3);
81    gestures[0] = type0;
82    gestures[1] = type1;
83    gestures[2] = type2;
84    return gestures;
85  }
86
87  GestureList Gestures(EventType type0,
88                       EventType type1,
89                       EventType type2,
90                       EventType type3) {
91    GestureList gestures(4);
92    gestures[0] = type0;
93    gestures[1] = type1;
94    gestures[2] = type2;
95    gestures[3] = type3;
96    return gestures;
97  }
98
99  void SendTouchGestures() {
100    touch_event_.SetTime(base::TimeTicks::Now());
101    EXPECT_EQ(TouchDispositionGestureFilter::SUCCESS,
102              SendTouchGestures(touch_event_, pending_gesture_packet_));
103    GestureEventDataPacket gesture_packet;
104    std::swap(gesture_packet, pending_gesture_packet_);
105  }
106
107  TouchDispositionGestureFilter::PacketResult
108  SendTouchGestures(const MotionEvent& touch,
109                    const GestureEventDataPacket& packet) {
110    GestureEventDataPacket touch_packet =
111        GestureEventDataPacket::FromTouch(touch);
112    for (size_t i = 0; i < packet.gesture_count(); ++i)
113      touch_packet.Push(packet.gesture(i));
114    return queue_->OnGesturePacket(touch_packet);
115  }
116
117  TouchDispositionGestureFilter::PacketResult
118  SendTimeoutGesture(EventType type) {
119    return queue_->OnGesturePacket(
120        GestureEventDataPacket::FromTouchTimeout(CreateGesture(type)));
121  }
122
123  TouchDispositionGestureFilter::PacketResult
124  SendGesturePacket(const GestureEventDataPacket& packet) {
125    return queue_->OnGesturePacket(packet);
126  }
127
128  void SendTouchEventAck(bool event_consumed) {
129    queue_->OnTouchEventAck(event_consumed);
130  }
131
132  void SendTouchConsumedAck() { SendTouchEventAck(true); }
133
134  void SendTouchNotConsumedAck() { SendTouchEventAck(false); }
135
136  void PushGesture(EventType type) {
137    pending_gesture_packet_.Push(CreateGesture(type));
138  }
139
140  void PressTouchPoint(int x, int y) {
141    touch_event_.PressPoint(x, y);
142    SendTouchGestures();
143  }
144
145  void MoveTouchPoint(size_t index, int x, int y) {
146    touch_event_.MovePoint(index, x, y);
147    SendTouchGestures();
148  }
149
150  void ReleaseTouchPoint() {
151    touch_event_.ReleasePoint();
152    SendTouchGestures();
153  }
154
155  void CancelTouchPoint() {
156    touch_event_.CancelPoint();
157    SendTouchGestures();
158  }
159
160  void ResetTouchPoints() { touch_event_ = MockMotionEvent(); }
161
162  bool GesturesSent() const { return !sent_gestures_.empty(); }
163
164  base::TimeTicks LastSentGestureTime() const {
165    return last_sent_gesture_time_;
166  }
167
168  base::TimeTicks CurrentTouchTime() const {
169    return touch_event_.GetEventTime();
170  }
171
172  bool IsEmpty() const { return queue_->IsEmpty(); }
173
174  GestureList GetAndResetSentGestures() {
175    GestureList sent_gestures;
176    sent_gestures.swap(sent_gestures_);
177    return sent_gestures;
178  }
179
180  void SetCancelAfterNextGesture(bool cancel_after_next_gesture) {
181    cancel_after_next_gesture_ = cancel_after_next_gesture;
182  }
183
184  static GestureEventData CreateGesture(EventType type) {
185    return GestureEventData(
186        type, 0, base::TimeTicks(), 0, 0, 1, gfx::RectF(0, 0, 0, 0));
187  }
188
189 private:
190  scoped_ptr<TouchDispositionGestureFilter> queue_;
191  bool cancel_after_next_gesture_;
192  MockMotionEvent touch_event_;
193  GestureEventDataPacket pending_gesture_packet_;
194  size_t sent_gesture_count_;
195  base::TimeTicks last_sent_gesture_time_;
196  GestureList sent_gestures_;
197};
198
199TEST_F(TouchDispositionGestureFilterTest, BasicNoGestures) {
200  PressTouchPoint(1, 1);
201  EXPECT_FALSE(GesturesSent());
202
203  MoveTouchPoint(0, 2, 2);
204  EXPECT_FALSE(GesturesSent());
205
206  // No gestures should be dispatched by the ack, as the queued packets
207  // contained no gestures.
208  SendTouchConsumedAck();
209  EXPECT_FALSE(GesturesSent());
210
211  // Release the touch gesture.
212  ReleaseTouchPoint();
213  SendTouchConsumedAck();
214  SendTouchConsumedAck();
215  EXPECT_FALSE(GesturesSent());
216}
217
218TEST_F(TouchDispositionGestureFilterTest, BasicGestures) {
219  // An unconsumed touch's gesture should be sent.
220  PushGesture(ET_GESTURE_BEGIN);
221  PushGesture(ET_GESTURE_SCROLL_BEGIN);
222  PressTouchPoint(1, 1);
223  EXPECT_FALSE(GesturesSent());
224  SendTouchNotConsumedAck();
225  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN),
226                            GetAndResetSentGestures()));
227
228  // Multiple gestures can be queued for a single event.
229  PushGesture(ET_SCROLL_FLING_START);
230  PushGesture(ET_SCROLL_FLING_CANCEL);
231  PushGesture(ET_GESTURE_END);
232  ReleaseTouchPoint();
233  EXPECT_FALSE(GesturesSent());
234  SendTouchNotConsumedAck();
235  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_START,
236                                     ET_SCROLL_FLING_CANCEL,
237                                     ET_GESTURE_END),
238                            GetAndResetSentGestures()));
239}
240
241TEST_F(TouchDispositionGestureFilterTest, BasicGesturesConsumed) {
242  // A consumed touch's gesture should not be sent.
243  PushGesture(ET_GESTURE_BEGIN);
244  PushGesture(ET_GESTURE_SCROLL_BEGIN);
245  PressTouchPoint(1, 1);
246  SendTouchConsumedAck();
247  EXPECT_FALSE(GesturesSent());
248
249  PushGesture(ET_GESTURE_SCROLL_UPDATE);
250  MoveTouchPoint(0, 2, 2);
251  SendTouchConsumedAck();
252  EXPECT_FALSE(GesturesSent());
253
254  PushGesture(ET_SCROLL_FLING_START);
255  PushGesture(ET_SCROLL_FLING_CANCEL);
256  PushGesture(ET_GESTURE_END);
257  ReleaseTouchPoint();
258  SendTouchConsumedAck();
259  EXPECT_FALSE(GesturesSent());
260}
261
262TEST_F(TouchDispositionGestureFilterTest, ConsumedThenNotConsumed) {
263  // A consumed touch's gesture should not be sent.
264  PushGesture(ET_GESTURE_SCROLL_BEGIN);
265  PressTouchPoint(1, 1);
266  SendTouchConsumedAck();
267  EXPECT_FALSE(GesturesSent());
268
269  // Even if the subsequent touch is not consumed, continue dropping gestures.
270  PushGesture(ET_GESTURE_SCROLL_UPDATE);
271  MoveTouchPoint(0, 2, 2);
272  SendTouchNotConsumedAck();
273  EXPECT_FALSE(GesturesSent());
274
275  // Even if the subsequent touch had no consumer, continue dropping gestures.
276  PushGesture(ET_SCROLL_FLING_START);
277  ReleaseTouchPoint();
278  SendTouchNotConsumedAck();
279  EXPECT_FALSE(GesturesSent());
280}
281
282TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenConsumed) {
283  // A not consumed touch's gesture should be sent.
284  PushGesture(ET_GESTURE_SCROLL_BEGIN);
285  PressTouchPoint(1, 1);
286  SendTouchNotConsumedAck();
287  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
288                            GetAndResetSentGestures()));
289
290  // A newly consumed gesture should not be sent.
291  PushGesture(ET_GESTURE_PINCH_BEGIN);
292  PressTouchPoint(10, 10);
293  SendTouchConsumedAck();
294  EXPECT_FALSE(GesturesSent());
295
296  // And subsequent non-consumed pinch updates should not be sent.
297  PushGesture(ET_GESTURE_SCROLL_UPDATE);
298  PushGesture(ET_GESTURE_PINCH_UPDATE);
299  MoveTouchPoint(0, 2, 2);
300  SendTouchNotConsumedAck();
301  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
302                            GetAndResetSentGestures()));
303
304  // End events dispatched only when their start events were.
305  PushGesture(ET_GESTURE_PINCH_END);
306  ReleaseTouchPoint();
307  SendTouchNotConsumedAck();
308  EXPECT_FALSE(GesturesSent());
309
310  PushGesture(ET_GESTURE_SCROLL_END);
311  ReleaseTouchPoint();
312  SendTouchConsumedAck();
313  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
314                            GetAndResetSentGestures()));
315}
316
317TEST_F(TouchDispositionGestureFilterTest, ScrollAlternatelyConsumed) {
318  // A consumed touch's gesture should not be sent.
319  PushGesture(ET_GESTURE_SCROLL_BEGIN);
320  PressTouchPoint(1, 1);
321  SendTouchNotConsumedAck();
322  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
323                            GetAndResetSentGestures()));
324
325  for (size_t i = 0; i < 3; ++i) {
326    PushGesture(ET_GESTURE_SCROLL_UPDATE);
327    MoveTouchPoint(0, 2, 2);
328    SendTouchConsumedAck();
329    EXPECT_FALSE(GesturesSent());
330
331    PushGesture(ET_GESTURE_SCROLL_UPDATE);
332    MoveTouchPoint(0, 3, 3);
333    SendTouchNotConsumedAck();
334    EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
335                              GetAndResetSentGestures()));
336  }
337
338  PushGesture(ET_GESTURE_SCROLL_END);
339  ReleaseTouchPoint();
340  SendTouchConsumedAck();
341  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
342                            GetAndResetSentGestures()));
343}
344
345TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenNoConsumer) {
346  // An unconsumed touch's gesture should be sent.
347  PushGesture(ET_GESTURE_SCROLL_BEGIN);
348  PressTouchPoint(1, 1);
349  SendTouchNotConsumedAck();
350  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
351                            GetAndResetSentGestures()));
352
353  // If the subsequent touch has no consumer (e.g., a secondary pointer is
354  // pressed but not on a touch handling rect), send the gesture.
355  PushGesture(ET_GESTURE_PINCH_BEGIN);
356  PressTouchPoint(2, 2);
357  SendTouchNotConsumedAck();
358  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
359                            GetAndResetSentGestures()));
360
361  // End events should be dispatched when their start events were, independent
362  // of the ack state.
363  PushGesture(ET_GESTURE_PINCH_END);
364  ReleaseTouchPoint();
365  SendTouchConsumedAck();
366  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
367                            GetAndResetSentGestures()));
368
369  PushGesture(ET_GESTURE_SCROLL_END);
370  ReleaseTouchPoint();
371  SendTouchConsumedAck();
372  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
373                            GetAndResetSentGestures()));
374}
375
376TEST_F(TouchDispositionGestureFilterTest, EndingEventsSent) {
377  PushGesture(ET_GESTURE_SCROLL_BEGIN);
378  PressTouchPoint(1, 1);
379  SendTouchNotConsumedAck();
380  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
381                            GetAndResetSentGestures()));
382
383  PushGesture(ET_GESTURE_PINCH_BEGIN);
384  PressTouchPoint(2, 2);
385  SendTouchNotConsumedAck();
386  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
387                            GetAndResetSentGestures()));
388
389  // Consuming the touchend event can't suppress the match end gesture.
390  PushGesture(ET_GESTURE_PINCH_END);
391  ReleaseTouchPoint();
392  SendTouchConsumedAck();
393  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
394                            GetAndResetSentGestures()));
395
396  // But other events in the same packet are still suppressed.
397  PushGesture(ET_GESTURE_SCROLL_UPDATE);
398  PushGesture(ET_GESTURE_SCROLL_END);
399  ReleaseTouchPoint();
400  SendTouchConsumedAck();
401  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
402                            GetAndResetSentGestures()));
403
404  // ET_GESTURE_SCROLL_END and ET_SCROLL_FLING_START behave the same in this
405  // regard.
406  PushGesture(ET_GESTURE_SCROLL_BEGIN);
407  PressTouchPoint(1, 1);
408  SendTouchNotConsumedAck();
409  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
410                            GetAndResetSentGestures()));
411
412  PushGesture(ET_SCROLL_FLING_START);
413  ReleaseTouchPoint();
414  SendTouchConsumedAck();
415  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_START),
416                            GetAndResetSentGestures()));
417}
418
419TEST_F(TouchDispositionGestureFilterTest, EndingEventsNotSent) {
420  // Consuming a begin event ensures no end events are sent.
421  PushGesture(ET_GESTURE_SCROLL_BEGIN);
422  PressTouchPoint(1, 1);
423  SendTouchConsumedAck();
424  EXPECT_FALSE(GesturesSent());
425
426  PushGesture(ET_GESTURE_PINCH_BEGIN);
427  PressTouchPoint(2, 2);
428  SendTouchNotConsumedAck();
429  EXPECT_FALSE(GesturesSent());
430
431  PushGesture(ET_GESTURE_PINCH_END);
432  ReleaseTouchPoint();
433  SendTouchNotConsumedAck();
434  EXPECT_FALSE(GesturesSent());
435
436  PushGesture(ET_GESTURE_SCROLL_END);
437  ReleaseTouchPoint();
438  SendTouchNotConsumedAck();
439  EXPECT_FALSE(GesturesSent());
440}
441
442TEST_F(TouchDispositionGestureFilterTest, UpdateEventsSuppressedPerEvent) {
443  PushGesture(ET_GESTURE_SCROLL_BEGIN);
444  PressTouchPoint(1, 1);
445  SendTouchNotConsumedAck();
446  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
447                            GetAndResetSentGestures()));
448
449  // Consuming a single scroll or pinch update should suppress only that event.
450  PushGesture(ET_GESTURE_SCROLL_UPDATE);
451  MoveTouchPoint(0, 2, 2);
452  SendTouchConsumedAck();
453  EXPECT_FALSE(GesturesSent());
454
455  PushGesture(ET_GESTURE_PINCH_BEGIN);
456  PressTouchPoint(2, 2);
457  SendTouchNotConsumedAck();
458  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
459                            GetAndResetSentGestures()));
460
461  PushGesture(ET_GESTURE_PINCH_UPDATE);
462  MoveTouchPoint(1, 2, 3);
463  SendTouchConsumedAck();
464  EXPECT_FALSE(GesturesSent());
465
466  // Subsequent updates should not be affected.
467  PushGesture(ET_GESTURE_SCROLL_UPDATE);
468  MoveTouchPoint(0, 4, 4);
469  SendTouchNotConsumedAck();
470  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
471                            GetAndResetSentGestures()));
472
473  PushGesture(ET_GESTURE_PINCH_UPDATE);
474  MoveTouchPoint(0, 4, 5);
475  SendTouchNotConsumedAck();
476  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_UPDATE),
477                            GetAndResetSentGestures()));
478
479  PushGesture(ET_GESTURE_PINCH_END);
480  ReleaseTouchPoint();
481  SendTouchConsumedAck();
482  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
483                            GetAndResetSentGestures()));
484
485  PushGesture(ET_GESTURE_SCROLL_END);
486  ReleaseTouchPoint();
487  SendTouchConsumedAck();
488  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
489                            GetAndResetSentGestures()));
490}
491
492TEST_F(TouchDispositionGestureFilterTest, UpdateEventsDependOnBeginEvents) {
493  PushGesture(ET_GESTURE_SCROLL_BEGIN);
494  PressTouchPoint(1, 1);
495  SendTouchConsumedAck();
496  EXPECT_FALSE(GesturesSent());
497
498  // Scroll and pinch gestures depend on the scroll begin gesture being
499  // dispatched.
500  PushGesture(ET_GESTURE_SCROLL_UPDATE);
501  MoveTouchPoint(0, 2, 2);
502  SendTouchNotConsumedAck();
503  EXPECT_FALSE(GesturesSent());
504
505  PushGesture(ET_GESTURE_PINCH_BEGIN);
506  PressTouchPoint(2, 2);
507  SendTouchNotConsumedAck();
508  EXPECT_FALSE(GesturesSent());
509
510  PushGesture(ET_GESTURE_PINCH_UPDATE);
511  MoveTouchPoint(1, 2, 3);
512  SendTouchConsumedAck();
513  EXPECT_FALSE(GesturesSent());
514
515  PushGesture(ET_GESTURE_PINCH_END);
516  ReleaseTouchPoint();
517  SendTouchNotConsumedAck();
518  EXPECT_FALSE(GesturesSent());
519
520  PushGesture(ET_GESTURE_SCROLL_END);
521  ReleaseTouchPoint();
522  SendTouchNotConsumedAck();
523  EXPECT_FALSE(GesturesSent());
524}
525
526TEST_F(TouchDispositionGestureFilterTest, MultipleTouchSequences) {
527  // Queue two touch-to-gestures sequences.
528  PushGesture(ET_GESTURE_TAP_DOWN);
529  PressTouchPoint(1, 1);
530  PushGesture(ET_GESTURE_TAP);
531  ReleaseTouchPoint();
532  PushGesture(ET_GESTURE_SCROLL_BEGIN);
533  PressTouchPoint(1, 1);
534  PushGesture(ET_GESTURE_SCROLL_END);
535  ReleaseTouchPoint();
536
537  // The first gesture sequence should not be allowed.
538  SendTouchConsumedAck();
539  SendTouchNotConsumedAck();
540  EXPECT_FALSE(GesturesSent());
541
542  // The subsequent sequence should "reset" allowance.
543  SendTouchNotConsumedAck();
544  SendTouchNotConsumedAck();
545  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
546                                     ET_GESTURE_SCROLL_END),
547                            GetAndResetSentGestures()));
548}
549
550TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnNewTouchSequence) {
551  // Simulate a fling.
552  PushGesture(ET_GESTURE_TAP_DOWN);
553  PushGesture(ET_GESTURE_SCROLL_BEGIN);
554  PressTouchPoint(1, 1);
555  SendTouchNotConsumedAck();
556  EXPECT_TRUE(GesturesMatch(
557      Gestures(
558          ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP_CANCEL, ET_GESTURE_SCROLL_BEGIN),
559      GetAndResetSentGestures()));
560  PushGesture(ET_SCROLL_FLING_START);
561  ReleaseTouchPoint();
562  SendTouchNotConsumedAck();
563  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_START),
564                            GetAndResetSentGestures()));
565
566  // A new touch sequence should cancel the outstanding fling.
567  PressTouchPoint(1, 1);
568  SendTouchNotConsumedAck();
569  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_CANCEL),
570                            GetAndResetSentGestures()));
571  EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
572  ReleaseTouchPoint();
573  SendTouchNotConsumedAck();
574  EXPECT_FALSE(GesturesSent());
575}
576
577TEST_F(TouchDispositionGestureFilterTest, ScrollEndedOnTouchReleaseIfNoFling) {
578  // Simulate a scroll.
579  PushGesture(ET_GESTURE_TAP_DOWN);
580  PushGesture(ET_GESTURE_SCROLL_BEGIN);
581  PressTouchPoint(1, 1);
582  SendTouchNotConsumedAck();
583  EXPECT_TRUE(GesturesMatch(
584      Gestures(
585          ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP_CANCEL, ET_GESTURE_SCROLL_BEGIN),
586      GetAndResetSentGestures()));
587  ReleaseTouchPoint();
588  SendTouchNotConsumedAck();
589  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
590                            GetAndResetSentGestures()));
591  EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
592}
593
594TEST_F(TouchDispositionGestureFilterTest, ScrollEndedOnNewTouchSequence) {
595  // Simulate a scroll.
596  PushGesture(ET_GESTURE_TAP_DOWN);
597  PushGesture(ET_GESTURE_SCROLL_BEGIN);
598  PressTouchPoint(1, 1);
599  SendTouchNotConsumedAck();
600  EXPECT_TRUE(GesturesMatch(
601      Gestures(
602          ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP_CANCEL, ET_GESTURE_SCROLL_BEGIN),
603      GetAndResetSentGestures()));
604
605  // A new touch sequence should end the outstanding scroll.
606  ResetTouchPoints();
607  PressTouchPoint(1, 1);
608  SendTouchConsumedAck();
609  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
610                            GetAndResetSentGestures()));
611  EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
612}
613
614TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnScrollBegin) {
615  // Simulate a fling sequence.
616  PushGesture(ET_GESTURE_TAP_DOWN);
617  PushGesture(ET_GESTURE_SCROLL_BEGIN);
618  PushGesture(ET_SCROLL_FLING_START);
619  PressTouchPoint(1, 1);
620  SendTouchNotConsumedAck();
621  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN,
622                                     ET_GESTURE_TAP_CANCEL,
623                                     ET_GESTURE_SCROLL_BEGIN,
624                                     ET_SCROLL_FLING_START),
625                            GetAndResetSentGestures()));
626
627  // The new fling should cancel the preceding one.
628  PushGesture(ET_GESTURE_SCROLL_BEGIN);
629  PushGesture(ET_SCROLL_FLING_START);
630  ReleaseTouchPoint();
631  SendTouchNotConsumedAck();
632  EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_CANCEL,
633                                     ET_GESTURE_SCROLL_BEGIN,
634                                     ET_SCROLL_FLING_START),
635                            GetAndResetSentGestures()));
636}
637
638TEST_F(TouchDispositionGestureFilterTest, FlingNotCancelledIfGFCEventReceived) {
639  // Simulate a fling that is started then cancelled.
640  PushGesture(ET_GESTURE_SCROLL_BEGIN);
641  PressTouchPoint(1, 1);
642  SendTouchNotConsumedAck();
643  PushGesture(ET_SCROLL_FLING_START);
644  MoveTouchPoint(0, 1, 1);
645  SendTouchNotConsumedAck();
646  PushGesture(ET_SCROLL_FLING_CANCEL);
647  ReleaseTouchPoint();
648  SendTouchNotConsumedAck();
649  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
650                                     ET_SCROLL_FLING_START,
651                                     ET_SCROLL_FLING_CANCEL),
652                            GetAndResetSentGestures()));
653
654  // A new touch sequence will not inject a ET_SCROLL_FLING_CANCEL, as the fling
655  // has already been cancelled.
656  PressTouchPoint(1, 1);
657  SendTouchNotConsumedAck();
658  ReleaseTouchPoint();
659  SendTouchNotConsumedAck();
660  EXPECT_FALSE(GesturesSent());
661}
662
663TEST_F(TouchDispositionGestureFilterTest, TapCancelledWhenScrollBegins) {
664  PushGesture(ET_GESTURE_TAP_DOWN);
665  PressTouchPoint(1, 1);
666  SendTouchNotConsumedAck();
667  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
668                            GetAndResetSentGestures()));
669
670  // If the subsequent touch turns into a scroll, the tap should be cancelled.
671  PushGesture(ET_GESTURE_SCROLL_BEGIN);
672  MoveTouchPoint(0, 2, 2);
673  SendTouchNotConsumedAck();
674  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
675                                     ET_GESTURE_SCROLL_BEGIN),
676                            GetAndResetSentGestures()));
677}
678
679TEST_F(TouchDispositionGestureFilterTest, TapCancelledWhenTouchConsumed) {
680  PushGesture(ET_GESTURE_TAP_DOWN);
681  PressTouchPoint(1, 1);
682  SendTouchNotConsumedAck();
683  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
684                            GetAndResetSentGestures()));
685
686  // If the subsequent touch is consumed, the tap should be cancelled.
687  PushGesture(ET_GESTURE_SCROLL_BEGIN);
688  MoveTouchPoint(0, 2, 2);
689  SendTouchConsumedAck();
690  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL),
691                            GetAndResetSentGestures()));
692}
693
694TEST_F(TouchDispositionGestureFilterTest,
695       TapNotCancelledIfTapEndingEventReceived) {
696  PushGesture(ET_GESTURE_TAP_DOWN);
697  PressTouchPoint(1, 1);
698  PressTouchPoint(2, 2);
699  SendTouchNotConsumedAck();
700  SendTouchNotConsumedAck();
701  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
702                            GetAndResetSentGestures()));
703
704  PushGesture(ET_GESTURE_TAP);
705  ReleaseTouchPoint();
706  SendTouchNotConsumedAck();
707  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS,
708                                     ET_GESTURE_TAP),
709                            GetAndResetSentGestures()));
710
711  // The tap should not be cancelled as it was terminated by a |ET_GESTURE_TAP|.
712  ReleaseTouchPoint();
713  SendTouchConsumedAck();
714  EXPECT_FALSE(GesturesSent());
715}
716
717TEST_F(TouchDispositionGestureFilterTest, TimeoutGestures) {
718  // If the sequence is allowed, and there are no preceding gestures, the
719  // timeout gestures should be forwarded immediately.
720  PushGesture(ET_GESTURE_TAP_DOWN);
721  PressTouchPoint(1, 1);
722  SendTouchNotConsumedAck();
723  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
724                            GetAndResetSentGestures()));
725
726  SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
727  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS),
728                            GetAndResetSentGestures()));
729
730  SendTimeoutGesture(ET_GESTURE_LONG_PRESS);
731  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_LONG_PRESS),
732                            GetAndResetSentGestures()));
733
734  PushGesture(ET_GESTURE_LONG_TAP);
735  ReleaseTouchPoint();
736  SendTouchNotConsumedAck();
737  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
738                                     ET_GESTURE_LONG_TAP),
739                            GetAndResetSentGestures()));
740
741  // If the sequence is disallowed, and there are no preceding gestures, the
742  // timeout gestures should be dropped immediately.
743  PushGesture(ET_GESTURE_TAP_DOWN);
744  PressTouchPoint(1, 1);
745  SendTouchConsumedAck();
746  EXPECT_FALSE(GesturesSent());
747
748  SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
749  EXPECT_FALSE(GesturesSent());
750  ReleaseTouchPoint();
751  SendTouchNotConsumedAck();
752
753  // If the sequence has a pending ack, the timeout gestures should
754  // remain queued until the ack is received.
755  PushGesture(ET_GESTURE_TAP_DOWN);
756  PressTouchPoint(1, 1);
757  EXPECT_FALSE(GesturesSent());
758
759  SendTimeoutGesture(ET_GESTURE_LONG_PRESS);
760  EXPECT_FALSE(GesturesSent());
761
762  SendTouchNotConsumedAck();
763  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN,
764                                     ET_GESTURE_LONG_PRESS),
765                            GetAndResetSentGestures()));
766}
767
768TEST_F(TouchDispositionGestureFilterTest, SpuriousAcksIgnored) {
769  // Acks received when the queue is empty will be safely ignored.
770  ASSERT_TRUE(IsEmpty());
771  SendTouchConsumedAck();
772  EXPECT_FALSE(GesturesSent());
773
774  PushGesture(ET_GESTURE_SCROLL_BEGIN);
775  PressTouchPoint(1, 1);
776  PushGesture(ET_GESTURE_SCROLL_UPDATE);
777  MoveTouchPoint(0, 3,3);
778  SendTouchNotConsumedAck();
779  SendTouchNotConsumedAck();
780  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
781                                     ET_GESTURE_SCROLL_UPDATE),
782                            GetAndResetSentGestures()));
783
784  // Even if all packets have been dispatched, the filter may not be empty as
785  // there could be follow-up timeout events.  Spurious acks in such cases
786  // should also be safely ignored.
787  ASSERT_FALSE(IsEmpty());
788  SendTouchConsumedAck();
789  EXPECT_FALSE(GesturesSent());
790}
791
792TEST_F(TouchDispositionGestureFilterTest, PacketWithInvalidTypeIgnored) {
793  GestureEventDataPacket packet;
794  EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_TYPE,
795            SendGesturePacket(packet));
796  EXPECT_TRUE(IsEmpty());
797}
798
799TEST_F(TouchDispositionGestureFilterTest, PacketsWithInvalidOrderIgnored) {
800  EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_ORDER,
801            SendTimeoutGesture(ET_GESTURE_SHOW_PRESS));
802  EXPECT_TRUE(IsEmpty());
803}
804
805TEST_F(TouchDispositionGestureFilterTest, ConsumedTouchCancel) {
806  // An unconsumed touch's gesture should be sent.
807  PushGesture(ET_GESTURE_TAP_DOWN);
808  PressTouchPoint(1, 1);
809  EXPECT_FALSE(GesturesSent());
810  SendTouchNotConsumedAck();
811  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
812                            GetAndResetSentGestures()));
813
814  PushGesture(ET_GESTURE_TAP_CANCEL);
815  PushGesture(ET_GESTURE_SCROLL_END);
816  CancelTouchPoint();
817  EXPECT_FALSE(GesturesSent());
818  SendTouchConsumedAck();
819  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
820                                     ET_GESTURE_SCROLL_END),
821                            GetAndResetSentGestures()));
822}
823
824TEST_F(TouchDispositionGestureFilterTest, TimeoutEventAfterRelease) {
825  PressTouchPoint(1, 1);
826  SendTouchNotConsumedAck();
827  EXPECT_FALSE(GesturesSent());
828  PushGesture(ET_GESTURE_TAP_DOWN);
829  PushGesture(ET_GESTURE_TAP_UNCONFIRMED);
830  ReleaseTouchPoint();
831  SendTouchNotConsumedAck();
832  EXPECT_TRUE(
833      GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP_UNCONFIRMED),
834                    GetAndResetSentGestures()));
835
836  SendTimeoutGesture(ET_GESTURE_TAP);
837  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS, ET_GESTURE_TAP),
838                            GetAndResetSentGestures()));
839}
840
841TEST_F(TouchDispositionGestureFilterTest, ShowPressInsertedBeforeTap) {
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  SendTimeoutGesture(ET_GESTURE_TAP_UNCONFIRMED);
849  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_UNCONFIRMED),
850                            GetAndResetSentGestures()));
851
852  PushGesture(ET_GESTURE_TAP);
853  ReleaseTouchPoint();
854  SendTouchNotConsumedAck();
855  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS,
856                                     ET_GESTURE_TAP),
857                            GetAndResetSentGestures()));
858}
859
860TEST_F(TouchDispositionGestureFilterTest, ShowPressNotInsertedIfAlreadySent) {
861  PushGesture(ET_GESTURE_TAP_DOWN);
862  PressTouchPoint(1, 1);
863  SendTouchNotConsumedAck();
864  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
865                            GetAndResetSentGestures()));
866
867  SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
868  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS),
869                            GetAndResetSentGestures()));
870
871  PushGesture(ET_GESTURE_TAP);
872  ReleaseTouchPoint();
873  SendTouchNotConsumedAck();
874  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP),
875                            GetAndResetSentGestures()));
876}
877
878TEST_F(TouchDispositionGestureFilterTest, TapAndScrollCancelledOnTouchCancel) {
879  PushGesture(ET_GESTURE_TAP_DOWN);
880  PressTouchPoint(1, 1);
881  SendTouchNotConsumedAck();
882  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
883                            GetAndResetSentGestures()));
884
885  // A cancellation motion event should cancel the tap.
886  CancelTouchPoint();
887  SendTouchNotConsumedAck();
888  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL),
889                            GetAndResetSentGestures()));
890  EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
891
892  PushGesture(ET_GESTURE_SCROLL_BEGIN);
893  PressTouchPoint(1, 1);
894  SendTouchNotConsumedAck();
895  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
896                            GetAndResetSentGestures()));
897
898  // A cancellation motion event should end the scroll, even if the touch was
899  // consumed.
900  CancelTouchPoint();
901  SendTouchConsumedAck();
902  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
903                            GetAndResetSentGestures()));
904  EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
905}
906
907TEST_F(TouchDispositionGestureFilterTest,
908       ConsumedScrollUpdateMakesFlingScrollEnd) {
909  // A consumed touch's gesture should not be sent.
910  PushGesture(ET_GESTURE_BEGIN);
911  PushGesture(ET_GESTURE_SCROLL_BEGIN);
912  PressTouchPoint(1, 1);
913  SendTouchNotConsumedAck();
914
915  EXPECT_TRUE(
916      GesturesMatch(Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN),
917                    GetAndResetSentGestures()));
918
919  PushGesture(ET_GESTURE_SCROLL_UPDATE);
920  MoveTouchPoint(0, 2, 2);
921  SendTouchConsumedAck();
922  EXPECT_FALSE(GesturesSent());
923
924  PushGesture(ET_SCROLL_FLING_START);
925  PushGesture(ET_SCROLL_FLING_CANCEL);
926  PushGesture(ET_GESTURE_END);
927  ReleaseTouchPoint();
928  SendTouchNotConsumedAck();
929  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_END, ET_GESTURE_SCROLL_END),
930                            GetAndResetSentGestures()));
931
932  PushGesture(ET_GESTURE_BEGIN);
933  PushGesture(ET_GESTURE_SCROLL_BEGIN);
934  PressTouchPoint(1, 1);
935  SendTouchNotConsumedAck();
936  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN),
937                            GetAndResetSentGestures()));
938}
939
940TEST_F(TouchDispositionGestureFilterTest, TapCancelledOnTouchCancel) {
941  PushGesture(ET_GESTURE_TAP_DOWN);
942  PressTouchPoint(1, 1);
943  SendTouchNotConsumedAck();
944  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
945                            GetAndResetSentGestures()));
946
947  // A cancellation motion event should cancel the tap.
948  CancelTouchPoint();
949  SendTouchNotConsumedAck();
950  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL),
951                            GetAndResetSentGestures()));
952  EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
953}
954
955// Test that a GestureEvent whose dispatch causes a cancel event to be fired
956// won't cause a crash.
957TEST_F(TouchDispositionGestureFilterTest, TestCancelMidGesture) {
958  SetCancelAfterNextGesture(true);
959  PushGesture(ET_GESTURE_TAP_DOWN);
960  PressTouchPoint(1, 1);
961  SendTouchNotConsumedAck();
962  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN,
963                                     ET_GESTURE_TAP_CANCEL),
964                            GetAndResetSentGestures()));
965}
966
967// Test that a MultiFingerSwipe event is dispatched when appropriate.
968TEST_F(TouchDispositionGestureFilterTest, TestAllowedMultiFingerSwipe) {
969  PushGesture(ET_GESTURE_SCROLL_BEGIN);
970  PressTouchPoint(1, 1);
971  SendTouchNotConsumedAck();
972  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
973                            GetAndResetSentGestures()));
974
975  PushGesture(ET_GESTURE_PINCH_BEGIN);
976  PressTouchPoint(1, 1);
977  SendTouchNotConsumedAck();
978  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
979                            GetAndResetSentGestures()));
980
981  PushGesture(ET_GESTURE_MULTIFINGER_SWIPE);
982  PressTouchPoint(1, 1);
983  SendTouchNotConsumedAck();
984  EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_MULTIFINGER_SWIPE),
985                            GetAndResetSentGestures()));
986}
987
988  // Test that a MultiFingerSwipe event is dispatched when appropriate.
989TEST_F(TouchDispositionGestureFilterTest, TestDisallowedMultiFingerSwipe) {
990  PressTouchPoint(1, 1);
991  SendTouchNotConsumedAck();
992
993  PushGesture(ET_GESTURE_SCROLL_BEGIN);
994  MoveTouchPoint(0, 0, 0);
995  SendTouchConsumedAck();
996  EXPECT_FALSE(GesturesSent());
997
998  PushGesture(ET_GESTURE_PINCH_BEGIN);
999  PressTouchPoint(1, 1);
1000  SendTouchNotConsumedAck();
1001  EXPECT_FALSE(GesturesSent());
1002
1003  PushGesture(ET_GESTURE_MULTIFINGER_SWIPE);
1004  PressTouchPoint(1, 1);
1005  SendTouchNotConsumedAck();
1006  EXPECT_FALSE(GesturesSent());
1007}
1008
1009}  // namespace ui
1010