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