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