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