Support minimum gesture bounds in GestureProvider

ui/events/gesture_detection/gesture_provider.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 "ui/events/gesture_detection/gesture_provider.h"
 
 #include <cmath>
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
@@ skipping 24 matching lines @@
   for (size_t i = 0; i < event.GetPointerCount(); ++i) {
     float diameter = event.GetTouchMajor(i);
     bounds.Union(gfx::RectF(event.GetX(i) - diameter / 2,
                             event.GetY(i) - diameter / 2,
                             diameter,
                             diameter));
   }
   return bounds;
 }
 
-GestureEventData CreateGesture(EventType type,
+GestureEventData CreateGesture(const GestureEventDetails& details,
                                int motion_event_id,
                                base::TimeTicks time,
                                float x,
                                float y,
                                size_t touch_point_count,
-                               const gfx::RectF& bounding_box,
-                               const GestureEventDetails& details) {
-  return GestureEventData(type,
+                               const gfx::RectF& bounding_box) {
+  return GestureEventData(details,
                           motion_event_id,
                           time,
                           x,
                           y,
                           static_cast<int>(touch_point_count),
-                          bounding_box,
-                          details);
+                          bounding_box);
 }
 
 GestureEventData CreateGesture(EventType type,
                                int motion_event_id,
                                base::TimeTicks time,
                                float x,
                                float y,
                                size_t touch_point_count,
                                const gfx::RectF& bounding_box) {
   return GestureEventData(type,
                           motion_event_id,
                           time,
                           x,
                           y,
                           static_cast<int>(touch_point_count),
                           bounding_box);
 }
 
-GestureEventData CreateGesture(EventType type,
-                               const MotionEvent& event,
-                               const GestureEventDetails& details) {
-  return CreateGesture(type,
+GestureEventData CreateGesture(const GestureEventDetails& details,
+                               const MotionEvent& event) {
+  return CreateGesture(details,
                        event.GetId(),
                        event.GetEventTime(),
                        event.GetX(),
                        event.GetY(),
                        event.GetPointerCount(),
-                       GetBoundingBox(event),
-                       details);
+                       GetBoundingBox(event));
 }
 
 GestureEventData CreateGesture(EventType type,
                                const MotionEvent& event) {
   return CreateGesture(type,
                        event.GetId(),
                        event.GetEventTime(),
                        event.GetX(),
                        event.GetY(),
                        event.GetPointerCount(),
                        GetBoundingBox(event));
 }
 
-GestureEventDetails CreateTapGestureDetails(EventType type,
-                                            const MotionEvent& event) {
+GestureEventDetails CreateTapGestureDetails(EventType type) {
   // Set the tap count to 1 even for ET_GESTURE_DOUBLE_TAP, in order to be
   // consistent with double tap behavior on a mobile viewport. See
   // crbug.com/234986 for context.
   GestureEventDetails tap_details(type, 1, 0);
   return tap_details;
 }
 
 }  // namespace
 
 // GestureProvider:::Config
 
 GestureProvider::Config::Config()
     : display(gfx::Display::kInvalidDisplayID, gfx::Rect(1, 1)),
       disable_click_delay(false),
-      gesture_begin_end_types_enabled(false) {}
+      gesture_begin_end_types_enabled(false),
+      min_gesture_bounds_length(0) {}
 
 GestureProvider::Config::~Config() {}
 
 // GestureProvider::ScaleGestureListener
 
 class GestureProvider::ScaleGestureListenerImpl
     : public ScaleGestureDetector::ScaleGestureListener {
  public:
   ScaleGestureListenerImpl(const ScaleGestureDetector::Config& config,
                            GestureProvider* provider)
@@ skipping 68 matching lines @@
       // For historical reasons, Chrome has instead adopted a scale factor
       // computation that is invariant to the focal distance, where
       // the scale delta remains constant if the touch velocity is constant.
       float dy =
           (detector.GetCurrentSpanY() - detector.GetPreviousSpanY()) * 0.5f;
       scale = std::pow(scale > 1 ? 1.0f + kDoubleTapDragZoomSpeed
                                  : 1.0f - kDoubleTapDragZoomSpeed,
                        std::abs(dy));
     }
     GestureEventDetails pinch_details(ET_GESTURE_PINCH_UPDATE, scale, 0);
-    provider_->Send(CreateGesture(ET_GESTURE_PINCH_UPDATE,
+    provider_->Send(CreateGesture(pinch_details,
                                   e.GetId(),
                                   detector.GetEventTime(),
                                   detector.GetFocusX(),
                                   detector.GetFocusY(),
                                   e.GetPointerCount(),
-                                  GetBoundingBox(e),
-                                  pinch_details));
+                                  GetBoundingBox(e)));
     return true;
   }
 
   void SetDoubleTapEnabled(bool enabled) {
     DCHECK(!IsDoubleTapInProgress());
     scale_gesture_detector_.SetQuickScaleEnabled(enabled);
   }
 
   void SetMultiTouchEnabled(bool enabled) {
     // Note that returning false from OnScaleBegin / OnScale makes the
@@ skipping 70 matching lines @@
     return gesture_detector_.OnTouchEvent(e);
   }
 
   // GestureDetector::GestureListener implementation.
   virtual bool OnDown(const MotionEvent& e) OVERRIDE {
     current_down_time_ = e.GetEventTime();
     ignore_single_tap_ = false;
     seen_first_scroll_event_ = false;
 
     GestureEventDetails tap_details(ET_GESTURE_TAP_DOWN, 0, 0);
-    provider_->Send(CreateGesture(ET_GESTURE_TAP_DOWN, e, tap_details));
+    provider_->Send(CreateGesture(tap_details, e));
 
     // Return true to indicate that we want to handle touch.
     return true;
   }
 
   virtual bool OnScroll(const MotionEvent& e1,
                         const MotionEvent& e2,
                         float raw_distance_x,
                         float raw_distance_y) OVERRIDE {
     float distance_x = raw_distance_x;
@@ skipping 21 matching lines @@
     }
 
     if (!provider_->IsScrollInProgress()) {
       // Note that scroll start hints are in distance traveled, where
       // scroll deltas are in the opposite direction.
       GestureEventDetails scroll_details(
           ET_GESTURE_SCROLL_BEGIN, -raw_distance_x, -raw_distance_y);
 
       // Use the co-ordinates from the touch down, as these co-ordinates are
       // used to determine which layer the scroll should affect.
-      provider_->Send(CreateGesture(ET_GESTURE_SCROLL_BEGIN,
+      provider_->Send(CreateGesture(scroll_details,
                                     e2.GetId(),
                                     e2.GetEventTime(),
                                     e1.GetX(),
                                     e1.GetY(),
                                     e2.GetPointerCount(),
-                                    GetBoundingBox(e2),
-                                    scroll_details));
+                                    GetBoundingBox(e2)));
     }
 
     if (distance_x || distance_y) {
       const gfx::RectF bounding_box = GetBoundingBox(e2);
       GestureEventDetails scroll_details(
           ET_GESTURE_SCROLL_UPDATE, -distance_x, -distance_y);
-      provider_->Send(CreateGesture(ET_GESTURE_SCROLL_UPDATE,
+      provider_->Send(CreateGesture(scroll_details,
                                     e2.GetId(),
                                     e2.GetEventTime(),
                                     bounding_box.CenterPoint().x(),
                                     bounding_box.CenterPoint().y(),
                                     e2.GetPointerCount(),
-                                    bounding_box,
-                                    scroll_details));
+                                    bounding_box));
     }
 
     return true;
   }
 
   virtual bool OnFling(const MotionEvent& e1,
                        const MotionEvent& e2,
                        float velocity_x,
                        float velocity_y) OVERRIDE {
     if (snap_scroll_controller_.IsSnappingScrolls()) {
       if (snap_scroll_controller_.IsSnapHorizontal()) {
         velocity_y = 0;
       } else {
         velocity_x = 0;
       }
     }
 
     provider_->Fling(e2, velocity_x, velocity_y);
     return true;
   }
 
   virtual bool OnSwipe(const MotionEvent& e1,
                        const MotionEvent& e2,
                        float velocity_x,
                        float velocity_y) OVERRIDE {
     GestureEventDetails swipe_details(ET_GESTURE_SWIPE, velocity_x, velocity_y);
-    provider_->Send(CreateGesture(ET_GESTURE_SWIPE, e2, swipe_details));
+    provider_->Send(CreateGesture(swipe_details, e2));
     return true;
   }
 
   virtual bool OnTwoFingerTap(const MotionEvent& e1,
                               const MotionEvent& e2) OVERRIDE {
     // The location of the two finger tap event should be the location of the
     // primary pointer.
     GestureEventDetails two_finger_tap_details(ET_GESTURE_TWO_FINGER_TAP,
                                                e1.GetTouchMajor(),
                                                e1.GetTouchMajor());
-    provider_->Send(CreateGesture(ET_GESTURE_TWO_FINGER_TAP,
+    provider_->Send(CreateGesture(two_finger_tap_details,
                                   e2.GetId(),
                                   e2.GetEventTime(),
                                   e1.GetX(),
                                   e1.GetY(),
                                   e2.GetPointerCount(),
-                                  GetBoundingBox(e2),
-                                  two_finger_tap_details));
+                                  GetBoundingBox(e2)));
     return true;
   }
 
   virtual void OnShowPress(const MotionEvent& e) OVERRIDE {
     GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS, 0, 0);
-    provider_->Send(
-        CreateGesture(ET_GESTURE_SHOW_PRESS, e, show_press_details));
+    provider_->Send(CreateGesture(show_press_details, e));
   }
 
   virtual bool OnSingleTapUp(const MotionEvent& e) OVERRIDE {
     // This is a hack to address the issue where user hovers
     // over a link for longer than double_tap_timeout_, then
     // OnSingleTapConfirmed() is not triggered. But we still
     // want to trigger the tap event at UP. So we override
     // OnSingleTapUp() in this case. This assumes singleTapUp
     // gets always called before singleTapConfirmed.
     if (!ignore_single_tap_) {
       if (e.GetEventTime() - current_down_time_ > double_tap_timeout_) {
         return OnSingleTapConfirmed(e);
       } else if (!IsDoubleTapEnabled() || disable_click_delay_) {
         // If double-tap has been disabled, there is no need to wait
         // for the double-tap timeout.
         return OnSingleTapConfirmed(e);
       } else {
         // Notify Blink about this tapUp event anyway, when none of the above
         // conditions applied.
         provider_->Send(CreateGesture(
-            ET_GESTURE_TAP_UNCONFIRMED,
-            e,
-            CreateTapGestureDetails(ET_GESTURE_TAP_UNCONFIRMED, e)));
+            CreateTapGestureDetails(ET_GESTURE_TAP_UNCONFIRMED), e));
       }
     }
 
     return provider_->SendLongTapIfNecessary(e);
   }
 
   // GestureDetector::DoubleTapListener implementation.
   virtual bool OnSingleTapConfirmed(const MotionEvent& e) OVERRIDE {
     // Long taps in the edges of the screen have their events delayed by
     // ContentViewHolder for tab swipe operations. As a consequence of the delay
     // this method might be called after receiving the up event.
     // These corner cases should be ignored.
     if (ignore_single_tap_)
       return true;
 
     ignore_single_tap_ = true;
 
-    provider_->Send(CreateGesture(
-        ET_GESTURE_TAP, e, CreateTapGestureDetails(ET_GESTURE_TAP, e)));
+    provider_->Send(CreateGesture(CreateTapGestureDetails(ET_GESTURE_TAP), e));
     return true;
   }
 
   virtual bool OnDoubleTap(const MotionEvent& e) OVERRIDE { return false; }
 
   virtual bool OnDoubleTapEvent(const MotionEvent& e) OVERRIDE {
     switch (e.GetAction()) {
       case MotionEvent::ACTION_DOWN:
         gesture_detector_.set_longpress_enabled(false);
         break;
 
       case MotionEvent::ACTION_UP:
         if (!provider_->IsPinchInProgress() &&
             !provider_->IsScrollInProgress()) {
           provider_->Send(
-              CreateGesture(ET_GESTURE_DOUBLE_TAP,
-                            e,
-                            CreateTapGestureDetails(ET_GESTURE_DOUBLE_TAP, e)));
+              CreateGesture(CreateTapGestureDetails(ET_GESTURE_DOUBLE_TAP), e));
           return true;
         }
         break;
       default:
         break;
     }
     return false;
   }
 
   virtual bool OnLongPress(const MotionEvent& e) OVERRIDE {
     DCHECK(!IsDoubleTapInProgress());
     SetIgnoreSingleTap(true);
 
     GestureEventDetails long_press_details(ET_GESTURE_LONG_PRESS, 0, 0);
-    provider_->Send(
-        CreateGesture(ET_GESTURE_LONG_PRESS, e, long_press_details));
+    provider_->Send(CreateGesture(long_press_details, e));
 
     // Returning true puts the GestureDetector in "longpress" mode, disabling
     // further scrolling.  This is undesirable, as it is quite common for a
     // longpress gesture to fire on content that won't trigger a context menu.
     return false;
   }
 
   void SetDoubleTapEnabled(bool enabled) {
     DCHECK(!IsDoubleTapInProgress());
     gesture_detector_.SetDoubleTapListener(enabled ? this : NULL);
@@ skipping 39 matching lines @@
 
 // GestureProvider
 
 GestureProvider::GestureProvider(const Config& config,
                                  GestureProviderClient* client)
     : client_(client),
       touch_scroll_in_progress_(false),
       pinch_in_progress_(false),
       double_tap_support_for_page_(true),
       double_tap_support_for_platform_(true),
-      gesture_begin_end_types_enabled_(config.gesture_begin_end_types_enabled) {
+      gesture_begin_end_types_enabled_(config.gesture_begin_end_types_enabled),
+      min_gesture_bounds_length_(config.min_gesture_bounds_length) {
   DCHECK(client);
   InitGestureDetectors(config);
 }
 
 GestureProvider::~GestureProvider() {}
 
 bool GestureProvider::OnTouchEvent(const MotionEvent& event) {
   TRACE_EVENT1("input", "GestureProvider::OnTouchEvent",
                "action", GetMotionEventActionName(event.GetAction()));
 
@@ skipping 69 matching lines @@
     return;
   }
 
   if (!touch_scroll_in_progress_) {
     // The native side needs a ET_GESTURE_SCROLL_BEGIN before
     // ET_SCROLL_FLING_START to send the fling to the correct target. Send if it
     // has not sent.  The distance traveled in one second is a reasonable scroll
     // start hint.
     GestureEventDetails scroll_details(
         ET_GESTURE_SCROLL_BEGIN, velocity_x, velocity_y);
-    Send(CreateGesture(ET_GESTURE_SCROLL_BEGIN, event, scroll_details));
+    Send(CreateGesture(scroll_details, event));
   }
   EndTouchScrollIfNecessary(event, false);
 
   GestureEventDetails fling_details(
       ET_SCROLL_FLING_START, velocity_x, velocity_y);
-  Send(CreateGesture(
-      ET_SCROLL_FLING_START, event, fling_details));
+  Send(CreateGesture(fling_details, event));
 }
 
-void GestureProvider::Send(const GestureEventData& gesture) {
+void GestureProvider::Send(GestureEventData gesture) {
   DCHECK(!gesture.time.is_null());
   // The only valid events that should be sent without an active touch sequence
   // are SHOW_PRESS and TAP, potentially triggered by the double-tap
   // delay timing out.
-  DCHECK(current_down_event_ || gesture.type == ET_GESTURE_TAP ||
-         gesture.type == ET_GESTURE_SHOW_PRESS);
+  DCHECK(current_down_event_ || gesture.type() == ET_GESTURE_TAP ||
+         gesture.type() == ET_GESTURE_SHOW_PRESS);
 
-  switch (gesture.type) {
+  // TODO(jdduke): Provide a way of skipping this clamping for stylus and/or
+  // mouse-based input, perhaps by exposing the source type on MotionEvent.
+  const gfx::RectF& gesture_bounds = gesture.details.bounding_box_f();
+  gesture.details.set_bounding_box(gfx::RectF(
+      gesture_bounds.x(),
+      gesture_bounds.y(),
+      std::max(min_gesture_bounds_length_, gesture_bounds.width()),
+      std::max(min_gesture_bounds_length_, gesture_bounds.height())));
+
+  switch (gesture.type()) {
     case ET_GESTURE_LONG_PRESS:
       DCHECK(!scale_gesture_listener_->IsScaleGestureDetectionInProgress());
       current_longpress_time_ = gesture.time;
       break;
     case ET_GESTURE_LONG_TAP:
       current_longpress_time_ = base::TimeTicks();
       break;
     case ET_GESTURE_SCROLL_BEGIN:
       DCHECK(!touch_scroll_in_progress_);
       touch_scroll_in_progress_ = true;
@@ skipping 37 matching lines @@
   };
 
   client_->OnGestureEvent(gesture);
 }
 
 bool GestureProvider::SendLongTapIfNecessary(const MotionEvent& event) {
   if (event.GetAction() == MotionEvent::ACTION_UP &&
       !current_longpress_time_.is_null() &&
       !scale_gesture_listener_->IsScaleGestureDetectionInProgress()) {
     GestureEventDetails long_tap_details(ET_GESTURE_LONG_TAP, 0, 0);
-    Send(CreateGesture(ET_GESTURE_LONG_TAP, event, long_tap_details));
+    Send(CreateGesture(long_tap_details, event));
     return true;
   }
   return false;
 }
 
 void GestureProvider::EndTouchScrollIfNecessary(const MotionEvent& event,
                                                 bool send_scroll_end_event) {
   if (!touch_scroll_in_progress_)
     return;
   if (send_scroll_end_event)
@@ skipping 75 matching lines @@
   if (current_down_event_)
     return;
 
   const bool double_tap_enabled = double_tap_support_for_page_ &&
                                   double_tap_support_for_platform_;
   gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
   scale_gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
 }
 
 }  //  namespace ui