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/touch_disposition_gesture_filter.h"
   9 #include "ui/events/test/mock_motion_event.h"
  10
  11 using ui::test::MockMotionEvent;
  12
  13 namespace ui {
  14
  15 class 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
 224 TEST_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
 243 TEST_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
 266 TEST_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
 287 TEST_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
 307 TEST_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
 342 TEST_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
 370 TEST_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
 401 TEST_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
 444 TEST_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
 467 TEST_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
 517 TEST_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
 551 TEST_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
 575 TEST_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
 606 TEST_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
 624 TEST_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
 645 TEST_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
 669 TEST_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
 695 TEST_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
 711 TEST_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
 727 TEST_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
 747 TEST_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
 798 TEST_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
 822 TEST_F(TouchDispositionGestureFilterTest, PacketWithInvalidTypeIgnored) {
 823   GestureEventDataPacket packet;
 824   EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_TYPE,
 825             SendGesturePacket(packet));
 826   EXPECT_TRUE(IsEmpty());
 827 }
 828
 829 TEST_F(TouchDispositionGestureFilterTest, PacketsWithInvalidOrderIgnored) {
 830   EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_ORDER,
 831             SendTimeoutGesture(ET_GESTURE_SHOW_PRESS));
 832   EXPECT_TRUE(IsEmpty());
 833 }
 834
 835 TEST_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
 854 TEST_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
 871 TEST_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
 890 TEST_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
 908 TEST_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
 943 TEST_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
 977 TEST_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.
 995 TEST_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.
1007 TEST_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.
1028 TEST_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
1048 TEST_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