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