Eliminate pinch drift by removing touch radius from span calculation

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 <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
 #include "ui/events/gesture_detection/motion_event.h"
 #include "ui/events/gesture_detection/scale_gesture_listeners.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace ui {
 namespace {
 
 // Using a small epsilon when comparing slop distances allows pixel perfect
 // slop determination when using fractional DPI coordinates (assuming the slop
 // region and DPI scale are reasonably proportioned).
 const float kSlopEpsilon = .05f;
 
-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. Do not change these default
 // values without explicitly consulting an OWNER.
 ScaleGestureDetector::Config::Config()
     : span_slop(16),
-      min_scaling_touch_major(48),
       min_scaling_span(200),
       min_pinch_update_span_delta(0),
       stylus_scale_enabled(false) {}
 
 ScaleGestureDetector::Config::~Config() {}
 
 ScaleGestureDetector::ScaleGestureDetector(const Config& config,
                                            ScaleGestureListener* listener)
     : listener_(listener),
       stylus_scale_enabled_(config.stylus_scale_enabled),
       focus_x_(0),
       focus_y_(0),
       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),
-      touch_upper_(0),
-      touch_lower_(0),
-      touch_history_last_accepted_(0),
-      touch_history_direction_(0),
-      touch_min_major_(0),
-      touch_max_major_(0),
       anchored_scale_start_x_(0),
       anchored_scale_start_y_(0),
       anchored_scale_mode_(ANCHORED_SCALE_MODE_NONE),
       event_before_or_above_starting_gesture_event_(false) {
   DCHECK(listener_);
   span_slop_ = config.span_slop + kSlopEpsilon;
-  touch_min_major_ = config.min_scaling_touch_major;
-  touch_max_major_ = std::min(config.min_scaling_span / std::sqrt(2.f),
-                              2.f * touch_min_major_);
   min_span_ = config.min_scaling_span + kSlopEpsilon;
-  ResetTouchHistory();
 }
 
 ScaleGestureDetector::~ScaleGestureDetector() {}
 
 bool ScaleGestureDetector::OnTouchEvent(const MotionEvent& event) {
   curr_time_ = event.GetEventTime();
 
   const int action = event.GetAction();
 
   const int count = static_cast<int>(event.GetPointerCount());
@@ skipping 13 matching lines @@
     // Reset any scale in progress with the listener.
     // If it's an ACTION_DOWN we're beginning a new event stream.
     // This means the app probably didn't give us all the events. Shame on it.
     if (in_progress_) {
       listener_->OnScaleEnd(*this, event);
       ResetScaleWithSpan(0);
     } else if (InAnchoredScaleMode() && stream_complete) {
       ResetScaleWithSpan(0);
     }
 
-    if (stream_complete) {
-      ResetTouchHistory();
+    if (stream_complete)
       return true;
-    }
   }
 
   if (!in_progress_ && stylus_scale_enabled_ && !InAnchoredScaleMode() &&
       !stream_complete && is_stylus_button_down) {
     // Start of a stylus scale gesture.
     anchored_scale_start_x_ = event.GetX();
     anchored_scale_start_y_ = event.GetY();
     anchored_scale_mode_ = ANCHORED_SCALE_MODE_STYLUS;
     initial_span_ = 0;
   }
@@ skipping 28 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);
-
   // 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_radius = touch_history_last_accepted_ / 2;
 
-  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;
+  const float dev_x = dev_sum_x * inverse_unreleased_point_count;
+  const float dev_y = dev_sum_y * inverse_unreleased_point_count;
 
   // 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 (InAnchoredScaleMode()) {
     span = span_y;
   } else {
@@ skipping 98 matching lines @@
 }
 
 bool ScaleGestureDetector::OnDoubleTap(const MotionEvent& ev) {
   // Double tap: start watching for a swipe.
   anchored_scale_start_x_ = ev.GetX();
   anchored_scale_start_y_ = ev.GetY();
   anchored_scale_mode_ = ANCHORED_SCALE_MODE_DOUBLE_TAP;
   return true;
 }
 
-void ScaleGestureDetector::AddTouchHistory(const MotionEvent& ev) {
-  const base::TimeTicks current_time = ev.GetEventTime();
-  DCHECK(!current_time.is_null());
-  const int count = static_cast<int>(ev.GetPointerCount());
-  bool accept = touch_history_last_accepted_time_.is_null() ||
-                (current_time - touch_history_last_accepted_time_) >=
-                    base::TimeDelta::FromMilliseconds(kTouchStabilizeTimeMs);
-  float total = 0;
-  int sample_count = 0;
-  for (int i = 0; i < count; i++) {
-    const bool has_last_accepted = !std::isnan(touch_history_last_accepted_);
-    const int history_size = static_cast<int>(ev.GetHistorySize());
-    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 (std::isnan(touch_upper_) || major > touch_upper_) {
-        touch_upper_ = major;
-      }
-      if (std::isnan(touch_lower_) || major < touch_lower_) {
-        touch_lower_ = major;
-      }
-
-      if (has_last_accepted) {
-        const float major_delta = major - touch_history_last_accepted_;
-        const int direction_sig =
-            major_delta > 0 ? 1 : (major_delta < 0 ? -1 : 0);
-        if (direction_sig != touch_history_direction_ ||
-            (direction_sig == 0 && touch_history_direction_ == 0)) {
-          touch_history_direction_ = direction_sig;
-          touch_history_last_accepted_time_ = h < history_size
-                                                  ? ev.GetHistoricalEventTime(h)
-                                                  : ev.GetEventTime();
-          accept = false;
-        }
-      }
-    }
-    sample_count += pointersample_count;
-  }
-
-  const float avg = total / sample_count;
-
-  if (accept) {
-    float new_accepted = (touch_upper_ + touch_lower_ + avg) / 3;
-    touch_upper_ = (touch_upper_ + new_accepted) / 2;
-    touch_lower_ = (touch_lower_ + new_accepted) / 2;
-    touch_history_last_accepted_ = new_accepted;
-    touch_history_direction_ = 0;
-    touch_history_last_accepted_time_ = ev.GetEventTime();
-  }
-}
-
-void ScaleGestureDetector::ResetTouchHistory() {
-  touch_upper_ = std::numeric_limits<float>::quiet_NaN();
-  touch_lower_ = std::numeric_limits<float>::quiet_NaN();
-  touch_history_last_accepted_ = std::numeric_limits<float>::quiet_NaN();
-  touch_history_direction_ = 0;
-  touch_history_last_accepted_time_ = base::TimeTicks();
-}
-
 void ScaleGestureDetector::ResetScaleWithSpan(float span) {
   in_progress_ = false;
   initial_span_ = span;
   anchored_scale_mode_ = ANCHORED_SCALE_MODE_NONE;
 }
 
 }  // namespace ui