src/ui/events/gesture_detection/gesture_provider_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/basictypes.h"
   6 #include "base/logging.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/time/time.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "ui/events/event_constants.h"
  12 #include "ui/events/gesture_detection/gesture_event_data.h"
  13 #include "ui/events/gesture_detection/gesture_provider.h"
  14 #include "ui/events/gesture_detection/motion_event.h"
  15 #include "ui/events/test/mock_motion_event.h"
  16 #include "ui/gfx/geometry/point_f.h"
  17
  18 using base::TimeDelta;
  19 using base::TimeTicks;
  20 using ui::test::MockMotionEvent;
  21
  22 namespace ui {
  23 namespace {
  24
  25 const float kFakeCoordX = 42.f;
  26 const float kFakeCoordY = 24.f;
  27 const TimeDelta kOneSecond = TimeDelta::FromSeconds(1);
  28 const TimeDelta kOneMicrosecond = TimeDelta::FromMicroseconds(1);
  29 const TimeDelta kDeltaTimeForFlingSequences = TimeDelta::FromMilliseconds(5);
  30 const float kMockTouchRadius = MockMotionEvent::TOUCH_MAJOR / 2;
  31 const float kMaxTwoFingerTapSeparation = 300;
  32
  33 GestureProvider::Config CreateDefaultConfig() {
  34   GestureProvider::Config sConfig;
  35   // The longpress timeout is non-zero only to indicate ordering with respect to
  36   // the showpress timeout.
  37   sConfig.gesture_detector_config.showpress_timeout = base::TimeDelta();
  38   sConfig.gesture_detector_config.longpress_timeout = kOneMicrosecond;
  39
  40   // A valid doubletap timeout should always be non-zero. The value is used not
  41   // only to trigger the timeout that confirms the tap event, but also to gate
  42   // whether the second tap is in fact a double-tap (using a strict inequality
  43   // between times for the first up and the second down events). We use 4
  44   // microseconds simply to allow several intermediate events to occur before
  45   // the second tap at microsecond intervals.
  46   sConfig.gesture_detector_config.double_tap_timeout = kOneMicrosecond * 4;
  47   sConfig.gesture_detector_config.double_tap_min_time = kOneMicrosecond * 2;
  48   return sConfig;
  49 }
  50
  51 gfx::RectF BoundsForSingleMockTouchAtLocation(float x, float y) {
  52   float diameter = MockMotionEvent::TOUCH_MAJOR;
  53   return gfx::RectF(x - diameter / 2, y - diameter / 2, diameter, diameter);
  54 }
  55
  56 }  // namespace
  57
  58 class GestureProviderTest : public testing::Test, public GestureProviderClient {
  59  public:
  60   GestureProviderTest() {}
  61   virtual ~GestureProviderTest() {}
  62
  63   static MockMotionEvent ObtainMotionEvent(base::TimeTicks event_time,
  64                                            MotionEvent::Action action,
  65                                            float x,
  66                                            float y) {
  67     return MockMotionEvent(action, event_time, x, y);
  68   }
  69
  70   static MockMotionEvent ObtainMotionEvent(base::TimeTicks event_time,
  71                                            MotionEvent::Action action,
  72                                            float x0,
  73                                            float y0,
  74                                            float x1,
  75                                            float y1) {
  76     return MockMotionEvent(action, event_time, x0, y0, x1, y1);
  77   }
  78
  79   static MockMotionEvent ObtainMotionEvent(base::TimeTicks event_time,
  80                                            MotionEvent::Action action,
  81                                            float x0,
  82                                            float y0,
  83                                            float x1,
  84                                            float y1,
  85                                            float x2,
  86                                            float y2) {
  87     return MockMotionEvent(action, event_time, x0, y0, x1, y1, x2, y2);
  88   }
  89
  90   static MockMotionEvent ObtainMotionEvent(
  91       base::TimeTicks event_time,
  92       MotionEvent::Action action,
  93       const std::vector<gfx::PointF>& positions) {
  94     switch (positions.size()) {
  95       case 1:
  96         return MockMotionEvent(
  97             action, event_time, positions[0].x(), positions[0].y());
  98       case 2:
  99         return MockMotionEvent(action,
 100                                event_time,
 101                                positions[0].x(),
 102                                positions[0].y(),
 103                                positions[1].x(),
 104                                positions[1].y());
 105       case 3:
 106         return MockMotionEvent(action,
 107                                event_time,
 108                                positions[0].x(),
 109                                positions[0].y(),
 110                                positions[1].x(),
 111                                positions[1].y(),
 112                                positions[2].x(),
 113                                positions[2].y());
 114       default:
 115         CHECK(false) << "MockMotionEvent only supports 1-3 pointers";
 116         return MockMotionEvent();
 117     }
 118   }
 119
 120   static MockMotionEvent ObtainMotionEvent(base::TimeTicks event_time,
 121                                            MotionEvent::Action action) {
 122     return ObtainMotionEvent(event_time, action, kFakeCoordX, kFakeCoordY);
 123   }
 124
 125   // Test
 126   virtual void SetUp() OVERRIDE { SetUpWithConfig(GetDefaultConfig()); }
 127
 128   virtual void TearDown() OVERRIDE {
 129     gestures_.clear();
 130     gesture_provider_.reset();
 131   }
 132
 133   // GestureProviderClient
 134   virtual void OnGestureEvent(const GestureEventData& gesture) OVERRIDE {
 135     if (gesture.type() == ET_GESTURE_SCROLL_BEGIN)
 136       active_scroll_begin_event_.reset(new GestureEventData(gesture));
 137     gestures_.push_back(gesture);
 138   }
 139
 140   void SetUpWithConfig(const GestureProvider::Config& config) {
 141     gesture_provider_.reset(new GestureProvider(config, this));
 142     gesture_provider_->SetMultiTouchZoomSupportEnabled(false);
 143   }
 144
 145   void ResetGestureDetection() {
 146     CancelActiveTouchSequence();
 147     gestures_.clear();
 148   }
 149   bool CancelActiveTouchSequence() {
 150     if (!gesture_provider_->current_down_event())
 151       return false;
 152     return gesture_provider_->OnTouchEvent(
 153         *gesture_provider_->current_down_event()->Cancel());
 154   }
 155
 156   bool HasReceivedGesture(EventType type) const {
 157     for (size_t i = 0; i < gestures_.size(); ++i) {
 158       if (gestures_[i].type() == type)
 159         return true;
 160     }
 161     return false;
 162   }
 163
 164   const GestureEventData& GetMostRecentGestureEvent() const {
 165     EXPECT_FALSE(gestures_.empty());
 166     return gestures_.back();
 167   }
 168
 169   EventType GetMostRecentGestureEventType() const {
 170     EXPECT_FALSE(gestures_.empty());
 171     return gestures_.back().type();
 172   }
 173
 174   size_t GetReceivedGestureCount() const { return gestures_.size(); }
 175
 176   const GestureEventData& GetReceivedGesture(size_t index) const {
 177     EXPECT_LT(index, GetReceivedGestureCount());
 178     return gestures_[index];
 179   }
 180
 181   const GestureEventData* GetActiveScrollBeginEvent() const {
 182     return active_scroll_begin_event_ ? active_scroll_begin_event_.get() : NULL;
 183   }
 184
 185   const GestureProvider::Config& GetDefaultConfig() const {
 186     static GestureProvider::Config sConfig = CreateDefaultConfig();
 187     return sConfig;
 188   }
 189
 190   float GetTouchSlop() const {
 191     return GetDefaultConfig().gesture_detector_config.touch_slop;
 192   }
 193
 194   float GetMinScalingSpan() const {
 195     return GetDefaultConfig().scale_gesture_detector_config.min_scaling_span;
 196   }
 197
 198   float GetMinSwipeVelocity() const {
 199     return GetDefaultConfig().gesture_detector_config.minimum_swipe_velocity;
 200   }
 201
 202   base::TimeDelta GetLongPressTimeout() const {
 203     return GetDefaultConfig().gesture_detector_config.longpress_timeout;
 204   }
 205
 206   base::TimeDelta GetShowPressTimeout() const {
 207     return GetDefaultConfig().gesture_detector_config.showpress_timeout;
 208   }
 209
 210   base::TimeDelta GetDoubleTapTimeout() const {
 211     return GetDefaultConfig().gesture_detector_config.double_tap_timeout;
 212   }
 213
 214   base::TimeDelta GetDoubleTapMinTime() const {
 215     return GetDefaultConfig().gesture_detector_config.double_tap_min_time;
 216   }
 217
 218   base::TimeDelta GetValidDoubleTapDelay() const {
 219     return (GetDoubleTapTimeout() + GetDoubleTapMinTime()) / 2;
 220   }
 221
 222   void EnableBeginEndTypes() {
 223     GestureProvider::Config config = GetDefaultConfig();
 224     config.gesture_begin_end_types_enabled = true;
 225     SetUpWithConfig(config);
 226   }
 227
 228   void EnableSwipe() {
 229     GestureProvider::Config config = GetDefaultConfig();
 230     config.gesture_detector_config.swipe_enabled = true;
 231     SetUpWithConfig(config);
 232   }
 233
 234   void EnableTwoFingerTap(float max_distance_for_two_finger_tap,
 235                           base::TimeDelta two_finger_tap_timeout) {
 236     GestureProvider::Config config = GetDefaultConfig();
 237     config.gesture_detector_config.two_finger_tap_enabled = true;
 238     config.gesture_detector_config.two_finger_tap_max_separation =
 239         max_distance_for_two_finger_tap;
 240     config.gesture_detector_config.two_finger_tap_timeout =
 241         two_finger_tap_timeout;
 242     SetUpWithConfig(config);
 243   }
 244
 245   void SetMinPinchUpdateSpanDelta(float min_pinch_update_span_delta) {
 246     GestureProvider::Config config = GetDefaultConfig();
 247     config.scale_gesture_detector_config.min_pinch_update_span_delta =
 248         min_pinch_update_span_delta;
 249     SetUpWithConfig(config);
 250   }
 251
 252   void SetMinMaxGestureBoundsLength(float min_gesture_bound_length,
 253                                     float max_gesture_bound_length) {
 254     GestureProvider::Config config = GetDefaultConfig();
 255     config.min_gesture_bounds_length = min_gesture_bound_length;
 256     config.max_gesture_bounds_length = max_gesture_bound_length;
 257     SetUpWithConfig(config);
 258   }
 259
 260   void SetShowPressAndLongPressTimeout(base::TimeDelta showpress_timeout,
 261                                        base::TimeDelta longpress_timeout) {
 262     GestureProvider::Config config = GetDefaultConfig();
 263     config.gesture_detector_config.showpress_timeout = showpress_timeout;
 264     config.gesture_detector_config.longpress_timeout = longpress_timeout;
 265     SetUpWithConfig(config);
 266   }
 267
 268   bool HasDownEvent() const { return gesture_provider_->current_down_event(); }
 269
 270  protected:
 271   void CheckScrollEventSequenceForEndActionType(
 272       MotionEvent::Action end_action_type) {
 273     base::TimeTicks event_time = base::TimeTicks::Now();
 274     const float scroll_to_x = kFakeCoordX + 100;
 275     const float scroll_to_y = kFakeCoordY + 100;
 276     int motion_event_id = 0;
 277     int motion_event_flags = EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN;
 278
 279     MockMotionEvent event =
 280         ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 281     event.set_id(++motion_event_id);
 282     event.set_flags(motion_event_flags);
 283
 284     EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 285     EXPECT_EQ(motion_event_flags, GetMostRecentGestureEvent().flags);
 286
 287     event = ObtainMotionEvent(event_time + kOneSecond,
 288                               MotionEvent::ACTION_MOVE,
 289                               scroll_to_x,
 290                               scroll_to_y);
 291     event.SetToolType(0, MotionEvent::TOOL_TYPE_FINGER);
 292     event.set_id(++motion_event_id);
 293     event.set_flags(motion_event_flags);
 294
 295     EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 296     EXPECT_TRUE(gesture_provider_->IsScrollInProgress());
 297     EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
 298     EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
 299     EXPECT_EQ(motion_event_flags, GetMostRecentGestureEvent().flags);
 300     EXPECT_EQ(event.GetToolType(0),
 301               GetMostRecentGestureEvent().primary_tool_type);
 302     EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
 303     EXPECT_EQ(BoundsForSingleMockTouchAtLocation(scroll_to_x, scroll_to_y),
 304               GetMostRecentGestureEvent().details.bounding_box());
 305     ASSERT_EQ(3U, GetReceivedGestureCount()) << "Only TapDown, "
 306                                                 "ScrollBegin and ScrollBy "
 307                                                 "should have been sent";
 308
 309     EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
 310     EXPECT_EQ(motion_event_id, GetReceivedGesture(1).motion_event_id);
 311     EXPECT_EQ(event_time + kOneSecond, GetReceivedGesture(1).time)
 312         << "ScrollBegin should have the time of the ACTION_MOVE";
 313
 314     event = ObtainMotionEvent(
 315         event_time + kOneSecond, end_action_type, scroll_to_x, scroll_to_y);
 316     event.SetToolType(0, MotionEvent::TOOL_TYPE_FINGER);
 317     event.set_id(++motion_event_id);
 318
 319     gesture_provider_->OnTouchEvent(event);
 320     EXPECT_FALSE(gesture_provider_->IsScrollInProgress());
 321     EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_END));
 322     EXPECT_EQ(ET_GESTURE_SCROLL_END, GetMostRecentGestureEventType());
 323     EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
 324     EXPECT_EQ(event.GetToolType(0),
 325               GetMostRecentGestureEvent().primary_tool_type);
 326     EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 327     EXPECT_EQ(BoundsForSingleMockTouchAtLocation(scroll_to_x, scroll_to_y),
 328               GetMostRecentGestureEvent().details.bounding_box());
 329   }
 330
 331   void OneFingerSwipe(float vx, float vy) {
 332     std::vector<gfx::Vector2dF> velocities;
 333     velocities.push_back(gfx::Vector2dF(vx, vy));
 334     MultiFingerSwipe(velocities);
 335   }
 336
 337   void TwoFingerSwipe(float vx0, float vy0, float vx1, float vy1) {
 338     std::vector<gfx::Vector2dF> velocities;
 339     velocities.push_back(gfx::Vector2dF(vx0, vy0));
 340     velocities.push_back(gfx::Vector2dF(vx1, vy1));
 341     MultiFingerSwipe(velocities);
 342   }
 343
 344   void ThreeFingerSwipe(float vx0,
 345                         float vy0,
 346                         float vx1,
 347                         float vy1,
 348                         float vx2,
 349                         float vy2) {
 350     std::vector<gfx::Vector2dF> velocities;
 351     velocities.push_back(gfx::Vector2dF(vx0, vy0));
 352     velocities.push_back(gfx::Vector2dF(vx1, vy1));
 353     velocities.push_back(gfx::Vector2dF(vx2, vy2));
 354     MultiFingerSwipe(velocities);
 355   }
 356
 357   void MultiFingerSwipe(std::vector<gfx::Vector2dF> velocities) {
 358     ASSERT_GT(velocities.size(), 0U);
 359
 360     base::TimeTicks event_time = base::TimeTicks::Now();
 361
 362     std::vector<gfx::PointF> positions(velocities.size());
 363     for (size_t i = 0; i < positions.size(); ++i)
 364       positions[i] = gfx::PointF(kFakeCoordX * (i + 1), kFakeCoordY * (i + 1));
 365
 366     float dt = kDeltaTimeForFlingSequences.InSecondsF();
 367
 368     // Each pointer down should be a separate event.
 369     for (size_t i = 0; i < positions.size(); ++i) {
 370       const size_t pointer_count = i + 1;
 371       std::vector<gfx::PointF> event_positions(pointer_count);
 372       event_positions.assign(positions.begin(),
 373                              positions.begin() + pointer_count);
 374       MockMotionEvent event =
 375           ObtainMotionEvent(event_time,
 376                             pointer_count > 1 ? MotionEvent::ACTION_POINTER_DOWN
 377                                               : MotionEvent::ACTION_DOWN,
 378                             event_positions);
 379       EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 380     }
 381
 382     for (size_t i = 0; i < positions.size(); ++i)
 383       positions[i] += gfx::ScaleVector2d(velocities[i], dt);
 384     MockMotionEvent event =
 385         ObtainMotionEvent(event_time + kDeltaTimeForFlingSequences,
 386                           MotionEvent::ACTION_MOVE,
 387                           positions);
 388     EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 389
 390     for (size_t i = 0; i < positions.size(); ++i)
 391       positions[i] += gfx::ScaleVector2d(velocities[i], dt);
 392     event = ObtainMotionEvent(event_time + 2 * kDeltaTimeForFlingSequences,
 393                               MotionEvent::ACTION_MOVE,
 394                               positions);
 395     EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 396
 397     event = ObtainMotionEvent(event_time + 2 * kDeltaTimeForFlingSequences,
 398                               MotionEvent::ACTION_POINTER_UP,
 399                               positions);
 400     EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 401   }
 402
 403   static void RunTasksAndWait(base::TimeDelta delay) {
 404     base::MessageLoop::current()->PostDelayedTask(
 405         FROM_HERE, base::MessageLoop::QuitClosure(), delay);
 406     base::MessageLoop::current()->Run();
 407   }
 408
 409   std::vector<GestureEventData> gestures_;
 410   scoped_ptr<GestureProvider> gesture_provider_;
 411   scoped_ptr<GestureEventData> active_scroll_begin_event_;
 412   base::MessageLoopForUI message_loop_;
 413 };
 414
 415 // Verify that a DOWN followed shortly by an UP will trigger a single tap.
 416 TEST_F(GestureProviderTest, GestureTap) {
 417   base::TimeTicks event_time = base::TimeTicks::Now();
 418   int motion_event_id = 0;
 419   int motion_event_flags = EF_CONTROL_DOWN | EF_ALT_DOWN;
 420
 421   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
 422
 423   MockMotionEvent event =
 424       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 425   event.SetToolType(0, MotionEvent::TOOL_TYPE_FINGER);
 426   event.set_id(++motion_event_id);
 427   event.set_flags(motion_event_flags);
 428
 429   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 430   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 431   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 432   EXPECT_EQ(event.GetToolType(0),
 433             GetMostRecentGestureEvent().primary_tool_type);
 434   EXPECT_EQ(motion_event_flags, GetMostRecentGestureEvent().flags);
 435   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY),
 436             GetMostRecentGestureEvent().details.bounding_box());
 437
 438   event = ObtainMotionEvent(event_time + kOneMicrosecond,
 439                             MotionEvent::ACTION_UP);
 440   event.SetToolType(0, MotionEvent::TOOL_TYPE_FINGER);
 441   event.set_id(++motion_event_id);
 442   event.set_flags(motion_event_flags);
 443
 444   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 445   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
 446   // Ensure tap details have been set.
 447   EXPECT_EQ(1, GetMostRecentGestureEvent().details.tap_count());
 448   EXPECT_EQ(event.GetToolType(0),
 449             GetMostRecentGestureEvent().primary_tool_type);
 450   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
 451   EXPECT_EQ(motion_event_flags, GetMostRecentGestureEvent().flags);
 452   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 453   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY),
 454             GetMostRecentGestureEvent().details.bounding_box());
 455 }
 456
 457 // Verify that a DOWN followed shortly by an UP will trigger
 458 // a ET_GESTURE_TAP_UNCONFIRMED event if double-tap is enabled.
 459 TEST_F(GestureProviderTest, GestureTapWithDelay) {
 460   base::TimeTicks event_time = base::TimeTicks::Now();
 461   int motion_event_id = 0;
 462   int motion_event_flags = EF_CONTROL_DOWN | EF_ALT_DOWN | EF_CAPS_LOCK_DOWN;
 463
 464   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(true);
 465
 466   MockMotionEvent event =
 467       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 468   event.set_id(++motion_event_id);
 469   event.set_flags(motion_event_flags);
 470
 471   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 472   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 473   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
 474   EXPECT_EQ(motion_event_flags, GetMostRecentGestureEvent().flags);
 475   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 476   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY),
 477             GetMostRecentGestureEvent().details.bounding_box());
 478
 479   event = ObtainMotionEvent(event_time + kOneMicrosecond,
 480                             MotionEvent::ACTION_UP);
 481   event.set_id(++motion_event_id);
 482   event.set_flags(motion_event_flags);
 483
 484   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 485   EXPECT_EQ(ET_GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
 486   // Ensure tap details have been set.
 487   EXPECT_EQ(1, GetMostRecentGestureEvent().details.tap_count());
 488   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
 489   EXPECT_EQ(motion_event_flags, GetMostRecentGestureEvent().flags);
 490   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 491   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY),
 492             GetMostRecentGestureEvent().details.bounding_box());
 493
 494   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_TAP));
 495   RunTasksAndWait(GetDoubleTapTimeout());
 496   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_TAP));
 497 }
 498
 499 // Verify that a DOWN followed by a MOVE will trigger fling (but not LONG).
 500 TEST_F(GestureProviderTest, GestureFlingAndCancelLongPress) {
 501   base::TimeTicks event_time = TimeTicks::Now();
 502   base::TimeDelta delta_time = kDeltaTimeForFlingSequences;
 503   int motion_event_id = 0;
 504   int motion_event_flags = EF_ALT_DOWN;
 505
 506   MockMotionEvent event =
 507       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 508   event.set_id(++motion_event_id);
 509   event.set_flags(motion_event_flags);
 510
 511   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 512   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 513   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
 514   EXPECT_EQ(motion_event_flags, GetMostRecentGestureEvent().flags);
 515   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 516
 517   event = ObtainMotionEvent(event_time + delta_time,
 518                             MotionEvent::ACTION_MOVE,
 519                             kFakeCoordX * 10,
 520                             kFakeCoordY * 10);
 521   event.set_id(++motion_event_id);
 522   event.set_flags(motion_event_flags);
 523   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 524
 525   event = ObtainMotionEvent(event_time + delta_time * 2,
 526                             MotionEvent::ACTION_UP,
 527                             kFakeCoordX * 10,
 528                             kFakeCoordY * 10);
 529   event.set_id(++motion_event_id);
 530   event.set_flags(motion_event_flags);
 531
 532   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 533   EXPECT_EQ(ET_SCROLL_FLING_START, GetMostRecentGestureEventType());
 534   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
 535   EXPECT_EQ(motion_event_flags, GetMostRecentGestureEvent().flags);
 536   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 537   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_LONG_PRESS));
 538   EXPECT_EQ(
 539       BoundsForSingleMockTouchAtLocation(kFakeCoordX * 10, kFakeCoordY * 10),
 540       GetMostRecentGestureEvent().details.bounding_box());
 541 }
 542
 543 // Verify that for a normal scroll the following events are sent:
 544 // - ET_GESTURE_SCROLL_BEGIN
 545 // - ET_GESTURE_SCROLL_UPDATE
 546 // - ET_GESTURE_SCROLL_END
 547 TEST_F(GestureProviderTest, ScrollEventActionUpSequence) {
 548   CheckScrollEventSequenceForEndActionType(MotionEvent::ACTION_UP);
 549 }
 550
 551 // Verify that for a cancelled scroll the following events are sent:
 552 // - ET_GESTURE_SCROLL_BEGIN
 553 // - ET_GESTURE_SCROLL_UPDATE
 554 // - ET_GESTURE_SCROLL_END
 555 TEST_F(GestureProviderTest, ScrollEventActionCancelSequence) {
 556   CheckScrollEventSequenceForEndActionType(MotionEvent::ACTION_CANCEL);
 557 }
 558
 559 // Verify that for a normal fling (fling after scroll) the following events are
 560 // sent:
 561 // - ET_GESTURE_SCROLL_BEGIN
 562 // - ET_SCROLL_FLING_START
 563 TEST_F(GestureProviderTest, FlingEventSequence) {
 564   base::TimeTicks event_time = base::TimeTicks::Now();
 565   base::TimeDelta delta_time = kDeltaTimeForFlingSequences;
 566   int motion_event_id = 0;
 567
 568   MockMotionEvent event =
 569       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 570   event.set_id(++motion_event_id);
 571
 572   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 573
 574   event = ObtainMotionEvent(event_time + delta_time,
 575                             MotionEvent::ACTION_MOVE,
 576                             kFakeCoordX * 5,
 577                             kFakeCoordY * 5);
 578   event.set_id(++motion_event_id);
 579
 580   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 581   EXPECT_TRUE(gesture_provider_->IsScrollInProgress());
 582   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
 583   EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
 584   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
 585   ASSERT_EQ(3U, GetReceivedGestureCount());
 586   ASSERT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
 587   EXPECT_EQ(motion_event_id, GetReceivedGesture(1).motion_event_id);
 588
 589   // We don't want to take a dependency here on exactly how hints are calculated
 590   // for a fling (eg. may depend on velocity), so just validate the direction.
 591   int hint_x = GetReceivedGesture(1).details.scroll_x_hint();
 592   int hint_y = GetReceivedGesture(1).details.scroll_y_hint();
 593   EXPECT_TRUE(hint_x > 0 && hint_y > 0 && hint_x > hint_y)
 594       << "ScrollBegin hint should be in positive X axis";
 595
 596   event = ObtainMotionEvent(event_time + delta_time * 2,
 597                             MotionEvent::ACTION_UP,
 598                             kFakeCoordX * 10,
 599                             kFakeCoordY * 10);
 600   event.set_id(++motion_event_id);
 601
 602   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 603   EXPECT_FALSE(gesture_provider_->IsScrollInProgress());
 604   EXPECT_EQ(ET_SCROLL_FLING_START, GetMostRecentGestureEventType());
 605   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
 606   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 607   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SCROLL_END));
 608   EXPECT_EQ(event_time + delta_time * 2, GetMostRecentGestureEvent().time)
 609       << "FlingStart should have the time of the ACTION_UP";
 610 }
 611
 612 TEST_F(GestureProviderTest, GestureCancelledWhenWindowFocusLost) {
 613   const base::TimeTicks event_time = TimeTicks::Now();
 614
 615   MockMotionEvent event =
 616       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 617   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 618   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 619
 620   RunTasksAndWait(GetLongPressTimeout() + GetShowPressTimeout() +
 621                   kOneMicrosecond);
 622   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SHOW_PRESS));
 623   EXPECT_EQ(ET_GESTURE_LONG_PRESS, GetMostRecentGestureEventType());
 624
 625   // The long press triggers window focus loss by opening a context menu.
 626   EXPECT_TRUE(CancelActiveTouchSequence());
 627   EXPECT_FALSE(HasDownEvent());
 628
 629   // A final ACTION_UP should have no effect.
 630   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
 631                             MotionEvent::ACTION_UP);
 632   EXPECT_FALSE(gesture_provider_->OnTouchEvent(event));
 633 }
 634
 635 TEST_F(GestureProviderTest, NoTapAfterScrollBegins) {
 636   base::TimeTicks event_time = base::TimeTicks::Now();
 637
 638   MockMotionEvent event =
 639       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 640
 641   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 642
 643   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 644   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 645   event = ObtainMotionEvent(event_time + kOneMicrosecond,
 646                             MotionEvent::ACTION_MOVE,
 647                             kFakeCoordX + 50,
 648                             kFakeCoordY + 50);
 649   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 650   EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
 651
 652   event = ObtainMotionEvent(event_time + kOneSecond,
 653                             MotionEvent::ACTION_UP,
 654                             kFakeCoordX + 50,
 655                             kFakeCoordY + 50);
 656   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 657   EXPECT_EQ(ET_GESTURE_SCROLL_END, GetMostRecentGestureEventType());
 658   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_LONG_TAP));
 659 }
 660
 661 TEST_F(GestureProviderTest, DoubleTap) {
 662   base::TimeTicks event_time = base::TimeTicks::Now();
 663
 664   MockMotionEvent event =
 665       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 666   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 667
 668   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 669   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 670
 671   event = ObtainMotionEvent(event_time + kOneMicrosecond,
 672                             MotionEvent::ACTION_UP,
 673                             kFakeCoordX,
 674                             kFakeCoordY);
 675   gesture_provider_->OnTouchEvent(event);
 676   EXPECT_EQ(ET_GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
 677   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 678
 679   event_time += GetValidDoubleTapDelay();
 680   event = ObtainMotionEvent(event_time,
 681                             MotionEvent::ACTION_DOWN,
 682                             kFakeCoordX,
 683                             kFakeCoordY);
 684   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 685   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 686   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 687
 688   // Moving a very small amount of distance should not trigger the double tap
 689   // drag zoom mode.
 690   event = ObtainMotionEvent(event_time + kOneMicrosecond,
 691                             MotionEvent::ACTION_MOVE,
 692                             kFakeCoordX,
 693                             kFakeCoordY + 1);
 694   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 695   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 696   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 697
 698   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
 699                             MotionEvent::ACTION_UP,
 700                             kFakeCoordX,
 701                             kFakeCoordY + 1);
 702   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 703
 704   const GestureEventData& double_tap = GetMostRecentGestureEvent();
 705   EXPECT_EQ(ET_GESTURE_DOUBLE_TAP, double_tap.type());
 706   // Ensure tap details have been set.
 707   EXPECT_EQ(10, double_tap.details.bounding_box().width());
 708   EXPECT_EQ(10, double_tap.details.bounding_box().height());
 709   EXPECT_EQ(1, double_tap.details.tap_count());
 710 }
 711
 712 TEST_F(GestureProviderTest, DoubleTapDragZoomBasic) {
 713   const base::TimeTicks down_time_1 = TimeTicks::Now();
 714   const base::TimeTicks down_time_2 = down_time_1 + GetValidDoubleTapDelay();
 715
 716   MockMotionEvent event =
 717       ObtainMotionEvent(down_time_1, MotionEvent::ACTION_DOWN);
 718   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 719
 720   event = ObtainMotionEvent(down_time_1 + kOneMicrosecond,
 721                             MotionEvent::ACTION_UP,
 722                             kFakeCoordX,
 723                             kFakeCoordY);
 724   gesture_provider_->OnTouchEvent(event);
 725   EXPECT_EQ(ET_GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
 726   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 727
 728   event = ObtainMotionEvent(
 729       down_time_2, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
 730   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 731   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 732   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 733
 734   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond,
 735                             MotionEvent::ACTION_MOVE,
 736                             kFakeCoordX,
 737                             kFakeCoordY + 100);
 738   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 739   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
 740   ASSERT_EQ(ET_GESTURE_PINCH_BEGIN, GetMostRecentGestureEventType());
 741   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY + 100),
 742             GetMostRecentGestureEvent().details.bounding_box());
 743
 744   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 2,
 745                             MotionEvent::ACTION_MOVE,
 746                             kFakeCoordX,
 747                             kFakeCoordY + 200);
 748   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 749   ASSERT_EQ(ET_GESTURE_PINCH_UPDATE, GetMostRecentGestureEventType());
 750   EXPECT_LT(1.f, GetMostRecentGestureEvent().details.scale());
 751   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY + 200),
 752             GetMostRecentGestureEvent().details.bounding_box());
 753
 754   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 3,
 755                             MotionEvent::ACTION_MOVE,
 756                             kFakeCoordX,
 757                             kFakeCoordY + 100);
 758   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 759   ASSERT_EQ(ET_GESTURE_PINCH_UPDATE, GetMostRecentGestureEventType());
 760   EXPECT_GT(1.f, GetMostRecentGestureEvent().details.scale());
 761   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY + 100),
 762             GetMostRecentGestureEvent().details.bounding_box());
 763
 764   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 4,
 765                             MotionEvent::ACTION_UP,
 766                             kFakeCoordX,
 767                             kFakeCoordY - 200);
 768   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 769   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_PINCH_END));
 770   EXPECT_EQ(ET_GESTURE_SCROLL_END, GetMostRecentGestureEventType());
 771   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY - 200),
 772             GetMostRecentGestureEvent().details.bounding_box());
 773 }
 774
 775 // Generate a scroll gesture and verify that the resulting scroll motion event
 776 // has both absolute and relative position information.
 777 TEST_F(GestureProviderTest, ScrollUpdateValues) {
 778   const float delta_x = 16;
 779   const float delta_y = 84;
 780   const float raw_offset_x = 17.3f;
 781   const float raw_offset_y = 13.7f;
 782
 783   const base::TimeTicks event_time = TimeTicks::Now();
 784
 785   MockMotionEvent event =
 786       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 787   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 788
 789   // Move twice so that we get two ET_GESTURE_SCROLL_UPDATE events and can
 790   // compare the relative and absolute coordinates.
 791   event = ObtainMotionEvent(event_time + kOneMicrosecond,
 792                             MotionEvent::ACTION_MOVE,
 793                             kFakeCoordX - delta_x / 2,
 794                             kFakeCoordY - delta_y / 2);
 795   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 796
 797   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
 798                             MotionEvent::ACTION_MOVE,
 799                             kFakeCoordX - delta_x,
 800                             kFakeCoordY - delta_y);
 801   event.SetRawOffset(raw_offset_x, raw_offset_y);
 802   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 803
 804   // Make sure the reported gesture event has all the expected details.
 805   ASSERT_LT(0U, GetReceivedGestureCount());
 806   GestureEventData gesture = GetMostRecentGestureEvent();
 807   EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, gesture.type());
 808   EXPECT_EQ(event_time + kOneMicrosecond * 2, gesture.time);
 809   EXPECT_EQ(kFakeCoordX - delta_x, gesture.x);
 810   EXPECT_EQ(kFakeCoordY - delta_y, gesture.y);
 811   EXPECT_EQ(kFakeCoordX - delta_x + raw_offset_x, gesture.raw_x);
 812   EXPECT_EQ(kFakeCoordY - delta_y + raw_offset_y, gesture.raw_y);
 813   EXPECT_EQ(1, gesture.details.touch_points());
 814
 815   // No horizontal delta because of snapping.
 816   EXPECT_EQ(0, gesture.details.scroll_x());
 817   EXPECT_EQ(-delta_y / 2, gesture.details.scroll_y());
 818 }
 819
 820 // Verify that fractional scroll deltas are rounded as expected and that
 821 // fractional scrolling doesn't break scroll snapping.
 822 TEST_F(GestureProviderTest, FractionalScroll) {
 823   const float delta_x = 0.4f;
 824   const float delta_y = 5.2f;
 825
 826   const base::TimeTicks event_time = TimeTicks::Now();
 827
 828   MockMotionEvent event =
 829       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 830   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 831
 832   // Skip past the touch slop and move back.
 833   event = ObtainMotionEvent(event_time,
 834                             MotionEvent::ACTION_MOVE,
 835                             kFakeCoordX,
 836                             kFakeCoordY + 100);
 837   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 838   event = ObtainMotionEvent(event_time,
 839                             MotionEvent::ACTION_MOVE);
 840   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 841
 842   // Now move up slowly, mostly vertically but with a (fractional) bit of
 843   // horizontal motion.
 844   for(int i = 1; i <= 10; i++) {
 845     event = ObtainMotionEvent(event_time + kOneMicrosecond * i,
 846                               MotionEvent::ACTION_MOVE,
 847                               kFakeCoordX + delta_x * i,
 848                               kFakeCoordY + delta_y * i);
 849     EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 850
 851     ASSERT_LT(0U, GetReceivedGestureCount());
 852     GestureEventData gesture = GetMostRecentGestureEvent();
 853     EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, gesture.type());
 854     EXPECT_EQ(event_time + kOneMicrosecond * i, gesture.time);
 855     EXPECT_EQ(1, gesture.details.touch_points());
 856
 857     // Verify that the event co-ordinates are still the precise values we
 858     // supplied.
 859     EXPECT_EQ(kFakeCoordX + delta_x * i, gesture.x);
 860     EXPECT_FLOAT_EQ(kFakeCoordY + delta_y * i, gesture.y);
 861
 862     // Verify that we're scrolling vertically by the expected amount
 863     // (modulo rounding).
 864     EXPECT_GE(gesture.details.scroll_y(), (int)delta_y);
 865     EXPECT_LE(gesture.details.scroll_y(), ((int)delta_y) + 1);
 866
 867     // And that there has been no horizontal motion at all.
 868     EXPECT_EQ(0, gesture.details.scroll_x());
 869   }
 870 }
 871
 872 // Generate a scroll gesture and verify that the resulting scroll begin event
 873 // has the expected hint values.
 874 TEST_F(GestureProviderTest, ScrollBeginValues) {
 875   const float delta_x = 13;
 876   const float delta_y = 89;
 877
 878   const base::TimeTicks event_time = TimeTicks::Now();
 879
 880   MockMotionEvent event =
 881       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 882   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 883
 884   // Move twice such that the first event isn't sufficient to start
 885   // scrolling on it's own.
 886   event = ObtainMotionEvent(event_time + kOneMicrosecond,
 887                             MotionEvent::ACTION_MOVE,
 888                             kFakeCoordX + 2,
 889                             kFakeCoordY + 1);
 890   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 891   EXPECT_FALSE(gesture_provider_->IsScrollInProgress());
 892
 893   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
 894                             MotionEvent::ACTION_MOVE,
 895                             kFakeCoordX + delta_x,
 896                             kFakeCoordY + delta_y);
 897   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 898   EXPECT_TRUE(gesture_provider_->IsScrollInProgress());
 899
 900   const GestureEventData* scroll_begin_gesture = GetActiveScrollBeginEvent();
 901   ASSERT_TRUE(!!scroll_begin_gesture);
 902   EXPECT_EQ(delta_x, scroll_begin_gesture->details.scroll_x_hint());
 903   EXPECT_EQ(delta_y, scroll_begin_gesture->details.scroll_y_hint());
 904 }
 905
 906 TEST_F(GestureProviderTest, LongPressAndTapCancelledWhenScrollBegins) {
 907   base::TimeTicks event_time = base::TimeTicks::Now();
 908
 909   MockMotionEvent event =
 910       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 911   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 912   event = ObtainMotionEvent(event_time + kOneMicrosecond,
 913                             MotionEvent::ACTION_MOVE,
 914                             kFakeCoordX * 5,
 915                             kFakeCoordY * 5);
 916   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 917   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
 918                             MotionEvent::ACTION_MOVE,
 919                             kFakeCoordX * 10,
 920                             kFakeCoordY * 10);
 921   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 922
 923   const base::TimeDelta long_press_timeout =
 924       GetLongPressTimeout() + GetShowPressTimeout() + kOneMicrosecond;
 925   RunTasksAndWait(long_press_timeout);
 926
 927   // No LONG_TAP as the LONG_PRESS timer is cancelled.
 928   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_LONG_PRESS));
 929   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_LONG_TAP));
 930 }
 931
 932 // Verify that LONG_TAP is triggered after LONG_PRESS followed by an UP.
 933 TEST_F(GestureProviderTest, GestureLongTap) {
 934   base::TimeTicks event_time = base::TimeTicks::Now();
 935
 936   MockMotionEvent event =
 937       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 938   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 939
 940   const base::TimeDelta long_press_timeout =
 941       GetLongPressTimeout() + GetShowPressTimeout() + kOneMicrosecond;
 942   RunTasksAndWait(long_press_timeout);
 943
 944   EXPECT_EQ(ET_GESTURE_LONG_PRESS, GetMostRecentGestureEventType());
 945   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 946   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY),
 947             GetMostRecentGestureEvent().details.bounding_box());
 948
 949   event = ObtainMotionEvent(event_time + kOneSecond, MotionEvent::ACTION_UP);
 950   gesture_provider_->OnTouchEvent(event);
 951   EXPECT_EQ(ET_GESTURE_LONG_TAP, GetMostRecentGestureEventType());
 952   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 953   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY),
 954             GetMostRecentGestureEvent().details.bounding_box());
 955 }
 956
 957 TEST_F(GestureProviderTest, GestureLongPressDoesNotPreventScrolling) {
 958   base::TimeTicks event_time = base::TimeTicks::Now();
 959
 960   MockMotionEvent event =
 961       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 962   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 963
 964   const base::TimeDelta long_press_timeout =
 965       GetLongPressTimeout() + GetShowPressTimeout() + kOneMicrosecond;
 966   RunTasksAndWait(long_press_timeout);
 967
 968   EXPECT_EQ(ET_GESTURE_LONG_PRESS, GetMostRecentGestureEventType());
 969   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 970   event = ObtainMotionEvent(event_time + long_press_timeout,
 971                             MotionEvent::ACTION_MOVE,
 972                             kFakeCoordX + 100,
 973                             kFakeCoordY + 100);
 974   gesture_provider_->OnTouchEvent(event);
 975
 976   EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
 977   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 978   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
 979
 980   event = ObtainMotionEvent(event_time + long_press_timeout,
 981                             MotionEvent::ACTION_UP);
 982   gesture_provider_->OnTouchEvent(event);
 983   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_LONG_TAP));
 984 }
 985
 986 TEST_F(GestureProviderTest, NoGestureLongPressDuringDoubleTap) {
 987   base::TimeTicks event_time = base::TimeTicks::Now();
 988   int motion_event_id = 0;
 989
 990   MockMotionEvent event = ObtainMotionEvent(
 991       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
 992   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 993
 994   event = ObtainMotionEvent(event_time + kOneMicrosecond,
 995                             MotionEvent::ACTION_UP,
 996                             kFakeCoordX,
 997                             kFakeCoordY);
 998   gesture_provider_->OnTouchEvent(event);
 999   EXPECT_EQ(ET_GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
1000   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1001
1002   event_time += GetValidDoubleTapDelay();
1003   event = ObtainMotionEvent(event_time,
1004                             MotionEvent::ACTION_DOWN,
1005                             kFakeCoordX,
1006                             kFakeCoordY);
1007   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1008   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1009   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1010   EXPECT_TRUE(gesture_provider_->IsDoubleTapInProgress());
1011
1012   const base::TimeDelta long_press_timeout =
1013       GetLongPressTimeout() + GetShowPressTimeout() + kOneMicrosecond;
1014   RunTasksAndWait(long_press_timeout);
1015   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_LONG_PRESS));
1016
1017   event = ObtainMotionEvent(event_time + long_press_timeout,
1018                             MotionEvent::ACTION_MOVE,
1019                             kFakeCoordX + 20,
1020                             kFakeCoordY + 20);
1021   event.set_id(++motion_event_id);
1022
1023   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1024   EXPECT_EQ(ET_GESTURE_PINCH_BEGIN, GetMostRecentGestureEventType());
1025   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
1026   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1027   EXPECT_TRUE(gesture_provider_->IsDoubleTapInProgress());
1028
1029   event = ObtainMotionEvent(event_time + long_press_timeout + kOneMicrosecond,
1030                             MotionEvent::ACTION_UP,
1031                             kFakeCoordX,
1032                             kFakeCoordY + 1);
1033   event.set_id(++motion_event_id);
1034   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1035   EXPECT_EQ(ET_GESTURE_SCROLL_END, GetMostRecentGestureEventType());
1036   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
1037   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1038   EXPECT_FALSE(gesture_provider_->IsDoubleTapInProgress());
1039 }
1040
1041 // Verify that the touch slop region is removed from the first scroll delta to
1042 // avoid a jump when starting to scroll.
1043 TEST_F(GestureProviderTest, TouchSlopRemovedFromScroll) {
1044   const float touch_slop = GetTouchSlop();
1045   const float scroll_delta = 5;
1046
1047   base::TimeTicks event_time = base::TimeTicks::Now();
1048
1049   MockMotionEvent event =
1050       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
1051   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1052
1053   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
1054                             MotionEvent::ACTION_MOVE,
1055                             kFakeCoordX,
1056                             kFakeCoordY + touch_slop + scroll_delta);
1057   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1058
1059   EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
1060   GestureEventData gesture = GetMostRecentGestureEvent();
1061   EXPECT_EQ(0, gesture.details.scroll_x());
1062   EXPECT_EQ(scroll_delta, gesture.details.scroll_y());
1063   EXPECT_EQ(1, gesture.details.touch_points());
1064 }
1065
1066 // Verify that movement within the touch slop region does not generate a scroll,
1067 // and that the slop region is correct even when using fractional coordinates.
1068 TEST_F(GestureProviderTest, NoScrollWithinTouchSlop) {
1069   const float touch_slop = GetTouchSlop();
1070   const float scale_factor = 2.5f;
1071   const int touch_slop_pixels = static_cast<int>(scale_factor * touch_slop);
1072
1073   base::TimeTicks event_time = base::TimeTicks::Now();
1074
1075   MockMotionEvent event =
1076       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
1077   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1078
1079   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
1080                             MotionEvent::ACTION_MOVE,
1081                             kFakeCoordX + touch_slop_pixels / scale_factor,
1082                             kFakeCoordY);
1083   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1084   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
1085
1086   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
1087                             MotionEvent::ACTION_MOVE,
1088                             kFakeCoordX,
1089                             kFakeCoordY + touch_slop_pixels / scale_factor);
1090   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1091   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
1092
1093   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
1094                             MotionEvent::ACTION_MOVE,
1095                             kFakeCoordX - touch_slop_pixels / scale_factor,
1096                             kFakeCoordY);
1097   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1098   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
1099
1100   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
1101                             MotionEvent::ACTION_MOVE,
1102                             kFakeCoordX,
1103                             kFakeCoordY - touch_slop_pixels / scale_factor);
1104   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1105   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
1106
1107   event =
1108       ObtainMotionEvent(event_time + kOneMicrosecond * 2,
1109                         MotionEvent::ACTION_MOVE,
1110                         kFakeCoordX,
1111                         kFakeCoordY + (touch_slop_pixels + 1.f) / scale_factor);
1112   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1113   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
1114 }
1115
1116 TEST_F(GestureProviderTest, NoDoubleTapWhenTooRapid) {
1117   base::TimeTicks event_time = base::TimeTicks::Now();
1118
1119   MockMotionEvent event =
1120       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
1121   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1122
1123   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1124   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1125
1126   event = ObtainMotionEvent(event_time + kOneMicrosecond,
1127                             MotionEvent::ACTION_UP,
1128                             kFakeCoordX,
1129                             kFakeCoordY);
1130   gesture_provider_->OnTouchEvent(event);
1131   EXPECT_EQ(ET_GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
1132   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1133
1134   // If the second tap follows the first in too short a time span, no double-tap
1135   // will occur.
1136   event_time += (GetDoubleTapMinTime() / 2);
1137   event = ObtainMotionEvent(event_time,
1138                             MotionEvent::ACTION_DOWN,
1139                             kFakeCoordX,
1140                             kFakeCoordY);
1141   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1142   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1143   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1144
1145   event = ObtainMotionEvent(event_time + kOneMicrosecond,
1146                             MotionEvent::ACTION_UP,
1147                             kFakeCoordX,
1148                             kFakeCoordY);
1149   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1150   EXPECT_EQ(ET_GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
1151 }
1152
1153 TEST_F(GestureProviderTest, NoDoubleTapWhenExplicitlyDisabled) {
1154   // Ensure that double-tap gestures can be disabled.
1155   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
1156
1157   base::TimeTicks event_time = base::TimeTicks::Now();
1158   MockMotionEvent event = ObtainMotionEvent(
1159       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
1160   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1161   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1162
1163   event = ObtainMotionEvent(event_time + kOneMicrosecond,
1164                             MotionEvent::ACTION_UP,
1165                             kFakeCoordX,
1166                             kFakeCoordY);
1167   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1168   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
1169
1170   event_time += GetValidDoubleTapDelay();
1171   event = ObtainMotionEvent(event_time,
1172                             MotionEvent::ACTION_DOWN,
1173                             kFakeCoordX,
1174                             kFakeCoordY);
1175   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1176   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1177
1178   event = ObtainMotionEvent(event_time + kOneMicrosecond,
1179                             MotionEvent::ACTION_UP,
1180                             kFakeCoordX,
1181                             kFakeCoordY);
1182   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1183   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
1184
1185   // Ensure that double-tap gestures can be interrupted.
1186   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(true);
1187
1188   event_time = base::TimeTicks::Now();
1189   event = ObtainMotionEvent(
1190       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
1191   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1192   EXPECT_EQ(5U, GetReceivedGestureCount());
1193
1194   event = ObtainMotionEvent(event_time + kOneMicrosecond,
1195                             MotionEvent::ACTION_UP,
1196                             kFakeCoordX,
1197                             kFakeCoordY);
1198   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1199   EXPECT_EQ(ET_GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
1200
1201   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
1202   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
1203
1204   // Ensure that double-tap gestures can be resumed.
1205   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(true);
1206
1207   event_time += GetValidDoubleTapDelay();
1208   event = ObtainMotionEvent(event_time,
1209                             MotionEvent::ACTION_DOWN,
1210                             kFakeCoordX,
1211                             kFakeCoordY);
1212   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1213   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1214
1215   event = ObtainMotionEvent(event_time + kOneMicrosecond,
1216                             MotionEvent::ACTION_UP,
1217                             kFakeCoordX,
1218                             kFakeCoordY);
1219   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1220   EXPECT_EQ(ET_GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
1221
1222   event_time += GetValidDoubleTapDelay();
1223   event = ObtainMotionEvent(event_time,
1224                             MotionEvent::ACTION_DOWN,
1225                             kFakeCoordX,
1226                             kFakeCoordY);
1227   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1228   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1229
1230   event = ObtainMotionEvent(event_time + kOneMicrosecond,
1231                             MotionEvent::ACTION_UP,
1232                             kFakeCoordX,
1233                             kFakeCoordY);
1234   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1235   EXPECT_EQ(ET_GESTURE_DOUBLE_TAP, GetMostRecentGestureEventType());
1236 }
1237
1238 TEST_F(GestureProviderTest, NoDelayedTapWhenDoubleTapSupportToggled) {
1239   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(true);
1240
1241   base::TimeTicks event_time = base::TimeTicks::Now();
1242   MockMotionEvent event = ObtainMotionEvent(
1243       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
1244   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1245   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1246   EXPECT_EQ(1U, GetReceivedGestureCount());
1247
1248   event = ObtainMotionEvent(event_time + kOneMicrosecond,
1249                             MotionEvent::ACTION_UP,
1250                             kFakeCoordX,
1251                             kFakeCoordY);
1252   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1253   EXPECT_EQ(ET_GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
1254   EXPECT_EQ(2U, GetReceivedGestureCount());
1255
1256   // Disabling double-tap during the tap timeout should flush the delayed tap.
1257   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
1258   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
1259   EXPECT_EQ(3U, GetReceivedGestureCount());
1260
1261   // No further timeout gestures should arrive.
1262   const base::TimeDelta long_press_timeout =
1263       GetLongPressTimeout() + GetShowPressTimeout() + kOneMicrosecond;
1264   RunTasksAndWait(long_press_timeout);
1265   EXPECT_EQ(3U, GetReceivedGestureCount());
1266 }
1267
1268 TEST_F(GestureProviderTest, NoDoubleTapDragZoomWhenDisabledOnPlatform) {
1269   const base::TimeTicks down_time_1 = TimeTicks::Now();
1270   const base::TimeTicks down_time_2 = down_time_1 + GetValidDoubleTapDelay();
1271
1272   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
1273
1274   MockMotionEvent event =
1275       ObtainMotionEvent(down_time_1, MotionEvent::ACTION_DOWN);
1276   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1277
1278   event = ObtainMotionEvent(down_time_1 + kOneMicrosecond,
1279                             MotionEvent::ACTION_UP,
1280                             kFakeCoordX,
1281                             kFakeCoordY);
1282   gesture_provider_->OnTouchEvent(event);
1283
1284   event = ObtainMotionEvent(
1285       down_time_2, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
1286   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1287
1288   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond,
1289                             MotionEvent::ACTION_MOVE,
1290                             kFakeCoordX,
1291                             kFakeCoordY + 100);
1292
1293   // The move should become a scroll, as doubletap drag zoom is disabled.
1294   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1295   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
1296   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_BEGIN));
1297
1298   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 2,
1299                             MotionEvent::ACTION_MOVE,
1300                             kFakeCoordX,
1301                             kFakeCoordY + 200);
1302   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1303   EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
1304   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1305   EXPECT_EQ(down_time_2 + kOneMicrosecond * 2,
1306             GetMostRecentGestureEvent().time);
1307   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_UPDATE));
1308
1309   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 3,
1310                             MotionEvent::ACTION_UP,
1311                             kFakeCoordX,
1312                             kFakeCoordY + 200);
1313   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1314   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_END));
1315 }
1316
1317 // Verify that double tap drag zoom feature is not invoked when the gesture
1318 // handler is told to disable double tap gesture detection.
1319 // The second tap sequence should be treated just as the first would be.
1320 TEST_F(GestureProviderTest, NoDoubleTapDragZoomWhenDisabledOnPage) {
1321   const base::TimeTicks down_time_1 = TimeTicks::Now();
1322   const base::TimeTicks down_time_2 = down_time_1 + GetValidDoubleTapDelay();
1323
1324   gesture_provider_->SetDoubleTapSupportForPageEnabled(false);
1325
1326   MockMotionEvent event =
1327       ObtainMotionEvent(down_time_1, MotionEvent::ACTION_DOWN);
1328   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1329
1330   event = ObtainMotionEvent(down_time_1 + kOneMicrosecond,
1331                             MotionEvent::ACTION_UP,
1332                             kFakeCoordX,
1333                             kFakeCoordY);
1334   gesture_provider_->OnTouchEvent(event);
1335
1336   event = ObtainMotionEvent(
1337       down_time_2, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
1338   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1339
1340   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond,
1341                             MotionEvent::ACTION_MOVE,
1342                             kFakeCoordX,
1343                             kFakeCoordY + 100);
1344
1345   // The move should become a scroll, as double tap drag zoom is disabled.
1346   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1347   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
1348   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_BEGIN));
1349
1350   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 2,
1351                             MotionEvent::ACTION_MOVE,
1352                             kFakeCoordX,
1353                             kFakeCoordY + 200);
1354   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1355   EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
1356   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1357   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_UPDATE));
1358
1359   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 3,
1360                             MotionEvent::ACTION_UP,
1361                             kFakeCoordX,
1362                             kFakeCoordY + 200);
1363   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1364   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_END));
1365 }
1366
1367 // Verify that updating double tap support during a double tap drag zoom
1368 // disables double tap detection after the gesture has ended.
1369 TEST_F(GestureProviderTest, FixedPageScaleDuringDoubleTapDragZoom) {
1370   base::TimeTicks down_time_1 = TimeTicks::Now();
1371   base::TimeTicks down_time_2 = down_time_1 + GetValidDoubleTapDelay();
1372
1373   gesture_provider_->SetDoubleTapSupportForPageEnabled(true);
1374   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(true);
1375
1376   // Start a double-tap drag gesture.
1377   MockMotionEvent event =
1378       ObtainMotionEvent(down_time_1, MotionEvent::ACTION_DOWN);
1379   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1380   event = ObtainMotionEvent(down_time_1 + kOneMicrosecond,
1381                             MotionEvent::ACTION_UP,
1382                             kFakeCoordX,
1383                             kFakeCoordY);
1384   gesture_provider_->OnTouchEvent(event);
1385   event = ObtainMotionEvent(
1386       down_time_2, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
1387   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1388   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond,
1389                             MotionEvent::ACTION_MOVE,
1390                             kFakeCoordX,
1391                             kFakeCoordY + 100);
1392   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1393   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
1394   EXPECT_EQ(ET_GESTURE_PINCH_BEGIN, GetMostRecentGestureEventType());
1395   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1396
1397   // Simulate setting a fixed page scale (or a mobile viewport);
1398   // this should not disrupt the current double-tap gesture.
1399   gesture_provider_->SetDoubleTapSupportForPageEnabled(false);
1400
1401   // Double tap zoom updates should continue.
1402   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 2,
1403                             MotionEvent::ACTION_MOVE,
1404                             kFakeCoordX,
1405                             kFakeCoordY + 200);
1406   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1407   EXPECT_EQ(ET_GESTURE_PINCH_UPDATE, GetMostRecentGestureEventType());
1408   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1409   EXPECT_LT(1.f, GetMostRecentGestureEvent().details.scale());
1410   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 3,
1411                             MotionEvent::ACTION_UP,
1412                             kFakeCoordX,
1413                             kFakeCoordY + 200);
1414   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1415   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_PINCH_END));
1416   EXPECT_EQ(ET_GESTURE_SCROLL_END, GetMostRecentGestureEventType());
1417   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1418
1419   // The double-tap gesture has finished, but the page scale is fixed.
1420   // The same event sequence should not generate any double tap getsures.
1421   gestures_.clear();
1422   down_time_1 += kOneMicrosecond * 40;
1423   down_time_2 += kOneMicrosecond * 40;
1424
1425   // Start a double-tap drag gesture.
1426   event = ObtainMotionEvent(down_time_1, MotionEvent::ACTION_DOWN);
1427   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1428   event = ObtainMotionEvent(down_time_1 + kOneMicrosecond,
1429                             MotionEvent::ACTION_UP,
1430                             kFakeCoordX,
1431                             kFakeCoordY);
1432   gesture_provider_->OnTouchEvent(event);
1433   event = ObtainMotionEvent(
1434       down_time_2, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
1435   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1436   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond,
1437                             MotionEvent::ACTION_MOVE,
1438                             kFakeCoordX,
1439                             kFakeCoordY + 100);
1440   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1441   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
1442   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_BEGIN));
1443
1444   // Double tap zoom updates should not be sent.
1445   // Instead, the second tap drag becomes a scroll gesture sequence.
1446   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 2,
1447                             MotionEvent::ACTION_MOVE,
1448                             kFakeCoordX,
1449                             kFakeCoordY + 200);
1450   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1451   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_UPDATE));
1452   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_UPDATE));
1453   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 3,
1454                             MotionEvent::ACTION_UP,
1455                             kFakeCoordX,
1456                             kFakeCoordY + 200);
1457   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1458   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_END));
1459 }
1460
1461 // Verify that pinch zoom sends the proper event sequence.
1462 TEST_F(GestureProviderTest, PinchZoom) {
1463   base::TimeTicks event_time = base::TimeTicks::Now();
1464   const float touch_slop = GetTouchSlop();
1465   const float raw_offset_x = 3.2f;
1466   const float raw_offset_y = 4.3f;
1467   int motion_event_id = 0;
1468
1469   gesture_provider_->SetDoubleTapSupportForPageEnabled(false);
1470   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(true);
1471   gesture_provider_->SetMultiTouchZoomSupportEnabled(true);
1472
1473   int secondary_coord_x = kFakeCoordX + 20 * touch_slop;
1474   int secondary_coord_y = kFakeCoordY + 20 * touch_slop;
1475
1476   MockMotionEvent event =
1477       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
1478   event.set_id(++motion_event_id);
1479   event.SetRawOffset(raw_offset_x, raw_offset_y);
1480   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1481   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1482   EXPECT_EQ(kFakeCoordX, GetMostRecentGestureEvent().x);
1483   EXPECT_EQ(kFakeCoordY, GetMostRecentGestureEvent().y);
1484   EXPECT_EQ(kFakeCoordX + raw_offset_x, GetMostRecentGestureEvent().raw_x);
1485   EXPECT_EQ(kFakeCoordY + raw_offset_y, GetMostRecentGestureEvent().raw_y);
1486   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1487   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY),
1488             GetMostRecentGestureEvent().details.bounding_box());
1489
1490   // Toggling double-tap support should not take effect until the next sequence.
1491   gesture_provider_->SetDoubleTapSupportForPageEnabled(true);
1492
1493   event = ObtainMotionEvent(event_time,
1494                             MotionEvent::ACTION_POINTER_DOWN,
1495                             kFakeCoordX,
1496                             kFakeCoordY,
1497                             secondary_coord_x,
1498                             secondary_coord_y);
1499   event.set_id(++motion_event_id);
1500   event.SetRawOffset(raw_offset_x, raw_offset_y);
1501
1502   gesture_provider_->OnTouchEvent(event);
1503   EXPECT_EQ(1U, GetReceivedGestureCount());
1504   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1505   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY),
1506             GetMostRecentGestureEvent().details.bounding_box());
1507
1508   secondary_coord_x += 5 * touch_slop;
1509   secondary_coord_y += 5 * touch_slop;
1510   event = ObtainMotionEvent(event_time,
1511                             MotionEvent::ACTION_MOVE,
1512                             kFakeCoordX,
1513                             kFakeCoordY,
1514                             secondary_coord_x,
1515                             secondary_coord_y);
1516   event.set_id(++motion_event_id);
1517   event.SetRawOffset(raw_offset_x, raw_offset_y);
1518
1519   // Toggling double-tap support should not take effect until the next sequence.
1520   gesture_provider_->SetDoubleTapSupportForPageEnabled(false);
1521
1522   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1523   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
1524   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
1525   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_PINCH_BEGIN));
1526   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
1527   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_UPDATE));
1528
1529   EXPECT_EQ((kFakeCoordX + secondary_coord_x) / 2, GetReceivedGesture(3).x);
1530   EXPECT_EQ((kFakeCoordY + secondary_coord_y) / 2, GetReceivedGesture(3).y);
1531   EXPECT_EQ((kFakeCoordX + secondary_coord_x) / 2 + raw_offset_x,
1532             GetReceivedGesture(3).raw_x);
1533   EXPECT_EQ((kFakeCoordY + secondary_coord_y) / 2 + raw_offset_y,
1534             GetReceivedGesture(3).raw_y);
1535
1536   EXPECT_EQ(
1537       gfx::RectF(kFakeCoordX - kMockTouchRadius,
1538                  kFakeCoordY - kMockTouchRadius,
1539                  secondary_coord_x - kFakeCoordX + kMockTouchRadius * 2,
1540                  secondary_coord_y - kFakeCoordY + kMockTouchRadius * 2),
1541       GetMostRecentGestureEvent().details.bounding_box());
1542
1543   secondary_coord_x += 2 * touch_slop;
1544   secondary_coord_y += 2 * touch_slop;
1545   event = ObtainMotionEvent(event_time,
1546                             MotionEvent::ACTION_MOVE,
1547                             kFakeCoordX,
1548                             kFakeCoordY,
1549                             secondary_coord_x,
1550                             secondary_coord_y);
1551   event.set_id(++motion_event_id);
1552
1553   // Toggling double-tap support should not take effect until the next sequence.
1554   gesture_provider_->SetDoubleTapSupportForPageEnabled(true);
1555
1556   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1557   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
1558   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_UPDATE));
1559   EXPECT_EQ(ET_GESTURE_PINCH_UPDATE, GetMostRecentGestureEventType());
1560   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
1561   EXPECT_LT(1.f, GetMostRecentGestureEvent().details.scale());
1562   EXPECT_EQ(
1563       gfx::RectF(kFakeCoordX - kMockTouchRadius,
1564                  kFakeCoordY - kMockTouchRadius,
1565                  secondary_coord_x - kFakeCoordX + kMockTouchRadius * 2,
1566                  secondary_coord_y - kFakeCoordY + kMockTouchRadius * 2),
1567       GetMostRecentGestureEvent().details.bounding_box());
1568
1569   event = ObtainMotionEvent(event_time,
1570                             MotionEvent::ACTION_POINTER_UP,
1571                             kFakeCoordX,
1572                             kFakeCoordY,
1573                             secondary_coord_x,
1574                             secondary_coord_y);
1575   event.set_id(++motion_event_id);
1576
1577   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1578   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
1579   EXPECT_EQ(ET_GESTURE_PINCH_END, GetMostRecentGestureEventType());
1580   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
1581   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SCROLL_END));
1582   EXPECT_EQ(
1583       gfx::RectF(kFakeCoordX - kMockTouchRadius,
1584                  kFakeCoordY - kMockTouchRadius,
1585                  secondary_coord_x - kFakeCoordX + kMockTouchRadius * 2,
1586                  secondary_coord_y - kFakeCoordY + kMockTouchRadius * 2),
1587       GetMostRecentGestureEvent().details.bounding_box());
1588
1589   event = ObtainMotionEvent(event_time, MotionEvent::ACTION_UP);
1590   gesture_provider_->OnTouchEvent(event);
1591   EXPECT_EQ(ET_GESTURE_SCROLL_END, GetMostRecentGestureEventType());
1592   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1593   EXPECT_EQ(gfx::RectF(kFakeCoordX - kMockTouchRadius,
1594                        kFakeCoordY - kMockTouchRadius,
1595                        kMockTouchRadius * 2,
1596                        kMockTouchRadius * 2),
1597             GetMostRecentGestureEvent().details.bounding_box());
1598 }
1599
1600 // Verify that no accidental pinching occurs if the touch size is large relative
1601 // to the min scaling span when the touch major value is used in scaling.
1602 TEST_F(GestureProviderTest, NoPinchZoomWithFatFinger) {
1603   base::TimeTicks event_time = base::TimeTicks::Now();
1604   const float kFatFingerSize = GetMinScalingSpan() * 3.f;
1605
1606   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
1607   gesture_provider_->SetMultiTouchZoomSupportEnabled(true);
1608
1609   MockMotionEvent event =
1610       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
1611   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1612   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1613   EXPECT_EQ(1U, GetReceivedGestureCount());
1614
1615   event = ObtainMotionEvent(event_time + kOneSecond,
1616                             MotionEvent::ACTION_MOVE);
1617   event.SetTouchMajor(0.1f);
1618   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1619   EXPECT_EQ(1U, GetReceivedGestureCount());
1620
1621   event = ObtainMotionEvent(event_time + kOneSecond * 2,
1622                             MotionEvent::ACTION_MOVE,
1623                             kFakeCoordX + 1.f,
1624                             kFakeCoordY);
1625   event.SetTouchMajor(1.f);
1626   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1627   EXPECT_EQ(1U, GetReceivedGestureCount());
1628
1629   event = ObtainMotionEvent(event_time + kOneSecond * 3,
1630                             MotionEvent::ACTION_MOVE);
1631   event.SetTouchMajor(kFatFingerSize * 3.5f);
1632   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1633   EXPECT_EQ(1U, GetReceivedGestureCount());
1634
1635   event = ObtainMotionEvent(event_time + kOneSecond * 4,
1636                             MotionEvent::ACTION_MOVE);
1637   event.SetTouchMajor(kFatFingerSize * 5.f);
1638   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1639   EXPECT_EQ(1U, GetReceivedGestureCount());
1640
1641   event = ObtainMotionEvent(event_time + kOneSecond * 4,
1642                             MotionEvent::ACTION_MOVE,
1643                             kFakeCoordX + 50.f,
1644                             kFakeCoordY - 25.f);
1645   event.SetTouchMajor(kFatFingerSize * 10.f);
1646   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1647   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_BEGIN));
1648
1649   event = ObtainMotionEvent(event_time + kOneSecond * 4,
1650                             MotionEvent::ACTION_MOVE,
1651                             kFakeCoordX + 100.f,
1652                             kFakeCoordY - 50.f);
1653   event.SetTouchMajor(kFatFingerSize * 5.f);
1654   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1655   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_BEGIN));
1656 }
1657
1658 // Verify that multi-finger swipe sends the proper event sequence.
1659 TEST_F(GestureProviderTest, MultiFingerSwipe) {
1660   EnableSwipe();
1661   gesture_provider_->SetMultiTouchZoomSupportEnabled(false);
1662   const float min_swipe_velocity = GetMinSwipeVelocity();
1663
1664   // One finger - swipe right
1665   OneFingerSwipe(2 * min_swipe_velocity, 0);
1666   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SWIPE));
1667   EXPECT_TRUE(GetMostRecentGestureEvent().details.swipe_right());
1668   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1669   ResetGestureDetection();
1670
1671   // One finger - swipe left
1672   OneFingerSwipe(-2 * min_swipe_velocity, 0);
1673   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SWIPE));
1674   EXPECT_TRUE(GetMostRecentGestureEvent().details.swipe_left());
1675   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1676   ResetGestureDetection();
1677
1678   // One finger - swipe down
1679   OneFingerSwipe(0, 2 * min_swipe_velocity);
1680   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SWIPE));
1681   EXPECT_TRUE(GetMostRecentGestureEvent().details.swipe_down());
1682   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1683   ResetGestureDetection();
1684
1685   // One finger - swipe up
1686   OneFingerSwipe(0, -2 * min_swipe_velocity);
1687   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SWIPE));
1688   EXPECT_TRUE(GetMostRecentGestureEvent().details.swipe_up());
1689   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1690   ResetGestureDetection();
1691
1692   // Two fingers
1693   // Swipe right.
1694   TwoFingerSwipe(min_swipe_velocity * 2, 0, min_swipe_velocity * 2, 0);
1695   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SWIPE));
1696   EXPECT_TRUE(GetMostRecentGestureEvent().details.swipe_right());
1697   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
1698   ResetGestureDetection();
1699
1700   // Swipe left.
1701   TwoFingerSwipe(-min_swipe_velocity * 2, 0, -min_swipe_velocity * 2, 0);
1702   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SWIPE));
1703   EXPECT_TRUE(GetMostRecentGestureEvent().details.swipe_left());
1704   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
1705   ResetGestureDetection();
1706
1707   // No swipe with different touch directions.
1708   TwoFingerSwipe(min_swipe_velocity * 2, 0, -min_swipe_velocity * 2, 0);
1709   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SWIPE));
1710   ResetGestureDetection();
1711
1712   // No swipe without a dominant direction.
1713   TwoFingerSwipe(min_swipe_velocity * 2,
1714                  min_swipe_velocity * 2,
1715                  min_swipe_velocity * 2,
1716                  min_swipe_velocity * 2);
1717   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SWIPE));
1718   ResetGestureDetection();
1719
1720   // Swipe down with non-zero velocities on both axes and dominant direction.
1721   TwoFingerSwipe(-min_swipe_velocity,
1722                  min_swipe_velocity * 4,
1723                  -min_swipe_velocity,
1724                  min_swipe_velocity * 4);
1725   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SWIPE));
1726   EXPECT_TRUE(GetMostRecentGestureEvent().details.swipe_down());
1727   EXPECT_FALSE(GetMostRecentGestureEvent().details.swipe_left());
1728   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
1729   ResetGestureDetection();
1730
1731   // Swipe up with non-zero velocities on both axes.
1732   TwoFingerSwipe(min_swipe_velocity,
1733                  -min_swipe_velocity * 4,
1734                  min_swipe_velocity,
1735                  -min_swipe_velocity * 4);
1736   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SWIPE));
1737   EXPECT_TRUE(GetMostRecentGestureEvent().details.swipe_up());
1738   EXPECT_FALSE(GetMostRecentGestureEvent().details.swipe_right());
1739   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
1740   ResetGestureDetection();
1741
1742   // No swipe without sufficient velocity.
1743   TwoFingerSwipe(min_swipe_velocity / 2, 0, 0, 0);
1744   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SWIPE));
1745   ResetGestureDetection();
1746
1747   // Swipe up with one small and one medium velocity in slightly different but
1748   // not opposing directions.
1749   TwoFingerSwipe(min_swipe_velocity / 2,
1750                  min_swipe_velocity / 2,
1751                  0,
1752                  min_swipe_velocity * 2);
1753   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SWIPE));
1754   EXPECT_TRUE(GetMostRecentGestureEvent().details.swipe_down());
1755   EXPECT_FALSE(GetMostRecentGestureEvent().details.swipe_right());
1756   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
1757   ResetGestureDetection();
1758
1759   // No swipe in orthogonal directions.
1760   TwoFingerSwipe(min_swipe_velocity * 2, 0, 0, min_swipe_velocity * 7);
1761   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SWIPE));
1762   ResetGestureDetection();
1763
1764   // Three finger swipe in same directions.
1765   ThreeFingerSwipe(min_swipe_velocity * 2,
1766                    0,
1767                    min_swipe_velocity * 3,
1768                    0,
1769                    min_swipe_velocity * 4,
1770                    0);
1771   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SWIPE));
1772   EXPECT_TRUE(GetMostRecentGestureEvent().details.swipe_right());
1773   EXPECT_EQ(3, GetMostRecentGestureEvent().details.touch_points());
1774   ResetGestureDetection();
1775
1776   // No three finger swipe in different directions.
1777   ThreeFingerSwipe(min_swipe_velocity * 2,
1778                    0,
1779                    0,
1780                    min_swipe_velocity * 3,
1781                    min_swipe_velocity * 4,
1782                    0);
1783   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_SWIPE));
1784 }
1785
1786 // Verify that the timer of LONG_PRESS will be cancelled when scrolling begins
1787 // so LONG_PRESS and LONG_TAP won't be triggered.
1788 TEST_F(GestureProviderTest, GesturesCancelledAfterLongPressCausesLostFocus) {
1789   base::TimeTicks event_time = base::TimeTicks::Now();
1790
1791   MockMotionEvent event =
1792       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
1793   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1794
1795   const base::TimeDelta long_press_timeout =
1796       GetLongPressTimeout() + GetShowPressTimeout() + kOneMicrosecond;
1797   RunTasksAndWait(long_press_timeout);
1798   EXPECT_EQ(ET_GESTURE_LONG_PRESS, GetMostRecentGestureEventType());
1799   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1800
1801   EXPECT_TRUE(CancelActiveTouchSequence());
1802   EXPECT_FALSE(HasDownEvent());
1803
1804   event = ObtainMotionEvent(event_time + long_press_timeout,
1805                             MotionEvent::ACTION_UP);
1806   gesture_provider_->OnTouchEvent(event);
1807   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_LONG_TAP));
1808 }
1809
1810 // Verify that inserting a touch cancel event will trigger proper touch and
1811 // gesture sequence cancellation.
1812 TEST_F(GestureProviderTest, CancelActiveTouchSequence) {
1813   base::TimeTicks event_time = base::TimeTicks::Now();
1814   int motion_event_id = 0;
1815
1816   EXPECT_FALSE(CancelActiveTouchSequence());
1817   EXPECT_EQ(0U, GetReceivedGestureCount());
1818
1819   MockMotionEvent event =
1820       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
1821   event.set_id(++motion_event_id);
1822   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1823   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1824   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
1825   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1826
1827   ASSERT_TRUE(CancelActiveTouchSequence());
1828   EXPECT_FALSE(HasDownEvent());
1829
1830   // Subsequent MotionEvent's are dropped until ACTION_DOWN.
1831   event = ObtainMotionEvent(event_time + kOneMicrosecond,
1832                             MotionEvent::ACTION_MOVE);
1833   EXPECT_FALSE(gesture_provider_->OnTouchEvent(event));
1834
1835   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
1836                             MotionEvent::ACTION_UP);
1837   EXPECT_FALSE(gesture_provider_->OnTouchEvent(event));
1838
1839   event = ObtainMotionEvent(event_time + kOneMicrosecond * 3,
1840                             MotionEvent::ACTION_DOWN);
1841   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1842   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1843   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1844 }
1845
1846 TEST_F(GestureProviderTest, DoubleTapDragZoomCancelledOnSecondaryPointerDown) {
1847   const base::TimeTicks down_time_1 = TimeTicks::Now();
1848   const base::TimeTicks down_time_2 = down_time_1 + GetValidDoubleTapDelay();
1849
1850   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(true);
1851
1852   MockMotionEvent event =
1853       ObtainMotionEvent(down_time_1, MotionEvent::ACTION_DOWN);
1854   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1855   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1856   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1857
1858   event =
1859       ObtainMotionEvent(down_time_1 + kOneMicrosecond, MotionEvent::ACTION_UP);
1860   gesture_provider_->OnTouchEvent(event);
1861   EXPECT_EQ(ET_GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
1862   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1863
1864   event = ObtainMotionEvent(down_time_2, MotionEvent::ACTION_DOWN);
1865   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1866   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1867   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1868
1869   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond,
1870                             MotionEvent::ACTION_MOVE,
1871                             kFakeCoordX,
1872                             kFakeCoordY - 30);
1873   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1874   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
1875   EXPECT_EQ(ET_GESTURE_PINCH_BEGIN, GetMostRecentGestureEventType());
1876   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1877
1878   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 2,
1879                             MotionEvent::ACTION_POINTER_DOWN,
1880                             kFakeCoordX,
1881                             kFakeCoordY - 30,
1882                             kFakeCoordX + 50,
1883                             kFakeCoordY + 50);
1884   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1885   EXPECT_EQ(ET_GESTURE_PINCH_END, GetMostRecentGestureEventType());
1886   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
1887
1888   const size_t gesture_count = GetReceivedGestureCount();
1889   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 3,
1890                             MotionEvent::ACTION_POINTER_UP,
1891                             kFakeCoordX,
1892                             kFakeCoordY - 30,
1893                             kFakeCoordX + 50,
1894                             kFakeCoordY + 50);
1895   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1896   EXPECT_EQ(gesture_count, GetReceivedGestureCount());
1897
1898   event = ObtainMotionEvent(down_time_2 + kOneSecond,
1899                             MotionEvent::ACTION_UP);
1900   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1901   EXPECT_EQ(gesture_count + 1, GetReceivedGestureCount());
1902   EXPECT_EQ(ET_GESTURE_SCROLL_END, GetMostRecentGestureEventType());
1903   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1904 }
1905
1906 // Verify that gesture begin and gesture end events are dispatched correctly.
1907 TEST_F(GestureProviderTest, GestureBeginAndEnd) {
1908   EnableBeginEndTypes();
1909   base::TimeTicks event_time = base::TimeTicks::Now();
1910   const float raw_offset_x = 7.5f;
1911   const float raw_offset_y = 5.7f;
1912
1913   EXPECT_EQ(0U, GetReceivedGestureCount());
1914   MockMotionEvent event =
1915       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 1, 1);
1916   event.SetRawOffset(raw_offset_x, raw_offset_y);
1917   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1918   EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type());
1919   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
1920   EXPECT_EQ(2U, GetReceivedGestureCount());
1921   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
1922   EXPECT_EQ(1, GetMostRecentGestureEvent().x);
1923   EXPECT_EQ(1, GetMostRecentGestureEvent().y);
1924   EXPECT_EQ(1 + raw_offset_x, GetMostRecentGestureEvent().raw_x);
1925   EXPECT_EQ(1 + raw_offset_y, GetMostRecentGestureEvent().raw_y);
1926   EXPECT_EQ(gfx::RectF(1 - kMockTouchRadius,
1927                        1 - kMockTouchRadius,
1928                        kMockTouchRadius * 2,
1929                        kMockTouchRadius * 2),
1930             GetMostRecentGestureEvent().details.bounding_box());
1931
1932   event = ObtainMotionEvent(
1933       event_time, MotionEvent::ACTION_POINTER_DOWN, 1, 1, 2, 2);
1934   event.SetRawOffset(raw_offset_x, raw_offset_y);
1935   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1936   EXPECT_EQ(ET_GESTURE_BEGIN, GetMostRecentGestureEventType());
1937   EXPECT_EQ(3U, GetReceivedGestureCount());
1938   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
1939   EXPECT_EQ(2, GetMostRecentGestureEvent().x);
1940   EXPECT_EQ(2, GetMostRecentGestureEvent().y);
1941   EXPECT_EQ(2 + raw_offset_x, GetMostRecentGestureEvent().raw_x);
1942   EXPECT_EQ(2 + raw_offset_y, GetMostRecentGestureEvent().raw_y);
1943
1944   event = ObtainMotionEvent(
1945       event_time, MotionEvent::ACTION_POINTER_DOWN, 1, 1, 2, 2, 3, 3);
1946   event.SetRawOffset(raw_offset_x, raw_offset_y);
1947   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1948   EXPECT_EQ(ET_GESTURE_BEGIN, GetMostRecentGestureEventType());
1949   EXPECT_EQ(4U, GetReceivedGestureCount());
1950   EXPECT_EQ(3, GetMostRecentGestureEvent().details.touch_points());
1951   EXPECT_EQ(3, GetMostRecentGestureEvent().x);
1952   EXPECT_EQ(3, GetMostRecentGestureEvent().y);
1953   EXPECT_EQ(3 + raw_offset_x, GetMostRecentGestureEvent().raw_x);
1954   EXPECT_EQ(3 + raw_offset_y, GetMostRecentGestureEvent().raw_y);
1955
1956   event = ObtainMotionEvent(
1957       event_time, MotionEvent::ACTION_POINTER_UP, 1, 1, 2, 2, 3, 3);
1958   event.SetRawOffset(raw_offset_x, raw_offset_y);
1959   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1960   EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEventType());
1961   EXPECT_EQ(5U, GetReceivedGestureCount());
1962   EXPECT_EQ(3, GetMostRecentGestureEvent().details.touch_points());
1963   EXPECT_EQ(1, GetMostRecentGestureEvent().x);
1964   EXPECT_EQ(1, GetMostRecentGestureEvent().y);
1965   EXPECT_EQ(1 + raw_offset_x, GetMostRecentGestureEvent().raw_x);
1966   EXPECT_EQ(1 + raw_offset_y, GetMostRecentGestureEvent().raw_y);
1967
1968   event = ObtainMotionEvent(
1969       event_time, MotionEvent::ACTION_POINTER_DOWN, 2, 2, 3, 3, 4, 4);
1970   event.SetRawOffset(raw_offset_x, raw_offset_y);
1971   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1972   EXPECT_EQ(ET_GESTURE_BEGIN, GetMostRecentGestureEventType());
1973   EXPECT_EQ(6U, GetReceivedGestureCount());
1974   EXPECT_EQ(3, GetMostRecentGestureEvent().details.touch_points());
1975   EXPECT_EQ(4, GetMostRecentGestureEvent().x);
1976   EXPECT_EQ(4, GetMostRecentGestureEvent().y);
1977   EXPECT_EQ(4 + raw_offset_x, GetMostRecentGestureEvent().raw_x);
1978   EXPECT_EQ(4 + raw_offset_y, GetMostRecentGestureEvent().raw_y);
1979
1980   event = ObtainMotionEvent(
1981       event_time, MotionEvent::ACTION_POINTER_UP, 2, 2, 3, 3, 4, 4);
1982   event.SetRawOffset(raw_offset_x, raw_offset_y);
1983   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1984   EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEventType());
1985   EXPECT_EQ(7U, GetReceivedGestureCount());
1986   EXPECT_EQ(3, GetMostRecentGestureEvent().details.touch_points());
1987   EXPECT_EQ(2, GetMostRecentGestureEvent().x);
1988   EXPECT_EQ(2, GetMostRecentGestureEvent().y);
1989   EXPECT_EQ(2 + raw_offset_x, GetMostRecentGestureEvent().raw_x);
1990   EXPECT_EQ(2 + raw_offset_y, GetMostRecentGestureEvent().raw_y);
1991
1992   event =
1993       ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_UP, 3, 3, 4, 4);
1994   event.SetRawOffset(raw_offset_x, raw_offset_y);
1995   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
1996   EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEventType());
1997   EXPECT_EQ(8U, GetReceivedGestureCount());
1998   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
1999   EXPECT_EQ(3, GetMostRecentGestureEvent().x);
2000   EXPECT_EQ(3, GetMostRecentGestureEvent().y);
2001   EXPECT_EQ(3 + raw_offset_x, GetMostRecentGestureEvent().raw_x);
2002   EXPECT_EQ(3 + raw_offset_y, GetMostRecentGestureEvent().raw_y);
2003
2004
2005   event = ObtainMotionEvent(event_time, MotionEvent::ACTION_UP, 4, 4);
2006   event.SetRawOffset(raw_offset_x, raw_offset_y);
2007   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2008   EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEventType());
2009   EXPECT_EQ(9U, GetReceivedGestureCount());
2010   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
2011   EXPECT_EQ(4, GetMostRecentGestureEvent().x);
2012   EXPECT_EQ(4, GetMostRecentGestureEvent().y);
2013   EXPECT_EQ(4 + raw_offset_x, GetMostRecentGestureEvent().raw_x);
2014   EXPECT_EQ(4 + raw_offset_y, GetMostRecentGestureEvent().raw_y);
2015 }
2016
2017 // Verify that gesture begin and gesture end events are dispatched correctly
2018 // when an ACTION_CANCEL is received.
2019 TEST_F(GestureProviderTest, GestureBeginAndEndOnCancel) {
2020   EnableBeginEndTypes();
2021   base::TimeTicks event_time = base::TimeTicks::Now();
2022
2023   EXPECT_EQ(0U, GetReceivedGestureCount());
2024   MockMotionEvent event =
2025       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 1, 1);
2026   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2027   EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type());
2028   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
2029   EXPECT_EQ(2U, GetReceivedGestureCount());
2030   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
2031   EXPECT_EQ(gfx::RectF(1 - kMockTouchRadius,
2032                        1 - kMockTouchRadius,
2033                        kMockTouchRadius * 2,
2034                        kMockTouchRadius * 2),
2035             GetMostRecentGestureEvent().details.bounding_box());
2036   EXPECT_EQ(1, GetMostRecentGestureEvent().x);
2037   EXPECT_EQ(1, GetMostRecentGestureEvent().y);
2038
2039   event = ObtainMotionEvent(
2040       event_time, MotionEvent::ACTION_POINTER_DOWN, 1, 1, 2, 2);
2041   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2042   EXPECT_EQ(ET_GESTURE_BEGIN, GetMostRecentGestureEventType());
2043   EXPECT_EQ(3U, GetReceivedGestureCount());
2044   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
2045   EXPECT_EQ(2, GetMostRecentGestureEvent().x);
2046   EXPECT_EQ(2, GetMostRecentGestureEvent().y);
2047
2048   event = ObtainMotionEvent(
2049       event_time, MotionEvent::ACTION_POINTER_DOWN, 1, 1, 2, 2, 3, 3);
2050   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2051   EXPECT_EQ(ET_GESTURE_BEGIN, GetMostRecentGestureEventType());
2052   EXPECT_EQ(4U, GetReceivedGestureCount());
2053   EXPECT_EQ(3, GetMostRecentGestureEvent().details.touch_points());
2054   EXPECT_EQ(3, GetMostRecentGestureEvent().x);
2055   EXPECT_EQ(3, GetMostRecentGestureEvent().y);
2056
2057   event = ObtainMotionEvent(
2058       event_time, MotionEvent::ACTION_CANCEL, 1, 1, 2, 2, 3, 3);
2059   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2060   EXPECT_EQ(5U, GetReceivedGestureCount());
2061   EXPECT_EQ(3, GetReceivedGesture(4).details.touch_points());
2062   EXPECT_EQ(ET_GESTURE_END, GetReceivedGesture(4).type());
2063   EXPECT_EQ(1, GetMostRecentGestureEvent().x);
2064   EXPECT_EQ(1, GetMostRecentGestureEvent().y);
2065
2066   event = ObtainMotionEvent(
2067       event_time, MotionEvent::ACTION_CANCEL, 1, 1, 3, 3);
2068   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2069   EXPECT_EQ(6U, GetReceivedGestureCount());
2070   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
2071   EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEvent().type());
2072   EXPECT_EQ(1, GetMostRecentGestureEvent().x);
2073   EXPECT_EQ(1, GetMostRecentGestureEvent().y);
2074
2075   event = ObtainMotionEvent(
2076       event_time, MotionEvent::ACTION_CANCEL, 3, 3);
2077   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2078   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
2079   EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEvent().type());
2080   EXPECT_EQ(3, GetMostRecentGestureEvent().x);
2081   EXPECT_EQ(3, GetMostRecentGestureEvent().y);
2082 }
2083
2084 // Test a simple two finger tap
2085 TEST_F(GestureProviderTest, TwoFingerTap) {
2086   // The time between ACTION_POINTER_DOWN and ACTION_POINTER_UP must be <= the
2087   // two finger tap delay.
2088   EnableTwoFingerTap(kMaxTwoFingerTapSeparation, base::TimeDelta());
2089   const float scaled_touch_slop = GetTouchSlop();
2090
2091   base::TimeTicks event_time = base::TimeTicks::Now();
2092
2093   MockMotionEvent event =
2094       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 0, 0);
2095   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2096
2097   event = ObtainMotionEvent(event_time,
2098                             MotionEvent::ACTION_MOVE,
2099                             0,
2100                             scaled_touch_slop / 2);
2101
2102   event = ObtainMotionEvent(event_time,
2103                             MotionEvent::ACTION_POINTER_DOWN,
2104                             0,
2105                             0,
2106                             kMaxTwoFingerTapSeparation / 2,
2107                             0);
2108   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2109
2110   event =
2111       ObtainMotionEvent(event_time,
2112                         MotionEvent::ACTION_MOVE,
2113                         0,
2114                         -scaled_touch_slop / 2,
2115                         kMaxTwoFingerTapSeparation / 2 + scaled_touch_slop / 2,
2116                         0);
2117   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2118
2119   event = ObtainMotionEvent(event_time,
2120                             MotionEvent::ACTION_POINTER_UP,
2121                             0,
2122                             0,
2123                             kMaxTwoFingerTapSeparation,
2124                             0);
2125   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2126
2127   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
2128   EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
2129   EXPECT_EQ(ET_GESTURE_TWO_FINGER_TAP, GetReceivedGesture(2).type());
2130   EXPECT_EQ(3U, GetReceivedGestureCount());
2131
2132   EXPECT_EQ(kMockTouchRadius * 2,
2133             GetReceivedGesture(2).details.first_finger_width());
2134   EXPECT_EQ(kMockTouchRadius * 2,
2135             GetReceivedGesture(2).details.first_finger_height());
2136 }
2137
2138 // Test preventing a two finger tap via finger movement.
2139 TEST_F(GestureProviderTest, TwoFingerTapCancelledByFingerMovement) {
2140   EnableTwoFingerTap(kMaxTwoFingerTapSeparation, base::TimeDelta());
2141   const float scaled_touch_slop = GetTouchSlop();
2142   base::TimeTicks event_time = base::TimeTicks::Now();
2143
2144   MockMotionEvent event = ObtainMotionEvent(
2145       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
2146   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2147
2148   event = ObtainMotionEvent(event_time,
2149                             MotionEvent::ACTION_POINTER_DOWN,
2150                             kFakeCoordX,
2151                             kFakeCoordY,
2152                             kFakeCoordX,
2153                             kFakeCoordY);
2154   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2155
2156   event = ObtainMotionEvent(event_time,
2157                             MotionEvent::ACTION_MOVE,
2158                             kFakeCoordX,
2159                             kFakeCoordY,
2160                             kFakeCoordX + scaled_touch_slop + 0.1,
2161                             kFakeCoordY);
2162   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2163
2164   event = ObtainMotionEvent(event_time,
2165                             MotionEvent::ACTION_POINTER_UP,
2166                             kFakeCoordX,
2167                             kFakeCoordY,
2168                             kFakeCoordX,
2169                             kFakeCoordY);
2170   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2171
2172   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
2173   EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
2174   EXPECT_EQ(2U, GetReceivedGestureCount());
2175 }
2176
2177 // Test preventing a two finger tap by waiting too long before releasing the
2178 // secondary pointer.
2179 TEST_F(GestureProviderTest, TwoFingerTapCancelledByDelay) {
2180   base::TimeDelta two_finger_tap_timeout = kOneSecond;
2181   EnableTwoFingerTap(kMaxTwoFingerTapSeparation, two_finger_tap_timeout);
2182   base::TimeTicks event_time = base::TimeTicks::Now();
2183
2184   MockMotionEvent event = ObtainMotionEvent(
2185       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
2186   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2187
2188   event = ObtainMotionEvent(event_time,
2189                             MotionEvent::ACTION_MOVE,
2190                             kFakeCoordX,
2191                             kFakeCoordY);
2192
2193   event = ObtainMotionEvent(event_time,
2194                             MotionEvent::ACTION_POINTER_DOWN,
2195                             kFakeCoordX,
2196                             kFakeCoordY,
2197                             kFakeCoordX + kMaxTwoFingerTapSeparation / 2,
2198                             kFakeCoordY);
2199   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2200
2201   event = ObtainMotionEvent(event_time + kOneSecond + kOneMicrosecond,
2202                             MotionEvent::ACTION_POINTER_UP,
2203                             kFakeCoordX,
2204                             kFakeCoordY,
2205                             kFakeCoordX + kMaxTwoFingerTapSeparation / 2,
2206                             kFakeCoordY);
2207   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2208
2209   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
2210   EXPECT_EQ(1U, GetReceivedGestureCount());
2211 }
2212
2213 // Test preventing a two finger tap by pressing the secondary pointer too far
2214 // from the first
2215 TEST_F(GestureProviderTest, TwoFingerTapCancelledByDistanceBetweenPointers) {
2216   EnableTwoFingerTap(kMaxTwoFingerTapSeparation, base::TimeDelta());
2217   base::TimeTicks event_time = base::TimeTicks::Now();
2218
2219   MockMotionEvent event = ObtainMotionEvent(
2220       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
2221   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2222
2223   event = ObtainMotionEvent(event_time,
2224                             MotionEvent::ACTION_POINTER_DOWN,
2225                             kFakeCoordX,
2226                             kFakeCoordY,
2227                             kFakeCoordX + kMaxTwoFingerTapSeparation,
2228                             kFakeCoordY);
2229   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2230
2231   event = ObtainMotionEvent(event_time,
2232                             MotionEvent::ACTION_POINTER_UP,
2233                             kFakeCoordX,
2234                             kFakeCoordY,
2235                             kFakeCoordX + kMaxTwoFingerTapSeparation,
2236                             kFakeCoordY);
2237   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2238
2239   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
2240   EXPECT_EQ(1U, GetReceivedGestureCount());
2241 }
2242
2243 // Verify that pinch zoom only sends updates which exceed the
2244 // min_pinch_update_span_delta.
2245 TEST_F(GestureProviderTest, PinchZoomWithThreshold) {
2246   const float kMinPinchUpdateDistance = 5;
2247
2248   base::TimeTicks event_time = base::TimeTicks::Now();
2249   const float touch_slop = GetTouchSlop();
2250
2251   SetMinPinchUpdateSpanDelta(kMinPinchUpdateDistance);
2252   gesture_provider_->SetDoubleTapSupportForPageEnabled(false);
2253   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(true);
2254   gesture_provider_->SetMultiTouchZoomSupportEnabled(true);
2255
2256   int secondary_coord_x = kFakeCoordX + 20 * touch_slop;
2257   int secondary_coord_y = kFakeCoordY + 20 * touch_slop;
2258
2259   // First finger down.
2260   MockMotionEvent event =
2261       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
2262   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2263   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
2264   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
2265
2266   // Second finger down.
2267   event = ObtainMotionEvent(event_time,
2268                             MotionEvent::ACTION_POINTER_DOWN,
2269                             kFakeCoordX,
2270                             kFakeCoordY,
2271                             secondary_coord_x,
2272                             secondary_coord_y);
2273
2274   gesture_provider_->OnTouchEvent(event);
2275   EXPECT_EQ(1U, GetReceivedGestureCount());
2276   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
2277
2278   // Move second finger.
2279   secondary_coord_x += 5 * touch_slop;
2280   secondary_coord_y += 5 * touch_slop;
2281   event = ObtainMotionEvent(event_time,
2282                             MotionEvent::ACTION_MOVE,
2283                             kFakeCoordX,
2284                             kFakeCoordY,
2285                             secondary_coord_x,
2286                             secondary_coord_y);
2287
2288   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2289   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
2290   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_PINCH_BEGIN));
2291   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_UPDATE));
2292   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
2293   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_UPDATE));
2294
2295   // Small move, shouldn't trigger pinch.
2296   event = ObtainMotionEvent(event_time,
2297                             MotionEvent::ACTION_MOVE,
2298                             kFakeCoordX,
2299                             kFakeCoordY,
2300                             secondary_coord_x + kMinPinchUpdateDistance,
2301                             secondary_coord_y);
2302
2303   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2304   EXPECT_FALSE(HasReceivedGesture(ET_GESTURE_PINCH_UPDATE));
2305   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
2306
2307   // Small move, but combined with the previous move, should trigger pinch. We
2308   // need to overshoot kMinPinchUpdateDistance by a fair bit, as the span
2309   // calculation factors in touch radius.
2310   const float kOvershootMinPinchUpdateDistance = 3;
2311   event = ObtainMotionEvent(event_time,
2312                             MotionEvent::ACTION_MOVE,
2313                             kFakeCoordX,
2314                             kFakeCoordY,
2315                             secondary_coord_x + kMinPinchUpdateDistance +
2316                                 kOvershootMinPinchUpdateDistance,
2317                             secondary_coord_y);
2318
2319   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2320   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_PINCH_UPDATE));
2321   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
2322 }
2323
2324 // Verify that the min gesture bound setting is honored.
2325 TEST_F(GestureProviderTest, MinGestureBoundsLength) {
2326   const float kMinGestureBoundsLength = 10.f * kMockTouchRadius;
2327   SetMinMaxGestureBoundsLength(kMinGestureBoundsLength, 0.f);
2328   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
2329
2330   base::TimeTicks event_time = base::TimeTicks::Now();
2331   MockMotionEvent event =
2332       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
2333   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2334
2335   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
2336   EXPECT_EQ(kMinGestureBoundsLength,
2337             GetMostRecentGestureEvent().details.bounding_box_f().width());
2338   EXPECT_EQ(kMinGestureBoundsLength,
2339             GetMostRecentGestureEvent().details.bounding_box_f().height());
2340
2341   event =
2342       ObtainMotionEvent(event_time + kOneMicrosecond, MotionEvent::ACTION_UP);
2343   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2344   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
2345   EXPECT_EQ(kMinGestureBoundsLength,
2346             GetMostRecentGestureEvent().details.bounding_box_f().width());
2347   EXPECT_EQ(kMinGestureBoundsLength,
2348             GetMostRecentGestureEvent().details.bounding_box_f().height());
2349 }
2350
2351 TEST_F(GestureProviderTest, MaxGestureBoundsLength) {
2352   const float kMaxGestureBoundsLength = kMockTouchRadius / 10.f;
2353   SetMinMaxGestureBoundsLength(0.f, kMaxGestureBoundsLength);
2354   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
2355
2356   base::TimeTicks event_time = base::TimeTicks::Now();
2357   MockMotionEvent event =
2358       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
2359   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2360
2361   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
2362   EXPECT_EQ(kMaxGestureBoundsLength,
2363             GetMostRecentGestureEvent().details.bounding_box_f().width());
2364   EXPECT_EQ(kMaxGestureBoundsLength,
2365             GetMostRecentGestureEvent().details.bounding_box_f().height());
2366
2367   event =
2368       ObtainMotionEvent(event_time + kOneMicrosecond, MotionEvent::ACTION_UP);
2369   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2370   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
2371   EXPECT_EQ(kMaxGestureBoundsLength,
2372             GetMostRecentGestureEvent().details.bounding_box_f().width());
2373   EXPECT_EQ(kMaxGestureBoundsLength,
2374             GetMostRecentGestureEvent().details.bounding_box_f().height());
2375 }
2376
2377 TEST_F(GestureProviderTest, ZeroRadiusBoundingBox) {
2378   base::TimeTicks event_time = base::TimeTicks::Now();
2379   MockMotionEvent event =
2380       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 10, 20);
2381   event.SetTouchMajor(0);
2382   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2383   EXPECT_EQ(gfx::RectF(10, 20, 0, 0),
2384             GetMostRecentGestureEvent().details.bounding_box());
2385
2386   event = ObtainMotionEvent(
2387       event_time, MotionEvent::ACTION_POINTER_DOWN, 10, 20, 110, 120);
2388   event.SetTouchMajor(0);
2389   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2390
2391   event = ObtainMotionEvent(
2392       event_time, MotionEvent::ACTION_MOVE, 10, 20, 110, 150);
2393   event.SetTouchMajor(0);
2394   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2395
2396   EXPECT_EQ(gfx::RectF(10, 20, 100, 130),
2397             GetMostRecentGestureEvent().details.bounding_box());
2398 }
2399
2400 // Verify that the min/max gesture bound settings are not applied to stylus
2401 // or mouse-derived MotionEvents.
2402 TEST_F(GestureProviderTest, NoMinOrMaxGestureBoundsLengthWithStylusOrMouse) {
2403   const float kMinGestureBoundsLength = 5.f * kMockTouchRadius;
2404   const float kMaxGestureBoundsLength = 10.f * kMockTouchRadius;
2405   SetMinMaxGestureBoundsLength(kMinGestureBoundsLength,
2406                                kMaxGestureBoundsLength);
2407   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
2408
2409   base::TimeTicks event_time = base::TimeTicks::Now();
2410   MockMotionEvent event =
2411       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
2412   event.SetTouchMajor(0);
2413   event.SetToolType(0, MotionEvent::TOOL_TYPE_MOUSE);
2414   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2415
2416   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
2417   EXPECT_EQ(MotionEvent::TOOL_TYPE_MOUSE,
2418             GetMostRecentGestureEvent().primary_tool_type);
2419   EXPECT_EQ(0.f, GetMostRecentGestureEvent().details.bounding_box_f().width());
2420   EXPECT_EQ(0.f, GetMostRecentGestureEvent().details.bounding_box_f().height());
2421
2422   event =
2423       ObtainMotionEvent(event_time + kOneMicrosecond, MotionEvent::ACTION_UP);
2424   event.SetTouchMajor(1);
2425   event.SetToolType(0, MotionEvent::TOOL_TYPE_STYLUS);
2426   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2427   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
2428   EXPECT_EQ(MotionEvent::TOOL_TYPE_STYLUS,
2429             GetMostRecentGestureEvent().primary_tool_type);
2430   EXPECT_EQ(0, GetMostRecentGestureEvent().details.bounding_box_f().width());
2431   EXPECT_EQ(0, GetMostRecentGestureEvent().details.bounding_box_f().height());
2432
2433   event = ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
2434   event.SetTouchMajor(2.f * kMaxGestureBoundsLength);
2435   event.SetToolType(0, MotionEvent::TOOL_TYPE_MOUSE);
2436   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2437   EXPECT_EQ(MotionEvent::TOOL_TYPE_MOUSE,
2438             GetMostRecentGestureEvent().primary_tool_type);
2439   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
2440   EXPECT_EQ(2.f * kMaxGestureBoundsLength,
2441             GetMostRecentGestureEvent().details.bounding_box_f().width());
2442   EXPECT_EQ(2.f * kMaxGestureBoundsLength,
2443             GetMostRecentGestureEvent().details.bounding_box_f().height());
2444
2445   event =
2446       ObtainMotionEvent(event_time + kOneMicrosecond, MotionEvent::ACTION_UP);
2447   event.SetTouchMajor(2.f * kMaxGestureBoundsLength);
2448   event.SetToolType(0, MotionEvent::TOOL_TYPE_ERASER);
2449   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2450   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
2451   EXPECT_EQ(MotionEvent::TOOL_TYPE_ERASER,
2452             GetMostRecentGestureEvent().primary_tool_type);
2453   EXPECT_EQ(2.f * kMaxGestureBoundsLength,
2454             GetMostRecentGestureEvent().details.bounding_box_f().width());
2455   EXPECT_EQ(2.f * kMaxGestureBoundsLength,
2456             GetMostRecentGestureEvent().details.bounding_box_f().height());
2457 }
2458
2459 // Test the bounding box for show press and tap gestures.
2460 TEST_F(GestureProviderTest, BoundingBoxForShowPressAndTapGesture) {
2461   base::TimeTicks event_time = base::TimeTicks::Now();
2462   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
2463   base::TimeDelta showpress_timeout = kOneMicrosecond;
2464   base::TimeDelta longpress_timeout = kOneSecond;
2465   SetShowPressAndLongPressTimeout(showpress_timeout, longpress_timeout);
2466
2467   MockMotionEvent event =
2468       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 10, 10);
2469   event.SetTouchMajor(10);
2470
2471   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2472   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
2473   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
2474   EXPECT_EQ(gfx::RectF(5, 5, 10, 10),
2475             GetMostRecentGestureEvent().details.bounding_box());
2476
2477   event = ObtainMotionEvent(
2478       event_time + kOneMicrosecond, MotionEvent::ACTION_MOVE, 11, 9);
2479   event.SetTouchMajor(20);
2480   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2481   event = ObtainMotionEvent(
2482       event_time + kOneMicrosecond, MotionEvent::ACTION_MOVE, 8, 11);
2483   event.SetTouchMajor(10);
2484   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2485   RunTasksAndWait(showpress_timeout + kOneMicrosecond);
2486   EXPECT_EQ(ET_GESTURE_SHOW_PRESS, GetMostRecentGestureEventType());
2487   EXPECT_EQ(gfx::RectF(0, 0, 20, 20),
2488             GetMostRecentGestureEvent().details.bounding_box());
2489
2490   event =
2491       ObtainMotionEvent(event_time + kOneMicrosecond, MotionEvent::ACTION_UP);
2492   event.SetTouchMajor(30);
2493   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
2494   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
2495
2496   EXPECT_EQ(1, GetMostRecentGestureEvent().details.tap_count());
2497   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
2498   EXPECT_EQ(gfx::RectF(0, 0, 20, 20),
2499             GetMostRecentGestureEvent().details.bounding_box());
2500 }
2501
2502 }  // namespace ui