[Aura] Reduce frequency of PinchUpdate events.

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 98 matching lines @@
   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) {}

[jdduke (slow), 2014/05/22 18:06:35]

Let's initialize the min_pinch_update_span_delta to 0.

[tdresser, 2014/05/22 18:25:17]

It's in ScaleGestureDetector::Config, but done.

 
 GestureProvider::Config::~Config() {}
 
 // GestureProvider::ScaleGestureListener
 
 class GestureProvider::ScaleGestureListenerImpl
     : public ScaleGestureDetector::ScaleGestureListener {
  public:
   ScaleGestureListenerImpl(const ScaleGestureDetector::Config& config,
                            GestureProvider* provider)
       : scale_gesture_detector_(config, this),
         provider_(provider),
         ignore_multitouch_events_(false),
-        pinch_event_sent_(false) {}
+        pinch_event_sent_(false),
+        min_pinch_update_span_delta_(config.min_pinch_update_span_delta) {}
 
   bool OnTouchEvent(const MotionEvent& event) {
     // TODO: Need to deal with multi-touch transition.
     const bool in_scale_gesture = IsScaleGestureDetectionInProgress();
     bool handled = scale_gesture_detector_.OnTouchEvent(event);
     if (!in_scale_gesture &&
         (event.GetAction() == MotionEvent::ACTION_UP ||
          event.GetAction() == MotionEvent::ACTION_CANCEL)) {
       return false;
     }
@@ skipping 20 matching lines @@
                                   0,
                                   e.GetPointerCount(),
                                   GetBoundingBox(e)));
     pinch_event_sent_ = false;
   }
 
   virtual bool OnScale(const ScaleGestureDetector& detector,
                        const MotionEvent& e) OVERRIDE {
     if (ignore_multitouch_events_ && !detector.InDoubleTapMode())
       return false;
+
     if (!pinch_event_sent_) {
       pinch_event_sent_ = true;
       provider_->Send(CreateGesture(ET_GESTURE_PINCH_BEGIN,
                                     e.GetId(),
                                     detector.GetEventTime(),
                                     detector.GetFocusX(),
                                     detector.GetFocusY(),
                                     e.GetPointerCount(),
                                     GetBoundingBox(e)));
     }
 
+    float span = detector.GetCurrentSpan();
+    bool pinch_occured = std::abs(span - detector.GetPreviousSpan()) >=
+                         min_pinch_update_span_delta_;
+

[jdduke (slow), 2014/05/22 18:06:35]

You might consider merging all of this into:

if (std::abs(detector.GetCurrentSpan() - detector.GetPreviousSpan()) <
min_pinch_update_span_delta_)) {
  return false;
}

[tdresser, 2014/05/22 18:25:17]

Done.

+    if (!pinch_occured)
+      return false;
+
     float scale = detector.GetScaleFactor();
     if (scale == 1)
       return true;
 
     if (detector.InDoubleTapMode()) {
       // Relative changes in the double-tap scale factor computed by |detector|
       // diminish as the touch moves away from the original double-tap focus.
       // 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.
@@ skipping 45 matching lines @@
 
   GestureProvider* const provider_;
 
   // Completely silence multi-touch (pinch) scaling events. Used in WebView when
   // zoom support is turned off.
   bool ignore_multitouch_events_;
 
   // Whether any pinch zoom event has been sent to native.
   bool pinch_event_sent_;
 
+  // The minimum change in span required before this is considered a pinch. See
+  // crbug.com/373318.
+  float min_pinch_update_span_delta_;
+
   DISALLOW_COPY_AND_ASSIGN(ScaleGestureListenerImpl);
 };
 
 // GestureProvider::GestureListener
 
 class GestureProvider::GestureListenerImpl
     : public GestureDetector::GestureListener,
       public GestureDetector::DoubleTapListener {
  public:
   GestureListenerImpl(
@@ skipping 515 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