1 // Copyright (c) 2012 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/command_line.h" 6 #include "base/memory/scoped_vector.h" 7 #include "base/run_loop.h" 8 #include "base/strings/string_number_conversions.h" 9 #include "base/timer/timer.h" 10 #include "testing/gtest/include/gtest/gtest.h" 11 #include "ui/aura/env.h" 12 #include "ui/aura/test/aura_test_base.h" 13 #include "ui/aura/test/event_generator.h" 14 #include "ui/aura/test/test_window_delegate.h" 15 #include "ui/aura/test/test_windows.h" 16 #include "ui/aura/window.h" 17 #include "ui/aura/window_event_dispatcher.h" 18 #include "ui/base/hit_test.h" 19 #include "ui/base/ui_base_switches.h" 20 #include "ui/events/event.h" 21 #include "ui/events/event_switches.h" 22 #include "ui/events/event_utils.h" 23 #include "ui/events/gestures/gesture_configuration.h" 24 #include "ui/events/gestures/gesture_recognizer_impl.h" 25 #include "ui/events/gestures/gesture_sequence.h" 26 #include "ui/events/gestures/gesture_types.h" 27 #include "ui/gfx/point.h" 28 #include "ui/gfx/rect.h" 29 30 #include <queue> 31 32 namespace aura { 33 namespace test { 34 35 namespace { 36 37 std::string WindowIDAsString(ui::GestureConsumer* consumer) { 38 return consumer ? 39 base::IntToString(static_cast<Window*>(consumer)->id()) : "?"; 40 } 41 42 #define EXPECT_0_EVENTS(events) \ 43 EXPECT_EQ(0u, events.size()) 44 45 #define EXPECT_1_EVENT(events, e0) \ 46 EXPECT_EQ(1u, events.size()); \ 47 EXPECT_EQ(e0, events[0]) 48 49 #define EXPECT_2_EVENTS(events, e0, e1) \ 50 EXPECT_EQ(2u, events.size()); \ 51 EXPECT_EQ(e0, events[0]); \ 52 EXPECT_EQ(e1, events[1]) 53 54 #define EXPECT_3_EVENTS(events, e0, e1, e2) \ 55 EXPECT_EQ(3u, events.size()); \ 56 EXPECT_EQ(e0, events[0]); \ 57 EXPECT_EQ(e1, events[1]); \ 58 EXPECT_EQ(e2, events[2]) 59 60 #define EXPECT_4_EVENTS(events, e0, e1, e2, e3) \ 61 EXPECT_EQ(4u, events.size()); \ 62 EXPECT_EQ(e0, events[0]); \ 63 EXPECT_EQ(e1, events[1]); \ 64 EXPECT_EQ(e2, events[2]); \ 65 EXPECT_EQ(e3, events[3]) 66 67 // A delegate that keeps track of gesture events. 68 class GestureEventConsumeDelegate : public TestWindowDelegate { 69 public: 70 GestureEventConsumeDelegate() 71 : tap_(false), 72 tap_down_(false), 73 tap_cancel_(false), 74 begin_(false), 75 end_(false), 76 scroll_begin_(false), 77 scroll_update_(false), 78 scroll_end_(false), 79 pinch_begin_(false), 80 pinch_update_(false), 81 pinch_end_(false), 82 long_press_(false), 83 fling_(false), 84 two_finger_tap_(false), 85 show_press_(false), 86 swipe_left_(false), 87 swipe_right_(false), 88 swipe_up_(false), 89 swipe_down_(false), 90 scroll_x_(0), 91 scroll_y_(0), 92 scroll_velocity_x_(0), 93 scroll_velocity_y_(0), 94 velocity_x_(0), 95 velocity_y_(0), 96 scroll_x_hint_(0), 97 scroll_y_hint_(0), 98 tap_count_(0), 99 flags_(0), 100 wait_until_event_(ui::ET_UNKNOWN) {} 101 102 virtual ~GestureEventConsumeDelegate() {} 103 104 void Reset() { 105 events_.clear(); 106 tap_ = false; 107 tap_down_ = false; 108 tap_cancel_ = false; 109 begin_ = false; 110 end_ = false; 111 scroll_begin_ = false; 112 scroll_update_ = false; 113 scroll_end_ = false; 114 pinch_begin_ = false; 115 pinch_update_ = false; 116 pinch_end_ = false; 117 long_press_ = false; 118 fling_ = false; 119 two_finger_tap_ = false; 120 show_press_ = false; 121 swipe_left_ = false; 122 swipe_right_ = false; 123 swipe_up_ = false; 124 swipe_down_ = false; 125 126 scroll_begin_position_.SetPoint(0, 0); 127 tap_location_.SetPoint(0, 0); 128 gesture_end_location_.SetPoint(0, 0); 129 130 scroll_x_ = 0; 131 scroll_y_ = 0; 132 scroll_velocity_x_ = 0; 133 scroll_velocity_y_ = 0; 134 velocity_x_ = 0; 135 velocity_y_ = 0; 136 scroll_x_hint_ = 0; 137 scroll_y_hint_ = 0; 138 tap_count_ = 0; 139 scale_ = 0; 140 flags_ = 0; 141 latency_info_.Clear(); 142 } 143 144 const std::vector<ui::EventType>& events() const { return events_; }; 145 146 bool tap() const { return tap_; } 147 bool tap_down() const { return tap_down_; } 148 bool tap_cancel() const { return tap_cancel_; } 149 bool begin() const { return begin_; } 150 bool end() const { return end_; } 151 bool scroll_begin() const { return scroll_begin_; } 152 bool scroll_update() const { return scroll_update_; } 153 bool scroll_end() const { return scroll_end_; } 154 bool pinch_begin() const { return pinch_begin_; } 155 bool pinch_update() const { return pinch_update_; } 156 bool pinch_end() const { return pinch_end_; } 157 bool long_press() const { return long_press_; } 158 bool long_tap() const { return long_tap_; } 159 bool fling() const { return fling_; } 160 bool two_finger_tap() const { return two_finger_tap_; } 161 bool show_press() const { return show_press_; } 162 bool swipe_left() const { return swipe_left_; } 163 bool swipe_right() const { return swipe_right_; } 164 bool swipe_up() const { return swipe_up_; } 165 bool swipe_down() const { return swipe_down_; } 166 167 const gfx::Point& scroll_begin_position() const { 168 return scroll_begin_position_; 169 } 170 171 const gfx::Point& tap_location() const { 172 return tap_location_; 173 } 174 175 const gfx::Point& gesture_end_location() const { 176 return gesture_end_location_; 177 } 178 179 float scroll_x() const { return scroll_x_; } 180 float scroll_y() const { return scroll_y_; } 181 float scroll_velocity_x() const { return scroll_velocity_x_; } 182 float scroll_velocity_y() const { return scroll_velocity_y_; } 183 float velocity_x() const { return velocity_x_; } 184 float velocity_y() const { return velocity_y_; } 185 float scroll_x_hint() const { return scroll_x_hint_; } 186 float scroll_y_hint() const { return scroll_y_hint_; } 187 float scale() const { return scale_; } 188 const gfx::Rect& bounding_box() const { return bounding_box_; } 189 int tap_count() const { return tap_count_; } 190 int flags() const { return flags_; } 191 const ui::LatencyInfo& latency_info() const { return latency_info_; } 192 193 void WaitUntilReceivedGesture(ui::EventType type) { 194 wait_until_event_ = type; 195 run_loop_.reset(new base::RunLoop()); 196 run_loop_->Run(); 197 } 198 199 virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE { 200 events_.push_back(gesture->type()); 201 bounding_box_ = gesture->details().bounding_box(); 202 flags_ = gesture->flags(); 203 latency_info_ = *gesture->latency(); 204 switch (gesture->type()) { 205 case ui::ET_GESTURE_TAP: 206 tap_location_ = gesture->location(); 207 tap_count_ = gesture->details().tap_count(); 208 tap_ = true; 209 break; 210 case ui::ET_GESTURE_TAP_DOWN: 211 tap_down_ = true; 212 break; 213 case ui::ET_GESTURE_TAP_CANCEL: 214 tap_cancel_ = true; 215 break; 216 case ui::ET_GESTURE_BEGIN: 217 begin_ = true; 218 break; 219 case ui::ET_GESTURE_END: 220 end_ = true; 221 gesture_end_location_ = gesture->location(); 222 break; 223 case ui::ET_GESTURE_SCROLL_BEGIN: 224 scroll_begin_ = true; 225 scroll_begin_position_ = gesture->location(); 226 scroll_x_hint_ = gesture->details().scroll_x_hint(); 227 scroll_y_hint_ = gesture->details().scroll_y_hint(); 228 break; 229 case ui::ET_GESTURE_SCROLL_UPDATE: 230 scroll_update_ = true; 231 scroll_x_ += gesture->details().scroll_x(); 232 scroll_y_ += gesture->details().scroll_y(); 233 break; 234 case ui::ET_GESTURE_SCROLL_END: 235 EXPECT_TRUE(velocity_x_ == 0 && velocity_y_ == 0); 236 scroll_end_ = true; 237 break; 238 case ui::ET_GESTURE_PINCH_BEGIN: 239 pinch_begin_ = true; 240 break; 241 case ui::ET_GESTURE_PINCH_UPDATE: 242 pinch_update_ = true; 243 scale_ = gesture->details().scale(); 244 break; 245 case ui::ET_GESTURE_PINCH_END: 246 pinch_end_ = true; 247 break; 248 case ui::ET_GESTURE_LONG_PRESS: 249 long_press_ = true; 250 break; 251 case ui::ET_GESTURE_LONG_TAP: 252 long_tap_ = true; 253 break; 254 case ui::ET_SCROLL_FLING_START: 255 EXPECT_TRUE(gesture->details().velocity_x() != 0 || 256 gesture->details().velocity_y() != 0); 257 EXPECT_FALSE(scroll_end_); 258 fling_ = true; 259 velocity_x_ = gesture->details().velocity_x(); 260 velocity_y_ = gesture->details().velocity_y(); 261 break; 262 case ui::ET_GESTURE_TWO_FINGER_TAP: 263 two_finger_tap_ = true; 264 break; 265 case ui::ET_GESTURE_SHOW_PRESS: 266 show_press_ = true; 267 break; 268 case ui::ET_GESTURE_SWIPE: 269 swipe_left_ = gesture->details().swipe_left(); 270 swipe_right_ = gesture->details().swipe_right(); 271 swipe_up_ = gesture->details().swipe_up(); 272 swipe_down_ = gesture->details().swipe_down(); 273 break; 274 case ui::ET_SCROLL_FLING_CANCEL: 275 // Only used in unified gesture detection. 276 break; 277 default: 278 NOTREACHED(); 279 } 280 if (wait_until_event_ == gesture->type() && run_loop_) { 281 run_loop_->Quit(); 282 wait_until_event_ = ui::ET_UNKNOWN; 283 } 284 gesture->StopPropagation(); 285 } 286 287 private: 288 scoped_ptr<base::RunLoop> run_loop_; 289 std::vector<ui::EventType> events_; 290 291 bool tap_; 292 bool tap_down_; 293 bool tap_cancel_; 294 bool begin_; 295 bool end_; 296 bool scroll_begin_; 297 bool scroll_update_; 298 bool scroll_end_; 299 bool pinch_begin_; 300 bool pinch_update_; 301 bool pinch_end_; 302 bool long_press_; 303 bool long_tap_; 304 bool fling_; 305 bool two_finger_tap_; 306 bool show_press_; 307 bool swipe_left_; 308 bool swipe_right_; 309 bool swipe_up_; 310 bool swipe_down_; 311 312 gfx::Point scroll_begin_position_; 313 gfx::Point tap_location_; 314 gfx::Point gesture_end_location_; 315 316 float scroll_x_; 317 float scroll_y_; 318 float scroll_velocity_x_; 319 float scroll_velocity_y_; 320 float velocity_x_; 321 float velocity_y_; 322 float scroll_x_hint_; 323 float scroll_y_hint_; 324 float scale_; 325 gfx::Rect bounding_box_; 326 int tap_count_; 327 int flags_; 328 ui::LatencyInfo latency_info_; 329 330 ui::EventType wait_until_event_; 331 332 DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate); 333 }; 334 335 class QueueTouchEventDelegate : public GestureEventConsumeDelegate { 336 public: 337 explicit QueueTouchEventDelegate(WindowEventDispatcher* dispatcher) 338 : window_(NULL), 339 dispatcher_(dispatcher), 340 queue_events_(true) { 341 } 342 virtual ~QueueTouchEventDelegate() { 343 while(!queue_.empty()) { 344 delete queue_.front(); 345 queue_.pop(); 346 } 347 } 348 349 virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE { 350 if (queue_events_) { 351 queue_.push(new ui::TouchEvent(*event, window_, window_)); 352 event->StopPropagation(); 353 } 354 } 355 356 void ReceivedAck() { 357 ReceivedAckImpl(false); 358 } 359 360 void ReceivedAckPreventDefaulted() { 361 ReceivedAckImpl(true); 362 } 363 364 void set_window(Window* w) { window_ = w; } 365 void set_queue_events(bool queue) { queue_events_ = queue; } 366 367 private: 368 void ReceivedAckImpl(bool prevent_defaulted) { 369 scoped_ptr<ui::TouchEvent> event(queue_.front()); 370 dispatcher_->ProcessedTouchEvent(event.get(), window_, 371 prevent_defaulted ? ui::ER_HANDLED : ui::ER_UNHANDLED); 372 queue_.pop(); 373 } 374 375 std::queue<ui::TouchEvent*> queue_; 376 Window* window_; 377 WindowEventDispatcher* dispatcher_; 378 bool queue_events_; 379 380 DISALLOW_COPY_AND_ASSIGN(QueueTouchEventDelegate); 381 }; 382 383 // A delegate that ignores gesture events but keeps track of [synthetic] mouse 384 // events. 385 class GestureEventSynthDelegate : public TestWindowDelegate { 386 public: 387 GestureEventSynthDelegate() 388 : mouse_enter_(false), 389 mouse_exit_(false), 390 mouse_press_(false), 391 mouse_release_(false), 392 mouse_move_(false), 393 double_click_(false) { 394 } 395 396 void Reset() { 397 mouse_enter_ = false; 398 mouse_exit_ = false; 399 mouse_press_ = false; 400 mouse_release_ = false; 401 mouse_move_ = false; 402 double_click_ = false; 403 } 404 405 bool mouse_enter() const { return mouse_enter_; } 406 bool mouse_exit() const { return mouse_exit_; } 407 bool mouse_press() const { return mouse_press_; } 408 bool mouse_move() const { return mouse_move_; } 409 bool mouse_release() const { return mouse_release_; } 410 bool double_click() const { return double_click_; } 411 412 virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE { 413 switch (event->type()) { 414 case ui::ET_MOUSE_PRESSED: 415 double_click_ = event->flags() & ui::EF_IS_DOUBLE_CLICK; 416 mouse_press_ = true; 417 break; 418 case ui::ET_MOUSE_RELEASED: 419 mouse_release_ = true; 420 break; 421 case ui::ET_MOUSE_MOVED: 422 mouse_move_ = true; 423 break; 424 case ui::ET_MOUSE_ENTERED: 425 mouse_enter_ = true; 426 break; 427 case ui::ET_MOUSE_EXITED: 428 mouse_exit_ = true; 429 break; 430 default: 431 NOTREACHED(); 432 } 433 event->SetHandled(); 434 } 435 436 private: 437 bool mouse_enter_; 438 bool mouse_exit_; 439 bool mouse_press_; 440 bool mouse_release_; 441 bool mouse_move_; 442 bool double_click_; 443 444 DISALLOW_COPY_AND_ASSIGN(GestureEventSynthDelegate); 445 }; 446 447 class TestOneShotGestureSequenceTimer 448 : public base::OneShotTimer<ui::GestureSequence> { 449 public: 450 TestOneShotGestureSequenceTimer() {} 451 452 void ForceTimeout() { 453 if (IsRunning()) { 454 user_task().Run(); 455 Stop(); 456 } 457 } 458 459 private: 460 DISALLOW_COPY_AND_ASSIGN(TestOneShotGestureSequenceTimer); 461 }; 462 463 class TimerTestGestureSequence : public ui::GestureSequence { 464 public: 465 explicit TimerTestGestureSequence(ui::GestureSequenceDelegate* delegate) 466 : ui::GestureSequence(delegate) { 467 } 468 469 void ForceTimeout() { 470 static_cast<TestOneShotGestureSequenceTimer*>( 471 GetLongPressTimer())->ForceTimeout(); 472 } 473 474 bool IsTimerRunning() { 475 return GetLongPressTimer()->IsRunning(); 476 } 477 478 virtual base::OneShotTimer<ui::GestureSequence>* CreateTimer() OVERRIDE { 479 return new TestOneShotGestureSequenceTimer(); 480 } 481 482 private: 483 DISALLOW_COPY_AND_ASSIGN(TimerTestGestureSequence); 484 }; 485 486 class TestGestureRecognizer : public ui::GestureRecognizerImpl { 487 public: 488 TestGestureRecognizer() : GestureRecognizerImpl() { 489 } 490 491 ui::GestureSequence* GetGestureSequenceForTesting(Window* window) { 492 return GetGestureSequenceForConsumer(window); 493 } 494 495 private: 496 DISALLOW_COPY_AND_ASSIGN(TestGestureRecognizer); 497 }; 498 499 class TimerTestGestureRecognizer : public TestGestureRecognizer { 500 public: 501 TimerTestGestureRecognizer() : TestGestureRecognizer() { 502 } 503 504 virtual ui::GestureSequence* CreateSequence( 505 ui::GestureSequenceDelegate* delegate) OVERRIDE { 506 return new TimerTestGestureSequence(delegate); 507 } 508 509 private: 510 DISALLOW_COPY_AND_ASSIGN(TimerTestGestureRecognizer); 511 }; 512 513 base::TimeDelta GetTime() { 514 return ui::EventTimeForNow(); 515 } 516 517 class ScopedGestureRecognizerSetter { 518 public: 519 // Takes ownership of |new_gr|. 520 explicit ScopedGestureRecognizerSetter(ui::GestureRecognizer* new_gr) 521 : new_gr_(new_gr) { 522 original_gr_ = ui::GestureRecognizer::Get(); 523 ui::SetGestureRecognizerForTesting(new_gr_.get()); 524 } 525 526 virtual ~ScopedGestureRecognizerSetter() { 527 ui::SetGestureRecognizerForTesting(original_gr_); 528 } 529 530 private: 531 ui::GestureRecognizer* original_gr_; 532 scoped_ptr<ui::GestureRecognizer> new_gr_; 533 534 DISALLOW_COPY_AND_ASSIGN(ScopedGestureRecognizerSetter); 535 }; 536 537 class TimedEvents { 538 private: 539 int simulated_now_; 540 541 public: 542 // Use a non-zero start time to pass DCHECKs which ensure events have had a 543 // time assigned. 544 TimedEvents() : simulated_now_(1) { 545 } 546 547 base::TimeDelta Now() { 548 base::TimeDelta t = base::TimeDelta::FromMilliseconds(simulated_now_); 549 simulated_now_++; 550 return t; 551 } 552 553 base::TimeDelta LeapForward(int time_in_millis) { 554 simulated_now_ += time_in_millis; 555 return base::TimeDelta::FromMilliseconds(simulated_now_); 556 } 557 558 base::TimeDelta InFuture(int time_in_millis) { 559 return base::TimeDelta::FromMilliseconds(simulated_now_ + time_in_millis); 560 } 561 562 void SendScrollEvents(ui::EventProcessor* dispatcher, 563 float x_start, 564 float y_start, 565 int dx, 566 int dy, 567 int touch_id, 568 int time_step, 569 int num_steps, 570 GestureEventConsumeDelegate* delegate) { 571 int x = x_start; 572 int y = y_start; 573 574 for (int i = 0; i < num_steps; i++) { 575 x += dx; 576 y += dy; 577 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(x, y), 578 touch_id, 579 base::TimeDelta::FromMilliseconds(simulated_now_)); 580 ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&move); 581 ASSERT_FALSE(details.dispatcher_destroyed); 582 simulated_now_ += time_step; 583 } 584 } 585 586 void SendScrollEvent(ui::EventProcessor* dispatcher, 587 float x, 588 float y, 589 int touch_id, 590 GestureEventConsumeDelegate* delegate) { 591 delegate->Reset(); 592 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(x, y), 593 touch_id, 594 base::TimeDelta::FromMilliseconds(simulated_now_)); 595 ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&move); 596 ASSERT_FALSE(details.dispatcher_destroyed); 597 simulated_now_++; 598 } 599 }; 600 601 // An event handler to keep track of events. 602 class TestEventHandler : public ui::EventHandler { 603 public: 604 TestEventHandler() : touch_released_count_(0), 605 touch_pressed_count_(0), 606 touch_moved_count_(0), 607 touch_cancelled_count_(0) { 608 } 609 610 virtual ~TestEventHandler() {} 611 612 virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE { 613 switch (event->type()) { 614 case ui::ET_TOUCH_RELEASED: 615 touch_released_count_++; 616 break; 617 case ui::ET_TOUCH_PRESSED: 618 touch_pressed_count_++; 619 break; 620 case ui::ET_TOUCH_MOVED: 621 touch_moved_count_++; 622 break; 623 case ui::ET_TOUCH_CANCELLED: 624 touch_cancelled_count_++; 625 break; 626 default: 627 break; 628 } 629 } 630 631 void Reset() { 632 touch_released_count_ = 0; 633 touch_pressed_count_ = 0; 634 touch_moved_count_ = 0; 635 touch_cancelled_count_ = 0; 636 } 637 638 int touch_released_count() const { return touch_released_count_; } 639 int touch_pressed_count() const { return touch_pressed_count_; } 640 int touch_moved_count() const { return touch_moved_count_; } 641 int touch_cancelled_count() const { return touch_cancelled_count_; } 642 643 private: 644 int touch_released_count_; 645 int touch_pressed_count_; 646 int touch_moved_count_; 647 int touch_cancelled_count_; 648 649 DISALLOW_COPY_AND_ASSIGN(TestEventHandler); 650 }; 651 652 // Removes the target window from its parent when it receives a touch-cancel 653 // event. 654 class RemoveOnTouchCancelHandler : public TestEventHandler { 655 public: 656 RemoveOnTouchCancelHandler() {} 657 virtual ~RemoveOnTouchCancelHandler() {} 658 659 private: 660 // ui::EventHandler: 661 virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE { 662 TestEventHandler::OnTouchEvent(event); 663 if (event->type() == ui::ET_TOUCH_CANCELLED) { 664 Window* target = static_cast<Window*>(event->target()); 665 // This is tiptoeing around crbug.com/310172. If this event handler isn't 666 // removed, we enter an infinite loop. 667 target->RemovePreTargetHandler(this); 668 target->parent()->RemoveChild(target); 669 } 670 } 671 672 DISALLOW_COPY_AND_ASSIGN(RemoveOnTouchCancelHandler); 673 }; 674 675 } // namespace 676 677 class GestureRecognizerTest : public AuraTestBase, 678 public ::testing::WithParamInterface<bool> { 679 public: 680 GestureRecognizerTest() {} 681 682 bool UsingUnifiedGR() { 683 return GetParam(); 684 } 685 686 virtual void SetUp() OVERRIDE { 687 // TODO(tdresser): Once unified GR has landed, only run these tests once. 688 CommandLine::ForCurrentProcess()->AppendSwitchASCII( 689 switches::kUnifiedGestureDetector, 690 UsingUnifiedGR() ? switches::kUnifiedGestureDetectorEnabled 691 : switches::kUnifiedGestureDetectorDisabled); 692 693 AuraTestBase::SetUp(); 694 ui::GestureConfiguration::set_min_touch_down_duration_in_seconds_for_click( 695 0.001); 696 ui::GestureConfiguration::set_show_press_delay_in_ms(2); 697 ui::GestureConfiguration::set_long_press_time_in_seconds(0.003); 698 } 699 700 DISALLOW_COPY_AND_ASSIGN(GestureRecognizerTest); 701 }; 702 703 // Check that appropriate touch events generate tap gesture events. 704 TEST_P(GestureRecognizerTest, GestureEventTap) { 705 scoped_ptr<GestureEventConsumeDelegate> delegate( 706 new GestureEventConsumeDelegate()); 707 TimedEvents tes; 708 const int kWindowWidth = 123; 709 const int kWindowHeight = 45; 710 const int kTouchId = 2; 711 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 712 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 713 delegate.get(), -1234, bounds, root_window())); 714 715 delegate->Reset(); 716 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 717 kTouchId, tes.Now()); 718 DispatchEventUsingWindowDispatcher(&press); 719 EXPECT_FALSE(delegate->tap()); 720 EXPECT_FALSE(delegate->show_press()); 721 EXPECT_TRUE(delegate->tap_down()); 722 EXPECT_FALSE(delegate->tap_cancel()); 723 EXPECT_TRUE(delegate->begin()); 724 EXPECT_FALSE(delegate->scroll_begin()); 725 EXPECT_FALSE(delegate->scroll_update()); 726 EXPECT_FALSE(delegate->scroll_end()); 727 EXPECT_FALSE(delegate->long_press()); 728 729 delegate->Reset(); 730 delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_SHOW_PRESS); 731 EXPECT_TRUE(delegate->show_press()); 732 EXPECT_FALSE(delegate->tap_down()); 733 734 // Make sure there is enough delay before the touch is released so that it is 735 // recognized as a tap. 736 delegate->Reset(); 737 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 738 kTouchId, tes.LeapForward(50)); 739 740 DispatchEventUsingWindowDispatcher(&release); 741 EXPECT_TRUE(delegate->tap()); 742 EXPECT_FALSE(delegate->tap_down()); 743 EXPECT_FALSE(delegate->tap_cancel()); 744 EXPECT_FALSE(delegate->begin()); 745 EXPECT_TRUE(delegate->end()); 746 EXPECT_FALSE(delegate->scroll_begin()); 747 EXPECT_FALSE(delegate->scroll_update()); 748 EXPECT_FALSE(delegate->scroll_end()); 749 750 EXPECT_EQ(1, delegate->tap_count()); 751 } 752 753 // Check that appropriate touch events generate tap gesture events 754 // when information about the touch radii are provided. 755 TEST_P(GestureRecognizerTest, GestureEventTapRegion) { 756 // TODO(tdresser): enable this test with unified GR once we resolve the 757 // bounding box differences. See crbug.com/366641. 758 if (UsingUnifiedGR()) 759 return; 760 761 scoped_ptr<GestureEventConsumeDelegate> delegate( 762 new GestureEventConsumeDelegate()); 763 TimedEvents tes; 764 const int kWindowWidth = 800; 765 const int kWindowHeight = 600; 766 const int kTouchId = 2; 767 gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight); 768 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 769 delegate.get(), -1234, bounds, root_window())); 770 771 // Test with no ET_TOUCH_MOVED events. 772 { 773 delegate->Reset(); 774 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 775 kTouchId, tes.Now()); 776 press.set_radius_x(5); 777 press.set_radius_y(12); 778 DispatchEventUsingWindowDispatcher(&press); 779 EXPECT_FALSE(delegate->tap()); 780 EXPECT_TRUE(delegate->tap_down()); 781 EXPECT_FALSE(delegate->tap_cancel()); 782 EXPECT_TRUE(delegate->begin()); 783 EXPECT_FALSE(delegate->scroll_begin()); 784 EXPECT_FALSE(delegate->scroll_update()); 785 EXPECT_FALSE(delegate->scroll_end()); 786 EXPECT_FALSE(delegate->long_press()); 787 788 // Make sure there is enough delay before the touch is released so that it 789 // is recognized as a tap. 790 delegate->Reset(); 791 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 792 kTouchId, tes.LeapForward(50)); 793 release.set_radius_x(5); 794 release.set_radius_y(12); 795 796 DispatchEventUsingWindowDispatcher(&release); 797 EXPECT_TRUE(delegate->tap()); 798 EXPECT_FALSE(delegate->tap_down()); 799 EXPECT_FALSE(delegate->tap_cancel()); 800 EXPECT_FALSE(delegate->begin()); 801 EXPECT_TRUE(delegate->end()); 802 EXPECT_FALSE(delegate->scroll_begin()); 803 EXPECT_FALSE(delegate->scroll_update()); 804 EXPECT_FALSE(delegate->scroll_end()); 805 806 EXPECT_EQ(1, delegate->tap_count()); 807 gfx::Point actual_point(delegate->tap_location()); 808 EXPECT_EQ(24, delegate->bounding_box().width()); 809 EXPECT_EQ(24, delegate->bounding_box().height()); 810 EXPECT_EQ(101, actual_point.x()); 811 EXPECT_EQ(201, actual_point.y()); 812 } 813 814 // Test with no ET_TOUCH_MOVED events but different touch points and radii. 815 { 816 delegate->Reset(); 817 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(365, 290), 818 kTouchId, tes.Now()); 819 press.set_radius_x(8); 820 press.set_radius_y(14); 821 DispatchEventUsingWindowDispatcher(&press); 822 EXPECT_FALSE(delegate->tap()); 823 EXPECT_TRUE(delegate->tap_down()); 824 EXPECT_FALSE(delegate->tap_cancel()); 825 EXPECT_TRUE(delegate->begin()); 826 EXPECT_FALSE(delegate->scroll_begin()); 827 EXPECT_FALSE(delegate->scroll_update()); 828 EXPECT_FALSE(delegate->scroll_end()); 829 EXPECT_FALSE(delegate->long_press()); 830 831 delegate->Reset(); 832 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(367, 291), 833 kTouchId, tes.LeapForward(50)); 834 release.set_radius_x(20); 835 release.set_radius_y(13); 836 837 DispatchEventUsingWindowDispatcher(&release); 838 EXPECT_TRUE(delegate->tap()); 839 EXPECT_FALSE(delegate->tap_down()); 840 EXPECT_FALSE(delegate->tap_cancel()); 841 EXPECT_FALSE(delegate->begin()); 842 EXPECT_TRUE(delegate->end()); 843 EXPECT_FALSE(delegate->scroll_begin()); 844 EXPECT_FALSE(delegate->scroll_update()); 845 EXPECT_FALSE(delegate->scroll_end()); 846 847 EXPECT_EQ(1, delegate->tap_count()); 848 gfx::Point actual_point(delegate->tap_location()); 849 EXPECT_EQ(40, delegate->bounding_box().width()); 850 EXPECT_EQ(40, delegate->bounding_box().height()); 851 EXPECT_EQ(367, actual_point.x()); 852 EXPECT_EQ(291, actual_point.y()); 853 } 854 855 // Test with a single ET_TOUCH_MOVED event. 856 { 857 delegate->Reset(); 858 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(46, 205), 859 kTouchId, tes.Now()); 860 press.set_radius_x(6); 861 press.set_radius_y(10); 862 DispatchEventUsingWindowDispatcher(&press); 863 EXPECT_FALSE(delegate->tap()); 864 EXPECT_TRUE(delegate->tap_down()); 865 EXPECT_FALSE(delegate->tap_cancel()); 866 EXPECT_TRUE(delegate->begin()); 867 EXPECT_FALSE(delegate->tap_cancel()); 868 EXPECT_FALSE(delegate->scroll_begin()); 869 EXPECT_FALSE(delegate->scroll_update()); 870 EXPECT_FALSE(delegate->scroll_end()); 871 EXPECT_FALSE(delegate->long_press()); 872 873 delegate->Reset(); 874 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(49, 204), 875 kTouchId, tes.LeapForward(50)); 876 move.set_radius_x(8); 877 move.set_radius_y(12); 878 DispatchEventUsingWindowDispatcher(&move); 879 EXPECT_FALSE(delegate->tap()); 880 EXPECT_FALSE(delegate->tap_down()); 881 EXPECT_FALSE(delegate->tap_cancel()); 882 EXPECT_FALSE(delegate->begin()); 883 EXPECT_FALSE(delegate->scroll_begin()); 884 EXPECT_FALSE(delegate->scroll_update()); 885 EXPECT_FALSE(delegate->scroll_end()); 886 EXPECT_FALSE(delegate->long_press()); 887 888 delegate->Reset(); 889 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(49, 204), 890 kTouchId, tes.LeapForward(50)); 891 release.set_radius_x(4); 892 release.set_radius_y(8); 893 894 DispatchEventUsingWindowDispatcher(&release); 895 EXPECT_TRUE(delegate->tap()); 896 EXPECT_FALSE(delegate->tap_down()); 897 EXPECT_FALSE(delegate->tap_cancel()); 898 EXPECT_FALSE(delegate->begin()); 899 EXPECT_TRUE(delegate->end()); 900 EXPECT_FALSE(delegate->scroll_begin()); 901 EXPECT_FALSE(delegate->scroll_update()); 902 EXPECT_FALSE(delegate->scroll_end()); 903 904 EXPECT_EQ(1, delegate->tap_count()); 905 gfx::Point actual_point(delegate->tap_location()); 906 EXPECT_EQ(25, delegate->bounding_box().width()); 907 EXPECT_EQ(24, delegate->bounding_box().height()); 908 EXPECT_EQ(48, actual_point.x()); 909 EXPECT_EQ(204, actual_point.y()); 910 } 911 912 // Test with a few ET_TOUCH_MOVED events. 913 { 914 delegate->Reset(); 915 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(400, 150), 916 kTouchId, tes.Now()); 917 press.set_radius_x(7); 918 press.set_radius_y(10); 919 DispatchEventUsingWindowDispatcher(&press); 920 EXPECT_FALSE(delegate->tap()); 921 EXPECT_TRUE(delegate->tap_down()); 922 EXPECT_FALSE(delegate->tap_cancel()); 923 EXPECT_TRUE(delegate->begin()); 924 EXPECT_FALSE(delegate->scroll_begin()); 925 EXPECT_FALSE(delegate->scroll_update()); 926 EXPECT_FALSE(delegate->scroll_end()); 927 EXPECT_FALSE(delegate->long_press()); 928 929 delegate->Reset(); 930 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(397, 151), 931 kTouchId, tes.LeapForward(50)); 932 move.set_radius_x(13); 933 move.set_radius_y(12); 934 DispatchEventUsingWindowDispatcher(&move); 935 EXPECT_FALSE(delegate->tap()); 936 EXPECT_FALSE(delegate->tap_down()); 937 EXPECT_FALSE(delegate->tap_cancel()); 938 EXPECT_FALSE(delegate->begin()); 939 EXPECT_FALSE(delegate->scroll_begin()); 940 EXPECT_FALSE(delegate->scroll_update()); 941 EXPECT_FALSE(delegate->scroll_end()); 942 EXPECT_FALSE(delegate->long_press()); 943 944 delegate->Reset(); 945 ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(397, 149), 946 kTouchId, tes.LeapForward(50)); 947 move1.set_radius_x(16); 948 move1.set_radius_y(16); 949 DispatchEventUsingWindowDispatcher(&move1); 950 EXPECT_FALSE(delegate->tap()); 951 EXPECT_FALSE(delegate->tap_down()); 952 EXPECT_FALSE(delegate->tap_cancel()); 953 EXPECT_FALSE(delegate->begin()); 954 EXPECT_FALSE(delegate->scroll_begin()); 955 EXPECT_FALSE(delegate->scroll_update()); 956 EXPECT_FALSE(delegate->scroll_end()); 957 EXPECT_FALSE(delegate->long_press()); 958 959 delegate->Reset(); 960 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(400, 150), 961 kTouchId, tes.LeapForward(50)); 962 move2.set_radius_x(14); 963 move2.set_radius_y(10); 964 DispatchEventUsingWindowDispatcher(&move2); 965 EXPECT_FALSE(delegate->tap()); 966 EXPECT_FALSE(delegate->tap_down()); 967 EXPECT_FALSE(delegate->tap_cancel()); 968 EXPECT_FALSE(delegate->begin()); 969 EXPECT_FALSE(delegate->scroll_begin()); 970 EXPECT_FALSE(delegate->scroll_update()); 971 EXPECT_FALSE(delegate->scroll_end()); 972 EXPECT_FALSE(delegate->long_press()); 973 974 delegate->Reset(); 975 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(401, 149), 976 kTouchId, tes.LeapForward(50)); 977 release.set_radius_x(8); 978 release.set_radius_y(9); 979 980 DispatchEventUsingWindowDispatcher(&release); 981 EXPECT_TRUE(delegate->tap()); 982 EXPECT_FALSE(delegate->tap_down()); 983 EXPECT_FALSE(delegate->tap_cancel()); 984 EXPECT_FALSE(delegate->begin()); 985 EXPECT_TRUE(delegate->end()); 986 EXPECT_FALSE(delegate->scroll_begin()); 987 EXPECT_FALSE(delegate->scroll_update()); 988 EXPECT_FALSE(delegate->scroll_end()); 989 990 EXPECT_EQ(1, delegate->tap_count()); 991 gfx::Point actual_point(delegate->tap_location()); 992 EXPECT_EQ(33, delegate->bounding_box().width()); 993 EXPECT_EQ(32, delegate->bounding_box().height()); 994 EXPECT_EQ(397, actual_point.x()); 995 EXPECT_EQ(149, actual_point.y()); 996 } 997 } 998 999 // Check that appropriate touch events generate scroll gesture events. 1000 TEST_P(GestureRecognizerTest, GestureEventScroll) { 1001 // We'll start by moving the touch point by (10.5, 10.5). We want 5 dips of 1002 // that distance to be consumed by the slop, so we set the slop radius to 1003 // sqrt(5 * 5 + 5 * 5). 1004 ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click( 1005 sqrt(static_cast<double>(5 * 5 + 5 * 5))); 1006 scoped_ptr<GestureEventConsumeDelegate> delegate( 1007 new GestureEventConsumeDelegate()); 1008 TimedEvents tes; 1009 const int kWindowWidth = 123; 1010 const int kWindowHeight = 45; 1011 const int kTouchId = 5; 1012 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 1013 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1014 delegate.get(), -1234, bounds, root_window())); 1015 1016 delegate->Reset(); 1017 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 1018 kTouchId, tes.Now()); 1019 DispatchEventUsingWindowDispatcher(&press); 1020 EXPECT_2_EVENTS(delegate->events(), 1021 ui::ET_GESTURE_BEGIN, 1022 ui::ET_GESTURE_TAP_DOWN); 1023 1024 // Move the touch-point enough so that it is considered as a scroll. This 1025 // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures. 1026 // The first movement is diagonal, to ensure that we have a free scroll, 1027 // and not a rail scroll. 1028 tes.SendScrollEvent(event_processor(), 111.5, 211.5, kTouchId, 1029 delegate.get()); 1030 EXPECT_3_EVENTS(delegate->events(), 1031 ui::ET_GESTURE_TAP_CANCEL, 1032 ui::ET_GESTURE_SCROLL_BEGIN, 1033 ui::ET_GESTURE_SCROLL_UPDATE); 1034 // The slop consumed 5 dips 1035 EXPECT_FLOAT_EQ(5.5, delegate->scroll_x()); 1036 EXPECT_FLOAT_EQ(5.5, delegate->scroll_y()); 1037 EXPECT_EQ(gfx::Point(1, 1).ToString(), 1038 delegate->scroll_begin_position().ToString()); 1039 1040 // When scrolling with a single finger, the bounding box of the gesture should 1041 // be empty, since it's a single point and the radius for testing is zero. 1042 EXPECT_TRUE(delegate->bounding_box().IsEmpty()); 1043 1044 // Move some more to generate a few more scroll updates. Make sure that we get 1045 // out of the snap channel for the unified GR. 1046 tes.SendScrollEvent(event_processor(), 20, 120, kTouchId, delegate.get()); 1047 EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE); 1048 EXPECT_FLOAT_EQ(-91.5, delegate->scroll_x()); 1049 EXPECT_FLOAT_EQ(-91.5, delegate->scroll_y()); 1050 EXPECT_TRUE(delegate->bounding_box().IsEmpty()); 1051 1052 tes.SendScrollEvent(event_processor(), 50, 124, kTouchId, delegate.get()); 1053 EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE); 1054 EXPECT_EQ(30, delegate->scroll_x()); 1055 EXPECT_EQ(4, delegate->scroll_y()); 1056 EXPECT_TRUE(delegate->bounding_box().IsEmpty()); 1057 1058 // Release the touch. This should end the scroll. 1059 delegate->Reset(); 1060 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 1061 kTouchId, 1062 tes.LeapForward(50)); 1063 DispatchEventUsingWindowDispatcher(&release); 1064 EXPECT_2_EVENTS(delegate->events(), 1065 ui::ET_SCROLL_FLING_START, 1066 ui::ET_GESTURE_END); 1067 EXPECT_TRUE(delegate->bounding_box().IsEmpty()); 1068 } 1069 1070 // Check that predicted scroll update positions are correct. 1071 TEST_P(GestureRecognizerTest, GestureEventScrollPrediction) { 1072 const double prediction_interval = 0.03; 1073 ui::GestureConfiguration::set_scroll_prediction_seconds(prediction_interval); 1074 // We'll start by moving the touch point by (5, 5). We want all of that 1075 // distance to be consumed by the slop, so we set the slop radius to 1076 // sqrt(5 * 5 + 5 * 5). 1077 ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click( 1078 sqrt(static_cast<double>(5 * 5 + 5 * 5))); 1079 1080 scoped_ptr<GestureEventConsumeDelegate> delegate( 1081 new GestureEventConsumeDelegate()); 1082 TimedEvents tes; 1083 const int kWindowWidth = 123; 1084 const int kWindowHeight = 45; 1085 const int kTouchId = 5; 1086 gfx::Rect bounds(95, 195, kWindowWidth, kWindowHeight); 1087 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1088 delegate.get(), -1234, bounds, root_window())); 1089 1090 delegate->Reset(); 1091 // Tracks the total scroll since we want to verify that the correct position 1092 // will be scrolled to throughout the prediction. 1093 gfx::Vector2dF total_scroll; 1094 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(96, 196), 1095 kTouchId, tes.Now()); 1096 DispatchEventUsingWindowDispatcher(&press); 1097 EXPECT_2_EVENTS(delegate->events(), 1098 ui::ET_GESTURE_BEGIN, 1099 ui::ET_GESTURE_TAP_DOWN); 1100 delegate->Reset(); 1101 1102 // Get rid of touch slop. 1103 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(111, 211), 1104 kTouchId, tes.Now()); 1105 DispatchEventUsingWindowDispatcher(&move); 1106 EXPECT_3_EVENTS(delegate->events(), 1107 ui::ET_GESTURE_TAP_CANCEL, 1108 ui::ET_GESTURE_SCROLL_BEGIN, 1109 ui::ET_GESTURE_SCROLL_UPDATE); 1110 total_scroll.set_x(total_scroll.x() + delegate->scroll_x()); 1111 total_scroll.set_y(total_scroll.y() + delegate->scroll_y()); 1112 1113 // Move the touch-point enough so that it is considered as a scroll. This 1114 // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures. 1115 // The first movement is diagonal, to ensure that we have a free scroll, 1116 // and not a rail scroll. 1117 tes.LeapForward(30); 1118 tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get()); 1119 EXPECT_1_EVENT(delegate->events(), 1120 ui::ET_GESTURE_SCROLL_UPDATE); 1121 total_scroll.set_x(total_scroll.x() + delegate->scroll_x()); 1122 total_scroll.set_y(total_scroll.y() + delegate->scroll_y()); 1123 1124 // Move some more to generate a few more scroll updates. 1125 tes.LeapForward(30); 1126 tes.SendScrollEvent(event_processor(), 110, 211, kTouchId, delegate.get()); 1127 EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE); 1128 total_scroll.set_x(total_scroll.x() + delegate->scroll_x()); 1129 total_scroll.set_y(total_scroll.y() + delegate->scroll_y()); 1130 1131 tes.LeapForward(30); 1132 tes.SendScrollEvent(event_processor(), 140, 215, kTouchId, delegate.get()); 1133 EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE); 1134 total_scroll.set_x(total_scroll.x() + delegate->scroll_x()); 1135 total_scroll.set_y(total_scroll.y() + delegate->scroll_y()); 1136 1137 // Release the touch. This should end the scroll. 1138 delegate->Reset(); 1139 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 1140 kTouchId, 1141 tes.LeapForward(50)); 1142 DispatchEventUsingWindowDispatcher(&release); 1143 } 1144 1145 // Check that the bounding box during a scroll event is correct. 1146 TEST_P(GestureRecognizerTest, GestureEventScrollBoundingBox) { 1147 TimedEvents tes; 1148 for (int radius = 1; radius <= 10; ++radius) { 1149 ui::GestureConfiguration::set_default_radius(radius); 1150 scoped_ptr<GestureEventConsumeDelegate> delegate( 1151 new GestureEventConsumeDelegate()); 1152 const int kWindowWidth = 123; 1153 const int kWindowHeight = 45; 1154 const int kTouchId = 5; 1155 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 1156 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1157 delegate.get(), -1234, bounds, root_window())); 1158 1159 const int kPositionX = 101; 1160 const int kPositionY = 201; 1161 delegate->Reset(); 1162 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, 1163 gfx::Point(kPositionX, kPositionY), 1164 kTouchId, 1165 tes.Now()); 1166 DispatchEventUsingWindowDispatcher(&press); 1167 EXPECT_EQ(gfx::Rect(kPositionX - radius, 1168 kPositionY - radius, 1169 radius * 2, 1170 radius * 2).ToString(), 1171 delegate->bounding_box().ToString()); 1172 1173 const int kScrollAmount = 50; 1174 tes.SendScrollEvents(event_processor(), kPositionX, kPositionY, 1175 1, 1, kTouchId, 1, kScrollAmount, delegate.get()); 1176 EXPECT_EQ(gfx::Point(1, 1).ToString(), 1177 delegate->scroll_begin_position().ToString()); 1178 EXPECT_EQ(gfx::Rect(kPositionX + kScrollAmount - radius, 1179 kPositionY + kScrollAmount - radius, 1180 radius * 2, 1181 radius * 2).ToString(), 1182 delegate->bounding_box().ToString()); 1183 1184 // Release the touch. This should end the scroll. 1185 delegate->Reset(); 1186 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, 1187 gfx::Point(kPositionX + kScrollAmount, 1188 kPositionY + kScrollAmount), 1189 kTouchId, press.time_stamp() + 1190 base::TimeDelta::FromMilliseconds(50)); 1191 DispatchEventUsingWindowDispatcher(&release); 1192 EXPECT_EQ(gfx::Rect(kPositionX + kScrollAmount - radius, 1193 kPositionY + kScrollAmount - radius, 1194 radius * 2, 1195 radius * 2).ToString(), 1196 delegate->bounding_box().ToString()); 1197 } 1198 ui::GestureConfiguration::set_default_radius(0); 1199 } 1200 1201 // Check Scroll End Events report correct velocities 1202 // if the user was on a horizontal rail 1203 TEST_P(GestureRecognizerTest, GestureEventHorizontalRailFling) { 1204 scoped_ptr<GestureEventConsumeDelegate> delegate( 1205 new GestureEventConsumeDelegate()); 1206 TimedEvents tes; 1207 const int kTouchId = 7; 1208 gfx::Rect bounds(0, 0, 1000, 1000); 1209 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1210 delegate.get(), -1234, bounds, root_window())); 1211 1212 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 1213 kTouchId, tes.Now()); 1214 DispatchEventUsingWindowDispatcher(&press); 1215 1216 // Get rid of touch slop. 1217 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(10, 0), 1218 kTouchId, tes.Now()); 1219 DispatchEventUsingWindowDispatcher(&move); 1220 delegate->Reset(); 1221 1222 1223 // Move the touch-point horizontally enough that it is considered a 1224 // horizontal scroll. 1225 tes.SendScrollEvent(event_processor(), 30, 1, kTouchId, delegate.get()); 1226 EXPECT_FLOAT_EQ(0, delegate->scroll_y()); 1227 EXPECT_FLOAT_EQ(20, delegate->scroll_x()); 1228 1229 // Get a high x velocity, while still staying on the rail 1230 tes.SendScrollEvents(event_processor(), 1, 1, 1231 100, 10, kTouchId, 1, 1232 ui::GestureConfiguration::points_buffered_for_velocity(), 1233 delegate.get()); 1234 1235 delegate->Reset(); 1236 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 1237 kTouchId, tes.Now()); 1238 DispatchEventUsingWindowDispatcher(&release); 1239 1240 EXPECT_TRUE(delegate->fling()); 1241 EXPECT_FALSE(delegate->scroll_end()); 1242 EXPECT_GT(delegate->velocity_x(), 0); 1243 EXPECT_EQ(0, delegate->velocity_y()); 1244 } 1245 1246 // Check Scroll End Events report correct velocities 1247 // if the user was on a vertical rail 1248 TEST_P(GestureRecognizerTest, GestureEventVerticalRailFling) { 1249 scoped_ptr<GestureEventConsumeDelegate> delegate( 1250 new GestureEventConsumeDelegate()); 1251 TimedEvents tes; 1252 const int kTouchId = 7; 1253 gfx::Rect bounds(0, 0, 1000, 1000); 1254 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1255 delegate.get(), -1234, bounds, root_window())); 1256 1257 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 1258 kTouchId, tes.Now()); 1259 DispatchEventUsingWindowDispatcher(&press); 1260 1261 // Get rid of touch slop. 1262 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(0, 10), 1263 kTouchId, tes.Now()); 1264 DispatchEventUsingWindowDispatcher(&move); 1265 delegate->Reset(); 1266 1267 // Move the touch-point vertically enough that it is considered a 1268 // vertical scroll. 1269 tes.SendScrollEvent(event_processor(), 1, 30, kTouchId, delegate.get()); 1270 EXPECT_EQ(20, delegate->scroll_y()); 1271 EXPECT_EQ(0, delegate->scroll_x()); 1272 EXPECT_EQ(0, delegate->scroll_velocity_x()); 1273 1274 // Get a high y velocity, while still staying on the rail 1275 tes.SendScrollEvents(event_processor(), 1, 6, 1276 10, 100, kTouchId, 1, 1277 ui::GestureConfiguration::points_buffered_for_velocity(), 1278 delegate.get()); 1279 EXPECT_EQ(0, delegate->scroll_velocity_x()); 1280 1281 delegate->Reset(); 1282 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 206), 1283 kTouchId, tes.Now()); 1284 DispatchEventUsingWindowDispatcher(&release); 1285 1286 EXPECT_TRUE(delegate->fling()); 1287 EXPECT_FALSE(delegate->scroll_end()); 1288 EXPECT_EQ(0, delegate->velocity_x()); 1289 EXPECT_GT(delegate->velocity_y(), 0); 1290 } 1291 1292 // Check Scroll End Events report non-zero velocities if the user is not on a 1293 // rail 1294 TEST_P(GestureRecognizerTest, GestureEventNonRailFling) { 1295 ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(0); 1296 scoped_ptr<GestureEventConsumeDelegate> delegate( 1297 new GestureEventConsumeDelegate()); 1298 TimedEvents tes; 1299 const int kTouchId = 7; 1300 gfx::Rect bounds(0, 0, 1000, 1000); 1301 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1302 delegate.get(), -1234, bounds, root_window())); 1303 1304 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 1305 kTouchId, tes.Now()); 1306 DispatchEventUsingWindowDispatcher(&press); 1307 1308 // Move the touch-point such that a non-rail scroll begins, and we're outside 1309 // the snap channel for the unified GR. 1310 tes.SendScrollEvent(event_processor(), 50, 50, kTouchId, delegate.get()); 1311 EXPECT_EQ(50, delegate->scroll_y()); 1312 EXPECT_EQ(50, delegate->scroll_x()); 1313 1314 tes.SendScrollEvents(event_processor(), 1, 1, 1315 10, 100, kTouchId, 1, 1316 ui::GestureConfiguration::points_buffered_for_velocity(), 1317 delegate.get()); 1318 1319 delegate->Reset(); 1320 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 1321 kTouchId, tes.Now()); 1322 DispatchEventUsingWindowDispatcher(&release); 1323 1324 EXPECT_TRUE(delegate->fling()); 1325 EXPECT_FALSE(delegate->scroll_end()); 1326 EXPECT_GT(delegate->velocity_x(), 0); 1327 EXPECT_GT(delegate->velocity_y(), 0); 1328 } 1329 1330 // Check that appropriate touch events generate long press events 1331 TEST_P(GestureRecognizerTest, GestureEventLongPress) { 1332 ui::GestureConfiguration::set_max_touch_down_duration_in_seconds_for_click( 1333 0.0025); 1334 1335 scoped_ptr<GestureEventConsumeDelegate> delegate( 1336 new GestureEventConsumeDelegate()); 1337 const int kWindowWidth = 123; 1338 const int kWindowHeight = 45; 1339 const int kTouchId = 2; 1340 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 1341 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1342 delegate.get(), -1234, bounds, root_window())); 1343 1344 delegate->Reset(); 1345 1346 TimerTestGestureRecognizer* gesture_recognizer = 1347 new TimerTestGestureRecognizer(); 1348 1349 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 1350 1351 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, 1352 gfx::Point(101, 201), 1353 kTouchId, 1354 ui::EventTimeForNow()); 1355 DispatchEventUsingWindowDispatcher(&press1); 1356 EXPECT_TRUE(delegate->tap_down()); 1357 EXPECT_TRUE(delegate->begin()); 1358 EXPECT_FALSE(delegate->tap_cancel()); 1359 1360 // We haven't pressed long enough for a long press to occur 1361 EXPECT_FALSE(delegate->long_press()); 1362 1363 // Wait until the timer runs out 1364 delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_LONG_PRESS); 1365 EXPECT_TRUE(delegate->long_press()); 1366 EXPECT_FALSE(delegate->tap_cancel()); 1367 1368 delegate->Reset(); 1369 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, 1370 gfx::Point(101, 201), 1371 kTouchId, 1372 ui::EventTimeForNow()); 1373 DispatchEventUsingWindowDispatcher(&release1); 1374 EXPECT_FALSE(delegate->long_press()); 1375 1376 // Note the tap cancel isn't dispatched until the release 1377 EXPECT_TRUE(delegate->tap_cancel()); 1378 EXPECT_FALSE(delegate->tap()); 1379 } 1380 1381 // Check that scrolling cancels a long press 1382 TEST_P(GestureRecognizerTest, GestureEventLongPressCancelledByScroll) { 1383 scoped_ptr<GestureEventConsumeDelegate> delegate( 1384 new GestureEventConsumeDelegate()); 1385 TimedEvents tes; 1386 const int kWindowWidth = 123; 1387 const int kWindowHeight = 45; 1388 const int kTouchId = 6; 1389 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 1390 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1391 delegate.get(), -1234, bounds, root_window())); 1392 1393 delegate->Reset(); 1394 1395 TimerTestGestureRecognizer* gesture_recognizer = 1396 new TimerTestGestureRecognizer(); 1397 TimerTestGestureSequence* gesture_sequence = 1398 static_cast<TimerTestGestureSequence*>( 1399 gesture_recognizer->GetGestureSequenceForTesting(window.get())); 1400 1401 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 1402 1403 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 1404 kTouchId, tes.Now()); 1405 DispatchEventUsingWindowDispatcher(&press1); 1406 EXPECT_TRUE(delegate->tap_down()); 1407 1408 // We haven't pressed long enough for a long press to occur 1409 EXPECT_FALSE(delegate->long_press()); 1410 EXPECT_FALSE(delegate->tap_cancel()); 1411 1412 // Scroll around, to cancel the long press 1413 tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get()); 1414 // Wait until the timer runs out 1415 gesture_sequence->ForceTimeout(); 1416 EXPECT_FALSE(delegate->long_press()); 1417 EXPECT_TRUE(delegate->tap_cancel()); 1418 1419 delegate->Reset(); 1420 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 1421 kTouchId, tes.LeapForward(10)); 1422 DispatchEventUsingWindowDispatcher(&release1); 1423 EXPECT_FALSE(delegate->long_press()); 1424 EXPECT_FALSE(delegate->tap_cancel()); 1425 } 1426 1427 // Check that appropriate touch events generate long tap events 1428 TEST_P(GestureRecognizerTest, GestureEventLongTap) { 1429 ui::GestureConfiguration::set_max_touch_down_duration_in_seconds_for_click( 1430 0.0025); 1431 scoped_ptr<GestureEventConsumeDelegate> delegate( 1432 new GestureEventConsumeDelegate()); 1433 const int kWindowWidth = 123; 1434 const int kWindowHeight = 45; 1435 const int kTouchId = 2; 1436 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 1437 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1438 delegate.get(), -1234, bounds, root_window())); 1439 1440 delegate->Reset(); 1441 1442 TimerTestGestureRecognizer* gesture_recognizer = 1443 new TimerTestGestureRecognizer(); 1444 1445 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 1446 1447 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, 1448 gfx::Point(101, 201), 1449 kTouchId, 1450 ui::EventTimeForNow()); 1451 DispatchEventUsingWindowDispatcher(&press1); 1452 EXPECT_TRUE(delegate->tap_down()); 1453 EXPECT_TRUE(delegate->begin()); 1454 EXPECT_FALSE(delegate->tap_cancel()); 1455 1456 // We haven't pressed long enough for a long press to occur 1457 EXPECT_FALSE(delegate->long_press()); 1458 1459 // Wait until the timer runs out 1460 delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_LONG_PRESS); 1461 EXPECT_TRUE(delegate->long_press()); 1462 EXPECT_FALSE(delegate->tap_cancel()); 1463 1464 delegate->Reset(); 1465 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, 1466 gfx::Point(101, 201), 1467 kTouchId, 1468 ui::EventTimeForNow()); 1469 DispatchEventUsingWindowDispatcher(&release1); 1470 EXPECT_FALSE(delegate->long_press()); 1471 EXPECT_TRUE(delegate->long_tap()); 1472 1473 // Note the tap cancel isn't dispatched until the release 1474 EXPECT_TRUE(delegate->tap_cancel()); 1475 EXPECT_FALSE(delegate->tap()); 1476 } 1477 1478 // Check that second tap cancels a long press 1479 TEST_P(GestureRecognizerTest, GestureEventLongPressCancelledBySecondTap) { 1480 scoped_ptr<GestureEventConsumeDelegate> delegate( 1481 new GestureEventConsumeDelegate()); 1482 TimedEvents tes; 1483 const int kWindowWidth = 300; 1484 const int kWindowHeight = 400; 1485 const int kTouchId1 = 8; 1486 const int kTouchId2 = 2; 1487 gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight); 1488 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1489 delegate.get(), -1234, bounds, root_window())); 1490 1491 TimerTestGestureRecognizer* gesture_recognizer = 1492 new TimerTestGestureRecognizer(); 1493 TimerTestGestureSequence* gesture_sequence = 1494 static_cast<TimerTestGestureSequence*>( 1495 gesture_recognizer->GetGestureSequenceForTesting(window.get())); 1496 1497 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 1498 1499 delegate->Reset(); 1500 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 1501 kTouchId1, tes.Now()); 1502 DispatchEventUsingWindowDispatcher(&press); 1503 EXPECT_TRUE(delegate->tap_down()); 1504 EXPECT_TRUE(delegate->begin()); 1505 1506 // We haven't pressed long enough for a long press to occur 1507 EXPECT_FALSE(delegate->long_press()); 1508 1509 // Second tap, to cancel the long press 1510 delegate->Reset(); 1511 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 1512 kTouchId2, tes.Now()); 1513 DispatchEventUsingWindowDispatcher(&press2); 1514 EXPECT_FALSE(delegate->tap_down()); // no touch down for second tap. 1515 EXPECT_TRUE(delegate->tap_cancel()); 1516 EXPECT_TRUE(delegate->begin()); 1517 1518 // Wait until the timer runs out 1519 gesture_sequence->ForceTimeout(); 1520 1521 // No long press occurred 1522 EXPECT_FALSE(delegate->long_press()); 1523 1524 delegate->Reset(); 1525 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 1526 kTouchId1, tes.Now()); 1527 DispatchEventUsingWindowDispatcher(&release1); 1528 EXPECT_FALSE(delegate->long_press()); 1529 EXPECT_TRUE(delegate->two_finger_tap()); 1530 EXPECT_FALSE(delegate->tap_cancel()); 1531 } 1532 1533 // Check that horizontal scroll gestures cause scrolls on horizontal rails. 1534 // Also tests that horizontal rails can be broken. 1535 TEST_P(GestureRecognizerTest, GestureEventHorizontalRailScroll) { 1536 scoped_ptr<GestureEventConsumeDelegate> delegate( 1537 new GestureEventConsumeDelegate()); 1538 TimedEvents tes; 1539 const int kTouchId = 7; 1540 gfx::Rect bounds(0, 0, 1000, 1000); 1541 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1542 delegate.get(), -1234, bounds, root_window())); 1543 1544 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 1545 kTouchId, tes.Now()); 1546 DispatchEventUsingWindowDispatcher(&press); 1547 1548 // Get rid of touch slop. 1549 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(5, 0), 1550 kTouchId, tes.Now()); 1551 1552 DispatchEventUsingWindowDispatcher(&move); 1553 delegate->Reset(); 1554 1555 // Move the touch-point horizontally enough that it is considered a 1556 // horizontal scroll. 1557 tes.SendScrollEvent(event_processor(), 25, 0, kTouchId, delegate.get()); 1558 EXPECT_EQ(0, delegate->scroll_y()); 1559 EXPECT_EQ(20, delegate->scroll_x()); 1560 1561 tes.SendScrollEvent(event_processor(), 30, 6, kTouchId, delegate.get()); 1562 EXPECT_TRUE(delegate->scroll_update()); 1563 EXPECT_EQ(5, delegate->scroll_x()); 1564 // y shouldn't change, as we're on a horizontal rail. 1565 EXPECT_EQ(0, delegate->scroll_y()); 1566 1567 // Send enough information that a velocity can be calculated for the gesture, 1568 // and we can break the rail 1569 tes.SendScrollEvents(event_processor(), 1, 1, 1570 6, 100, kTouchId, 1, 1571 ui::GestureConfiguration::points_buffered_for_velocity(), 1572 delegate.get()); 1573 1574 tes.SendScrollEvent(event_processor(), 5, 0, kTouchId, delegate.get()); 1575 tes.SendScrollEvent(event_processor(), 10, 5, kTouchId, delegate.get()); 1576 1577 // The rail should be broken 1578 EXPECT_TRUE(delegate->scroll_update()); 1579 EXPECT_EQ(5, delegate->scroll_x()); 1580 EXPECT_EQ(5, delegate->scroll_y()); 1581 } 1582 1583 // Check that vertical scroll gestures cause scrolls on vertical rails. 1584 // Also tests that vertical rails can be broken. 1585 TEST_P(GestureRecognizerTest, GestureEventVerticalRailScroll) { 1586 scoped_ptr<GestureEventConsumeDelegate> delegate( 1587 new GestureEventConsumeDelegate()); 1588 TimedEvents tes; 1589 const int kTouchId = 7; 1590 gfx::Rect bounds(0, 0, 1000, 1000); 1591 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1592 delegate.get(), -1234, bounds, root_window())); 1593 1594 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 1595 kTouchId, tes.Now()); 1596 DispatchEventUsingWindowDispatcher(&press); 1597 1598 // Get rid of touch slop. 1599 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(0, 5), 1600 kTouchId, tes.Now()); 1601 DispatchEventUsingWindowDispatcher(&move); 1602 delegate->Reset(); 1603 1604 // Move the touch-point vertically enough that it is considered a 1605 // vertical scroll. 1606 tes.SendScrollEvent(event_processor(), 0, 25, kTouchId, delegate.get()); 1607 EXPECT_EQ(0, delegate->scroll_x()); 1608 EXPECT_EQ(20, delegate->scroll_y()); 1609 1610 tes.SendScrollEvent(event_processor(), 6, 30, kTouchId, delegate.get()); 1611 EXPECT_TRUE(delegate->scroll_update()); 1612 EXPECT_EQ(5, delegate->scroll_y()); 1613 // x shouldn't change, as we're on a vertical rail. 1614 EXPECT_EQ(0, delegate->scroll_x()); 1615 EXPECT_EQ(0, delegate->scroll_velocity_x()); 1616 1617 // Send enough information that a velocity can be calculated for the gesture, 1618 // and we can break the rail 1619 tes.SendScrollEvents(event_processor(), 1, 6, 1620 100, 1, kTouchId, 1, 1621 ui::GestureConfiguration::points_buffered_for_velocity(), 1622 delegate.get()); 1623 1624 tes.SendScrollEvent(event_processor(), 0, 5, kTouchId, delegate.get()); 1625 tes.SendScrollEvent(event_processor(), 5, 10, kTouchId, delegate.get()); 1626 1627 // The rail should be broken 1628 EXPECT_TRUE(delegate->scroll_update()); 1629 EXPECT_EQ(5, delegate->scroll_x()); 1630 EXPECT_EQ(5, delegate->scroll_y()); 1631 } 1632 1633 TEST_P(GestureRecognizerTest, GestureTapFollowedByScroll) { 1634 // We'll start by moving the touch point by (5, 5). We want all of that 1635 // distance to be consumed by the slop, so we set the slop radius to 1636 // sqrt(5 * 5 + 5 * 5). 1637 ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click( 1638 sqrt(static_cast<double>(5 * 5 + 5 * 5))); 1639 1640 // First, tap. Then, do a scroll using the same touch-id. 1641 scoped_ptr<GestureEventConsumeDelegate> delegate( 1642 new GestureEventConsumeDelegate()); 1643 TimedEvents tes; 1644 const int kWindowWidth = 123; 1645 const int kWindowHeight = 45; 1646 const int kTouchId = 3; 1647 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 1648 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1649 delegate.get(), -1234, bounds, root_window())); 1650 1651 delegate->Reset(); 1652 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 1653 kTouchId, tes.Now()); 1654 DispatchEventUsingWindowDispatcher(&press); 1655 EXPECT_FALSE(delegate->tap()); 1656 EXPECT_TRUE(delegate->tap_down()); 1657 EXPECT_FALSE(delegate->tap_cancel()); 1658 EXPECT_FALSE(delegate->scroll_begin()); 1659 EXPECT_FALSE(delegate->scroll_update()); 1660 EXPECT_FALSE(delegate->scroll_end()); 1661 1662 // Make sure there is enough delay before the touch is released so that it is 1663 // recognized as a tap. 1664 delegate->Reset(); 1665 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 1666 kTouchId, tes.LeapForward(50)); 1667 DispatchEventUsingWindowDispatcher(&release); 1668 EXPECT_TRUE(delegate->tap()); 1669 EXPECT_FALSE(delegate->tap_down()); 1670 EXPECT_FALSE(delegate->tap_cancel()); 1671 EXPECT_FALSE(delegate->scroll_begin()); 1672 EXPECT_FALSE(delegate->scroll_update()); 1673 EXPECT_FALSE(delegate->scroll_end()); 1674 1675 // Now, do a scroll gesture. Delay it sufficiently so that it doesn't trigger 1676 // a double-tap. 1677 delegate->Reset(); 1678 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 1679 kTouchId, tes.LeapForward(1000)); 1680 DispatchEventUsingWindowDispatcher(&press1); 1681 EXPECT_FALSE(delegate->tap()); 1682 EXPECT_TRUE(delegate->tap_down()); 1683 EXPECT_FALSE(delegate->tap_cancel()); 1684 EXPECT_FALSE(delegate->scroll_begin()); 1685 EXPECT_FALSE(delegate->scroll_update()); 1686 EXPECT_FALSE(delegate->scroll_end()); 1687 1688 // Get rid of touch slop. 1689 ui::TouchEvent move_remove_slop(ui::ET_TOUCH_MOVED, gfx::Point(116, 216), 1690 kTouchId, tes.Now()); 1691 DispatchEventUsingWindowDispatcher(&move_remove_slop); 1692 EXPECT_TRUE(delegate->tap_cancel()); 1693 EXPECT_TRUE(delegate->scroll_begin()); 1694 EXPECT_TRUE(delegate->scroll_update()); 1695 EXPECT_EQ(15, delegate->scroll_x_hint()); 1696 EXPECT_EQ(15, delegate->scroll_y_hint()); 1697 1698 delegate->Reset(); 1699 1700 // Move the touch-point enough so that it is considered as a scroll. This 1701 // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures. 1702 // The first movement is diagonal, to ensure that we have a free scroll, 1703 // and not a rail scroll. 1704 delegate->Reset(); 1705 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(135, 235), 1706 kTouchId, tes.Now()); 1707 DispatchEventUsingWindowDispatcher(&move); 1708 EXPECT_FALSE(delegate->tap()); 1709 EXPECT_FALSE(delegate->tap_down()); 1710 EXPECT_FALSE(delegate->tap_cancel()); 1711 EXPECT_FALSE(delegate->scroll_begin()); 1712 EXPECT_TRUE(delegate->scroll_update()); 1713 EXPECT_FALSE(delegate->scroll_end()); 1714 EXPECT_EQ(19, delegate->scroll_x()); 1715 EXPECT_EQ(19, delegate->scroll_y()); 1716 1717 // Move some more to generate a few more scroll updates. 1718 delegate->Reset(); 1719 ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(115, 216), 1720 kTouchId, tes.Now()); 1721 DispatchEventUsingWindowDispatcher(&move1); 1722 EXPECT_FALSE(delegate->tap()); 1723 EXPECT_FALSE(delegate->tap_down()); 1724 EXPECT_FALSE(delegate->tap_cancel()); 1725 EXPECT_FALSE(delegate->scroll_begin()); 1726 EXPECT_TRUE(delegate->scroll_update()); 1727 EXPECT_FALSE(delegate->scroll_end()); 1728 EXPECT_EQ(-20, delegate->scroll_x()); 1729 EXPECT_EQ(-19, delegate->scroll_y()); 1730 EXPECT_EQ(0, delegate->scroll_x_hint()); 1731 EXPECT_EQ(0, delegate->scroll_y_hint()); 1732 1733 delegate->Reset(); 1734 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(145, 220), 1735 kTouchId, tes.Now()); 1736 DispatchEventUsingWindowDispatcher(&move2); 1737 EXPECT_FALSE(delegate->tap()); 1738 EXPECT_FALSE(delegate->tap_down()); 1739 EXPECT_FALSE(delegate->tap_cancel()); 1740 EXPECT_FALSE(delegate->scroll_begin()); 1741 EXPECT_TRUE(delegate->scroll_update()); 1742 EXPECT_FALSE(delegate->scroll_end()); 1743 EXPECT_EQ(30, delegate->scroll_x()); 1744 EXPECT_EQ(4, delegate->scroll_y()); 1745 1746 // Release the touch. This should end the scroll. 1747 delegate->Reset(); 1748 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 1749 kTouchId, tes.Now()); 1750 DispatchEventUsingWindowDispatcher(&release1); 1751 EXPECT_FALSE(delegate->tap()); 1752 EXPECT_FALSE(delegate->tap_down()); 1753 EXPECT_FALSE(delegate->tap_cancel()); 1754 EXPECT_FALSE(delegate->scroll_begin()); 1755 EXPECT_FALSE(delegate->scroll_update()); 1756 EXPECT_FALSE(delegate->scroll_end()); 1757 EXPECT_TRUE(delegate->fling()); 1758 } 1759 1760 TEST_P(GestureRecognizerTest, AsynchronousGestureRecognition) { 1761 scoped_ptr<QueueTouchEventDelegate> queued_delegate( 1762 new QueueTouchEventDelegate(host()->dispatcher())); 1763 const int kWindowWidth = 123; 1764 const int kWindowHeight = 45; 1765 const int kTouchId1 = 6; 1766 const int kTouchId2 = 4; 1767 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 1768 scoped_ptr<aura::Window> queue(CreateTestWindowWithDelegate( 1769 queued_delegate.get(), -1234, bounds, root_window())); 1770 1771 queued_delegate->set_window(queue.get()); 1772 1773 // Touch down on the window. This should not generate any gesture event. 1774 queued_delegate->Reset(); 1775 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 1776 kTouchId1, GetTime()); 1777 DispatchEventUsingWindowDispatcher(&press); 1778 EXPECT_FALSE(queued_delegate->tap()); 1779 EXPECT_FALSE(queued_delegate->tap_down()); 1780 EXPECT_FALSE(queued_delegate->tap_cancel()); 1781 EXPECT_FALSE(queued_delegate->begin()); 1782 EXPECT_FALSE(queued_delegate->scroll_begin()); 1783 EXPECT_FALSE(queued_delegate->scroll_update()); 1784 EXPECT_FALSE(queued_delegate->scroll_end()); 1785 1786 // Introduce some delay before the touch is released so that it is recognized 1787 // as a tap. However, this still should not create any gesture events. 1788 queued_delegate->Reset(); 1789 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 1790 kTouchId1, press.time_stamp() + 1791 base::TimeDelta::FromMilliseconds(50)); 1792 DispatchEventUsingWindowDispatcher(&release); 1793 EXPECT_FALSE(queued_delegate->tap()); 1794 EXPECT_FALSE(queued_delegate->tap_down()); 1795 EXPECT_FALSE(queued_delegate->tap_cancel()); 1796 EXPECT_FALSE(queued_delegate->begin()); 1797 EXPECT_FALSE(queued_delegate->end()); 1798 EXPECT_FALSE(queued_delegate->scroll_begin()); 1799 EXPECT_FALSE(queued_delegate->scroll_update()); 1800 EXPECT_FALSE(queued_delegate->scroll_end()); 1801 1802 // Create another window, and place a touch-down on it. This should create a 1803 // tap-down gesture. 1804 scoped_ptr<GestureEventConsumeDelegate> delegate( 1805 new GestureEventConsumeDelegate()); 1806 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1807 delegate.get(), -2345, gfx::Rect(0, 0, 50, 50), root_window())); 1808 delegate->Reset(); 1809 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 20), 1810 kTouchId2, GetTime()); 1811 DispatchEventUsingWindowDispatcher(&press2); 1812 EXPECT_FALSE(delegate->tap()); 1813 EXPECT_TRUE(delegate->tap_down()); 1814 EXPECT_FALSE(delegate->tap_cancel()); 1815 EXPECT_FALSE(queued_delegate->begin()); 1816 EXPECT_FALSE(queued_delegate->end()); 1817 EXPECT_FALSE(delegate->scroll_begin()); 1818 EXPECT_FALSE(delegate->scroll_update()); 1819 EXPECT_FALSE(delegate->scroll_end()); 1820 1821 ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(10, 20), 1822 kTouchId2, GetTime()); 1823 DispatchEventUsingWindowDispatcher(&release2); 1824 1825 // Process the first queued event. 1826 queued_delegate->Reset(); 1827 queued_delegate->ReceivedAck(); 1828 EXPECT_FALSE(queued_delegate->tap()); 1829 EXPECT_TRUE(queued_delegate->tap_down()); 1830 EXPECT_TRUE(queued_delegate->begin()); 1831 EXPECT_FALSE(queued_delegate->tap_cancel()); 1832 EXPECT_FALSE(queued_delegate->end()); 1833 EXPECT_FALSE(queued_delegate->scroll_begin()); 1834 EXPECT_FALSE(queued_delegate->scroll_update()); 1835 EXPECT_FALSE(queued_delegate->scroll_end()); 1836 1837 // Now, process the second queued event. 1838 queued_delegate->Reset(); 1839 queued_delegate->ReceivedAck(); 1840 EXPECT_TRUE(queued_delegate->tap()); 1841 EXPECT_FALSE(queued_delegate->tap_down()); 1842 EXPECT_FALSE(queued_delegate->tap_cancel()); 1843 EXPECT_FALSE(queued_delegate->begin()); 1844 EXPECT_TRUE(queued_delegate->end()); 1845 EXPECT_FALSE(queued_delegate->scroll_begin()); 1846 EXPECT_FALSE(queued_delegate->scroll_update()); 1847 EXPECT_FALSE(queued_delegate->scroll_end()); 1848 1849 // Start all over. Press on the first window, then press again on the second 1850 // window. The second press should still go to the first window. 1851 queued_delegate->Reset(); 1852 ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 1853 kTouchId1, GetTime()); 1854 DispatchEventUsingWindowDispatcher(&press3); 1855 EXPECT_FALSE(queued_delegate->tap()); 1856 EXPECT_FALSE(queued_delegate->tap_down()); 1857 EXPECT_FALSE(queued_delegate->tap_cancel()); 1858 EXPECT_FALSE(queued_delegate->begin()); 1859 EXPECT_FALSE(queued_delegate->end()); 1860 EXPECT_FALSE(queued_delegate->begin()); 1861 EXPECT_FALSE(queued_delegate->end()); 1862 EXPECT_FALSE(queued_delegate->scroll_begin()); 1863 EXPECT_FALSE(queued_delegate->scroll_update()); 1864 EXPECT_FALSE(queued_delegate->scroll_end()); 1865 1866 queued_delegate->Reset(); 1867 delegate->Reset(); 1868 ui::TouchEvent press4(ui::ET_TOUCH_PRESSED, gfx::Point(103, 203), 1869 kTouchId2, GetTime()); 1870 DispatchEventUsingWindowDispatcher(&press4); 1871 EXPECT_FALSE(delegate->tap()); 1872 EXPECT_FALSE(delegate->tap_down()); 1873 EXPECT_FALSE(delegate->tap_cancel()); 1874 EXPECT_FALSE(delegate->begin()); 1875 EXPECT_FALSE(delegate->end()); 1876 EXPECT_FALSE(delegate->scroll_begin()); 1877 EXPECT_FALSE(delegate->scroll_update()); 1878 EXPECT_FALSE(delegate->scroll_end()); 1879 EXPECT_FALSE(queued_delegate->tap()); 1880 EXPECT_FALSE(queued_delegate->tap_down()); 1881 EXPECT_FALSE(queued_delegate->tap_cancel()); 1882 EXPECT_FALSE(queued_delegate->begin()); 1883 EXPECT_FALSE(queued_delegate->end()); 1884 EXPECT_FALSE(queued_delegate->scroll_begin()); 1885 EXPECT_FALSE(queued_delegate->scroll_update()); 1886 EXPECT_FALSE(queued_delegate->scroll_end()); 1887 1888 // Move the second touch-point enough so that it is considered a pinch. This 1889 // should generate both SCROLL_BEGIN and PINCH_BEGIN gestures. 1890 queued_delegate->Reset(); 1891 delegate->Reset(); 1892 int x_move = ui::GestureConfiguration::max_touch_move_in_pixels_for_click(); 1893 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(203 + x_move, 303), 1894 kTouchId2, GetTime()); 1895 DispatchEventUsingWindowDispatcher(&move); 1896 EXPECT_FALSE(delegate->tap()); 1897 EXPECT_FALSE(delegate->tap_down()); 1898 EXPECT_FALSE(delegate->tap_cancel()); 1899 EXPECT_FALSE(delegate->begin()); 1900 EXPECT_FALSE(delegate->scroll_begin()); 1901 EXPECT_FALSE(delegate->scroll_update()); 1902 EXPECT_FALSE(delegate->scroll_end()); 1903 EXPECT_FALSE(queued_delegate->tap()); 1904 EXPECT_FALSE(queued_delegate->tap_down()); 1905 EXPECT_FALSE(queued_delegate->tap_cancel()); 1906 EXPECT_FALSE(queued_delegate->begin()); 1907 EXPECT_FALSE(queued_delegate->scroll_begin()); 1908 EXPECT_FALSE(queued_delegate->scroll_update()); 1909 EXPECT_FALSE(queued_delegate->scroll_end()); 1910 1911 queued_delegate->Reset(); 1912 queued_delegate->ReceivedAck(); 1913 EXPECT_FALSE(queued_delegate->tap()); 1914 EXPECT_TRUE(queued_delegate->tap_down()); 1915 EXPECT_TRUE(queued_delegate->begin()); 1916 EXPECT_FALSE(queued_delegate->tap_cancel()); 1917 EXPECT_FALSE(queued_delegate->end()); 1918 EXPECT_FALSE(queued_delegate->scroll_begin()); 1919 EXPECT_FALSE(queued_delegate->scroll_update()); 1920 EXPECT_FALSE(queued_delegate->scroll_end()); 1921 1922 queued_delegate->Reset(); 1923 queued_delegate->ReceivedAck(); 1924 EXPECT_FALSE(queued_delegate->tap()); 1925 EXPECT_FALSE(queued_delegate->tap_down()); // no touch down for second tap. 1926 EXPECT_TRUE(queued_delegate->tap_cancel()); 1927 EXPECT_TRUE(queued_delegate->begin()); 1928 EXPECT_FALSE(queued_delegate->end()); 1929 EXPECT_FALSE(queued_delegate->scroll_begin()); 1930 EXPECT_FALSE(queued_delegate->scroll_update()); 1931 EXPECT_FALSE(queued_delegate->scroll_end()); 1932 EXPECT_FALSE(queued_delegate->pinch_begin()); 1933 EXPECT_FALSE(queued_delegate->pinch_update()); 1934 EXPECT_FALSE(queued_delegate->pinch_end()); 1935 1936 queued_delegate->Reset(); 1937 queued_delegate->ReceivedAck(); 1938 EXPECT_FALSE(queued_delegate->tap()); 1939 EXPECT_FALSE(queued_delegate->tap_down()); 1940 EXPECT_FALSE(queued_delegate->tap_cancel()); 1941 EXPECT_FALSE(queued_delegate->begin()); 1942 EXPECT_FALSE(queued_delegate->end()); 1943 EXPECT_TRUE(queued_delegate->scroll_begin()); 1944 // TODO(tdresser): uncomment once we've switched to the unified GR. 1945 // EXPECT_TRUE(queued_delegate->scroll_update()); 1946 EXPECT_FALSE(queued_delegate->scroll_end()); 1947 EXPECT_TRUE(queued_delegate->pinch_begin()); 1948 EXPECT_FALSE(queued_delegate->pinch_update()); 1949 EXPECT_FALSE(queued_delegate->pinch_end()); 1950 } 1951 1952 // Check that appropriate touch events generate pinch gesture events. 1953 TEST_P(GestureRecognizerTest, GestureEventPinchFromScroll) { 1954 // Disabled for unified GR due to differences in when pinch begin is sent. The 1955 // Aura GR sends it earlier than is necessary. 1956 if (UsingUnifiedGR()) 1957 return; 1958 1959 scoped_ptr<GestureEventConsumeDelegate> delegate( 1960 new GestureEventConsumeDelegate()); 1961 TimedEvents tes; 1962 const int kWindowWidth = 300; 1963 const int kWindowHeight = 400; 1964 const int kTouchId1 = 5; 1965 const int kTouchId2 = 3; 1966 gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight); 1967 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 1968 delegate.get(), -1234, bounds, root_window())); 1969 1970 delegate->Reset(); 1971 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 1972 kTouchId1, tes.Now()); 1973 DispatchEventUsingWindowDispatcher(&press); 1974 EXPECT_2_EVENTS(delegate->events(), 1975 ui::ET_GESTURE_BEGIN, 1976 ui::ET_GESTURE_TAP_DOWN); 1977 1978 // Move the touch-point enough so that it is considered as a scroll. This 1979 // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures. 1980 delegate->Reset(); 1981 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(130, 301), 1982 kTouchId1, tes.Now()); 1983 DispatchEventUsingWindowDispatcher(&move); 1984 EXPECT_3_EVENTS(delegate->events(), 1985 ui::ET_GESTURE_TAP_CANCEL, 1986 ui::ET_GESTURE_SCROLL_BEGIN, 1987 ui::ET_GESTURE_SCROLL_UPDATE); 1988 1989 // Press the second finger. It should cause pinch-begin. Note that we will not 1990 // transition to two finger tap here because the touch points are far enough. 1991 delegate->Reset(); 1992 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 1993 kTouchId2, tes.Now()); 1994 DispatchEventUsingWindowDispatcher(&press2); 1995 EXPECT_2_EVENTS(delegate->events(), 1996 ui::ET_GESTURE_BEGIN, 1997 ui::ET_GESTURE_PINCH_BEGIN); 1998 EXPECT_EQ(gfx::Rect(10, 10, 120, 291).ToString(), 1999 delegate->bounding_box().ToString()); 2000 2001 // Move the first finger. 2002 delegate->Reset(); 2003 ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(95, 201), 2004 kTouchId1, tes.Now()); 2005 DispatchEventUsingWindowDispatcher(&move3); 2006 EXPECT_2_EVENTS(delegate->events(), 2007 ui::ET_GESTURE_PINCH_UPDATE, 2008 ui::ET_GESTURE_SCROLL_UPDATE); 2009 EXPECT_EQ(gfx::Rect(10, 10, 85, 191).ToString(), 2010 delegate->bounding_box().ToString()); 2011 2012 // Now move the second finger. 2013 delegate->Reset(); 2014 ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(55, 15), 2015 kTouchId2, tes.Now()); 2016 DispatchEventUsingWindowDispatcher(&move4); 2017 EXPECT_2_EVENTS(delegate->events(), 2018 ui::ET_GESTURE_PINCH_UPDATE, 2019 ui::ET_GESTURE_SCROLL_UPDATE); 2020 EXPECT_EQ(gfx::Rect(55, 15, 40, 186).ToString(), 2021 delegate->bounding_box().ToString()); 2022 2023 // Release the first finger. This should end pinch. 2024 delegate->Reset(); 2025 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2026 kTouchId1, tes.Now()); 2027 DispatchEventUsingWindowDispatcher(&release); 2028 EXPECT_2_EVENTS(delegate->events(), 2029 ui::ET_GESTURE_PINCH_END, 2030 ui::ET_GESTURE_END); 2031 EXPECT_EQ(gfx::Rect(55, 15, 46, 186).ToString(), 2032 delegate->bounding_box().ToString()); 2033 2034 // Move the second finger. This should still generate a scroll. 2035 delegate->Reset(); 2036 ui::TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10), 2037 kTouchId2, tes.Now()); 2038 DispatchEventUsingWindowDispatcher(&move5); 2039 EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE); 2040 EXPECT_TRUE(delegate->bounding_box().IsEmpty()); 2041 } 2042 2043 TEST_P(GestureRecognizerTest, GestureEventPinchFromScrollFromPinch) { 2044 scoped_ptr<GestureEventConsumeDelegate> delegate( 2045 new GestureEventConsumeDelegate()); 2046 TimedEvents tes; 2047 const int kWindowWidth = 300; 2048 const int kWindowHeight = 400; 2049 const int kTouchId1 = 5; 2050 const int kTouchId2 = 3; 2051 gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight); 2052 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2053 delegate.get(), -1234, bounds, root_window())); 2054 2055 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 301), 2056 kTouchId1, tes.Now()); 2057 DispatchEventUsingWindowDispatcher(&press); 2058 delegate->Reset(); 2059 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 2060 kTouchId2, tes.Now()); 2061 DispatchEventUsingWindowDispatcher(&press2); 2062 EXPECT_FALSE(delegate->pinch_begin()); 2063 2064 // Touch move triggers pinch begin. 2065 tes.SendScrollEvent(event_processor(), 130, 230, kTouchId1, delegate.get()); 2066 EXPECT_TRUE(delegate->pinch_begin()); 2067 EXPECT_FALSE(delegate->pinch_update()); 2068 2069 // Touch move triggers pinch update. 2070 tes.SendScrollEvent(event_processor(), 160, 200, kTouchId1, delegate.get()); 2071 EXPECT_FALSE(delegate->pinch_begin()); 2072 EXPECT_TRUE(delegate->pinch_update()); 2073 2074 // Pinch has started, now release the second finger 2075 delegate->Reset(); 2076 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2077 kTouchId1, tes.Now()); 2078 DispatchEventUsingWindowDispatcher(&release); 2079 EXPECT_TRUE(delegate->pinch_end()); 2080 2081 tes.SendScrollEvent(event_processor(), 130, 230, kTouchId2, delegate.get()); 2082 EXPECT_TRUE(delegate->scroll_update()); 2083 2084 // Pinch again 2085 delegate->Reset(); 2086 ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 2087 kTouchId1, tes.Now()); 2088 DispatchEventUsingWindowDispatcher(&press3); 2089 // Now the touch points are close. So we will go into two finger tap. 2090 // Move the touch-point enough to break two-finger-tap and enter pinch. 2091 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(101, 50), 2092 kTouchId1, tes.Now()); 2093 DispatchEventUsingWindowDispatcher(&move2); 2094 EXPECT_TRUE(delegate->pinch_begin()); 2095 2096 tes.SendScrollEvent(event_processor(), 350, 350, kTouchId1, delegate.get()); 2097 EXPECT_TRUE(delegate->pinch_update()); 2098 } 2099 2100 TEST_P(GestureRecognizerTest, GestureEventPinchFromTap) { 2101 // TODO(tdresser): enable this test with unified GR once two finger tap. 2102 if (UsingUnifiedGR()) 2103 return; 2104 2105 scoped_ptr<GestureEventConsumeDelegate> delegate( 2106 new GestureEventConsumeDelegate()); 2107 TimedEvents tes; 2108 const int kWindowWidth = 300; 2109 const int kWindowHeight = 400; 2110 const int kTouchId1 = 3; 2111 const int kTouchId2 = 5; 2112 gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight); 2113 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2114 delegate.get(), -1234, bounds, root_window())); 2115 2116 delegate->Reset(); 2117 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 301), 2118 kTouchId1, tes.Now()); 2119 DispatchEventUsingWindowDispatcher(&press); 2120 EXPECT_2_EVENTS(delegate->events(), 2121 ui::ET_GESTURE_BEGIN, 2122 ui::ET_GESTURE_TAP_DOWN); 2123 EXPECT_TRUE(delegate->bounding_box().IsEmpty()); 2124 2125 // Press the second finger far enough to break two finger tap. 2126 delegate->Reset(); 2127 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 2128 kTouchId2, tes.Now()); 2129 DispatchEventUsingWindowDispatcher(&press2); 2130 EXPECT_2_EVENTS(delegate->events(), 2131 ui::ET_GESTURE_TAP_CANCEL, 2132 ui::ET_GESTURE_BEGIN); 2133 EXPECT_EQ(gfx::Rect(10, 10, 91, 291).ToString(), 2134 delegate->bounding_box().ToString()); 2135 2136 // Move the first finger. 2137 delegate->Reset(); 2138 ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(65, 201), 2139 kTouchId1, tes.Now()); 2140 DispatchEventUsingWindowDispatcher(&move3); 2141 EXPECT_2_EVENTS(delegate->events(), 2142 ui::ET_GESTURE_SCROLL_BEGIN, 2143 ui::ET_GESTURE_PINCH_BEGIN); 2144 EXPECT_EQ(gfx::Rect(10, 10, 55, 191).ToString(), 2145 delegate->bounding_box().ToString()); 2146 2147 // Now move the second finger. 2148 delegate->Reset(); 2149 ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(55, 15), 2150 kTouchId2, tes.Now()); 2151 DispatchEventUsingWindowDispatcher(&move4); 2152 EXPECT_2_EVENTS(delegate->events(), 2153 ui::ET_GESTURE_PINCH_UPDATE, 2154 ui::ET_GESTURE_SCROLL_UPDATE); 2155 EXPECT_EQ(gfx::Rect(55, 15, 10, 186).ToString(), 2156 delegate->bounding_box().ToString()); 2157 2158 // Release the first finger. This should end pinch. 2159 delegate->Reset(); 2160 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2161 kTouchId1, tes.LeapForward(10)); 2162 DispatchEventUsingWindowDispatcher(&release); 2163 EXPECT_2_EVENTS(delegate->events(), 2164 ui::ET_GESTURE_PINCH_END, 2165 ui::ET_GESTURE_END); 2166 EXPECT_EQ(gfx::Rect(55, 15, 46, 186).ToString(), 2167 delegate->bounding_box().ToString()); 2168 2169 // Move the second finger. This should still generate a scroll. 2170 delegate->Reset(); 2171 ui::TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10), 2172 kTouchId2, tes.Now()); 2173 DispatchEventUsingWindowDispatcher(&move5); 2174 EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE); 2175 EXPECT_TRUE(delegate->bounding_box().IsEmpty()); 2176 } 2177 2178 TEST_P(GestureRecognizerTest, GestureEventIgnoresDisconnectedEvents) { 2179 scoped_ptr<GestureEventConsumeDelegate> delegate( 2180 new GestureEventConsumeDelegate()); 2181 TimedEvents tes; 2182 2183 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2184 6, tes.Now()); 2185 DispatchEventUsingWindowDispatcher(&release1); 2186 EXPECT_FALSE(delegate->tap()); 2187 EXPECT_FALSE(delegate->tap_down()); 2188 } 2189 2190 // Check that a touch is locked to the window of the closest current touch 2191 // within max_separation_for_gesture_touches_in_pixels 2192 TEST_P(GestureRecognizerTest, GestureEventTouchLockSelectsCorrectWindow) { 2193 ui::GestureRecognizer* gesture_recognizer = new ui::GestureRecognizerImpl(); 2194 TimedEvents tes; 2195 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 2196 2197 ui::GestureConsumer* target; 2198 const int kNumWindows = 4; 2199 2200 scoped_ptr<GestureEventConsumeDelegate*[]> delegates( 2201 new GestureEventConsumeDelegate*[kNumWindows]); 2202 2203 ui::GestureConfiguration:: 2204 set_max_separation_for_gesture_touches_in_pixels(499); 2205 2206 scoped_ptr<gfx::Rect[]> window_bounds(new gfx::Rect[kNumWindows]); 2207 window_bounds[0] = gfx::Rect(0, 0, 1, 1); 2208 window_bounds[1] = gfx::Rect(500, 0, 1, 1); 2209 window_bounds[2] = gfx::Rect(0, 500, 1, 1); 2210 window_bounds[3] = gfx::Rect(500, 500, 1, 1); 2211 2212 scoped_ptr<aura::Window*[]> windows(new aura::Window*[kNumWindows]); 2213 2214 // Instantiate windows with |window_bounds| and touch each window at 2215 // its origin. 2216 for (int i = 0; i < kNumWindows; ++i) { 2217 delegates[i] = new GestureEventConsumeDelegate(); 2218 windows[i] = CreateTestWindowWithDelegate( 2219 delegates[i], i, window_bounds[i], root_window()); 2220 windows[i]->set_id(i); 2221 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, window_bounds[i].origin(), 2222 i, tes.Now()); 2223 DispatchEventUsingWindowDispatcher(&press); 2224 } 2225 2226 // Touches should now be associated with the closest touch within 2227 // ui::GestureConfiguration::max_separation_for_gesture_touches_in_pixels 2228 target = gesture_recognizer->GetTargetForLocation(gfx::Point(11, 11), -1); 2229 EXPECT_EQ("0", WindowIDAsString(target)); 2230 target = gesture_recognizer->GetTargetForLocation(gfx::Point(511, 11), -1); 2231 EXPECT_EQ("1", WindowIDAsString(target)); 2232 target = gesture_recognizer->GetTargetForLocation(gfx::Point(11, 511), -1); 2233 EXPECT_EQ("2", WindowIDAsString(target)); 2234 target = gesture_recognizer->GetTargetForLocation(gfx::Point(511, 511), -1); 2235 EXPECT_EQ("3", WindowIDAsString(target)); 2236 2237 // Add a touch in the middle associated with windows[2] 2238 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 500), 2239 kNumWindows, tes.Now()); 2240 DispatchEventUsingWindowDispatcher(&press); 2241 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(250, 250), 2242 kNumWindows, tes.Now()); 2243 DispatchEventUsingWindowDispatcher(&move); 2244 2245 target = gesture_recognizer->GetTargetForLocation(gfx::Point(250, 250), -1); 2246 EXPECT_EQ("2", WindowIDAsString(target)); 2247 2248 // Make sure that ties are broken by distance to a current touch 2249 // Closer to the point in the bottom right. 2250 target = gesture_recognizer->GetTargetForLocation(gfx::Point(380, 380), -1); 2251 EXPECT_EQ("3", WindowIDAsString(target)); 2252 2253 // This touch is closer to the point in the middle 2254 target = gesture_recognizer->GetTargetForLocation(gfx::Point(300, 300), -1); 2255 EXPECT_EQ("2", WindowIDAsString(target)); 2256 2257 // A touch too far from other touches won't be locked to anything 2258 target = gesture_recognizer->GetTargetForLocation(gfx::Point(1000, 1000), -1); 2259 EXPECT_TRUE(target == NULL); 2260 2261 // Move a touch associated with windows[2] to 1000, 1000 2262 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(1000, 1000), 2263 kNumWindows, tes.Now()); 2264 DispatchEventUsingWindowDispatcher(&move2); 2265 2266 target = gesture_recognizer->GetTargetForLocation(gfx::Point(1000, 1000), -1); 2267 EXPECT_EQ("2", WindowIDAsString(target)); 2268 2269 for (int i = 0; i < kNumWindows; ++i) { 2270 // Delete windows before deleting delegates. 2271 delete windows[i]; 2272 delete delegates[i]; 2273 } 2274 } 2275 2276 // Check that a touch's target will not be effected by a touch on a different 2277 // screen. 2278 TEST_P(GestureRecognizerTest, GestureEventTouchLockIgnoresOtherScreens) { 2279 scoped_ptr<GestureEventConsumeDelegate> delegate( 2280 new GestureEventConsumeDelegate()); 2281 gfx::Rect bounds(0, 0, 10, 10); 2282 scoped_ptr<aura::Window> window( 2283 CreateTestWindowWithDelegate(delegate.get(), 0, bounds, root_window())); 2284 2285 const int kTouchId1 = 8; 2286 const int kTouchId2 = 2; 2287 TimedEvents tes; 2288 2289 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(5, 5), 2290 kTouchId1, tes.Now()); 2291 press1.set_source_device_id(1); 2292 DispatchEventUsingWindowDispatcher(&press1); 2293 2294 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(20, 20), 2295 kTouchId2, tes.Now()); 2296 press2.set_source_device_id(2); 2297 DispatchEventUsingWindowDispatcher(&press2); 2298 2299 // The second press should not have been locked to the same target as the 2300 // first, as they occured on different displays. 2301 EXPECT_NE( 2302 ui::GestureRecognizer::Get()->GetTouchLockedTarget(press1), 2303 ui::GestureRecognizer::Get()->GetTouchLockedTarget(press2)); 2304 } 2305 2306 // Check that touch events outside the root window are still handled 2307 // by the root window's gesture sequence. 2308 TEST_P(GestureRecognizerTest, GestureEventOutsideRootWindowTap) { 2309 // TODO(tdresser): write a version of this test for the unified GR. 2310 if (UsingUnifiedGR()) 2311 return; 2312 2313 TestGestureRecognizer* gesture_recognizer = 2314 new TestGestureRecognizer(); 2315 TimedEvents tes; 2316 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 2317 2318 scoped_ptr<aura::Window> window(CreateTestWindowWithBounds( 2319 gfx::Rect(-100, -100, 2000, 2000), root_window())); 2320 2321 ui::GestureSequence* window_gesture_sequence = 2322 gesture_recognizer->GetGestureSequenceForTesting(window.get()); 2323 2324 ui::GestureSequence* root_window_gesture_sequence = 2325 gesture_recognizer->GetGestureSequenceForTesting(root_window()); 2326 2327 gfx::Point pos1(-10, -10); 2328 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, pos1, 0, tes.Now()); 2329 DispatchEventUsingWindowDispatcher(&press1); 2330 2331 gfx::Point pos2(1000, 1000); 2332 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, pos2, 1, tes.Now()); 2333 DispatchEventUsingWindowDispatcher(&press2); 2334 2335 // As these presses were outside the root window, they should be 2336 // associated with the root window. 2337 EXPECT_EQ(0, window_gesture_sequence->point_count()); 2338 EXPECT_EQ(2, root_window_gesture_sequence->point_count()); 2339 } 2340 2341 TEST_P(GestureRecognizerTest, NoTapWithPreventDefaultedRelease) { 2342 scoped_ptr<QueueTouchEventDelegate> delegate( 2343 new QueueTouchEventDelegate(host()->dispatcher())); 2344 TimedEvents tes; 2345 const int kTouchId = 2; 2346 gfx::Rect bounds(100, 200, 100, 100); 2347 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2348 delegate.get(), -1234, bounds, root_window())); 2349 delegate->set_window(window.get()); 2350 2351 delegate->Reset(); 2352 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 2353 kTouchId, tes.Now()); 2354 DispatchEventUsingWindowDispatcher(&press); 2355 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2356 kTouchId, tes.LeapForward(50)); 2357 DispatchEventUsingWindowDispatcher(&release); 2358 2359 delegate->Reset(); 2360 delegate->ReceivedAck(); 2361 EXPECT_TRUE(delegate->tap_down()); 2362 delegate->Reset(); 2363 delegate->ReceivedAckPreventDefaulted(); 2364 EXPECT_FALSE(delegate->tap()); 2365 EXPECT_TRUE(delegate->tap_cancel()); 2366 } 2367 2368 TEST_P(GestureRecognizerTest, PinchScrollWithPreventDefaultedRelease) { 2369 // Disabled for unified GR due to differences in when pinch begin is sent. The 2370 // Aura GR sends it earlier than is necessary. 2371 if (UsingUnifiedGR()) 2372 return; 2373 2374 scoped_ptr<QueueTouchEventDelegate> delegate( 2375 new QueueTouchEventDelegate(host()->dispatcher())); 2376 TimedEvents tes; 2377 const int kTouchId1 = 7; 2378 const int kTouchId2 = 5; 2379 gfx::Rect bounds(10, 20, 100, 100); 2380 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2381 delegate.get(), -1234, bounds, root_window())); 2382 delegate->set_window(window.get()); 2383 2384 { 2385 delegate->Reset(); 2386 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(15, 25), kTouchId1, 2387 tes.Now()); 2388 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(20, 95), kTouchId1, 2389 tes.LeapForward(200)); 2390 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(15, 25), kTouchId1, 2391 tes.LeapForward(50)); 2392 DispatchEventUsingWindowDispatcher(&press); 2393 DispatchEventUsingWindowDispatcher(&move); 2394 DispatchEventUsingWindowDispatcher(&release); 2395 delegate->Reset(); 2396 2397 // Ack the press event. 2398 delegate->ReceivedAck(); 2399 EXPECT_TRUE(delegate->tap_down()); 2400 delegate->Reset(); 2401 2402 // Ack the move event. 2403 delegate->ReceivedAck(); 2404 EXPECT_TRUE(delegate->tap_cancel()); 2405 EXPECT_TRUE(delegate->scroll_begin()); 2406 delegate->Reset(); 2407 2408 // Ack the release event. Although the release event has been processed, it 2409 // should still generate a scroll-end event. 2410 delegate->ReceivedAckPreventDefaulted(); 2411 EXPECT_TRUE(delegate->scroll_end()); 2412 } 2413 2414 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(15, 25), kTouchId1, 2415 tes.Now()); 2416 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(20, 95), kTouchId1, 2417 tes.LeapForward(200)); 2418 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(15, 25), kTouchId1, 2419 tes.LeapForward(50)); 2420 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(55, 25), kTouchId2, 2421 tes.Now()); 2422 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(45, 85), kTouchId2, 2423 tes.LeapForward(1000)); 2424 ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(45, 85), kTouchId2, 2425 tes.LeapForward(14)); 2426 2427 // Do a pinch. 2428 DispatchEventUsingWindowDispatcher(&press); 2429 DispatchEventUsingWindowDispatcher(&move); 2430 DispatchEventUsingWindowDispatcher(&press2); 2431 DispatchEventUsingWindowDispatcher(&move2); 2432 DispatchEventUsingWindowDispatcher(&release); 2433 DispatchEventUsingWindowDispatcher(&release2); 2434 2435 // Ack the press and move events. 2436 delegate->Reset(); 2437 delegate->ReceivedAck(); 2438 EXPECT_TRUE(delegate->begin()); 2439 EXPECT_TRUE(delegate->tap_down()); 2440 2441 delegate->Reset(); 2442 delegate->ReceivedAck(); 2443 EXPECT_TRUE(delegate->scroll_begin()); 2444 2445 delegate->Reset(); 2446 delegate->ReceivedAck(); 2447 EXPECT_TRUE(delegate->begin()); 2448 EXPECT_TRUE(delegate->pinch_begin()); 2449 2450 delegate->Reset(); 2451 delegate->ReceivedAck(); 2452 EXPECT_TRUE(delegate->pinch_update()); 2453 2454 // Ack the first release. Although the release is processed, it should still 2455 // generate a pinch-end event. 2456 delegate->Reset(); 2457 delegate->ReceivedAckPreventDefaulted(); 2458 EXPECT_TRUE(delegate->pinch_end()); 2459 EXPECT_TRUE(delegate->end()); 2460 2461 delegate->Reset(); 2462 delegate->ReceivedAckPreventDefaulted(); 2463 EXPECT_TRUE(delegate->scroll_end()); 2464 EXPECT_TRUE(delegate->end()); 2465 } 2466 2467 TEST_P(GestureRecognizerTest, GestureEndLocation) { 2468 GestureEventConsumeDelegate delegate; 2469 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2470 &delegate, -1234, gfx::Rect(10, 10, 300, 300), root_window())); 2471 EventGenerator generator(root_window(), window.get()); 2472 const gfx::Point begin(20, 20); 2473 const gfx::Point end(150, 150); 2474 const gfx::Vector2d window_offset = 2475 window->bounds().origin().OffsetFromOrigin(); 2476 generator.GestureScrollSequence(begin, end, 2477 base::TimeDelta::FromMilliseconds(20), 2478 10); 2479 EXPECT_EQ((begin - window_offset).ToString(), 2480 delegate.scroll_begin_position().ToString()); 2481 EXPECT_EQ((end - window_offset).ToString(), 2482 delegate.gesture_end_location().ToString()); 2483 } 2484 2485 TEST_P(GestureRecognizerTest, CaptureSendsGestureEnd) { 2486 scoped_ptr<GestureEventConsumeDelegate> delegate( 2487 new GestureEventConsumeDelegate()); 2488 TestGestureRecognizer* gesture_recognizer = 2489 new TestGestureRecognizer(); 2490 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 2491 2492 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2493 delegate.get(), -1234, gfx::Rect(10, 10, 300, 300), root_window())); 2494 EventGenerator generator(root_window()); 2495 2496 generator.MoveMouseRelativeTo(window.get(), gfx::Point(10, 10)); 2497 generator.PressTouch(); 2498 RunAllPendingInMessageLoop(); 2499 2500 EXPECT_TRUE(delegate->tap_down()); 2501 2502 scoped_ptr<aura::Window> capture(CreateTestWindowWithBounds( 2503 gfx::Rect(10, 10, 200, 200), root_window())); 2504 capture->SetCapture(); 2505 RunAllPendingInMessageLoop(); 2506 2507 EXPECT_TRUE(delegate->end()); 2508 EXPECT_TRUE(delegate->tap_cancel()); 2509 } 2510 2511 // Check that previous touch actions that are completely finished (either 2512 // released or cancelled), do not receive extra synthetic cancels upon change of 2513 // capture. 2514 TEST_P(GestureRecognizerTest, CaptureDoesNotCancelFinishedTouches) { 2515 scoped_ptr<GestureEventConsumeDelegate> delegate( 2516 new GestureEventConsumeDelegate()); 2517 scoped_ptr<TestEventHandler> handler(new TestEventHandler); 2518 root_window()->AddPreTargetHandler(handler.get()); 2519 2520 // Create a window and set it as the capture window. 2521 scoped_ptr<aura::Window> window1(CreateTestWindowWithDelegate(delegate.get(), 2522 -1234, gfx::Rect(10, 10, 300, 300), root_window())); 2523 window1->SetCapture(); 2524 2525 EventGenerator generator(root_window()); 2526 TimedEvents tes; 2527 2528 // Generate two touch-press events on the window. 2529 scoped_ptr<ui::TouchEvent> touch0(new ui::TouchEvent(ui::ET_TOUCH_PRESSED, 2530 gfx::Point(20, 20), 0, 2531 tes.Now())); 2532 scoped_ptr<ui::TouchEvent> touch1(new ui::TouchEvent(ui::ET_TOUCH_PRESSED, 2533 gfx::Point(30, 30), 1, 2534 tes.Now())); 2535 generator.Dispatch(touch0.get()); 2536 generator.Dispatch(touch1.get()); 2537 RunAllPendingInMessageLoop(); 2538 EXPECT_EQ(2, handler->touch_pressed_count()); 2539 2540 // Advance time. 2541 tes.LeapForward(1000); 2542 2543 // End the two touches, one by a touch-release and one by a touch-cancel; to 2544 // cover both cases. 2545 touch0.reset(new ui::TouchEvent(ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), 0, 2546 tes.Now())); 2547 touch1.reset(new ui::TouchEvent(ui::ET_TOUCH_CANCELLED, gfx::Point(30, 30), 1, 2548 tes.Now())); 2549 generator.Dispatch(touch0.get()); 2550 generator.Dispatch(touch1.get()); 2551 RunAllPendingInMessageLoop(); 2552 EXPECT_EQ(1, handler->touch_released_count()); 2553 EXPECT_EQ(1, handler->touch_cancelled_count()); 2554 2555 // Create a new window and set it as the new capture window. 2556 scoped_ptr<aura::Window> window2(CreateTestWindowWithBounds( 2557 gfx::Rect(100, 100, 300, 300), root_window())); 2558 window2->SetCapture(); 2559 RunAllPendingInMessageLoop(); 2560 // Check that setting capture does not generate any synthetic touch-cancels 2561 // for the two previously finished touch actions. 2562 EXPECT_EQ(1, handler->touch_cancelled_count()); 2563 2564 root_window()->RemovePreTargetHandler(handler.get()); 2565 } 2566 2567 // Tests that a press with the same touch id as an existing touch is ignored. 2568 TEST_P(GestureRecognizerTest, PressDoesNotCrash) { 2569 scoped_ptr<GestureEventConsumeDelegate> delegate( 2570 new GestureEventConsumeDelegate()); 2571 TestGestureRecognizer* gesture_recognizer = 2572 new TestGestureRecognizer(); 2573 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 2574 TimedEvents tes; 2575 2576 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2577 delegate.get(), -1234, gfx::Rect(10, 10, 300, 300), root_window())); 2578 2579 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(45, 45), 7, tes.Now()); 2580 press.set_radius_x(40); 2581 DispatchEventUsingWindowDispatcher(&press); 2582 EXPECT_TRUE(delegate->tap_down()); 2583 EXPECT_EQ(gfx::Rect(5, 5, 80, 80).ToString(), 2584 delegate->bounding_box().ToString()); 2585 delegate->Reset(); 2586 2587 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(55, 45), 7, tes.Now()); 2588 DispatchEventUsingWindowDispatcher(&press2); 2589 2590 // This new press should not generate a tap-down. 2591 EXPECT_FALSE(delegate->begin()); 2592 EXPECT_FALSE(delegate->tap_down()); 2593 EXPECT_FALSE(delegate->tap_cancel()); 2594 EXPECT_FALSE(delegate->scroll_begin()); 2595 } 2596 2597 TEST_P(GestureRecognizerTest, TwoFingerTap) { 2598 // TODO(tdresser): enable this test with unified GR once two finger tap is 2599 // supported. See crbug.com/354396. 2600 if (UsingUnifiedGR()) 2601 return; 2602 2603 scoped_ptr<GestureEventConsumeDelegate> delegate( 2604 new GestureEventConsumeDelegate()); 2605 const int kWindowWidth = 123; 2606 const int kWindowHeight = 45; 2607 const int kTouchId1 = 2; 2608 const int kTouchId2 = 3; 2609 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 2610 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2611 delegate.get(), -1234, bounds, root_window())); 2612 TimedEvents tes; 2613 2614 delegate->Reset(); 2615 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 2616 kTouchId1, tes.Now()); 2617 DispatchEventUsingWindowDispatcher(&press1); 2618 EXPECT_FALSE(delegate->tap()); 2619 EXPECT_TRUE(delegate->tap_down()); 2620 EXPECT_FALSE(delegate->tap_cancel()); 2621 EXPECT_FALSE(delegate->scroll_begin()); 2622 EXPECT_FALSE(delegate->scroll_update()); 2623 EXPECT_FALSE(delegate->scroll_end()); 2624 EXPECT_FALSE(delegate->long_press()); 2625 EXPECT_FALSE(delegate->two_finger_tap()); 2626 2627 delegate->Reset(); 2628 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), 2629 kTouchId2, tes.Now()); 2630 DispatchEventUsingWindowDispatcher(&press2); 2631 EXPECT_FALSE(delegate->tap()); 2632 EXPECT_FALSE(delegate->tap_down()); // no touch down for second tap. 2633 EXPECT_TRUE(delegate->tap_cancel()); 2634 EXPECT_FALSE(delegate->scroll_begin()); 2635 EXPECT_FALSE(delegate->scroll_update()); 2636 EXPECT_FALSE(delegate->scroll_end()); 2637 EXPECT_FALSE(delegate->long_press()); 2638 EXPECT_FALSE(delegate->two_finger_tap()); 2639 2640 // Little bit of touch move should not affect our state. 2641 delegate->Reset(); 2642 ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(102, 202), 2643 kTouchId1, tes.Now()); 2644 DispatchEventUsingWindowDispatcher(&move1); 2645 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(131, 202), 2646 kTouchId2, tes.Now()); 2647 DispatchEventUsingWindowDispatcher(&move2); 2648 EXPECT_FALSE(delegate->tap()); 2649 EXPECT_FALSE(delegate->tap_down()); 2650 EXPECT_FALSE(delegate->tap_cancel()); 2651 EXPECT_FALSE(delegate->scroll_begin()); 2652 EXPECT_FALSE(delegate->scroll_update()); 2653 EXPECT_FALSE(delegate->scroll_end()); 2654 EXPECT_FALSE(delegate->long_press()); 2655 EXPECT_FALSE(delegate->two_finger_tap()); 2656 2657 // Make sure there is enough delay before the touch is released so that it is 2658 // recognized as a tap. 2659 delegate->Reset(); 2660 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2661 kTouchId1, tes.LeapForward(50)); 2662 2663 DispatchEventUsingWindowDispatcher(&release1); 2664 EXPECT_FALSE(delegate->tap()); 2665 EXPECT_FALSE(delegate->tap_down()); 2666 EXPECT_FALSE(delegate->tap_cancel()); 2667 EXPECT_TRUE(delegate->scroll_begin()); 2668 EXPECT_FALSE(delegate->scroll_update()); 2669 EXPECT_FALSE(delegate->scroll_end()); 2670 EXPECT_TRUE(delegate->two_finger_tap()); 2671 2672 // Lift second finger. 2673 // Make sure there is enough delay before the touch is released so that it is 2674 // recognized as a tap. 2675 delegate->Reset(); 2676 ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(130, 201), 2677 kTouchId2, tes.LeapForward(50)); 2678 2679 DispatchEventUsingWindowDispatcher(&release2); 2680 EXPECT_FALSE(delegate->tap()); 2681 EXPECT_FALSE(delegate->tap_down()); 2682 EXPECT_FALSE(delegate->tap_cancel()); 2683 EXPECT_FALSE(delegate->scroll_begin()); 2684 EXPECT_FALSE(delegate->scroll_update()); 2685 EXPECT_FALSE(delegate->scroll_end()); 2686 EXPECT_TRUE(delegate->fling()); 2687 EXPECT_FALSE(delegate->two_finger_tap()); 2688 } 2689 2690 TEST_P(GestureRecognizerTest, TwoFingerTapExpired) { 2691 scoped_ptr<GestureEventConsumeDelegate> delegate( 2692 new GestureEventConsumeDelegate()); 2693 const int kWindowWidth = 123; 2694 const int kWindowHeight = 45; 2695 const int kTouchId1 = 2; 2696 const int kTouchId2 = 3; 2697 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 2698 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2699 delegate.get(), -1234, bounds, root_window())); 2700 TimedEvents tes; 2701 2702 delegate->Reset(); 2703 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 2704 kTouchId1, tes.Now()); 2705 DispatchEventUsingWindowDispatcher(&press1); 2706 2707 delegate->Reset(); 2708 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), 2709 kTouchId2, tes.Now()); 2710 DispatchEventUsingWindowDispatcher(&press2); 2711 2712 // Send release event after sufficient delay so that two finger time expires. 2713 delegate->Reset(); 2714 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2715 kTouchId1, tes.LeapForward(1000)); 2716 2717 DispatchEventUsingWindowDispatcher(&release1); 2718 EXPECT_FALSE(delegate->two_finger_tap()); 2719 2720 // Lift second finger. 2721 // Make sure there is enough delay before the touch is released so that it is 2722 // recognized as a tap. 2723 delegate->Reset(); 2724 ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(130, 201), 2725 kTouchId2, tes.LeapForward(50)); 2726 2727 DispatchEventUsingWindowDispatcher(&release2); 2728 EXPECT_FALSE(delegate->two_finger_tap()); 2729 } 2730 2731 TEST_P(GestureRecognizerTest, TwoFingerTapChangesToPinch) { 2732 scoped_ptr<GestureEventConsumeDelegate> delegate( 2733 new GestureEventConsumeDelegate()); 2734 const int kWindowWidth = 123; 2735 const int kWindowHeight = 45; 2736 const int kTouchId1 = 2; 2737 const int kTouchId2 = 3; 2738 TimedEvents tes; 2739 2740 // Test moving first finger 2741 { 2742 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 2743 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2744 delegate.get(), -1234, bounds, root_window())); 2745 2746 delegate->Reset(); 2747 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 2748 kTouchId1, tes.Now()); 2749 DispatchEventUsingWindowDispatcher(&press1); 2750 2751 delegate->Reset(); 2752 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), 2753 kTouchId2, tes.Now()); 2754 DispatchEventUsingWindowDispatcher(&press2); 2755 2756 tes.SendScrollEvent(event_processor(), 230, 330, kTouchId1, delegate.get()); 2757 EXPECT_FALSE(delegate->two_finger_tap()); 2758 EXPECT_TRUE(delegate->pinch_begin()); 2759 2760 // Make sure there is enough delay before the touch is released so that it 2761 // is recognized as a tap. 2762 delegate->Reset(); 2763 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2764 kTouchId2, tes.LeapForward(50)); 2765 2766 DispatchEventUsingWindowDispatcher(&release); 2767 EXPECT_FALSE(delegate->two_finger_tap()); 2768 EXPECT_TRUE(delegate->pinch_end()); 2769 } 2770 2771 // Test moving second finger 2772 { 2773 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 2774 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2775 delegate.get(), -1234, bounds, root_window())); 2776 2777 delegate->Reset(); 2778 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 2779 kTouchId1, tes.Now()); 2780 DispatchEventUsingWindowDispatcher(&press1); 2781 2782 delegate->Reset(); 2783 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), 2784 kTouchId2, tes.Now()); 2785 DispatchEventUsingWindowDispatcher(&press2); 2786 2787 tes.SendScrollEvent(event_processor(), 301, 230, kTouchId2, delegate.get()); 2788 EXPECT_FALSE(delegate->two_finger_tap()); 2789 EXPECT_TRUE(delegate->pinch_begin()); 2790 2791 // Make sure there is enough delay before the touch is released so that it 2792 // is recognized as a tap. 2793 delegate->Reset(); 2794 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2795 kTouchId1, tes.LeapForward(50)); 2796 2797 DispatchEventUsingWindowDispatcher(&release); 2798 EXPECT_FALSE(delegate->two_finger_tap()); 2799 EXPECT_TRUE(delegate->pinch_end()); 2800 } 2801 } 2802 2803 TEST_P(GestureRecognizerTest, NoTwoFingerTapWhenFirstFingerHasScrolled) { 2804 // Disabled for unified GR due to differences in when pinch begin is sent. The 2805 // Aura GR sends it earlier than is necessary. 2806 if (UsingUnifiedGR()) 2807 return; 2808 2809 scoped_ptr<GestureEventConsumeDelegate> delegate( 2810 new GestureEventConsumeDelegate()); 2811 const int kWindowWidth = 123; 2812 const int kWindowHeight = 45; 2813 const int kTouchId1 = 2; 2814 const int kTouchId2 = 3; 2815 TimedEvents tes; 2816 2817 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 2818 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2819 delegate.get(), -1234, bounds, root_window())); 2820 2821 delegate->Reset(); 2822 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 2823 kTouchId1, tes.Now()); 2824 DispatchEventUsingWindowDispatcher(&press1); 2825 tes.SendScrollEvent(event_processor(), 130, 230, kTouchId1, delegate.get()); 2826 2827 delegate->Reset(); 2828 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), 2829 kTouchId2, tes.Now()); 2830 DispatchEventUsingWindowDispatcher(&press2); 2831 2832 EXPECT_TRUE(delegate->pinch_begin()); 2833 2834 // Make sure there is enough delay before the touch is released so that it 2835 // is recognized as a tap. 2836 delegate->Reset(); 2837 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2838 kTouchId2, tes.LeapForward(50)); 2839 2840 DispatchEventUsingWindowDispatcher(&release); 2841 EXPECT_FALSE(delegate->two_finger_tap()); 2842 EXPECT_TRUE(delegate->pinch_end()); 2843 } 2844 2845 TEST_P(GestureRecognizerTest, MultiFingerSwipe) { 2846 scoped_ptr<GestureEventConsumeDelegate> delegate( 2847 new GestureEventConsumeDelegate()); 2848 const int kWindowWidth = 123; 2849 const int kWindowHeight = 45; 2850 2851 gfx::Rect bounds(5, 10, kWindowWidth, kWindowHeight); 2852 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2853 delegate.get(), -1234, bounds, root_window())); 2854 2855 const int kSteps = 15; 2856 const int kTouchPoints = 4; 2857 gfx::Point points[kTouchPoints] = { 2858 gfx::Point(10, 30), 2859 gfx::Point(30, 20), 2860 gfx::Point(50, 30), 2861 gfx::Point(80, 50) 2862 }; 2863 2864 aura::test::EventGenerator generator(root_window(), window.get()); 2865 2866 // The unified gesture recognizer assumes a finger has stopped if it hasn't 2867 // moved for too long. See ui/events/gesture_detection/velocity_tracker.cc's 2868 // kAssumePointerStoppedTimeMs. 2869 for (int count = 2; count <= kTouchPoints; ++count) { 2870 generator.GestureMultiFingerScroll( 2871 count, points, 10, kSteps, 0, -11 * kSteps); 2872 EXPECT_TRUE(delegate->swipe_up()); 2873 delegate->Reset(); 2874 2875 generator.GestureMultiFingerScroll( 2876 count, points, 10, kSteps, 0, 11 * kSteps); 2877 EXPECT_TRUE(delegate->swipe_down()); 2878 delegate->Reset(); 2879 2880 generator.GestureMultiFingerScroll( 2881 count, points, 10, kSteps, -11 * kSteps, 0); 2882 EXPECT_TRUE(delegate->swipe_left()); 2883 delegate->Reset(); 2884 2885 generator.GestureMultiFingerScroll( 2886 count, points, 10, kSteps, 11 * kSteps, 0); 2887 EXPECT_TRUE(delegate->swipe_right()); 2888 delegate->Reset(); 2889 } 2890 } 2891 2892 TEST_P(GestureRecognizerTest, TwoFingerTapCancelled) { 2893 scoped_ptr<GestureEventConsumeDelegate> delegate( 2894 new GestureEventConsumeDelegate()); 2895 const int kWindowWidth = 123; 2896 const int kWindowHeight = 45; 2897 const int kTouchId1 = 2; 2898 const int kTouchId2 = 3; 2899 TimedEvents tes; 2900 2901 // Test canceling first finger. 2902 { 2903 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 2904 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2905 delegate.get(), -1234, bounds, root_window())); 2906 2907 delegate->Reset(); 2908 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 2909 kTouchId1, tes.Now()); 2910 DispatchEventUsingWindowDispatcher(&press1); 2911 2912 delegate->Reset(); 2913 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), 2914 kTouchId2, tes.Now()); 2915 DispatchEventUsingWindowDispatcher(&press2); 2916 2917 delegate->Reset(); 2918 ui::TouchEvent cancel(ui::ET_TOUCH_CANCELLED, gfx::Point(130, 201), 2919 kTouchId1, tes.Now()); 2920 DispatchEventUsingWindowDispatcher(&cancel); 2921 EXPECT_FALSE(delegate->two_finger_tap()); 2922 2923 // Make sure there is enough delay before the touch is released so that it 2924 // is recognized as a tap. 2925 delegate->Reset(); 2926 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2927 kTouchId2, tes.LeapForward(50)); 2928 2929 DispatchEventUsingWindowDispatcher(&release); 2930 EXPECT_FALSE(delegate->two_finger_tap()); 2931 } 2932 2933 // Test canceling second finger 2934 { 2935 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 2936 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2937 delegate.get(), -1234, bounds, root_window())); 2938 2939 delegate->Reset(); 2940 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 2941 kTouchId1, tes.Now()); 2942 DispatchEventUsingWindowDispatcher(&press1); 2943 2944 delegate->Reset(); 2945 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), 2946 kTouchId2, tes.Now()); 2947 DispatchEventUsingWindowDispatcher(&press2); 2948 2949 delegate->Reset(); 2950 ui::TouchEvent cancel(ui::ET_TOUCH_CANCELLED, gfx::Point(130, 201), 2951 kTouchId2, tes.Now()); 2952 DispatchEventUsingWindowDispatcher(&cancel); 2953 EXPECT_FALSE(delegate->two_finger_tap()); 2954 2955 // Make sure there is enough delay before the touch is released so that it 2956 // is recognized as a tap. 2957 delegate->Reset(); 2958 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 2959 kTouchId1, tes.LeapForward(50)); 2960 2961 DispatchEventUsingWindowDispatcher(&release); 2962 EXPECT_FALSE(delegate->two_finger_tap()); 2963 } 2964 } 2965 2966 TEST_P(GestureRecognizerTest, VeryWideTwoFingerTouchDownShouldBeAPinch) { 2967 // Disabled for unified GR due to differences in when scroll update is 2968 // sent. The Aura GR will never send a ScrollUpdate with a ScrollBegin, but 2969 // the unified GR will. 2970 if (UsingUnifiedGR()) 2971 return; 2972 2973 scoped_ptr<GestureEventConsumeDelegate> delegate( 2974 new GestureEventConsumeDelegate()); 2975 const int kWindowWidth = 523; 2976 const int kWindowHeight = 45; 2977 const int kTouchId1 = 2; 2978 const int kTouchId2 = 3; 2979 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 2980 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 2981 delegate.get(), -1234, bounds, root_window())); 2982 TimedEvents tes; 2983 2984 delegate->Reset(); 2985 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 2986 kTouchId1, tes.Now()); 2987 DispatchEventUsingWindowDispatcher(&press1); 2988 EXPECT_FALSE(delegate->tap()); 2989 EXPECT_TRUE(delegate->tap_down()); 2990 EXPECT_FALSE(delegate->tap_cancel()); 2991 EXPECT_FALSE(delegate->scroll_begin()); 2992 EXPECT_FALSE(delegate->scroll_update()); 2993 EXPECT_FALSE(delegate->scroll_end()); 2994 EXPECT_FALSE(delegate->long_press()); 2995 EXPECT_FALSE(delegate->two_finger_tap()); 2996 2997 delegate->Reset(); 2998 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(430, 201), 2999 kTouchId2, tes.Now()); 3000 DispatchEventUsingWindowDispatcher(&press2); 3001 EXPECT_FALSE(delegate->tap()); 3002 EXPECT_FALSE(delegate->tap_down()); // no touch down for second tap. 3003 EXPECT_TRUE(delegate->tap_cancel()); 3004 EXPECT_FALSE(delegate->scroll_begin()); 3005 EXPECT_FALSE(delegate->scroll_update()); 3006 EXPECT_FALSE(delegate->scroll_end()); 3007 EXPECT_FALSE(delegate->long_press()); 3008 EXPECT_FALSE(delegate->two_finger_tap()); 3009 EXPECT_FALSE(delegate->pinch_begin()); 3010 3011 delegate->Reset(); 3012 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(530, 301), 3013 kTouchId2, tes.Now()); 3014 DispatchEventUsingWindowDispatcher(&move2); 3015 EXPECT_FALSE(delegate->tap()); 3016 EXPECT_FALSE(delegate->tap_down()); 3017 EXPECT_FALSE(delegate->tap_cancel()); 3018 // Pinch & Scroll only when there is enough movement. 3019 EXPECT_TRUE(delegate->scroll_begin()); 3020 EXPECT_FALSE(delegate->scroll_update()); 3021 EXPECT_FALSE(delegate->scroll_end()); 3022 EXPECT_FALSE(delegate->long_press()); 3023 EXPECT_FALSE(delegate->two_finger_tap()); 3024 EXPECT_TRUE(delegate->pinch_begin()); 3025 } 3026 3027 // Verifies if a window is the target of multiple touch-ids and we hide the 3028 // window everything is cleaned up correctly. 3029 TEST_P(GestureRecognizerTest, FlushAllOnHide) { 3030 scoped_ptr<GestureEventConsumeDelegate> delegate( 3031 new GestureEventConsumeDelegate()); 3032 gfx::Rect bounds(0, 0, 200, 200); 3033 scoped_ptr<aura::Window> window( 3034 CreateTestWindowWithDelegate(delegate.get(), 0, bounds, root_window())); 3035 const int kTouchId1 = 8; 3036 const int kTouchId2 = 2; 3037 TimedEvents tes; 3038 3039 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 3040 kTouchId1, tes.Now()); 3041 DispatchEventUsingWindowDispatcher(&press1); 3042 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(20, 20), 3043 kTouchId2, tes.Now()); 3044 DispatchEventUsingWindowDispatcher(&press2); 3045 window->Hide(); 3046 EXPECT_EQ(NULL, 3047 ui::GestureRecognizer::Get()->GetTouchLockedTarget(press1)); 3048 EXPECT_EQ(NULL, 3049 ui::GestureRecognizer::Get()->GetTouchLockedTarget(press2)); 3050 } 3051 3052 TEST_P(GestureRecognizerTest, LongPressTimerStopsOnPreventDefaultedTouchMoves) { 3053 // TODO(tdresser): write a version of this test for the unified GR. 3054 if (UsingUnifiedGR()) 3055 return; 3056 3057 scoped_ptr<QueueTouchEventDelegate> delegate( 3058 new QueueTouchEventDelegate(host()->dispatcher())); 3059 const int kTouchId = 2; 3060 gfx::Rect bounds(100, 200, 100, 100); 3061 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3062 delegate.get(), -1234, bounds, root_window())); 3063 delegate->set_window(window.get()); 3064 TimedEvents tes; 3065 3066 TimerTestGestureRecognizer* gesture_recognizer = 3067 new TimerTestGestureRecognizer(); 3068 TimerTestGestureSequence* gesture_sequence = 3069 static_cast<TimerTestGestureSequence*>( 3070 gesture_recognizer->GetGestureSequenceForTesting(window.get())); 3071 3072 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 3073 3074 delegate->Reset(); 3075 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3076 kTouchId, tes.Now()); 3077 DispatchEventUsingWindowDispatcher(&press); 3078 // Scroll around, to cancel the long press 3079 tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get()); 3080 3081 delegate->Reset(); 3082 delegate->ReceivedAck(); 3083 EXPECT_TRUE(delegate->tap_down()); 3084 EXPECT_TRUE(gesture_sequence->IsTimerRunning()); 3085 3086 delegate->Reset(); 3087 delegate->ReceivedAckPreventDefaulted(); 3088 EXPECT_FALSE(gesture_sequence->IsTimerRunning()); 3089 gesture_sequence->ForceTimeout(); 3090 EXPECT_FALSE(delegate->long_press()); 3091 } 3092 3093 // Same as GestureEventConsumeDelegate, but consumes all the touch-move events. 3094 class ConsumesTouchMovesDelegate : public GestureEventConsumeDelegate { 3095 public: 3096 ConsumesTouchMovesDelegate() : consume_touch_move_(true) {} 3097 virtual ~ConsumesTouchMovesDelegate() {} 3098 3099 void set_consume_touch_move(bool consume) { consume_touch_move_ = consume; } 3100 3101 private: 3102 virtual void OnTouchEvent(ui::TouchEvent* touch) OVERRIDE { 3103 if (consume_touch_move_ && touch->type() == ui::ET_TOUCH_MOVED) 3104 touch->SetHandled(); 3105 else 3106 GestureEventConsumeDelegate::OnTouchEvent(touch); 3107 } 3108 3109 bool consume_touch_move_; 3110 3111 DISALLOW_COPY_AND_ASSIGN(ConsumesTouchMovesDelegate); 3112 }; 3113 3114 // Same as GestureEventScroll, but tests that the behavior is the same 3115 // even if all the touch-move events are consumed. 3116 TEST_P(GestureRecognizerTest, GestureEventScrollTouchMoveConsumed) { 3117 scoped_ptr<ConsumesTouchMovesDelegate> delegate( 3118 new ConsumesTouchMovesDelegate()); 3119 const int kWindowWidth = 123; 3120 const int kWindowHeight = 45; 3121 const int kTouchId = 5; 3122 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3123 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3124 delegate.get(), -1234, bounds, root_window())); 3125 TimedEvents tes; 3126 3127 delegate->Reset(); 3128 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3129 kTouchId, tes.Now()); 3130 DispatchEventUsingWindowDispatcher(&press); 3131 EXPECT_FALSE(delegate->tap()); 3132 EXPECT_TRUE(delegate->tap_down()); 3133 EXPECT_FALSE(delegate->tap_cancel()); 3134 EXPECT_TRUE(delegate->begin()); 3135 EXPECT_FALSE(delegate->scroll_begin()); 3136 EXPECT_FALSE(delegate->scroll_update()); 3137 EXPECT_FALSE(delegate->scroll_end()); 3138 3139 // Move the touch-point enough so that it would normally be considered a 3140 // scroll. But since the touch-moves will be consumed, the scroll should not 3141 // start. 3142 tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get()); 3143 EXPECT_FALSE(delegate->tap()); 3144 EXPECT_FALSE(delegate->tap_down()); 3145 EXPECT_TRUE(delegate->tap_cancel()); 3146 EXPECT_FALSE(delegate->begin()); 3147 EXPECT_FALSE(delegate->scroll_begin()); 3148 EXPECT_FALSE(delegate->scroll_update()); 3149 EXPECT_FALSE(delegate->scroll_end()); 3150 3151 // Release the touch back at the start point. This should end without causing 3152 // a tap. 3153 delegate->Reset(); 3154 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(130, 230), 3155 kTouchId, tes.LeapForward(50)); 3156 DispatchEventUsingWindowDispatcher(&release); 3157 EXPECT_FALSE(delegate->tap()); 3158 EXPECT_FALSE(delegate->tap_down()); 3159 EXPECT_FALSE(delegate->tap_cancel()); 3160 EXPECT_FALSE(delegate->begin()); 3161 EXPECT_TRUE(delegate->end()); 3162 EXPECT_FALSE(delegate->scroll_begin()); 3163 EXPECT_FALSE(delegate->scroll_update()); 3164 EXPECT_FALSE(delegate->scroll_end()); 3165 } 3166 3167 // Tests the behavior of 2F scroll when all the touch-move events are consumed. 3168 TEST_P(GestureRecognizerTest, GestureEventScrollTwoFingerTouchMoveConsumed) { 3169 // TODO(tdresser): enable this test with unified GR once two finger tap is 3170 // supported. See crbug.com/354396. 3171 if (UsingUnifiedGR()) 3172 return; 3173 3174 scoped_ptr<ConsumesTouchMovesDelegate> delegate( 3175 new ConsumesTouchMovesDelegate()); 3176 const int kWindowWidth = 123; 3177 const int kWindowHeight = 100; 3178 const int kTouchId1 = 2; 3179 const int kTouchId2 = 3; 3180 TimedEvents tes; 3181 3182 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3183 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3184 delegate.get(), -1234, bounds, root_window())); 3185 3186 delegate->Reset(); 3187 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3188 kTouchId1, tes.Now()); 3189 DispatchEventUsingWindowDispatcher(&press1); 3190 tes.SendScrollEvent(event_processor(), 131, 231, kTouchId1, delegate.get()); 3191 3192 // First finger touches down and moves. 3193 EXPECT_FALSE(delegate->tap()); 3194 EXPECT_FALSE(delegate->scroll_begin()); 3195 EXPECT_FALSE(delegate->scroll_update()); 3196 EXPECT_FALSE(delegate->scroll_end()); 3197 3198 delegate->Reset(); 3199 // Second finger touches down and moves. 3200 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), 3201 kTouchId2, tes.LeapForward(50)); 3202 DispatchEventUsingWindowDispatcher(&press2); 3203 tes.SendScrollEvent(event_processor(), 161, 231, kTouchId2, delegate.get()); 3204 3205 // PinchBegin & ScrollBegin were not sent if the touch-move events were 3206 // consumed. 3207 EXPECT_FALSE(delegate->pinch_begin()); 3208 EXPECT_FALSE(delegate->scroll_begin()); 3209 3210 EXPECT_FALSE(delegate->tap()); 3211 EXPECT_FALSE(delegate->two_finger_tap()); 3212 3213 // Should be no PinchUpdate & ScrollUpdate. 3214 EXPECT_FALSE(delegate->pinch_update()); 3215 EXPECT_FALSE(delegate->pinch_end()); 3216 EXPECT_FALSE(delegate->scroll_update()); 3217 EXPECT_FALSE(delegate->scroll_end()); 3218 3219 delegate->Reset(); 3220 // Moves First finger again, no PinchUpdate & ScrollUpdate. 3221 tes.SendScrollEvent(event_processor(), 161, 261, kTouchId1, delegate.get()); 3222 3223 EXPECT_FALSE(delegate->pinch_update()); 3224 EXPECT_FALSE(delegate->pinch_end()); 3225 EXPECT_FALSE(delegate->scroll_update()); 3226 EXPECT_FALSE(delegate->scroll_end()); 3227 3228 // Stops consuming touch-move. 3229 delegate->set_consume_touch_move(false); 3230 3231 delegate->Reset(); 3232 // Making a pinch gesture. 3233 tes.SendScrollEvent(event_processor(), 161, 251, kTouchId1, delegate.get()); 3234 // If touch moves are ever consumed, we should not see PinchBegin/Update 3235 // even touch moves become not consumed. 3236 EXPECT_FALSE(delegate->scroll_begin()); 3237 EXPECT_FALSE(delegate->scroll_update()); 3238 EXPECT_FALSE(delegate->scroll_end()); 3239 3240 EXPECT_FALSE(delegate->pinch_begin()); 3241 EXPECT_FALSE(delegate->pinch_update()); 3242 EXPECT_FALSE(delegate->pinch_end()); 3243 3244 delegate->Reset(); 3245 tes.SendScrollEvent(event_processor(), 161, 241, kTouchId2, delegate.get()); 3246 EXPECT_FALSE(delegate->scroll_begin()); 3247 EXPECT_FALSE(delegate->scroll_update()); 3248 EXPECT_FALSE(delegate->scroll_end()); 3249 3250 EXPECT_FALSE(delegate->pinch_begin()); 3251 EXPECT_FALSE(delegate->pinch_update()); 3252 EXPECT_FALSE(delegate->pinch_end()); 3253 3254 delegate->Reset(); 3255 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 3256 kTouchId1, tes.Now()); 3257 ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(130, 201), 3258 kTouchId2, tes.Now()); 3259 DispatchEventUsingWindowDispatcher(&release1); 3260 DispatchEventUsingWindowDispatcher(&release2); 3261 3262 EXPECT_FALSE(delegate->tap()); 3263 // Touch release is not consumed, so we still see two finger tap. 3264 EXPECT_TRUE(delegate->two_finger_tap()); 3265 3266 // Should not see PinchEnd. 3267 EXPECT_TRUE(delegate->scroll_begin()); 3268 EXPECT_FALSE(delegate->scroll_update()); 3269 EXPECT_FALSE(delegate->scroll_end()); 3270 EXPECT_TRUE(delegate->fling()); 3271 3272 EXPECT_FALSE(delegate->pinch_begin()); 3273 EXPECT_FALSE(delegate->pinch_update()); 3274 EXPECT_FALSE(delegate->pinch_end()); 3275 } 3276 3277 // Like as GestureEventTouchMoveConsumed but tests the different behavior 3278 // depending on whether the events were consumed before or after the scroll 3279 // started. 3280 TEST_P(GestureRecognizerTest, GestureEventScrollTouchMovePartialConsumed) { 3281 scoped_ptr<ConsumesTouchMovesDelegate> delegate( 3282 new ConsumesTouchMovesDelegate()); 3283 const int kWindowWidth = 123; 3284 const int kWindowHeight = 45; 3285 const int kTouchId = 5; 3286 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3287 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3288 delegate.get(), -1234, bounds, root_window())); 3289 TimedEvents tes; 3290 3291 delegate->Reset(); 3292 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3293 kTouchId, tes.Now()); 3294 DispatchEventUsingWindowDispatcher(&press); 3295 EXPECT_FALSE(delegate->tap()); 3296 EXPECT_TRUE(delegate->tap_down()); 3297 EXPECT_FALSE(delegate->tap_cancel()); 3298 EXPECT_TRUE(delegate->begin()); 3299 EXPECT_FALSE(delegate->scroll_begin()); 3300 EXPECT_FALSE(delegate->scroll_update()); 3301 EXPECT_FALSE(delegate->scroll_end()); 3302 3303 // Move the touch-point enough so that it would normally be considered a 3304 // scroll. But since the touch-moves will be consumed, the scroll should not 3305 // start. 3306 tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get()); 3307 EXPECT_FALSE(delegate->tap()); 3308 EXPECT_FALSE(delegate->tap_down()); 3309 EXPECT_TRUE(delegate->tap_cancel()); 3310 EXPECT_FALSE(delegate->begin()); 3311 EXPECT_FALSE(delegate->scroll_begin()); 3312 EXPECT_FALSE(delegate->scroll_update()); 3313 EXPECT_FALSE(delegate->scroll_end()); 3314 3315 // Now, stop consuming touch-move events, and move the touch-point again. 3316 delegate->set_consume_touch_move(false); 3317 tes.SendScrollEvent(event_processor(), 159, 259, kTouchId, delegate.get()); 3318 EXPECT_FALSE(delegate->tap()); 3319 EXPECT_FALSE(delegate->tap_down()); 3320 EXPECT_FALSE(delegate->tap_cancel()); 3321 EXPECT_FALSE(delegate->begin()); 3322 EXPECT_FALSE(delegate->scroll_begin()); 3323 EXPECT_FALSE(delegate->scroll_update()); 3324 EXPECT_FALSE(delegate->scroll_end()); 3325 // No scroll has occurred, because an early touch move was consumed. 3326 EXPECT_EQ(0, delegate->scroll_x()); 3327 EXPECT_EQ(0, delegate->scroll_y()); 3328 EXPECT_EQ(gfx::Point(0, 0).ToString(), 3329 delegate->scroll_begin_position().ToString()); 3330 3331 // Start consuming touch-move events again. 3332 delegate->set_consume_touch_move(true); 3333 3334 // Move some more to generate a few more scroll updates. 3335 tes.SendScrollEvent(event_processor(), 110, 211, kTouchId, delegate.get()); 3336 EXPECT_FALSE(delegate->tap()); 3337 EXPECT_FALSE(delegate->tap_down()); 3338 EXPECT_FALSE(delegate->tap_cancel()); 3339 EXPECT_FALSE(delegate->begin()); 3340 EXPECT_FALSE(delegate->scroll_begin()); 3341 EXPECT_FALSE(delegate->scroll_update()); 3342 EXPECT_FALSE(delegate->scroll_end()); 3343 EXPECT_EQ(0, delegate->scroll_x()); 3344 EXPECT_EQ(0, delegate->scroll_y()); 3345 3346 tes.SendScrollEvent(event_processor(), 140, 215, kTouchId, delegate.get()); 3347 EXPECT_FALSE(delegate->tap()); 3348 EXPECT_FALSE(delegate->tap_down()); 3349 EXPECT_FALSE(delegate->tap_cancel()); 3350 EXPECT_FALSE(delegate->begin()); 3351 EXPECT_FALSE(delegate->scroll_begin()); 3352 EXPECT_FALSE(delegate->scroll_update()); 3353 EXPECT_FALSE(delegate->scroll_end()); 3354 EXPECT_EQ(0, delegate->scroll_x()); 3355 EXPECT_EQ(0, delegate->scroll_y()); 3356 3357 // Release the touch. 3358 delegate->Reset(); 3359 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 3360 kTouchId, tes.LeapForward(50)); 3361 DispatchEventUsingWindowDispatcher(&release); 3362 EXPECT_FALSE(delegate->tap()); 3363 EXPECT_FALSE(delegate->tap_down()); 3364 EXPECT_FALSE(delegate->tap_cancel()); 3365 EXPECT_FALSE(delegate->begin()); 3366 EXPECT_TRUE(delegate->end()); 3367 EXPECT_FALSE(delegate->scroll_begin()); 3368 EXPECT_FALSE(delegate->scroll_update()); 3369 EXPECT_FALSE(delegate->scroll_end()); 3370 EXPECT_FALSE(delegate->fling()); 3371 } 3372 3373 // Check that appropriate touch events generate double tap gesture events. 3374 TEST_P(GestureRecognizerTest, GestureEventDoubleTap) { 3375 scoped_ptr<GestureEventConsumeDelegate> delegate( 3376 new GestureEventConsumeDelegate()); 3377 const int kWindowWidth = 123; 3378 const int kWindowHeight = 45; 3379 const int kTouchId = 2; 3380 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3381 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3382 delegate.get(), -1234, bounds, root_window())); 3383 TimedEvents tes; 3384 3385 // First tap (tested in GestureEventTap) 3386 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(104, 201), 3387 kTouchId, tes.Now()); 3388 DispatchEventUsingWindowDispatcher(&press1); 3389 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(104, 201), 3390 kTouchId, tes.LeapForward(50)); 3391 DispatchEventUsingWindowDispatcher(&release1); 3392 delegate->Reset(); 3393 3394 // Second tap 3395 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(101, 203), 3396 kTouchId, tes.LeapForward(200)); 3397 DispatchEventUsingWindowDispatcher(&press2); 3398 ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(102, 206), 3399 kTouchId, tes.LeapForward(50)); 3400 DispatchEventUsingWindowDispatcher(&release2); 3401 3402 EXPECT_TRUE(delegate->tap()); 3403 EXPECT_TRUE(delegate->tap_down()); 3404 EXPECT_FALSE(delegate->tap_cancel()); 3405 EXPECT_TRUE(delegate->begin()); 3406 EXPECT_TRUE(delegate->end()); 3407 EXPECT_FALSE(delegate->scroll_begin()); 3408 EXPECT_FALSE(delegate->scroll_update()); 3409 EXPECT_FALSE(delegate->scroll_end()); 3410 3411 EXPECT_EQ(2, delegate->tap_count()); 3412 } 3413 3414 // Check that appropriate touch events generate triple tap gesture events. 3415 TEST_P(GestureRecognizerTest, GestureEventTripleTap) { 3416 scoped_ptr<GestureEventConsumeDelegate> delegate( 3417 new GestureEventConsumeDelegate()); 3418 const int kWindowWidth = 123; 3419 const int kWindowHeight = 45; 3420 const int kTouchId = 2; 3421 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3422 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3423 delegate.get(), -1234, bounds, root_window())); 3424 TimedEvents tes; 3425 3426 // First tap (tested in GestureEventTap) 3427 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(104, 201), 3428 kTouchId, tes.Now()); 3429 DispatchEventUsingWindowDispatcher(&press1); 3430 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(104, 201), 3431 kTouchId, tes.LeapForward(50)); 3432 DispatchEventUsingWindowDispatcher(&release1); 3433 3434 EXPECT_EQ(1, delegate->tap_count()); 3435 delegate->Reset(); 3436 3437 // Second tap (tested in GestureEventDoubleTap) 3438 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(101, 203), 3439 kTouchId, tes.LeapForward(200)); 3440 DispatchEventUsingWindowDispatcher(&press2); 3441 ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(102, 206), 3442 kTouchId, tes.LeapForward(50)); 3443 DispatchEventUsingWindowDispatcher(&release2); 3444 3445 EXPECT_EQ(2, delegate->tap_count()); 3446 delegate->Reset(); 3447 3448 // Third tap 3449 ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::Point(102, 206), 3450 kTouchId, tes.LeapForward(200)); 3451 DispatchEventUsingWindowDispatcher(&press3); 3452 ui::TouchEvent release3(ui::ET_TOUCH_RELEASED, gfx::Point(102, 206), 3453 kTouchId, tes.LeapForward(50)); 3454 DispatchEventUsingWindowDispatcher(&release3); 3455 3456 // Third, Fourth and Fifth Taps. Taps after the third should have their 3457 // |tap_count| wrap around back to 1. 3458 for (int i = 3; i < 5; ++i) { 3459 ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, 3460 gfx::Point(102, 206), 3461 kTouchId, 3462 tes.LeapForward(200)); 3463 DispatchEventUsingWindowDispatcher(&press3); 3464 ui::TouchEvent release3(ui::ET_TOUCH_RELEASED, 3465 gfx::Point(102, 206), 3466 kTouchId, 3467 tes.LeapForward(50)); 3468 DispatchEventUsingWindowDispatcher(&release3); 3469 3470 EXPECT_TRUE(delegate->tap()); 3471 EXPECT_TRUE(delegate->tap_down()); 3472 EXPECT_FALSE(delegate->tap_cancel()); 3473 EXPECT_TRUE(delegate->begin()); 3474 EXPECT_TRUE(delegate->end()); 3475 EXPECT_FALSE(delegate->scroll_begin()); 3476 EXPECT_FALSE(delegate->scroll_update()); 3477 EXPECT_FALSE(delegate->scroll_end()); 3478 3479 // The behavior for the Aura GR is incorrect. 3480 if (UsingUnifiedGR()) 3481 EXPECT_EQ(1 + (i % 3), delegate->tap_count()); 3482 else 3483 EXPECT_EQ(3, delegate->tap_count()); 3484 } 3485 } 3486 3487 // Check that we don't get a double tap when the two taps are far apart. 3488 TEST_P(GestureRecognizerTest, TwoTapsFarApart) { 3489 scoped_ptr<GestureEventConsumeDelegate> delegate( 3490 new GestureEventConsumeDelegate()); 3491 const int kWindowWidth = 123; 3492 const int kWindowHeight = 45; 3493 const int kTouchId = 2; 3494 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3495 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3496 delegate.get(), -1234, bounds, root_window())); 3497 TimedEvents tes; 3498 3499 // First tap (tested in GestureEventTap) 3500 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3501 kTouchId, tes.Now()); 3502 DispatchEventUsingWindowDispatcher(&press1); 3503 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 3504 kTouchId, tes.LeapForward(50)); 3505 DispatchEventUsingWindowDispatcher(&release1); 3506 delegate->Reset(); 3507 3508 // Second tap, close in time but far in distance 3509 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(201, 201), 3510 kTouchId, tes.LeapForward(200)); 3511 DispatchEventUsingWindowDispatcher(&press2); 3512 ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(201, 201), 3513 kTouchId, tes.LeapForward(50)); 3514 DispatchEventUsingWindowDispatcher(&release2); 3515 3516 EXPECT_TRUE(delegate->tap()); 3517 EXPECT_TRUE(delegate->tap_down()); 3518 EXPECT_FALSE(delegate->tap_cancel()); 3519 EXPECT_TRUE(delegate->begin()); 3520 EXPECT_TRUE(delegate->end()); 3521 EXPECT_FALSE(delegate->scroll_begin()); 3522 EXPECT_FALSE(delegate->scroll_update()); 3523 EXPECT_FALSE(delegate->scroll_end()); 3524 3525 EXPECT_EQ(1, delegate->tap_count()); 3526 } 3527 3528 // Check that we don't get a double tap when the two taps have a long enough 3529 // delay in between. 3530 TEST_P(GestureRecognizerTest, TwoTapsWithDelayBetween) { 3531 scoped_ptr<GestureEventConsumeDelegate> delegate( 3532 new GestureEventConsumeDelegate()); 3533 const int kWindowWidth = 123; 3534 const int kWindowHeight = 45; 3535 const int kTouchId = 2; 3536 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3537 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3538 delegate.get(), -1234, bounds, root_window())); 3539 TimedEvents tes; 3540 3541 // First tap (tested in GestureEventTap) 3542 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3543 kTouchId, tes.Now()); 3544 DispatchEventUsingWindowDispatcher(&press1); 3545 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 3546 kTouchId, tes.LeapForward(50)); 3547 DispatchEventUsingWindowDispatcher(&release1); 3548 delegate->Reset(); 3549 3550 // Second tap, close in distance but after some delay 3551 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3552 kTouchId, tes.LeapForward(2000)); 3553 DispatchEventUsingWindowDispatcher(&press2); 3554 ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 3555 kTouchId, tes.LeapForward(50)); 3556 DispatchEventUsingWindowDispatcher(&release2); 3557 3558 EXPECT_TRUE(delegate->tap()); 3559 EXPECT_TRUE(delegate->tap_down()); 3560 EXPECT_FALSE(delegate->tap_cancel()); 3561 EXPECT_TRUE(delegate->begin()); 3562 EXPECT_TRUE(delegate->end()); 3563 EXPECT_FALSE(delegate->scroll_begin()); 3564 EXPECT_FALSE(delegate->scroll_update()); 3565 EXPECT_FALSE(delegate->scroll_end()); 3566 3567 EXPECT_EQ(1, delegate->tap_count()); 3568 } 3569 3570 // Checks that if the bounding-box of a gesture changes because of change in 3571 // radius of a touch-point, and not because of change in position, then there 3572 // are not gesture events from that. 3573 TEST_P(GestureRecognizerTest, BoundingBoxRadiusChange) { 3574 // TODO(tdresser): enable this test with unified GR when (if?) bounding box 3575 // behavior is unified. 3576 if (UsingUnifiedGR()) 3577 return; 3578 3579 scoped_ptr<GestureEventConsumeDelegate> delegate( 3580 new GestureEventConsumeDelegate()); 3581 const int kWindowWidth = 234; 3582 const int kWindowHeight = 345; 3583 const int kTouchId = 5, kTouchId2 = 7; 3584 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3585 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3586 delegate.get(), -1234, bounds, root_window())); 3587 TimedEvents tes; 3588 3589 ui::TouchEvent press1( 3590 ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId, tes.Now()); 3591 DispatchEventUsingWindowDispatcher(&press1); 3592 EXPECT_TRUE(delegate->bounding_box().IsEmpty()); 3593 3594 delegate->Reset(); 3595 3596 ui::TouchEvent press2( 3597 ui::ET_TOUCH_PRESSED, gfx::Point(201, 201), kTouchId2, 3598 tes.LeapForward(400)); 3599 press2.set_radius_x(5); 3600 DispatchEventUsingWindowDispatcher(&press2); 3601 EXPECT_FALSE(delegate->pinch_begin()); 3602 EXPECT_EQ(gfx::Rect(101, 201, 100, 0).ToString(), 3603 delegate->bounding_box().ToString()); 3604 3605 delegate->Reset(); 3606 3607 ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(141, 201), kTouchId, 3608 tes.LeapForward(40)); 3609 DispatchEventUsingWindowDispatcher(&move1); 3610 EXPECT_TRUE(delegate->pinch_begin()); 3611 EXPECT_EQ(gfx::Rect(141, 201, 60, 0).ToString(), 3612 delegate->bounding_box().ToString()); 3613 3614 delegate->Reset(); 3615 3616 // The position doesn't move, but the radius changes. 3617 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(101, 201), kTouchId, 3618 tes.LeapForward(40)); 3619 move2.set_radius_x(50); 3620 move2.set_radius_y(60); 3621 DispatchEventUsingWindowDispatcher(&move2); 3622 EXPECT_FALSE(delegate->tap()); 3623 EXPECT_FALSE(delegate->tap_cancel()); 3624 EXPECT_FALSE(delegate->scroll_update()); 3625 EXPECT_FALSE(delegate->pinch_update()); 3626 3627 delegate->Reset(); 3628 } 3629 3630 // Checks that slow scrolls deliver the correct deltas. 3631 // In particular, fix for http;//crbug.com/150573. 3632 TEST_P(GestureRecognizerTest, NoDriftInScroll) { 3633 ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(3); 3634 ui::GestureConfiguration::set_min_scroll_delta_squared(9); 3635 scoped_ptr<GestureEventConsumeDelegate> delegate( 3636 new GestureEventConsumeDelegate()); 3637 const int kWindowWidth = 234; 3638 const int kWindowHeight = 345; 3639 const int kTouchId = 5; 3640 TimedEvents tes; 3641 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3642 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3643 delegate.get(), -1234, bounds, root_window())); 3644 3645 ui::TouchEvent press1( 3646 ui::ET_TOUCH_PRESSED, gfx::Point(101, 208), kTouchId, tes.Now()); 3647 DispatchEventUsingWindowDispatcher(&press1); 3648 EXPECT_TRUE(delegate->begin()); 3649 3650 delegate->Reset(); 3651 3652 ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(101, 206), kTouchId, 3653 tes.LeapForward(40)); 3654 DispatchEventUsingWindowDispatcher(&move1); 3655 EXPECT_FALSE(delegate->scroll_begin()); 3656 3657 delegate->Reset(); 3658 3659 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(101, 204), kTouchId, 3660 tes.LeapForward(40)); 3661 DispatchEventUsingWindowDispatcher(&move2); 3662 EXPECT_TRUE(delegate->tap_cancel()); 3663 EXPECT_TRUE(delegate->scroll_begin()); 3664 EXPECT_TRUE(delegate->scroll_update()); 3665 // 3 px consumed by touch slop region. 3666 EXPECT_EQ(-1, delegate->scroll_y()); 3667 EXPECT_EQ(-4, delegate->scroll_y_hint()); 3668 3669 delegate->Reset(); 3670 3671 ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(101, 204), kTouchId, 3672 tes.LeapForward(40)); 3673 DispatchEventUsingWindowDispatcher(&move3); 3674 EXPECT_FALSE(delegate->scroll_update()); 3675 3676 delegate->Reset(); 3677 3678 ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(101, 203), kTouchId, 3679 tes.LeapForward(40)); 3680 DispatchEventUsingWindowDispatcher(&move4); 3681 EXPECT_TRUE(delegate->scroll_update()); 3682 EXPECT_EQ(-1, delegate->scroll_y()); 3683 3684 delegate->Reset(); 3685 } 3686 3687 // Ensure that move events which are preventDefaulted will cause a tap 3688 // cancel gesture event to be fired if the move would normally cause a 3689 // scroll. See bug http://crbug.com/146397. 3690 TEST_P(GestureRecognizerTest, GestureEventConsumedTouchMoveCanFireTapCancel) { 3691 scoped_ptr<ConsumesTouchMovesDelegate> delegate( 3692 new ConsumesTouchMovesDelegate()); 3693 const int kTouchId = 5; 3694 gfx::Rect bounds(100, 200, 123, 45); 3695 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3696 delegate.get(), -1234, bounds, root_window())); 3697 TimedEvents tes; 3698 3699 delegate->Reset(); 3700 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3701 kTouchId, tes.Now()); 3702 3703 delegate->set_consume_touch_move(false); 3704 DispatchEventUsingWindowDispatcher(&press); 3705 delegate->set_consume_touch_move(true); 3706 delegate->Reset(); 3707 // Move the touch-point enough so that it would normally be considered a 3708 // scroll. But since the touch-moves will be consumed, the scroll should not 3709 // start. 3710 tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get()); 3711 EXPECT_FALSE(delegate->tap()); 3712 EXPECT_FALSE(delegate->tap_down()); 3713 EXPECT_TRUE(delegate->tap_cancel()); 3714 EXPECT_FALSE(delegate->begin()); 3715 EXPECT_FALSE(delegate->scroll_begin()); 3716 EXPECT_FALSE(delegate->scroll_update()); 3717 EXPECT_FALSE(delegate->scroll_end()); 3718 } 3719 3720 TEST_P(GestureRecognizerTest, 3721 TransferEventDispatchesTouchCancel) { 3722 scoped_ptr<GestureEventConsumeDelegate> delegate( 3723 new GestureEventConsumeDelegate()); 3724 TimedEvents tes; 3725 const int kWindowWidth = 800; 3726 const int kWindowHeight = 600; 3727 const int kTouchId = 2; 3728 gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight); 3729 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3730 delegate.get(), -1234, bounds, root_window())); 3731 scoped_ptr<RemoveOnTouchCancelHandler> 3732 handler(new RemoveOnTouchCancelHandler()); 3733 window->AddPreTargetHandler(handler.get()); 3734 3735 // Start a gesture sequence on |window|. Then transfer the events to NULL. 3736 // Make sure |window| receives a touch-cancel event. 3737 delegate->Reset(); 3738 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3739 kTouchId, tes.Now()); 3740 ui::TouchEvent p2(ui::ET_TOUCH_PRESSED, gfx::Point(50, 50), 1, tes.Now()); 3741 DispatchEventUsingWindowDispatcher(&press); 3742 DispatchEventUsingWindowDispatcher(&p2); 3743 EXPECT_FALSE(delegate->tap()); 3744 EXPECT_TRUE(delegate->tap_down()); 3745 EXPECT_TRUE(delegate->tap_cancel()); 3746 EXPECT_TRUE(delegate->begin()); 3747 EXPECT_EQ(2, handler->touch_pressed_count()); 3748 delegate->Reset(); 3749 handler->Reset(); 3750 3751 ui::GestureRecognizer* gesture_recognizer = ui::GestureRecognizer::Get(); 3752 EXPECT_EQ(window.get(), 3753 gesture_recognizer->GetTouchLockedTarget(press)); 3754 gesture_recognizer->TransferEventsTo(window.get(), NULL); 3755 EXPECT_EQ(NULL, 3756 gesture_recognizer->GetTouchLockedTarget(press)); 3757 // The event-handler removes |window| from its parent on the first 3758 // touch-cancel event, so it won't receive the second touch-cancel event. 3759 EXPECT_EQ(1, handler->touch_cancelled_count()); 3760 } 3761 3762 // Check that appropriate touch events generate show press events 3763 TEST_P(GestureRecognizerTest, GestureEventShowPress) { 3764 scoped_ptr<GestureEventConsumeDelegate> delegate( 3765 new GestureEventConsumeDelegate()); 3766 TimedEvents tes; 3767 const int kWindowWidth = 123; 3768 const int kWindowHeight = 45; 3769 const int kTouchId = 2; 3770 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3771 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3772 delegate.get(), -1234, bounds, root_window())); 3773 3774 delegate->Reset(); 3775 3776 TimerTestGestureRecognizer* gesture_recognizer = 3777 new TimerTestGestureRecognizer(); 3778 3779 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 3780 3781 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3782 kTouchId, tes.Now()); 3783 DispatchEventUsingWindowDispatcher(&press1); 3784 EXPECT_TRUE(delegate->tap_down()); 3785 EXPECT_TRUE(delegate->begin()); 3786 EXPECT_FALSE(delegate->tap_cancel()); 3787 3788 // We haven't pressed long enough for a show press to occur 3789 EXPECT_FALSE(delegate->show_press()); 3790 3791 // Wait until the timer runs out 3792 delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_SHOW_PRESS); 3793 EXPECT_TRUE(delegate->show_press()); 3794 EXPECT_FALSE(delegate->tap_cancel()); 3795 3796 delegate->Reset(); 3797 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 3798 kTouchId, tes.Now()); 3799 DispatchEventUsingWindowDispatcher(&release1); 3800 EXPECT_FALSE(delegate->long_press()); 3801 3802 // Note the tap isn't dispatched until the release 3803 EXPECT_FALSE(delegate->tap_cancel()); 3804 EXPECT_TRUE(delegate->tap()); 3805 } 3806 3807 // Check that scrolling cancels a show press 3808 TEST_P(GestureRecognizerTest, GestureEventShowPressCancelledByScroll) { 3809 scoped_ptr<GestureEventConsumeDelegate> delegate( 3810 new GestureEventConsumeDelegate()); 3811 TimedEvents tes; 3812 const int kWindowWidth = 123; 3813 const int kWindowHeight = 45; 3814 const int kTouchId = 6; 3815 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3816 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3817 delegate.get(), -1234, bounds, root_window())); 3818 3819 delegate->Reset(); 3820 3821 TimerTestGestureRecognizer* gesture_recognizer = 3822 new TimerTestGestureRecognizer(); 3823 3824 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 3825 3826 TimerTestGestureSequence* gesture_sequence = 3827 static_cast<TimerTestGestureSequence*>( 3828 gesture_recognizer->GetGestureSequenceForTesting(window.get())); 3829 3830 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3831 kTouchId, tes.Now()); 3832 DispatchEventUsingWindowDispatcher(&press1); 3833 EXPECT_TRUE(delegate->tap_down()); 3834 3835 // We haven't pressed long enough for a show press to occur 3836 EXPECT_FALSE(delegate->show_press()); 3837 EXPECT_FALSE(delegate->tap_cancel()); 3838 3839 // Scroll around, to cancel the show press 3840 tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get()); 3841 // Wait until the timer runs out 3842 gesture_sequence->ForceTimeout(); 3843 EXPECT_FALSE(delegate->show_press()); 3844 EXPECT_TRUE(delegate->tap_cancel()); 3845 3846 delegate->Reset(); 3847 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 3848 kTouchId, tes.LeapForward(10)); 3849 DispatchEventUsingWindowDispatcher(&release1); 3850 EXPECT_FALSE(delegate->show_press()); 3851 EXPECT_FALSE(delegate->tap_cancel()); 3852 } 3853 3854 // Test that show press events are sent immediately on tap 3855 TEST_P(GestureRecognizerTest, GestureEventShowPressSentOnTap) { 3856 scoped_ptr<GestureEventConsumeDelegate> delegate( 3857 new GestureEventConsumeDelegate()); 3858 TimedEvents tes; 3859 const int kWindowWidth = 123; 3860 const int kWindowHeight = 45; 3861 const int kTouchId = 6; 3862 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 3863 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3864 delegate.get(), -1234, bounds, root_window())); 3865 3866 delegate->Reset(); 3867 3868 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 3869 kTouchId, tes.Now()); 3870 DispatchEventUsingWindowDispatcher(&press1); 3871 EXPECT_TRUE(delegate->tap_down()); 3872 3873 // We haven't pressed long enough for a show press to occur 3874 EXPECT_FALSE(delegate->show_press()); 3875 EXPECT_FALSE(delegate->tap_cancel()); 3876 3877 delegate->Reset(); 3878 ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 3879 kTouchId, tes.LeapForward(50)); 3880 DispatchEventUsingWindowDispatcher(&release1); 3881 EXPECT_TRUE(delegate->show_press()); 3882 EXPECT_FALSE(delegate->tap_cancel()); 3883 EXPECT_TRUE(delegate->tap()); 3884 } 3885 3886 // Test that consuming the first move touch event prevents a scroll. 3887 TEST_P(GestureRecognizerTest, GestureEventConsumedTouchMoveScrollTest) { 3888 scoped_ptr<QueueTouchEventDelegate> delegate( 3889 new QueueTouchEventDelegate(host()->dispatcher())); 3890 TimedEvents tes; 3891 const int kTouchId = 7; 3892 gfx::Rect bounds(0, 0, 1000, 1000); 3893 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3894 delegate.get(), -1234, bounds, root_window())); 3895 3896 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 3897 kTouchId, tes.Now()); 3898 DispatchEventUsingWindowDispatcher(&press); 3899 delegate->ReceivedAck(); 3900 3901 // A touch move within the slop region is never consumed in web contents. The 3902 // unified GR won't prevent scroll if a touch move within the slop region is 3903 // consumed, so make sure this touch move exceeds the slop region. 3904 ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(10, 10), 3905 kTouchId, tes.Now()); 3906 DispatchEventUsingWindowDispatcher(&move1); 3907 delegate->ReceivedAckPreventDefaulted(); 3908 3909 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(20, 20), 3910 kTouchId, tes.Now()); 3911 DispatchEventUsingWindowDispatcher(&move2); 3912 delegate->ReceivedAck(); 3913 3914 EXPECT_FALSE(delegate->scroll_begin()); 3915 EXPECT_FALSE(delegate->scroll_update()); 3916 } 3917 3918 // Test that consuming the first touch move event of a touch point doesn't 3919 // prevent pinching once an additional touch has been pressed. 3920 TEST_P(GestureRecognizerTest, GestureEventConsumedTouchMovePinchTest) { 3921 // Consuming moves within the touch slop and the the disposition handling of 3922 // pinch events behave differently between the Unified GR and the Aura GR. 3923 if (UsingUnifiedGR()) 3924 return; 3925 3926 scoped_ptr<QueueTouchEventDelegate> delegate( 3927 new QueueTouchEventDelegate(host()->dispatcher())); 3928 TimedEvents tes; 3929 const int kTouchId1 = 7; 3930 const int kTouchId2 = 4; 3931 gfx::Rect bounds(0, 0, 1000, 1000); 3932 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3933 delegate.get(), -1234, bounds, root_window())); 3934 3935 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 3936 kTouchId1, tes.Now()); 3937 DispatchEventUsingWindowDispatcher(&press1); 3938 delegate->ReceivedAck(); 3939 3940 ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(2, 2), 3941 kTouchId1, tes.Now()); 3942 DispatchEventUsingWindowDispatcher(&move1); 3943 delegate->ReceivedAckPreventDefaulted(); 3944 3945 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(20, 20), 3946 kTouchId1, tes.Now()); 3947 DispatchEventUsingWindowDispatcher(&move2); 3948 delegate->ReceivedAck(); 3949 3950 // We can't scroll, because a move has been consumed. 3951 EXPECT_FALSE(delegate->scroll_begin()); 3952 EXPECT_FALSE(delegate->scroll_update()); 3953 EXPECT_FALSE(delegate->pinch_begin()); 3954 3955 // An additional press will allow us to pinch. 3956 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 3957 kTouchId2, tes.Now()); 3958 DispatchEventUsingWindowDispatcher(&press2); 3959 delegate->ReceivedAck(); 3960 3961 ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(20, 20), 3962 kTouchId2, tes.Now()); 3963 DispatchEventUsingWindowDispatcher(&move3); 3964 delegate->ReceivedAck(); 3965 3966 EXPECT_TRUE(delegate->pinch_begin()); 3967 EXPECT_FALSE(delegate->pinch_update()); 3968 3969 delegate->Reset(); 3970 3971 ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(40, 40), 3972 kTouchId2, tes.Now()); 3973 DispatchEventUsingWindowDispatcher(&move4); 3974 delegate->ReceivedAck(); 3975 3976 EXPECT_TRUE(delegate->pinch_update()); 3977 EXPECT_EQ(10, delegate->scroll_x()); 3978 EXPECT_EQ(10, delegate->scroll_y()); 3979 } 3980 3981 // Test that consuming the first move touch doesn't prevent a tap. 3982 TEST_P(GestureRecognizerTest, GestureEventConsumedTouchMoveTapTest) { 3983 scoped_ptr<QueueTouchEventDelegate> delegate( 3984 new QueueTouchEventDelegate(host()->dispatcher())); 3985 TimedEvents tes; 3986 const int kTouchId = 7; 3987 gfx::Rect bounds(0, 0, 1000, 1000); 3988 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 3989 delegate.get(), -1234, bounds, root_window())); 3990 3991 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 3992 kTouchId, tes.Now()); 3993 DispatchEventUsingWindowDispatcher(&press); 3994 delegate->ReceivedAck(); 3995 3996 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(2, 2), 3997 kTouchId, tes.Now()); 3998 DispatchEventUsingWindowDispatcher(&move); 3999 delegate->ReceivedAckPreventDefaulted(); 4000 4001 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(2, 2), 4002 kTouchId, tes.LeapForward(50)); 4003 DispatchEventUsingWindowDispatcher(&release); 4004 delegate->ReceivedAck(); 4005 4006 EXPECT_TRUE(delegate->tap()); 4007 } 4008 4009 // Test that consuming the first move touch doesn't prevent a long press. 4010 TEST_P(GestureRecognizerTest, GestureEventConsumedTouchMoveLongPressTest) { 4011 scoped_ptr<QueueTouchEventDelegate> delegate( 4012 new QueueTouchEventDelegate(host()->dispatcher())); 4013 TimedEvents tes; 4014 const int kWindowWidth = 123; 4015 const int kWindowHeight = 45; 4016 const int kTouchId = 2; 4017 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 4018 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 4019 delegate.get(), -1234, bounds, root_window())); 4020 4021 delegate->Reset(); 4022 4023 TimerTestGestureRecognizer* gesture_recognizer = 4024 new TimerTestGestureRecognizer(); 4025 4026 ScopedGestureRecognizerSetter gr_setter(gesture_recognizer); 4027 4028 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 4029 kTouchId, tes.Now()); 4030 DispatchEventUsingWindowDispatcher(&press1); 4031 delegate->ReceivedAck(); 4032 4033 ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(103, 203), 4034 kTouchId, tes.Now()); 4035 DispatchEventUsingWindowDispatcher(&move); 4036 delegate->ReceivedAckPreventDefaulted(); 4037 4038 // Wait until the timer runs out 4039 delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_LONG_PRESS); 4040 EXPECT_TRUE(delegate->long_press()); 4041 } 4042 4043 // Tests that the deltas are correct when leaving the slop region very slowly. 4044 TEST_P(GestureRecognizerTest, TestExceedingSlopSlowly) { 4045 // Disabled for unified GR due to subtle differences in touch slop handling. 4046 if (UsingUnifiedGR()) 4047 return; 4048 4049 ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(3); 4050 scoped_ptr<GestureEventConsumeDelegate> delegate( 4051 new GestureEventConsumeDelegate()); 4052 const int kWindowWidth = 234; 4053 const int kWindowHeight = 345; 4054 const int kTouchId = 5; 4055 TimedEvents tes; 4056 gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight); 4057 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 4058 delegate.get(), -1234, bounds, root_window())); 4059 4060 ui::TouchEvent press( 4061 ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), kTouchId, tes.Now()); 4062 DispatchEventUsingWindowDispatcher(&press); 4063 EXPECT_FALSE(delegate->scroll_begin()); 4064 EXPECT_FALSE(delegate->scroll_update()); 4065 delegate->Reset(); 4066 4067 ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(11, 10), kTouchId, 4068 tes.LeapForward(40)); 4069 DispatchEventUsingWindowDispatcher(&move1); 4070 EXPECT_FALSE(delegate->scroll_begin()); 4071 EXPECT_FALSE(delegate->scroll_update()); 4072 EXPECT_EQ(0, delegate->scroll_x()); 4073 EXPECT_EQ(0, delegate->scroll_x_hint()); 4074 delegate->Reset(); 4075 4076 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(12, 10), kTouchId, 4077 tes.LeapForward(40)); 4078 DispatchEventUsingWindowDispatcher(&move2); 4079 EXPECT_FALSE(delegate->scroll_begin()); 4080 EXPECT_FALSE(delegate->scroll_update()); 4081 EXPECT_EQ(0, delegate->scroll_x()); 4082 EXPECT_EQ(0, delegate->scroll_x_hint()); 4083 delegate->Reset(); 4084 4085 4086 ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(13, 10), kTouchId, 4087 tes.LeapForward(40)); 4088 DispatchEventUsingWindowDispatcher(&move3); 4089 EXPECT_TRUE(delegate->scroll_begin()); 4090 EXPECT_FALSE(delegate->scroll_update()); 4091 EXPECT_EQ(0, delegate->scroll_x()); 4092 EXPECT_EQ(3, delegate->scroll_x_hint()); 4093 delegate->Reset(); 4094 4095 4096 ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(14, 10), kTouchId, 4097 tes.LeapForward(40)); 4098 DispatchEventUsingWindowDispatcher(&move4); 4099 EXPECT_FALSE(delegate->scroll_begin()); 4100 EXPECT_TRUE(delegate->scroll_update()); 4101 EXPECT_EQ(1, delegate->scroll_x()); 4102 EXPECT_EQ(0, delegate->scroll_x_hint()); 4103 delegate->Reset(); 4104 } 4105 4106 TEST_P(GestureRecognizerTest, ScrollAlternatelyConsumedTest) { 4107 scoped_ptr<QueueTouchEventDelegate> delegate( 4108 new QueueTouchEventDelegate(host()->dispatcher())); 4109 TimedEvents tes; 4110 const int kWindowWidth = 3000; 4111 const int kWindowHeight = 3000; 4112 const int kTouchId = 2; 4113 gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight); 4114 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 4115 delegate.get(), -1234, bounds, root_window())); 4116 4117 delegate->Reset(); 4118 4119 int x = 0; 4120 int y = 0; 4121 4122 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(x, y), 4123 kTouchId, tes.Now()); 4124 DispatchEventUsingWindowDispatcher(&press1); 4125 delegate->ReceivedAck(); 4126 EXPECT_FALSE(delegate->scroll_begin()); 4127 EXPECT_FALSE(delegate->scroll_update()); 4128 delegate->Reset(); 4129 4130 x += 100; 4131 y += 100; 4132 ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(x, y), 4133 kTouchId, tes.Now()); 4134 DispatchEventUsingWindowDispatcher(&move1); 4135 delegate->ReceivedAck(); 4136 EXPECT_TRUE(delegate->scroll_begin()); 4137 EXPECT_TRUE(delegate->scroll_update()); 4138 delegate->Reset(); 4139 4140 for (int i = 0; i < 3; ++i) { 4141 x += 10; 4142 y += 10; 4143 ui::TouchEvent move2( 4144 ui::ET_TOUCH_MOVED, gfx::Point(x, y), kTouchId, tes.Now()); 4145 DispatchEventUsingWindowDispatcher(&move2); 4146 delegate->ReceivedAck(); 4147 EXPECT_FALSE(delegate->scroll_begin()); 4148 EXPECT_TRUE(delegate->scroll_update()); 4149 EXPECT_EQ(10, delegate->scroll_x()); 4150 EXPECT_EQ(10, delegate->scroll_y()); 4151 delegate->Reset(); 4152 4153 x += 20; 4154 y += 20; 4155 ui::TouchEvent move3( 4156 ui::ET_TOUCH_MOVED, gfx::Point(x, y), kTouchId, tes.Now()); 4157 DispatchEventUsingWindowDispatcher(&move3); 4158 delegate->ReceivedAckPreventDefaulted(); 4159 EXPECT_FALSE(delegate->scroll_begin()); 4160 EXPECT_FALSE(delegate->scroll_update()); 4161 delegate->Reset(); 4162 } 4163 } 4164 4165 TEST_P(GestureRecognizerTest, PinchAlternatelyConsumedTest) { 4166 // Disabled for unified GR due to differences in when scroll update is 4167 // sent. The Aura GR will never send a ScrollUpdate with a ScrollBegin, but 4168 // the unified GR will. 4169 if (UsingUnifiedGR()) 4170 return; 4171 4172 scoped_ptr<QueueTouchEventDelegate> delegate( 4173 new QueueTouchEventDelegate(host()->dispatcher())); 4174 TimedEvents tes; 4175 const int kWindowWidth = 3000; 4176 const int kWindowHeight = 3000; 4177 const int kTouchId1 = 5; 4178 const int kTouchId2 = 7; 4179 gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight); 4180 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 4181 delegate.get(), -1234, bounds, root_window())); 4182 4183 delegate->Reset(); 4184 4185 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 4186 kTouchId1, tes.Now()); 4187 DispatchEventUsingWindowDispatcher(&press1); 4188 delegate->ReceivedAck(); 4189 EXPECT_FALSE(delegate->scroll_begin()); 4190 EXPECT_FALSE(delegate->scroll_update()); 4191 delegate->Reset(); 4192 4193 int x = 0; 4194 int y = 0; 4195 4196 ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(x, y), 4197 kTouchId2, tes.Now()); 4198 DispatchEventUsingWindowDispatcher(&press2); 4199 delegate->ReceivedAck(); 4200 EXPECT_FALSE(delegate->scroll_begin()); 4201 EXPECT_FALSE(delegate->scroll_update()); 4202 EXPECT_FALSE(delegate->pinch_begin()); 4203 EXPECT_FALSE(delegate->pinch_update()); 4204 4205 delegate->Reset(); 4206 4207 x += 100; 4208 y += 100; 4209 ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(x, y), 4210 kTouchId2, tes.Now()); 4211 DispatchEventUsingWindowDispatcher(&move1); 4212 delegate->ReceivedAck(); 4213 EXPECT_TRUE(delegate->scroll_begin()); 4214 EXPECT_FALSE(delegate->scroll_update()); 4215 EXPECT_TRUE(delegate->pinch_begin()); 4216 EXPECT_FALSE(delegate->pinch_update()); 4217 delegate->Reset(); 4218 4219 const float expected_scales[] = {1.5f, 1.2f, 1.125f}; 4220 4221 for (int i = 0; i < 3; ++i) { 4222 x += 50; 4223 y += 50; 4224 ui::TouchEvent move2( 4225 ui::ET_TOUCH_MOVED, gfx::Point(x, y), kTouchId2, tes.Now()); 4226 DispatchEventUsingWindowDispatcher(&move2); 4227 delegate->ReceivedAck(); 4228 EXPECT_FALSE(delegate->scroll_begin()); 4229 EXPECT_TRUE(delegate->scroll_update()); 4230 EXPECT_FALSE(delegate->scroll_end()); 4231 EXPECT_FALSE(delegate->pinch_begin()); 4232 EXPECT_TRUE(delegate->pinch_update()); 4233 EXPECT_FALSE(delegate->pinch_end()); 4234 EXPECT_EQ(25, delegate->scroll_x()); 4235 EXPECT_EQ(25, delegate->scroll_y()); 4236 EXPECT_FLOAT_EQ(expected_scales[i], delegate->scale()); 4237 delegate->Reset(); 4238 4239 x += 100; 4240 y += 100; 4241 ui::TouchEvent move3( 4242 ui::ET_TOUCH_MOVED, gfx::Point(x, y), kTouchId2, tes.Now()); 4243 DispatchEventUsingWindowDispatcher(&move3); 4244 delegate->ReceivedAckPreventDefaulted(); 4245 EXPECT_FALSE(delegate->scroll_begin()); 4246 EXPECT_FALSE(delegate->scroll_update()); 4247 EXPECT_FALSE(delegate->scroll_end()); 4248 EXPECT_FALSE(delegate->pinch_begin()); 4249 EXPECT_FALSE(delegate->pinch_update()); 4250 EXPECT_FALSE(delegate->pinch_end()); 4251 delegate->Reset(); 4252 } 4253 } 4254 4255 // Test that touch event flags are passed through to the gesture event. 4256 TEST_P(GestureRecognizerTest, GestureEventFlagsPassedFromTouchEvent) { 4257 scoped_ptr<GestureEventConsumeDelegate> delegate( 4258 new GestureEventConsumeDelegate()); 4259 TimedEvents tes; 4260 const int kWindowWidth = 123; 4261 const int kWindowHeight = 45; 4262 const int kTouchId = 6; 4263 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 4264 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 4265 delegate.get(), -1234, bounds, root_window())); 4266 4267 delegate->Reset(); 4268 4269 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 4270 kTouchId, tes.Now()); 4271 DispatchEventUsingWindowDispatcher(&press1); 4272 EXPECT_TRUE(delegate->tap_down()); 4273 4274 int default_flags = delegate->flags(); 4275 4276 ui::TouchEvent move1( 4277 ui::ET_TOUCH_MOVED, gfx::Point(397, 149), kTouchId, tes.LeapForward(50)); 4278 move1.set_flags(992); 4279 4280 DispatchEventUsingWindowDispatcher(&move1); 4281 EXPECT_NE(default_flags, delegate->flags()); 4282 } 4283 4284 // Test that latency info is passed through to the gesture event. 4285 TEST_P(GestureRecognizerTest, LatencyPassedFromTouchEvent) { 4286 scoped_ptr<GestureEventConsumeDelegate> delegate( 4287 new GestureEventConsumeDelegate()); 4288 TimedEvents tes; 4289 const int kWindowWidth = 123; 4290 const int kWindowHeight = 45; 4291 const int kTouchId = 6; 4292 4293 const base::TimeTicks time_original = base::TimeTicks::FromInternalValue(100); 4294 const base::TimeTicks time_ui = base::TimeTicks::FromInternalValue(200); 4295 const base::TimeTicks time_acked = base::TimeTicks::FromInternalValue(300); 4296 4297 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 4298 scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate( 4299 delegate.get(), -1234, bounds, root_window())); 4300 4301 delegate->Reset(); 4302 4303 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 4304 kTouchId, tes.Now()); 4305 4306 // Ensure the only components around are the ones we add. 4307 press1.latency()->Clear(); 4308 4309 press1.latency()->AddLatencyNumberWithTimestamp( 4310 ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, 0, time_original, 1); 4311 4312 press1.latency()->AddLatencyNumberWithTimestamp( 4313 ui::INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0, time_ui, 1); 4314 4315 press1.latency()->AddLatencyNumberWithTimestamp( 4316 ui::INPUT_EVENT_LATENCY_ACKED_TOUCH_COMPONENT, 0, 0, time_acked, 1); 4317 4318 DispatchEventUsingWindowDispatcher(&press1); 4319 EXPECT_TRUE(delegate->tap_down()); 4320 4321 ui::LatencyInfo::LatencyComponent component; 4322 4323 EXPECT_EQ(3U, delegate->latency_info().latency_components.size()); 4324 ASSERT_TRUE(delegate->latency_info().FindLatency( 4325 ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, &component)); 4326 EXPECT_EQ(time_original, component.event_time); 4327 4328 ASSERT_TRUE(delegate->latency_info().FindLatency( 4329 ui::INPUT_EVENT_LATENCY_UI_COMPONENT, 0, &component)); 4330 EXPECT_EQ(time_ui, component.event_time); 4331 4332 ASSERT_TRUE(delegate->latency_info().FindLatency( 4333 ui::INPUT_EVENT_LATENCY_ACKED_TOUCH_COMPONENT, 0, &component)); 4334 EXPECT_EQ(time_acked, component.event_time); 4335 4336 delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_SHOW_PRESS); 4337 EXPECT_TRUE(delegate->show_press()); 4338 EXPECT_EQ(0U, delegate->latency_info().latency_components.size()); 4339 } 4340 4341 // A delegate that deletes a window on long press. 4342 class GestureEventDeleteWindowOnLongPress : public GestureEventConsumeDelegate { 4343 public: 4344 GestureEventDeleteWindowOnLongPress() 4345 : window_(NULL) {} 4346 4347 void set_window(aura::Window** window) { window_ = window; } 4348 4349 virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE { 4350 GestureEventConsumeDelegate::OnGestureEvent(gesture); 4351 if (gesture->type() != ui::ET_GESTURE_LONG_PRESS) 4352 return; 4353 ui::GestureRecognizer::Get()->CleanupStateForConsumer(*window_); 4354 delete *window_; 4355 *window_ = NULL; 4356 } 4357 4358 private: 4359 aura::Window** window_; 4360 DISALLOW_COPY_AND_ASSIGN(GestureEventDeleteWindowOnLongPress); 4361 }; 4362 4363 // Check that deleting the window in response to a long press gesture doesn't 4364 // crash. 4365 TEST_P(GestureRecognizerTest, GestureEventLongPressDeletingWindow) { 4366 GestureEventDeleteWindowOnLongPress delegate; 4367 const int kWindowWidth = 123; 4368 const int kWindowHeight = 45; 4369 const int kTouchId = 2; 4370 gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight); 4371 aura::Window* window(CreateTestWindowWithDelegate( 4372 &delegate, -1234, bounds, root_window())); 4373 delegate.set_window(&window); 4374 4375 ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, 4376 gfx::Point(101, 201), 4377 kTouchId, 4378 ui::EventTimeForNow()); 4379 DispatchEventUsingWindowDispatcher(&press1); 4380 EXPECT_TRUE(window != NULL); 4381 4382 // Wait until the timer runs out. 4383 delegate.WaitUntilReceivedGesture(ui::ET_GESTURE_LONG_PRESS); 4384 EXPECT_EQ(NULL, window); 4385 } 4386 4387 INSTANTIATE_TEST_CASE_P(GestureRecognizer, 4388 GestureRecognizerTest, 4389 ::testing::Bool()); 4390 4391 } // namespace test 4392 } // namespace aura 4393
