Provide max gesture bounds and option to ignore touch size during pinch

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 89 matching lines @@
 }
 
 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;
 }
 
+gfx::RectF ClampBoundingBox(const gfx::RectF& bounds,
+                            float min_length,
+                            float max_length) {
+  float width = bounds.width();
+  float height = bounds.height();
+  if (min_length) {
+    width = std::max(min_length, width);
+    height = std::max(min_length, height);
+  }
+  if (max_length) {
+    width = std::min(max_length, width);
+    height = std::min(max_length, height);
+  }
+  const gfx::PointF center = bounds.CenterPoint();
+  return gfx::RectF(
+      center.x() - width / 2.f, center.y() - height / 2.f, width, height);
+}
+
 }  // namespace
 
 // GestureProvider:::Config
 
 GestureProvider::Config::Config()
     : display(gfx::Display::kInvalidDisplayID, gfx::Rect(1, 1)),
       disable_click_delay(false),
       gesture_begin_end_types_enabled(false),
-      min_gesture_bounds_length(0) {}
+      min_gesture_bounds_length(0),
+      max_gesture_bounds_length(0) {}
 
 GestureProvider::Config::~Config() {}
 
 // GestureProvider::ScaleGestureListener
 
 class GestureProvider::ScaleGestureListenerImpl
     : public ScaleGestureDetector::ScaleGestureListener {
  public:
   ScaleGestureListenerImpl(const ScaleGestureDetector::Config& config,
                            GestureProvider* provider)
@@ skipping 414 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),
-      min_gesture_bounds_length_(config.min_gesture_bounds_length) {
+      min_gesture_bounds_length_(config.min_gesture_bounds_length),
+      max_gesture_bounds_length_(config.max_gesture_bounds_length) {
   DCHECK(client);
+  DCHECK(!min_gesture_bounds_length_ || !max_gesture_bounds_length_ ||
+         min_gesture_bounds_length_ <= max_gesture_bounds_length_);
   InitGestureDetectors(config);
 }
 
 GestureProvider::~GestureProvider() {}
 
 bool GestureProvider::OnTouchEvent(const MotionEvent& event) {
   TRACE_EVENT1("input", "GestureProvider::OnTouchEvent",
                "action", GetMotionEventActionName(event.GetAction()));
 
   DCHECK_NE(0u, event.GetPointerCount());
@@ skipping 87 matching lines @@
 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);
 
   // 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())));
+  gesture.details.set_bounding_box(
+      ClampBoundingBox(gesture.details.bounding_box_f(),
+                       min_gesture_bounds_length_,
+                       max_gesture_bounds_length_));
 
   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:
@@ skipping 128 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