src/ui/events/gesture_detection/touch_disposition_gesture_filter_unittest.cc

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