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