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

ui/events/gesture_detection/scale_gesture_detector.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/scale_gesture_detector.h"
 
 #include <limits.h>
 #include <cmath>
 
 #include "base/float_util.h"
@@ skipping 14 matching lines @@
 const int kTouchStabilizeTimeMs = 128;
 
 const float kScaleFactor = .5f;
 
 }  // namespace
 
 // Note: These constants were taken directly from the default (unscaled)
 // versions found in Android's ViewConfiguration.
 ScaleGestureDetector::Config::Config()
     : min_scaling_touch_major(48),
-      min_scaling_span(200),
+      min_scaling_span(100),
+      use_touch_major_in_span(false),
       quick_scale_enabled(true),
       min_pinch_update_span_delta(0) {
 }
 
 ScaleGestureDetector::Config::~Config() {}
 
 bool ScaleGestureDetector::SimpleScaleGestureListener::OnScale(
     const ScaleGestureDetector&, const MotionEvent&) {
   return false;
 }
@@ skipping 16 matching lines @@
       curr_span_(0),
       prev_span_(0),
       initial_span_(0),
       curr_span_x_(0),
       curr_span_y_(0),
       prev_span_x_(0),
       prev_span_y_(0),
       in_progress_(0),
       span_slop_(0),
       min_span_(0),
+      use_touch_major_in_span_(config.use_touch_major_in_span),
       touch_upper_(0),
       touch_lower_(0),
       touch_history_last_accepted_(0),
       touch_history_direction_(0),
       touch_min_major_(0),
+      touch_max_major_(0),
       double_tap_focus_x_(0),
       double_tap_focus_y_(0),
       double_tap_mode_(DOUBLE_TAP_MODE_NONE),
       event_before_or_above_starting_gesture_event_(false) {
   DCHECK(listener_);
-  span_slop_ =
-      (config.gesture_detector_config.touch_slop + kSlopEpsilon) * 2;
+  span_slop_ = (config.gesture_detector_config.touch_slop + kSlopEpsilon) * 2;
   touch_min_major_ = config.min_scaling_touch_major;
+  touch_max_major_ = std::min(config.min_scaling_span, 2.f * touch_min_major_);
   min_span_ = config.min_scaling_span + kSlopEpsilon;
   ResetTouchHistory();
   SetQuickScaleEnabled(config.quick_scale_enabled);
 }
 
 ScaleGestureDetector::~ScaleGestureDetector() {}
 
 bool ScaleGestureDetector::OnTouchEvent(const MotionEvent& event) {
   curr_time_ = event.GetEventTime();
 
@@ skipping 57 matching lines @@
       if (skip_index == i)
         continue;
       sum_x += event.GetX(i);
       sum_y += event.GetY(i);
     }
 
     focus_x = sum_x * inverse_unreleased_point_count;
     focus_y = sum_y * inverse_unreleased_point_count;
   }
 
-  AddTouchHistory(event);
+  if (use_touch_major_in_span_)
+    AddTouchHistory(event);
 
   // Determine average deviation from focal point.
   float dev_sum_x = 0, dev_sum_y = 0;
   for (int i = 0; i < count; i++) {
     if (skip_index == i)
       continue;
 
     dev_sum_x += std::abs(event.GetX(i) - focus_x);
     dev_sum_y += std::abs(event.GetY(i) - focus_y);
   }
   // Convert the resulting diameter into a radius, to include touch
   // radius in overall deviation.
-  const float touch_size = touch_history_last_accepted_ / 2;
+  const float touch_radius =
+      use_touch_major_in_span_ ? touch_history_last_accepted_ / 2 : 0;
 
-  const float dev_x = (dev_sum_x * inverse_unreleased_point_count) + touch_size;
-  const float dev_y = (dev_sum_y * inverse_unreleased_point_count) + touch_size;
+  const float dev_x = dev_sum_x * inverse_unreleased_point_count + touch_radius;
+  const float dev_y = dev_sum_y * inverse_unreleased_point_count + touch_radius;
 
   // Span is the average distance between touch points through the focal point;
   // i.e. the diameter of the circle with a radius of the average deviation from
   // the focal point.
   const float span_x = dev_x * 2;
   const float span_y = dev_y * 2;
   float span;
   if (InDoubleTapMode()) {
     span = span_y;
   } else {
@@ skipping 132 matching lines @@
     const int pointersample_count = history_size + 1;
     for (int h = 0; h < pointersample_count; h++) {
       float major;
       if (h < history_size) {
         major = ev.GetHistoricalTouchMajor(i, h);
       } else {
         major = ev.GetTouchMajor(i);
       }
       if (major < touch_min_major_)
         major = touch_min_major_;
+      if (major > touch_max_major_)
+        major = touch_max_major_;
       total += major;
 
       if (base::IsNaN(touch_upper_) || major > touch_upper_) {
         touch_upper_ = major;
       }
       if (base::IsNaN(touch_lower_) || major < touch_lower_) {
         touch_lower_ = major;
       }
 
       if (has_last_accepted) {
@@ skipping 33 matching lines @@
   touch_history_last_accepted_time_ = base::TimeTicks();
 }
 
 void ScaleGestureDetector::ResetScaleWithSpan(float span) {
   in_progress_ = false;
   initial_span_ = span;
   double_tap_mode_ = DOUBLE_TAP_MODE_NONE;
 }
 
 }  // namespace ui