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
WindowIDAsString(ui::GestureConsumer * consumer)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:
GestureEventConsumeDelegate()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
~GestureEventConsumeDelegate()102 virtual ~GestureEventConsumeDelegate() {}
103
Reset()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
events() const144 const std::vector<ui::EventType>& events() const { return events_; };
145
tap() const146 bool tap() const { return tap_; }
tap_down() const147 bool tap_down() const { return tap_down_; }
tap_cancel() const148 bool tap_cancel() const { return tap_cancel_; }
begin() const149 bool begin() const { return begin_; }
end() const150 bool end() const { return end_; }
scroll_begin() const151 bool scroll_begin() const { return scroll_begin_; }
scroll_update() const152 bool scroll_update() const { return scroll_update_; }
scroll_end() const153 bool scroll_end() const { return scroll_end_; }
pinch_begin() const154 bool pinch_begin() const { return pinch_begin_; }
pinch_update() const155 bool pinch_update() const { return pinch_update_; }
pinch_end() const156 bool pinch_end() const { return pinch_end_; }
long_press() const157 bool long_press() const { return long_press_; }
long_tap() const158 bool long_tap() const { return long_tap_; }
fling() const159 bool fling() const { return fling_; }
two_finger_tap() const160 bool two_finger_tap() const { return two_finger_tap_; }
show_press() const161 bool show_press() const { return show_press_; }
swipe_left() const162 bool swipe_left() const { return swipe_left_; }
swipe_right() const163 bool swipe_right() const { return swipe_right_; }
swipe_up() const164 bool swipe_up() const { return swipe_up_; }
swipe_down() const165 bool swipe_down() const { return swipe_down_; }
166
scroll_begin_position() const167 const gfx::Point& scroll_begin_position() const {
168 return scroll_begin_position_;
169 }
170
tap_location() const171 const gfx::Point& tap_location() const {
172 return tap_location_;
173 }
174
gesture_end_location() const175 const gfx::Point& gesture_end_location() const {
176 return gesture_end_location_;
177 }
178
scroll_x() const179 float scroll_x() const { return scroll_x_; }
scroll_y() const180 float scroll_y() const { return scroll_y_; }
scroll_velocity_x() const181 float scroll_velocity_x() const { return scroll_velocity_x_; }
scroll_velocity_y() const182 float scroll_velocity_y() const { return scroll_velocity_y_; }
velocity_x() const183 float velocity_x() const { return velocity_x_; }
velocity_y() const184 float velocity_y() const { return velocity_y_; }
scroll_x_hint() const185 float scroll_x_hint() const { return scroll_x_hint_; }
scroll_y_hint() const186 float scroll_y_hint() const { return scroll_y_hint_; }
scale() const187 float scale() const { return scale_; }
bounding_box() const188 const gfx::Rect& bounding_box() const { return bounding_box_; }
tap_count() const189 int tap_count() const { return tap_count_; }
flags() const190 int flags() const { return flags_; }
latency_info() const191 const ui::LatencyInfo& latency_info() const { return latency_info_; }
192
WaitUntilReceivedGesture(ui::EventType type)193 void WaitUntilReceivedGesture(ui::EventType type) {
194 wait_until_event_ = type;
195 run_loop_.reset(new base::RunLoop());
196 run_loop_->Run();
197 }
198
OnGestureEvent(ui::GestureEvent * gesture)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:
QueueTouchEventDelegate(WindowEventDispatcher * dispatcher)337 explicit QueueTouchEventDelegate(WindowEventDispatcher* dispatcher)
338 : window_(NULL),
339 dispatcher_(dispatcher),
340 queue_events_(true) {
341 }
~QueueTouchEventDelegate()342 virtual ~QueueTouchEventDelegate() {
343 while(!queue_.empty()) {
344 delete queue_.front();
345 queue_.pop();
346 }
347 }
348
OnTouchEvent(ui::TouchEvent * event)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
ReceivedAck()356 void ReceivedAck() {
357 ReceivedAckImpl(false);
358 }
359
ReceivedAckPreventDefaulted()360 void ReceivedAckPreventDefaulted() {
361 ReceivedAckImpl(true);
362 }
363
set_window(Window * w)364 void set_window(Window* w) { window_ = w; }
set_queue_events(bool queue)365 void set_queue_events(bool queue) { queue_events_ = queue; }
366
367 private:
ReceivedAckImpl(bool prevent_defaulted)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:
GestureEventSynthDelegate()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
Reset()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
mouse_enter() const405 bool mouse_enter() const { return mouse_enter_; }
mouse_exit() const406 bool mouse_exit() const { return mouse_exit_; }
mouse_press() const407 bool mouse_press() const { return mouse_press_; }
mouse_move() const408 bool mouse_move() const { return mouse_move_; }
mouse_release() const409 bool mouse_release() const { return mouse_release_; }
double_click() const410 bool double_click() const { return double_click_; }
411
OnMouseEvent(ui::MouseEvent * event)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|.
ScopedGestureRecognizerSetter(ui::GestureRecognizer * 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
~ScopedGestureRecognizerSetter()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.
TimedEvents()474 TimedEvents() : simulated_now_(1) {
475 }
476
Now()477 base::TimeDelta Now() {
478 base::TimeDelta t = base::TimeDelta::FromMilliseconds(simulated_now_);
479 simulated_now_++;
480 return t;
481 }
482
LeapForward(int time_in_millis)483 base::TimeDelta LeapForward(int time_in_millis) {
484 simulated_now_ += time_in_millis;
485 return base::TimeDelta::FromMilliseconds(simulated_now_);
486 }
487
InFuture(int time_in_millis)488 base::TimeDelta InFuture(int time_in_millis) {
489 return base::TimeDelta::FromMilliseconds(simulated_now_ + time_in_millis);
490 }
491
SendScrollEvents(ui::EventProcessor * dispatcher,float x_start,float y_start,int dx,int dy,int touch_id,int time_step,int num_steps,GestureEventConsumeDelegate * delegate)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
SendScrollEvent(ui::EventProcessor * dispatcher,float x,float y,int touch_id,GestureEventConsumeDelegate * delegate)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:
TestEventHandler()534 TestEventHandler()
535 : touch_released_count_(0),
536 touch_pressed_count_(0),
537 touch_moved_count_(0) {}
538
~TestEventHandler()539 virtual ~TestEventHandler() {}
540
OnTouchEvent(ui::TouchEvent * event)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
Reset()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
touch_released_count() const567 int touch_released_count() const { return touch_released_count_; }
touch_pressed_count() const568 int touch_pressed_count() const { return touch_pressed_count_; }
touch_moved_count() const569 int touch_moved_count() const { return touch_moved_count_; }
touch_cancelled_count() const570 int touch_cancelled_count() const {
571 return static_cast<int>(cancelled_touch_points_.size());
572 }
cancelled_touch_points() const573 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:
RemoveOnTouchCancelHandler()590 RemoveOnTouchCancelHandler() {}
~RemoveOnTouchCancelHandler()591 virtual ~RemoveOnTouchCancelHandler() {}
592
593 private:
594 // ui::EventHandler:
OnTouchEvent(ui::TouchEvent * event)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
DelayByLongPressTimeout()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
DelayByShowPressTimeout()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:
GestureRecognizerTest()634 GestureRecognizerTest() {}
635
SetUp()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.
TEST_F(GestureRecognizerTest,GestureEventTap)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.
TEST_F(GestureRecognizerTest,GestureEventTapRegion)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.
TEST_F(GestureRecognizerTest,GestureEventScroll)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.
TEST_F(GestureRecognizerTest,GestureEventScrollPrediction)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.
TEST_F(GestureRecognizerTest,GestureEventScrollBoundingBox)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
TEST_F(GestureRecognizerTest,GestureEventHorizontalRailFling)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
TEST_F(GestureRecognizerTest,GestureEventVerticalRailFling)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
TEST_F(GestureRecognizerTest,GestureEventNonRailFling)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
TEST_F(GestureRecognizerTest,GestureEventLongPress)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.
TEST_F(GestureRecognizerTest,GestureEventLongPressCancelledByScroll)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
TEST_F(GestureRecognizerTest,GestureEventLongTap)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
TEST_F(GestureRecognizerTest,GestureEventLongPressCancelledBySecondTap)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.
TEST_F(GestureRecognizerTest,GestureEventHorizontalRailScroll)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.
TEST_F(GestureRecognizerTest,GestureEventVerticalRailScroll)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
TEST_F(GestureRecognizerTest,GestureTapFollowedByScroll)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
TEST_F(GestureRecognizerTest,AsynchronousGestureRecognition)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.
TEST_F(GestureRecognizerTest,GestureEventPinchFromScroll)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
TEST_F(GestureRecognizerTest,GestureEventPinchFromScrollFromPinch)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
TEST_F(GestureRecognizerTest,GestureEventPinchFromTap)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
TEST_F(GestureRecognizerTest,GestureEventIgnoresDisconnectedEvents)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
TEST_F(GestureRecognizerTest,GestureEventTouchLockSelectsCorrectWindow)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.
TEST_F(GestureRecognizerTest,GestureEventTouchLockIgnoresOtherScreens)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.
TEST_F(GestureRecognizerTest,GestureEventOutsideRootWindowTap)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
TEST_F(GestureRecognizerTest,NoTapWithPreventDefaultedRelease)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
TEST_F(GestureRecognizerTest,PinchScrollWithPreventDefaultedRelease)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
TEST_F(GestureRecognizerTest,GestureEndLocation)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
TEST_F(GestureRecognizerTest,CaptureSendsGestureEnd)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.
TEST_F(GestureRecognizerTest,CaptureDoesNotCancelFinishedTouches)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.
TEST_F(GestureRecognizerTest,PressDoesNotCrash)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
TEST_F(GestureRecognizerTest,TwoFingerTap)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
TEST_F(GestureRecognizerTest,TwoFingerTapExpired)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
TEST_F(GestureRecognizerTest,TwoFingerTapChangesToPinch)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
TEST_F(GestureRecognizerTest,NoTwoFingerTapWhenFirstFingerHasScrolled)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
TEST_F(GestureRecognizerTest,MultiFingerSwipe)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
TEST_F(GestureRecognizerTest,TwoFingerTapCancelled)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
TEST_F(GestureRecognizerTest,VeryWideTwoFingerTouchDownShouldBeAPinch)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.
TEST_F(GestureRecognizerTest,FlushAllOnHide)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
TEST_F(GestureRecognizerTest,LongPressTimerStopsOnPreventDefaultedTouchMoves)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:
ConsumesTouchMovesDelegate()2976 ConsumesTouchMovesDelegate() : consume_touch_move_(true) {}
~ConsumesTouchMovesDelegate()2977 virtual ~ConsumesTouchMovesDelegate() {}
2978
set_consume_touch_move(bool consume)2979 void set_consume_touch_move(bool consume) { consume_touch_move_ = consume; }
2980
2981 private:
OnTouchEvent(ui::TouchEvent * touch)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.
TEST_F(GestureRecognizerTest,GestureEventScrollTouchMoveConsumed)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.
TEST_F(GestureRecognizerTest,GestureEventScrollTwoFingerTouchMoveConsumed)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.
TEST_F(GestureRecognizerTest,GestureEventScrollTouchMovePartialConsumed)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.
TEST_F(GestureRecognizerTest,GestureEventDoubleTap)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.
TEST_F(GestureRecognizerTest,GestureEventTripleTap)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.
TEST_F(GestureRecognizerTest,TwoTapsFarApart)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.
TEST_F(GestureRecognizerTest,TwoTapsWithDelayBetween)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.
TEST_F(GestureRecognizerTest,BoundingBoxRadiusChange)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.
TEST_F(GestureRecognizerTest,NoDriftInScroll)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.
TEST_F(GestureRecognizerTest,GestureEventConsumedTouchMoveCanFireTapCancel)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
TEST_F(GestureRecognizerTest,TransferEventDispatchesTouchCancel)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
TEST_F(GestureRecognizerTest,GestureEventShowPress)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
TEST_F(GestureRecognizerTest,GestureEventShowPressCancelledByScroll)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
TEST_F(GestureRecognizerTest,GestureEventShowPressSentOnTap)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.
TEST_F(GestureRecognizerTest,GestureEventConsumedTouchMoveScrollTest)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.
TEST_F(GestureRecognizerTest,GestureEventConsumedTouchMoveTapTest)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.
TEST_F(GestureRecognizerTest,GestureEventConsumedTouchMoveLongPressTest)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.
TEST_F(GestureRecognizerTest,TestExceedingSlopSlowly)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
TEST_F(GestureRecognizerTest,ScrollAlternatelyConsumedTest)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
TEST_F(GestureRecognizerTest,PinchAlternatelyConsumedTest)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.
TEST_F(GestureRecognizerTest,GestureEventFlagsPassedFromTouchEvent)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.
TEST_F(GestureRecognizerTest,LatencyPassedFromTouchEvent)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:
GestureEventDeleteWindowOnLongPress()4103 GestureEventDeleteWindowOnLongPress()
4104 : window_(NULL) {}
4105
set_window(aura::Window ** window)4106 void set_window(aura::Window** window) { window_ = window; }
4107
OnGestureEvent(ui::GestureEvent * gesture)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.
TEST_F(GestureRecognizerTest,GestureEventLongPressDeletingWindow)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
TEST_F(GestureRecognizerTest,GestureEventSmallPinchDisabled)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
TEST_F(GestureRecognizerTest,GestureEventSmallPinchEnabled)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.
TEST_F(GestureRecognizerTest,DISABLED_EagerGestureDetection)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.
TEST_F(GestureRecognizerTest,IgnoredEventsDontPreventFutureEvents)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