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