Avoid an extra GestureDetector instance for double-tap drag zooming

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"
 #include "ui/events/event_constants.h"
 #include "ui/events/gesture_detection/gesture_event_data.h"
 #include "ui/events/gesture_detection/motion_event.h"
 
 namespace ui {
 namespace {
 
 // Double-tap drag zoom sensitivity (speed).
 const float kDoubleTapDragZoomSpeed = 0.005f;
 
 const char* GetMotionEventActionName(MotionEvent::Action action) {
-  switch(action) {
-    case MotionEvent::ACTION_POINTER_DOWN: return "ACTION_POINTER_DOWN";
-    case MotionEvent::ACTION_POINTER_UP:   return "ACTION_POINTER_UP";
-    case MotionEvent::ACTION_DOWN:         return "ACTION_DOWN";
-    case MotionEvent::ACTION_UP:           return "ACTION_UP";
-    case MotionEvent::ACTION_CANCEL:       return "ACTION_CANCEL";
-    case MotionEvent::ACTION_MOVE:         return "ACTION_MOVE";
+  switch (action) {
+    case MotionEvent::ACTION_POINTER_DOWN:
+      return "ACTION_POINTER_DOWN";
+    case MotionEvent::ACTION_POINTER_UP:
+      return "ACTION_POINTER_UP";
+    case MotionEvent::ACTION_DOWN:
+      return "ACTION_DOWN";
+    case MotionEvent::ACTION_UP:
+      return "ACTION_UP";
+    case MotionEvent::ACTION_CANCEL:
+      return "ACTION_CANCEL";
+    case MotionEvent::ACTION_MOVE:
+      return "ACTION_MOVE";
   }
   return "";
 }
 
 gfx::RectF GetBoundingBox(const MotionEvent& event) {
   // Can't use gfx::RectF::Union, as it ignores touches with a radius of 0.
   float left = std::numeric_limits<float>::max();
   float top = std::numeric_limits<float>::max();
   float right = -std::numeric_limits<float>::max();
   float bottom = -std::numeric_limits<float>::max();
@@ skipping 64 matching lines @@
                           event.GetRawX(),
                           event.GetRawY(),
                           event.GetPointerCount(),
                           GetBoundingBox(event));
 }
 
 GestureEventData CreateGesture(EventType type, const MotionEvent& event) {
   return CreateGesture(GestureEventDetails(type, 0, 0), event);
 }
 
-GestureEventDetails CreateTapGestureDetails(EventType type) {
+GestureEventData CreateTapGesture(EventType type, const MotionEvent& event) {
   // 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;
+  return CreateGesture(GestureEventDetails(type, 1, 0), event);
 }
 
 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),
-      max_gesture_bounds_length(0) {}
+      max_gesture_bounds_length(0) {
+}
 
-GestureProvider::Config::~Config() {}
+GestureProvider::Config::~Config() {
+}
 
-// GestureProvider::ScaleGestureListener
+// GestureProvider::GestureListener
 
-class GestureProvider::ScaleGestureListenerImpl
-    : public ScaleGestureDetector::ScaleGestureListener {
+class GestureProvider::GestureListenerImpl
+    : public ScaleGestureDetector::ScaleGestureListener,
+      public GestureDetector::GestureListener,
+      public GestureDetector::DoubleTapListener {
  public:
-  ScaleGestureListenerImpl(const ScaleGestureDetector::Config& config,
-                           GestureProvider* provider)
-      : scale_gesture_detector_(config, this),
-        provider_(provider),
-        ignore_multitouch_events_(false),
+  GestureListenerImpl(const GestureProvider::Config& config,
+                      GestureProviderClient* client)
+      : config_(config),
+        client_(client),
+        gesture_detector_(config.gesture_detector_config, this, this),
+        scale_gesture_detector_(config.scale_gesture_detector_config, this),
+        snap_scroll_controller_(config.display),
+        ignore_multitouch_zoom_events_(false),
+        ignore_single_tap_(false),
         pinch_event_sent_(false),
-        min_pinch_update_span_delta_(config.min_pinch_update_span_delta) {}
+        scroll_event_sent_(false) {}
 
-  bool OnTouchEvent(const MotionEvent& event) {
-    // TODO: Need to deal with multi-touch transition.
+  void OnTouchEvent(const MotionEvent& event) {
     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;
+    snap_scroll_controller_.SetSnapScrollingMode(event, in_scale_gesture);
+    if (in_scale_gesture)
+      SetIgnoreSingleTap(true);
+
+    const MotionEvent::Action action = event.GetAction();
+    if (action == MotionEvent::ACTION_DOWN) {
+      current_down_time_ = event.GetEventTime();
+      current_longpress_time_ = base::TimeTicks();
+      ignore_single_tap_ = false;
+      scroll_event_sent_ = false;
+      pinch_event_sent_ = false;
+      gesture_detector_.set_longpress_enabled(true);
     }
-    return handled;
+
+    gesture_detector_.OnTouchEvent(event);
+    scale_gesture_detector_.OnTouchEvent(event);
+
+    if (action == MotionEvent::ACTION_UP ||
+        action == MotionEvent::ACTION_CANCEL) {
+      // Note: This call will have no effect if a fling was just generated, as
+      // |Fling()| will have already signalled an end to touch-scrolling.
+      if (scroll_event_sent_)
+        Send(CreateGesture(ET_GESTURE_SCROLL_END, event));
+      current_down_time_ = base::TimeTicks();
+    }
+  }
+
+  void 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_time_.is_null() || gesture.type() == ET_GESTURE_TAP ||
+           gesture.type() == ET_GESTURE_SHOW_PRESS ||
+           gesture.type() == ET_GESTURE_BEGIN ||
+           gesture.type() == ET_GESTURE_END);
+
+    if (gesture.primary_tool_type == MotionEvent::TOOL_TYPE_UNKNOWN ||
+        gesture.primary_tool_type == MotionEvent::TOOL_TYPE_FINGER) {
+      gesture.details.set_bounding_box(
+          ClampBoundingBox(gesture.details.bounding_box_f(),
+                           config_.min_gesture_bounds_length,
+                           config_.max_gesture_bounds_length));
+    }
+
+    switch (gesture.type()) {
+      case ET_GESTURE_LONG_PRESS:
+        DCHECK(!IsScaleGestureDetectionInProgress());
+        current_longpress_time_ = gesture.time;
+        break;
+      case ET_GESTURE_LONG_TAP:
+        current_longpress_time_ = base::TimeTicks();
+        break;
+      case ET_GESTURE_SCROLL_BEGIN:
+        DCHECK(!scroll_event_sent_);
+        scroll_event_sent_ = true;
+        break;
+      case ET_GESTURE_SCROLL_END:
+        DCHECK(scroll_event_sent_);
+        if (pinch_event_sent_)
+          Send(GestureEventData(ET_GESTURE_PINCH_END, gesture));
+        scroll_event_sent_ = false;
+        break;
+      case ET_SCROLL_FLING_START:
+        DCHECK(scroll_event_sent_);
+        scroll_event_sent_ = false;
+        break;
+      case ET_GESTURE_PINCH_BEGIN:
+        DCHECK(!pinch_event_sent_);
+        if (!scroll_event_sent_)
+          Send(GestureEventData(ET_GESTURE_SCROLL_BEGIN, gesture));
+        pinch_event_sent_ = true;
+        break;
+      case ET_GESTURE_PINCH_END:
+        DCHECK(pinch_event_sent_);
+        pinch_event_sent_ = false;
+        break;
+      case ET_GESTURE_SHOW_PRESS:
+        // It's possible that a double-tap drag zoom (from ScaleGestureDetector)
+        // will start before the press gesture fires (from GestureDetector), in
+        // which case the press should simply be dropped.
+        if (pinch_event_sent_ || scroll_event_sent_)
+          return;
+      default:
+        break;
+    };
+
+    client_->OnGestureEvent(gesture);
   }
 
   // ScaleGestureDetector::ScaleGestureListener implementation.
   virtual bool OnScaleBegin(const ScaleGestureDetector& detector,
                             const MotionEvent& e) OVERRIDE {
-    if (ignore_multitouch_events_ && !detector.InDoubleTapMode())
+    if (ignore_multitouch_zoom_events_ && !detector.InDoubleTapMode())
       return false;
-    pinch_event_sent_ = false;
     return true;
   }
 
   virtual void OnScaleEnd(const ScaleGestureDetector& detector,
                           const MotionEvent& e) OVERRIDE {
     if (!pinch_event_sent_)
       return;
-    provider_->Send(CreateGesture(ET_GESTURE_PINCH_END, e));
-    pinch_event_sent_ = false;
+    Send(CreateGesture(ET_GESTURE_PINCH_END, e));
   }
 
   virtual bool OnScale(const ScaleGestureDetector& detector,
                        const MotionEvent& e) OVERRIDE {
-    if (ignore_multitouch_events_ && !detector.InDoubleTapMode())
+    if (ignore_multitouch_zoom_events_ && !detector.InDoubleTapMode())
       return false;
     if (!pinch_event_sent_) {
-      pinch_event_sent_ = true;
-      provider_->Send(CreateGesture(ET_GESTURE_PINCH_BEGIN,
-                                    e.GetId(),
-                                    e.GetToolType(),
-                                    detector.GetEventTime(),
-                                    detector.GetFocusX(),
-                                    detector.GetFocusY(),
-                                    detector.GetFocusX() + e.GetRawOffsetX(),
-                                    detector.GetFocusY() + e.GetRawOffsetY(),
-                                    e.GetPointerCount(),
-                                    GetBoundingBox(e)));
+      Send(CreateGesture(ET_GESTURE_PINCH_BEGIN,
+                         e.GetId(),
+                         e.GetToolType(),
+                         detector.GetEventTime(),
+                         detector.GetFocusX(),
+                         detector.GetFocusY(),
+                         detector.GetFocusX() + e.GetRawOffsetX(),
+                         detector.GetFocusY() + e.GetRawOffsetY(),
+                         e.GetPointerCount(),
+                         GetBoundingBox(e)));
     }
 
     if (std::abs(detector.GetCurrentSpan() - detector.GetPreviousSpan()) <
-        min_pinch_update_span_delta_) {
+        config_.scale_gesture_detector_config.min_pinch_update_span_delta) {
       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.
       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(pinch_details,
-                                  e.GetId(),
-                                  e.GetToolType(),
-                                  detector.GetEventTime(),
-                                  detector.GetFocusX(),
-                                  detector.GetFocusY(),
-                                  detector.GetFocusX() + e.GetRawOffsetX(),
-                                  detector.GetFocusY() + e.GetRawOffsetY(),
-                                  e.GetPointerCount(),
-                                  GetBoundingBox(e)));
+    Send(CreateGesture(pinch_details,
+                       e.GetId(),
+                       e.GetToolType(),
+                       detector.GetEventTime(),
+                       detector.GetFocusX(),
+                       detector.GetFocusY(),
+                       detector.GetFocusX() + e.GetRawOffsetX(),
+                       detector.GetFocusY() + e.GetRawOffsetY(),
+                       e.GetPointerCount(),
+                       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
-    // gesture detector not to emit further scaling notifications
-    // related to this gesture. Thus, if detector events are enabled in
-    // the middle of the gesture, we don't need to do anything.
-    ignore_multitouch_events_ = !enabled;
-  }
-
-  bool IsDoubleTapInProgress() const {
-    return IsScaleGestureDetectionInProgress() && InDoubleTapMode();
-  }
-
-  bool IsScaleGestureDetectionInProgress() const {
-    return scale_gesture_detector_.IsInProgress();
-  }
-
- private:
-  bool InDoubleTapMode() const {
-    return scale_gesture_detector_.InDoubleTapMode();
-  }
-
-  ScaleGestureDetector scale_gesture_detector_;
-
-  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(
-      const gfx::Display& display,
-      const GestureDetector::Config& gesture_detector_config,
-      bool disable_click_delay,
-      GestureProvider* provider)
-      : gesture_detector_(gesture_detector_config, this, this),
-        snap_scroll_controller_(display),
-        provider_(provider),
-        disable_click_delay_(disable_click_delay),
-        touch_slop_(gesture_detector_config.touch_slop),
-        double_tap_timeout_(gesture_detector_config.double_tap_timeout),
-        ignore_single_tap_(false),
-        seen_first_scroll_event_(false) {}
-
-  virtual ~GestureListenerImpl() {}
-
-  bool OnTouchEvent(const MotionEvent& e,
-                    bool is_scale_gesture_detection_in_progress) {
-    snap_scroll_controller_.SetSnapScrollingMode(
-        e, is_scale_gesture_detection_in_progress);
-
-    if (is_scale_gesture_detection_in_progress)
-      SetIgnoreSingleTap(true);
-
-    if (e.GetAction() == MotionEvent::ACTION_DOWN)
-      gesture_detector_.set_longpress_enabled(true);
-
-    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(tap_details, e));
+    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;
     float distance_y = raw_distance_y;
-    if (!seen_first_scroll_event_) {
+    if (!scroll_event_sent_) {
       // Remove the touch slop region from the first scroll event to avoid a
       // jump.
-      seen_first_scroll_event_ = true;
       double distance =
           std::sqrt(distance_x * distance_x + distance_y * distance_y);
       double epsilon = 1e-3;
       if (distance > epsilon) {
-        double ratio = std::max(0., distance - touch_slop_) / distance;
+        double ratio =
+            std::max(0.,
+                     distance - config_.gesture_detector_config.touch_slop) /
+            distance;
         distance_x *= ratio;
         distance_y *= ratio;
       }
-    }
-    snap_scroll_controller_.UpdateSnapScrollMode(distance_x, distance_y);
-    if (snap_scroll_controller_.IsSnappingScrolls()) {
-      if (snap_scroll_controller_.IsSnapHorizontal()) {
-        distance_y = 0;
-      } else {
-        distance_x = 0;
-      }
-    }
 
-    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(scroll_details,
-                                    e2.GetId(),
-                                    e2.GetToolType(),
-                                    e2.GetEventTime(),
-                                    e1.GetX(),
-                                    e1.GetY(),
-                                    e1.GetRawX(),
-                                    e1.GetRawY(),
-                                    e2.GetPointerCount(),
-                                    GetBoundingBox(e2)));
+      Send(CreateGesture(scroll_details,
+                         e2.GetId(),
+                         e2.GetToolType(),
+                         e2.GetEventTime(),
+                         e1.GetX(),
+                         e1.GetY(),
+                         e1.GetRawX(),
+                         e1.GetRawY(),
+                         e2.GetPointerCount(),
+                         GetBoundingBox(e2)));
+      DCHECK(scroll_event_sent_);
+    }
+
+    snap_scroll_controller_.UpdateSnapScrollMode(distance_x, distance_y);
+    if (snap_scroll_controller_.IsSnappingScrolls()) {
+      if (snap_scroll_controller_.IsSnapHorizontal()) {

[tdresser, 2014/08/22 18:19:04]

While you're here, you could switch to a braceless if.

[jdduke (slow), 2014/08/22 20:33:10]

Done.

+        distance_y = 0;
+      } else {
+        distance_x = 0;
+      }
     }
 
     if (distance_x || distance_y) {
       const gfx::RectF bounding_box = GetBoundingBox(e2);
       const gfx::PointF center = bounding_box.CenterPoint();
       const gfx::PointF raw_center =
           center + gfx::Vector2dF(e2.GetRawOffsetX(), e2.GetRawOffsetY());
       GestureEventDetails scroll_details(
           ET_GESTURE_SCROLL_UPDATE, -distance_x, -distance_y);
-      provider_->Send(CreateGesture(scroll_details,
-                                    e2.GetId(),
-                                    e2.GetToolType(),
-                                    e2.GetEventTime(),
-                                    center.x(),
-                                    center.y(),
-                                    raw_center.x(),
-                                    raw_center.y(),
-                                    e2.GetPointerCount(),
-                                    bounding_box));
+      Send(CreateGesture(scroll_details,
+                         e2.GetId(),
+                         e2.GetToolType(),
+                         e2.GetEventTime(),
+                         center.x(),
+                         center.y(),
+                         raw_center.x(),
+                         raw_center.y(),
+                         e2.GetPointerCount(),
+                         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);
+    if (!velocity_x && !velocity_y)
+      return true;
+
+    if (!scroll_event_sent_) {
+      // The native side needs a ET_GESTURE_SCROLL_BEGIN before
+      // ET_SCROLL_FLING_START to send the fling to the correct target.
+      // 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(scroll_details, e2));
+    }
+
+    GestureEventDetails fling_details(
+        ET_SCROLL_FLING_START, velocity_x, velocity_y);
+    Send(CreateGesture(fling_details, e2));
     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(swipe_details, e2));
+    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(two_finger_tap_details,
-                                  e2.GetId(),
-                                  e2.GetToolType(),
-                                  e2.GetEventTime(),
-                                  e1.GetX(),
-                                  e1.GetY(),
-                                  e1.GetRawX(),
-                                  e1.GetRawY(),
-                                  e2.GetPointerCount(),
-                                  GetBoundingBox(e2)));
+    GestureEventDetails two_finger_tap_details(
+        ET_GESTURE_TWO_FINGER_TAP, e1.GetTouchMajor(), e1.GetTouchMajor());
+    Send(CreateGesture(two_finger_tap_details,
+                       e2.GetId(),
+                       e2.GetToolType(),
+                       e2.GetEventTime(),
+                       e1.GetX(),
+                       e1.GetY(),
+                       e1.GetRawX(),
+                       e1.GetRawY(),
+                       e2.GetPointerCount(),
+                       GetBoundingBox(e2)));
     return true;
   }
 
   virtual void OnShowPress(const MotionEvent& e) OVERRIDE {
     GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS, 0, 0);
-    provider_->Send(CreateGesture(show_press_details, e));
+    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_) {
+      if (e.GetEventTime() - current_down_time_ >
+          config_.gesture_detector_config.double_tap_timeout) {
         return OnSingleTapConfirmed(e);
-      } else if (!IsDoubleTapEnabled() || disable_click_delay_) {
+      } else if (!IsDoubleTapEnabled() || config_.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(
-            CreateTapGestureDetails(ET_GESTURE_TAP_UNCONFIRMED), e));
+        Send(CreateTapGesture(ET_GESTURE_TAP_UNCONFIRMED, e));
       }
     }
 
-    return provider_->SendLongTapIfNecessary(e);
+    if (e.GetAction() == MotionEvent::ACTION_UP &&
+        !current_longpress_time_.is_null() &&
+        !IsScaleGestureDetectionInProgress()) {
+      GestureEventDetails long_tap_details(ET_GESTURE_LONG_TAP, 0, 0);
+      Send(CreateGesture(long_tap_details, e));
+      return true;
+    }
+
+    return false;
   }
 
   // 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(CreateTapGestureDetails(ET_GESTURE_TAP), e));
+    Send(CreateTapGesture(ET_GESTURE_TAP, e));
     return true;
   }
 
-  virtual bool OnDoubleTap(const MotionEvent& e) OVERRIDE { return false; }
+  virtual bool OnDoubleTap(const MotionEvent& e) OVERRIDE {
+    return scale_gesture_detector_.OnDoubleTap(e);
+  }
 
   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(CreateTapGestureDetails(ET_GESTURE_DOUBLE_TAP), e));
+        if (!IsPinchInProgress() && !IsScrollInProgress()) {
+          Send(CreateTapGesture(ET_GESTURE_DOUBLE_TAP, e));
           return true;
         }
         break;
+
       default:
         break;
     }
     return false;
   }
 
   virtual void OnLongPress(const MotionEvent& e) OVERRIDE {
     DCHECK(!IsDoubleTapInProgress());
     SetIgnoreSingleTap(true);
-
     GestureEventDetails long_press_details(ET_GESTURE_LONG_PRESS, 0, 0);
-    provider_->Send(CreateGesture(long_press_details, e));
+    Send(CreateGesture(long_press_details, e));
   }
 
   void SetDoubleTapEnabled(bool enabled) {
     DCHECK(!IsDoubleTapInProgress());
     gesture_detector_.SetDoubleTapListener(enabled ? this : NULL);
   }
 
-  bool IsDoubleTapInProgress() const {
-    return gesture_detector_.is_double_tapping();
+  void SetMultiTouchZoomEnabled(bool enabled) {
+    // Note that returning false from OnScaleBegin / OnScale makes the
+    // gesture detector not to emit further scaling notifications

[tdresser, 2014/08/22 18:19:04]

Might as well reword this comment while you're here.

At least:
"not to emit" -> "not emit"
"if detector events" -> "if multitouch zoom events"

On second thought, does this comment even make sense at this point? There's
nothing to worry about keeping in sync as of this patch... You can probably just
get rid of this comment.

[jdduke (slow), 2014/08/22 20:33:09]

Ah, yeah this can be cleaned up. I think we still want this behavior, but the
wording here is pretty bad.

+    // related to this gesture. Thus, if detector events are enabled in
+    // the middle of the gesture, we don't need to do anything.
+    ignore_multitouch_zoom_events_ = !enabled;
   }
 
+  bool IsDoubleTapInProgress() const {
+    return gesture_detector_.is_double_tapping() ||
+           (IsScaleGestureDetectionInProgress() && InDoubleTapMode());
+  }
+
+  bool IsScrollInProgress() const { return scroll_event_sent_; }
+
+  bool IsPinchInProgress() const { return pinch_event_sent_; }
+
  private:
-  void SetIgnoreSingleTap(bool value) { ignore_single_tap_ = value; }
+  bool IsScaleGestureDetectionInProgress() const {
+    return scale_gesture_detector_.IsInProgress();
+  }
+
+  bool InDoubleTapMode() const {
+    return scale_gesture_detector_.InDoubleTapMode();
+  }
 
   bool IsDoubleTapEnabled() const {
     return gesture_detector_.has_doubletap_listener();
   }
 
+  void SetIgnoreSingleTap(bool value) { ignore_single_tap_ = value; }
+
+  const GestureProvider::Config config_;
+  GestureProviderClient* const client_;
+
   GestureDetector gesture_detector_;
+  ScaleGestureDetector scale_gesture_detector_;
   SnapScrollController snap_scroll_controller_;
 
-  GestureProvider* const provider_;
-
-  // Whether the click delay should always be disabled by sending clicks for
-  // double-tap gestures.
-  const bool disable_click_delay_;
-
-  const float touch_slop_;
-
-  const base::TimeDelta double_tap_timeout_;
-
   base::TimeTicks current_down_time_;
 
+  // Keeps track of the current GESTURE_LONG_PRESS event. If a context menu is
+  // opened after a GESTURE_LONG_PRESS, this is used to insert a
+  // GESTURE_TAP_CANCEL for removing any ::active styling.
+  base::TimeTicks current_longpress_time_;
+
+  // Completely silence multi-touch (pinch) scaling events. Used in WebView when
+  // zoom support is turned off.
+  bool ignore_multitouch_zoom_events_;
+
   // TODO(klobag): This is to avoid a bug in GestureDetector. With multi-touch,
   // always_in_tap_region_ is not reset. So when the last finger is up,
-  // OnSingleTapUp() will be mistakenly fired.
+  // |OnSingleTapUp()| will be mistakenly fired.
   bool ignore_single_tap_;
 
-  // Used to remove the touch slop from the initial scroll event in a scroll
-  // gesture.
-  bool seen_first_scroll_event_;
+  // Tracks whether {PINCH|SCROLL|_BEGIN events have been forwadred for the

[tdresser, 2014/08/22 18:19:04]

forwadred -> forwarded
{PINCH|SCROLL|_BEGIN -> ...

[jdduke (slow), 2014/08/22 20:33:09]

Done.

+  // current touch sequence.
+  bool pinch_event_sent_;
+  bool scroll_event_sent_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureListenerImpl);
 };
 
 // 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_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),
-      max_gesture_bounds_length_(config.max_gesture_bounds_length) {
+      gesture_begin_end_types_enabled_(config.gesture_begin_end_types_enabled) {
   DCHECK(client);
-  DCHECK(!min_gesture_bounds_length_ || !max_gesture_bounds_length_ ||
-         min_gesture_bounds_length_ <= max_gesture_bounds_length_);
-  InitGestureDetectors(config);
+  DCHECK(!config.min_gesture_bounds_length ||
+         !config.max_gesture_bounds_length ||
+         config.min_gesture_bounds_length <= config.max_gesture_bounds_length);
+  TRACE_EVENT0("input", "GestureProvider::InitGestureDetectors");
+  gesture_listener_.reset(new GestureListenerImpl(config, client));
+  UpdateDoubleTapDetectionSupport();
 }
 
-GestureProvider::~GestureProvider() {}
+GestureProvider::~GestureProvider() {
+}
 
 bool GestureProvider::OnTouchEvent(const MotionEvent& event) {
-  TRACE_EVENT1("input", "GestureProvider::OnTouchEvent",
-               "action", GetMotionEventActionName(event.GetAction()));
+  TRACE_EVENT1("input",
+               "GestureProvider::OnTouchEvent",
+               "action",
+               GetMotionEventActionName(event.GetAction()));
 
   DCHECK_NE(0u, event.GetPointerCount());
 
   if (!CanHandle(event))
     return false;
 
-  const bool in_scale_gesture =
-      scale_gesture_listener_->IsScaleGestureDetectionInProgress();
-
   OnTouchEventHandlingBegin(event);
-  gesture_listener_->OnTouchEvent(event, in_scale_gesture);
-  scale_gesture_listener_->OnTouchEvent(event);
+  gesture_listener_->OnTouchEvent(event);
   OnTouchEventHandlingEnd(event);
   return true;
 }
 
 void GestureProvider::SetMultiTouchZoomSupportEnabled(bool enabled) {
-  scale_gesture_listener_->SetMultiTouchEnabled(enabled);
+  gesture_listener_->SetMultiTouchZoomEnabled(enabled);
 }
 
 void GestureProvider::SetDoubleTapSupportForPlatformEnabled(bool enabled) {
   if (double_tap_support_for_platform_ == enabled)
     return;
   double_tap_support_for_platform_ = enabled;
   UpdateDoubleTapDetectionSupport();
 }
 
 void GestureProvider::SetDoubleTapSupportForPageEnabled(bool enabled) {
   if (double_tap_support_for_page_ == enabled)
     return;
   double_tap_support_for_page_ = enabled;
   UpdateDoubleTapDetectionSupport();
 }
 
 bool GestureProvider::IsScrollInProgress() const {
-  // TODO(wangxianzhu): Also return true when fling is active once the UI knows
-  // exactly when the fling ends.
-  return touch_scroll_in_progress_;
+  return gesture_listener_->IsScrollInProgress();
 }
 
-bool GestureProvider::IsPinchInProgress() const { return pinch_in_progress_; }
+bool GestureProvider::IsPinchInProgress() const {
+  return gesture_listener_->IsPinchInProgress();
+}
 
 bool GestureProvider::IsDoubleTapInProgress() const {
-  return gesture_listener_->IsDoubleTapInProgress() ||
-         scale_gesture_listener_->IsDoubleTapInProgress();
-}
-
-void GestureProvider::InitGestureDetectors(const Config& config) {
-  TRACE_EVENT0("input", "GestureProvider::InitGestureDetectors");
-  gesture_listener_.reset(
-      new GestureListenerImpl(config.display,
-                              config.gesture_detector_config,
-                              config.disable_click_delay,
-                              this));
-
-  scale_gesture_listener_.reset(
-      new ScaleGestureListenerImpl(config.scale_gesture_detector_config, this));
-
-  UpdateDoubleTapDetectionSupport();
+  return gesture_listener_->IsDoubleTapInProgress();
 }
 
 bool GestureProvider::CanHandle(const MotionEvent& event) const {
   // Aura requires one cancel event per touch point, whereas Android requires
   // one cancel event per touch sequence. Thus we need to allow extra cancel
   // events.
-  return event.GetAction() == MotionEvent::ACTION_DOWN || current_down_event_ ||
+  return current_down_event_ || event.GetAction() == MotionEvent::ACTION_DOWN ||
          event.GetAction() == MotionEvent::ACTION_CANCEL;
 }
 
-void GestureProvider::Fling(const MotionEvent& event,
-                            float velocity_x,
-                            float velocity_y) {
-  if (!velocity_x && !velocity_y) {
-    EndTouchScrollIfNecessary(event, true);
-    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(scroll_details, event));
-  }
-  EndTouchScrollIfNecessary(event, false);
-
-  GestureEventDetails fling_details(
-      ET_SCROLL_FLING_START, velocity_x, velocity_y);
-  Send(CreateGesture(fling_details, event));
-}
-
-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 ||
-         gesture.type() == ET_GESTURE_END);
-
-  if (gesture.primary_tool_type == MotionEvent::TOOL_TYPE_UNKNOWN ||
-      gesture.primary_tool_type == MotionEvent::TOOL_TYPE_FINGER) {
-    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:
-      DCHECK(!touch_scroll_in_progress_);
-      touch_scroll_in_progress_ = true;
-      break;
-    case ET_GESTURE_SCROLL_END:
-      DCHECK(touch_scroll_in_progress_);
-      if (pinch_in_progress_)
-        Send(GestureEventData(ET_GESTURE_PINCH_END, gesture));
-      touch_scroll_in_progress_ = false;
-      break;
-    case ET_GESTURE_PINCH_BEGIN:
-      DCHECK(!pinch_in_progress_);
-      if (!touch_scroll_in_progress_)
-        Send(GestureEventData(ET_GESTURE_SCROLL_BEGIN, gesture));
-      pinch_in_progress_ = true;
-      break;
-    case ET_GESTURE_PINCH_END:
-      DCHECK(pinch_in_progress_);
-      pinch_in_progress_ = false;
-      break;
-    case ET_GESTURE_SHOW_PRESS:
-      // It's possible that a double-tap drag zoom (from ScaleGestureDetector)
-      // will start before the press gesture fires (from GestureDetector), in
-      // which case the press should simply be dropped.
-      if (pinch_in_progress_ || touch_scroll_in_progress_)
-        return;
-    default:
-      break;
-  };
-
-  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(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)
-    Send(CreateGesture(ET_GESTURE_SCROLL_END, event));
-  touch_scroll_in_progress_ = false;
-}
-
 void GestureProvider::OnTouchEventHandlingBegin(const MotionEvent& event) {
   switch (event.GetAction()) {
     case MotionEvent::ACTION_DOWN:
       current_down_event_ = event.Clone();
-      touch_scroll_in_progress_ = false;
-      pinch_in_progress_ = false;
-      current_longpress_time_ = base::TimeTicks();
       if (gesture_begin_end_types_enabled_)
-        Send(CreateGesture(ET_GESTURE_BEGIN, event));
+        gesture_listener_->Send(CreateGesture(ET_GESTURE_BEGIN, event));
       break;
     case MotionEvent::ACTION_POINTER_DOWN:
       if (gesture_begin_end_types_enabled_) {
         const int action_index = event.GetActionIndex();
-        Send(CreateGesture(ET_GESTURE_BEGIN,
-                           event.GetId(),
-                           event.GetToolType(),
-                           event.GetEventTime(),
-                           event.GetX(action_index),
-                           event.GetY(action_index),
-                           event.GetRawX(action_index),
-                           event.GetRawY(action_index),
-                           event.GetPointerCount(),
-                           GetBoundingBox(event)));
+        gesture_listener_->Send(CreateGesture(ET_GESTURE_BEGIN,
+                                              event.GetId(),
+                                              event.GetToolType(),
+                                              event.GetEventTime(),
+                                              event.GetX(action_index),
+                                              event.GetY(action_index),
+                                              event.GetRawX(action_index),
+                                              event.GetRawY(action_index),
+                                              event.GetPointerCount(),
+                                              GetBoundingBox(event)));
       }
       break;
     case MotionEvent::ACTION_POINTER_UP:
     case MotionEvent::ACTION_UP:
     case MotionEvent::ACTION_CANCEL:
     case MotionEvent::ACTION_MOVE:
       break;
   }
 }
 
 void GestureProvider::OnTouchEventHandlingEnd(const MotionEvent& event) {
   switch (event.GetAction()) {
     case MotionEvent::ACTION_UP:
     case MotionEvent::ACTION_CANCEL: {
-      // Note: This call will have no effect if a fling was just generated, as
-      // |Fling()| will have already signalled an end to touch-scrolling.
-      EndTouchScrollIfNecessary(event, true);
-
       if (gesture_begin_end_types_enabled_)
-        Send(CreateGesture(ET_GESTURE_END, event));
+        gesture_listener_->Send(CreateGesture(ET_GESTURE_END, event));
 
       current_down_event_.reset();
 
       UpdateDoubleTapDetectionSupport();
       break;
     }
     case MotionEvent::ACTION_POINTER_UP:
       if (gesture_begin_end_types_enabled_)
-        Send(CreateGesture(ET_GESTURE_END, event));
+        gesture_listener_->Send(CreateGesture(ET_GESTURE_END, event));
       break;
     case MotionEvent::ACTION_DOWN:
     case MotionEvent::ACTION_POINTER_DOWN:
     case MotionEvent::ACTION_MOVE:
       break;
   }
 }
 
 void GestureProvider::UpdateDoubleTapDetectionSupport() {
   // The GestureDetector requires that any provided DoubleTapListener remain
   // attached to it for the duration of a touch sequence. Defer any potential
   // null'ing of the listener until the sequence has ended.
   if (current_down_event_)
     return;
 
-  const bool double_tap_enabled = double_tap_support_for_page_ &&
-                                  double_tap_support_for_platform_;
+  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