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