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