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