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