Support minimum gesture bounds in GestureProvider

ui/events/gesture_detection/gesture_provider_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 112 matching lines @@
   // Test
   virtual void SetUp() OVERRIDE { SetUpWithConfig(GetDefaultConfig()); }
 
   virtual void TearDown() OVERRIDE {
     gestures_.clear();
     gesture_provider_.reset();
   }
 
   // GestureProviderClient
   virtual void OnGestureEvent(const GestureEventData& gesture) OVERRIDE {
-    if (gesture.type == ET_GESTURE_SCROLL_BEGIN)
+    if (gesture.type() == ET_GESTURE_SCROLL_BEGIN)
       active_scroll_begin_event_.reset(new GestureEventData(gesture));
     gestures_.push_back(gesture);
   }
 
   void SetUpWithConfig(const GestureProvider::Config& config) {
     gesture_provider_.reset(new GestureProvider(config, this));
     gesture_provider_->SetMultiTouchZoomSupportEnabled(false);
   }
 
   void ResetGestureDetection() {
     CancelActiveTouchSequence();
     gestures_.clear();
   }
   bool CancelActiveTouchSequence() {
     if (!gesture_provider_->current_down_event())
       return false;
     return gesture_provider_->OnTouchEvent(
         *gesture_provider_->current_down_event()->Cancel());
   }
 
   bool HasReceivedGesture(EventType type) const {
     for (size_t i = 0; i < gestures_.size(); ++i) {
-      if (gestures_[i].type == type)
+      if (gestures_[i].type() == type)
         return true;
     }
     return false;
   }
 
   const GestureEventData& GetMostRecentGestureEvent() const {
     EXPECT_FALSE(gestures_.empty());
     return gestures_.back();
   }
 
   EventType GetMostRecentGestureEventType() const {
     EXPECT_FALSE(gestures_.empty());
-    return gestures_.back().type;
+    return gestures_.back().type();
   }
 
   size_t GetReceivedGestureCount() const { return gestures_.size(); }
 
   const GestureEventData& GetReceivedGesture(size_t index) const {
     EXPECT_LT(index, GetReceivedGestureCount());
     return gestures_[index];
   }
 
   const GestureEventData* GetActiveScrollBeginEvent() const {
@@ skipping 48 matching lines @@
     SetUpWithConfig(config);
   }
 
   void SetMinPinchUpdateSpanDelta(float min_pinch_update_span_delta) {
     GestureProvider::Config config = GetDefaultConfig();
     config.scale_gesture_detector_config.min_pinch_update_span_delta =
         min_pinch_update_span_delta;
     SetUpWithConfig(config);
   }
 
+  void SetMinGestureBoundLength(float min_gesture_bound_length) {
+    GestureProvider::Config config = GetDefaultConfig();
+    config.min_gesture_bounds_length = min_gesture_bound_length;
+    SetUpWithConfig(config);
+  }
+
   bool HasDownEvent() const { return gesture_provider_->current_down_event(); }
 
  protected:
   void CheckScrollEventSequenceForEndActionType(
       MotionEvent::Action end_action_type) {
     base::TimeTicks event_time = base::TimeTicks::Now();
     const float scroll_to_x = kFakeCoordX + 100;
     const float scroll_to_y = kFakeCoordY + 100;
     int motion_event_id = 0;
 
@@ skipping 13 matching lines @@
     EXPECT_TRUE(gesture_provider_->IsScrollInProgress());
     EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
     EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
     EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
     EXPECT_EQ(BoundsForSingleMockTouchAtLocation(scroll_to_x, scroll_to_y),
               GetMostRecentGestureEvent().details.bounding_box());
     ASSERT_EQ(3U, GetReceivedGestureCount()) << "Only TapDown, "
                                                 "ScrollBegin and ScrollBy "
                                                 "should have been sent";
 
-    EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type);
+    EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
     EXPECT_EQ(motion_event_id, GetReceivedGesture(1).motion_event_id);
     EXPECT_EQ(event_time + kOneSecond, GetReceivedGesture(1).time)
         << "ScrollBegin should have the time of the ACTION_MOVE";
 
     event = ObtainMotionEvent(
         event_time + kOneSecond, end_action_type, scroll_to_x, scroll_to_y);
     event.SetId(++motion_event_id);
 
     gesture_provider_->OnTouchEvent(event);
     EXPECT_FALSE(gesture_provider_->IsScrollInProgress());
@@ skipping 83 matching lines @@
     base::MessageLoop::current()->Run();
   }
 
   std::vector<GestureEventData> gestures_;
   scoped_ptr<GestureProvider> gesture_provider_;
   scoped_ptr<GestureEventData> active_scroll_begin_event_;
   base::MessageLoopForUI message_loop_;
 };
 
 // Verify that a DOWN followed shortly by an UP will trigger a single tap.
-TEST_F(GestureProviderTest, GestureTapTap) {
+TEST_F(GestureProviderTest, GestureTap) {
   base::TimeTicks event_time = base::TimeTicks::Now();
   int motion_event_id = 0;
 
   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   event.SetId(++motion_event_id);
 
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
@@ skipping 11 matching lines @@
   // Ensure tap details have been set.
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.tap_count());
   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
   EXPECT_EQ(BoundsForSingleMockTouchAtLocation(kFakeCoordX, kFakeCoordY),
             GetMostRecentGestureEvent().details.bounding_box());
 }
 
 // Verify that a DOWN followed shortly by an UP will trigger
 // a ET_GESTURE_TAP_UNCONFIRMED event if double-tap is enabled.
-TEST_F(GestureProviderTest, GestureTapTapWithDelay) {
+TEST_F(GestureProviderTest, GestureTapWithDelay) {
   base::TimeTicks event_time = base::TimeTicks::Now();
   int motion_event_id = 0;
 
   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(true);
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   event.SetId(++motion_event_id);
 
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
@@ skipping 95 matching lines @@
                             kFakeCoordX * 5,
                             kFakeCoordY * 5);
   event.SetId(++motion_event_id);
 
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(gesture_provider_->IsScrollInProgress());
   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
   EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
   ASSERT_EQ(3U, GetReceivedGestureCount());
-  ASSERT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type);
+  ASSERT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
   EXPECT_EQ(motion_event_id, GetReceivedGesture(1).motion_event_id);
 
   // We don't want to take a dependency here on exactly how hints are calculated
   // for a fling (eg. may depend on velocity), so just validate the direction.
   int hint_x = GetReceivedGesture(1).details.scroll_x_hint();
   int hint_y = GetReceivedGesture(1).details.scroll_y_hint();
   EXPECT_TRUE(hint_x > 0 && hint_y > 0 && hint_x > hint_y)
       << "ScrollBegin hint should be in positive X axis";
 
   event = ObtainMotionEvent(event_time + delta_time * 2,
@@ skipping 97 matching lines @@
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 
   event = ObtainMotionEvent(event_time + kOneMicrosecond * 3,
                             MotionEvent::ACTION_UP,
                             kFakeCoordX,
                             kFakeCoordY + 1);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   const GestureEventData& double_tap = GetMostRecentGestureEvent();
-  EXPECT_EQ(ET_GESTURE_DOUBLE_TAP, double_tap.type);
+  EXPECT_EQ(ET_GESTURE_DOUBLE_TAP, double_tap.type());
   // Ensure tap details have been set.
   EXPECT_EQ(10, double_tap.details.bounding_box().width());
   EXPECT_EQ(10, double_tap.details.bounding_box().height());
   EXPECT_EQ(1, double_tap.details.tap_count());
 }
 
 TEST_F(GestureProviderTest, DoubleTapDragZoomBasic) {
   const base::TimeTicks down_time_1 = TimeTicks::Now();
   const base::TimeTicks down_time_2 = down_time_1 + kOneMicrosecond * 2;
 
@@ skipping 78 matching lines @@
 
   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX - delta_x,
                             kFakeCoordY - delta_y);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   // Make sure the reported gesture event has all the expected details.
   ASSERT_LT(0U, GetReceivedGestureCount());
   GestureEventData gesture = GetMostRecentGestureEvent();
-  EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, gesture.type);
+  EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, gesture.type());
   EXPECT_EQ(event_time + kOneMicrosecond * 2, gesture.time);
   EXPECT_EQ(kFakeCoordX - delta_x, gesture.x);
   EXPECT_EQ(kFakeCoordY - delta_y, gesture.y);
   EXPECT_EQ(1, gesture.details.touch_points());
 
   // No horizontal delta because of snapping.
   EXPECT_EQ(0, gesture.details.scroll_x());
   EXPECT_EQ(-delta_y / 2, gesture.details.scroll_y());
 }
 
@@ skipping 23 matching lines @@
   // horizontal motion.
   for(int i = 1; i <= 10; i++) {
     event = ObtainMotionEvent(event_time + kOneMicrosecond * i,
                               MotionEvent::ACTION_MOVE,
                               kFakeCoordX + delta_x * i,
                               kFakeCoordY + delta_y * i);
     EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
     ASSERT_LT(0U, GetReceivedGestureCount());
     GestureEventData gesture = GetMostRecentGestureEvent();
-    EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, gesture.type);
+    EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, gesture.type());
     EXPECT_EQ(event_time + kOneMicrosecond * i, gesture.time);
     EXPECT_EQ(1, gesture.details.touch_points());
 
     // Verify that the event co-ordinates are still the precise values we
     // supplied.
     EXPECT_EQ(kFakeCoordX + delta_x * i, gesture.x);
     EXPECT_EQ(kFakeCoordY + delta_y * i, gesture.y);
 
     // Verify that we're scrolling vertically by the expected amount
     // (modulo rounding).
@@ skipping 930 matching lines @@
 // Verify that gesture begin and gesture end events are dispatched correctly.
 TEST_F(GestureProviderTest, GestureBeginAndEnd) {
   EnableBeginEndTypes();
   base::TimeTicks event_time = base::TimeTicks::Now();
 
   EXPECT_EQ(0U, GetReceivedGestureCount());
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 1, 1);
   event.pointer_count = 1;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
-  EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type);
+  EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type());
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
   EXPECT_EQ(2U, GetReceivedGestureCount());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
   EXPECT_EQ(1, GetMostRecentGestureEvent().x);
   EXPECT_EQ(1, GetMostRecentGestureEvent().y);
   EXPECT_EQ(gfx::RectF(1 - kMockTouchRadius,
                        1 - kMockTouchRadius,
                        kMockTouchRadius * 2,
                        kMockTouchRadius * 2),
             GetMostRecentGestureEvent().details.bounding_box());
@@ skipping 73 matching lines @@
 // when an ACTION_CANCEL is received.
 TEST_F(GestureProviderTest, GestureBeginAndEndOnCancel) {
   EnableBeginEndTypes();
   base::TimeTicks event_time = base::TimeTicks::Now();
 
   EXPECT_EQ(0U, GetReceivedGestureCount());
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 1, 1);
   event.pointer_count = 1;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
-  EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type);
+  EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type());
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
   EXPECT_EQ(2U, GetReceivedGestureCount());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
   EXPECT_EQ(gfx::RectF(1 - kMockTouchRadius,
                        1 - kMockTouchRadius,
                        kMockTouchRadius * 2,
                        kMockTouchRadius * 2),
             GetMostRecentGestureEvent().details.bounding_box());
   EXPECT_EQ(1, GetMostRecentGestureEvent().x);
   EXPECT_EQ(1, GetMostRecentGestureEvent().y);
@@ skipping 18 matching lines @@
   EXPECT_EQ(3, GetMostRecentGestureEvent().details.touch_points());
   EXPECT_EQ(3, GetMostRecentGestureEvent().x);
   EXPECT_EQ(3, GetMostRecentGestureEvent().y);
 
   event = ObtainMotionEvent(
       event_time, MotionEvent::ACTION_CANCEL, 1, 1, 2, 2, 3, 3);
   event.pointer_count = 3;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(7U, GetReceivedGestureCount());
   EXPECT_EQ(3, GetReceivedGesture(4).details.touch_points());
-  EXPECT_EQ(ET_GESTURE_END, GetReceivedGesture(4).details.type());
+  EXPECT_EQ(ET_GESTURE_END, GetReceivedGesture(4).type());
   EXPECT_EQ(2, GetReceivedGesture(5).details.touch_points());
-  EXPECT_EQ(ET_GESTURE_END, GetReceivedGesture(5).details.type());
+  EXPECT_EQ(ET_GESTURE_END, GetReceivedGesture(5).type());
   EXPECT_EQ(1, GetReceivedGesture(6).details.touch_points());
-  EXPECT_EQ(ET_GESTURE_END, GetReceivedGesture(6).details.type());
+  EXPECT_EQ(ET_GESTURE_END, GetReceivedGesture(6).type());
   EXPECT_EQ(1, GetReceivedGesture(4).x);
   EXPECT_EQ(1, GetReceivedGesture(4).y);
   EXPECT_EQ(2, GetReceivedGesture(5).x);
   EXPECT_EQ(2, GetReceivedGesture(5).y);
   EXPECT_EQ(3, GetReceivedGesture(6).x);
   EXPECT_EQ(3, GetReceivedGesture(6).y);
 }
 
 // Test a simple two finger tap
 TEST_F(GestureProviderTest, TwoFingerTap) {
@@ skipping 31 matching lines @@
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_POINTER_UP,
                             0,
                             0,
                             kMaxTwoFingerTapSeparation,
                             0);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
-  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type);
-  EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type);
-  EXPECT_EQ(ET_GESTURE_TWO_FINGER_TAP, GetReceivedGesture(2).type);
+  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
+  EXPECT_EQ(ET_GESTURE_TWO_FINGER_TAP, GetReceivedGesture(2).type());
   EXPECT_EQ(3U, GetReceivedGestureCount());
 
   EXPECT_EQ(kMockTouchRadius * 2,
             GetReceivedGesture(2).details.first_finger_width());
   EXPECT_EQ(kMockTouchRadius * 2,
             GetReceivedGesture(2).details.first_finger_height());
 }
 
 // Test preventing a two finger tap via finger movement.
 TEST_F(GestureProviderTest, TwoFingerTapCancelledByFingerMovement) {
@@ skipping 22 matching lines @@
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_POINTER_UP,
                             kFakeCoordX,
                             kFakeCoordY,
                             kFakeCoordX,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
-  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type);
-  EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type);
+  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
+  EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(1).type());
   EXPECT_EQ(2U, GetReceivedGestureCount());
 }
 
 // Test preventing a two finger tap by waiting too long before releasing the
 // secondary pointer.
 TEST_F(GestureProviderTest, TwoFingerTapCancelledByDelay) {
   base::TimeDelta two_finger_tap_timeout = kOneSecond;
   EnableTwoFingerTap(kMaxTwoFingerTapSeparation, two_finger_tap_timeout);
   base::TimeTicks event_time = base::TimeTicks::Now();
 
@@ skipping 15 matching lines @@
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time + kOneSecond + kOneMicrosecond,
                             MotionEvent::ACTION_POINTER_UP,
                             kFakeCoordX,
                             kFakeCoordY,
                             kFakeCoordX + kMaxTwoFingerTapSeparation / 2,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
-  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type);
+  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
   EXPECT_EQ(1U, GetReceivedGestureCount());
 }
 
 // Test preventing a two finger tap by pressing the secondary pointer too far
 // from the first
 TEST_F(GestureProviderTest, TwoFingerTapCancelledByDistanceBetweenPointers) {
   EnableTwoFingerTap(kMaxTwoFingerTapSeparation, base::TimeDelta());
   base::TimeTicks event_time = base::TimeTicks::Now();
 
   MockMotionEvent event = ObtainMotionEvent(
       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_POINTER_DOWN,
                             kFakeCoordX,
                             kFakeCoordY,
                             kFakeCoordX + kMaxTwoFingerTapSeparation,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_POINTER_UP,
                             kFakeCoordX,
                             kFakeCoordY,
                             kFakeCoordX + kMaxTwoFingerTapSeparation,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
-  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type);
+  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(0).type());
   EXPECT_EQ(1U, GetReceivedGestureCount());
 }
 
 // Verify that pinch zoom only sends updates which exceed the
 // min_pinch_update_span_delta.
 TEST_F(GestureProviderTest, PinchZoomWithThreshold) {
   const float kMinPinchUpdateDistance = 5;
 
   base::TimeTicks event_time = base::TimeTicks::Now();
   const float touch_slop = GetTouchSlop();
@@ skipping 64 matching lines @@
                             kFakeCoordY,
                             secondary_coord_x + kMinPinchUpdateDistance +
                                 kOvershootMinPinchUpdateDistance,
                             secondary_coord_y);
 
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_PINCH_UPDATE));
   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
 }
 
+// Verify that the min gesture bound setting is honored.
+TEST_F(GestureProviderTest, MinGestureBoundLength) {
+  const float kMinGestureBoundLength = 10.f * kMockTouchRadius;
+  SetMinGestureBoundLength(kMinGestureBoundLength);
+  gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
+
+  base::TimeTicks event_time = base::TimeTicks::Now();
+  MockMotionEvent event =
+      ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
+  EXPECT_EQ(kMinGestureBoundLength,
+            GetMostRecentGestureEvent().details.bounding_box_f().width());
+  EXPECT_EQ(kMinGestureBoundLength,
+            GetMostRecentGestureEvent().details.bounding_box_f().height());
+
+  event =
+      ObtainMotionEvent(event_time + kOneMicrosecond, MotionEvent::ACTION_UP);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+  EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
+  EXPECT_EQ(kMinGestureBoundLength,
+            GetMostRecentGestureEvent().details.bounding_box_f().width());
+  EXPECT_EQ(kMinGestureBoundLength,
+            GetMostRecentGestureEvent().details.bounding_box_f().height());
+}
+
 }  // namespace ui