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