Make GestureTextSelector detect its own gestures

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/gesture_listeners.h"
 #include "ui/events/gesture_detection/motion_event.h"
+#include "ui/events/gesture_detection/scale_gesture_listeners.h"
 #include "ui/gfx/geometry/point_f.h"
 
 namespace ui {
 namespace {
 
 // Double-tap drag zoom sensitivity (speed).
 const float kDoubleTapDragZoomSpeed = 0.005f;
 
 const char* GetMotionEventActionName(MotionEvent::Action action) {
   switch (action) {
@@ skipping 41 matching lines @@
       gesture_begin_end_types_enabled(false),
       min_gesture_bounds_length(0),
       max_gesture_bounds_length(0) {
 }
 
 GestureProvider::Config::~Config() {
 }
 
 // GestureProvider::GestureListener
 
-class GestureProvider::GestureListenerImpl
-    : public ScaleGestureDetector::ScaleGestureListener,
-      public GestureDetector::GestureListener,
-      public GestureDetector::DoubleTapListener {
+class GestureProvider::GestureListenerImpl : public ScaleGestureListener,
+                                             public GestureListener,
+                                             public DoubleTapListener {
  public:
   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),
@@ skipping 96 matching lines @@
         if (pinch_event_sent_ || scroll_event_sent_)
           return;
       default:
         break;
     };
 
     client_->OnGestureEvent(gesture);
     GestureTouchUMAHistogram::RecordGestureEvent(gesture);
   }
 
-  // ScaleGestureDetector::ScaleGestureListener implementation.
+  // ScaleGestureListener implementation.
   virtual bool OnScaleBegin(const ScaleGestureDetector& detector,
                             const MotionEvent& e) OVERRIDE {
     if (ignore_multitouch_zoom_events_ && !detector.InDoubleTapMode())
       return false;
     return true;
   }
 
   virtual void OnScaleEnd(const ScaleGestureDetector& detector,
                           const MotionEvent& e) OVERRIDE {
     if (!pinch_event_sent_)
@@ skipping 49 matching lines @@
                        detector.GetFocusX(),
                        detector.GetFocusY(),
                        detector.GetFocusX() + e.GetRawOffsetX(),
                        detector.GetFocusY() + e.GetRawOffsetY(),
                        e.GetPointerCount(),
                        GetBoundingBox(e, pinch_details.type()),
                        e.GetFlags()));
     return true;
   }
 
-  // GestureDetector::GestureListener implementation.
+  // GestureListener implementation.
   virtual bool OnDown(const MotionEvent& e) OVERRIDE {
     GestureEventDetails tap_details(ET_GESTURE_TAP_DOWN);
     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,
@@ skipping 159 matching lines @@
         !current_longpress_time_.is_null() &&
         !IsScaleGestureDetectionInProgress()) {
       GestureEventDetails long_tap_details(ET_GESTURE_LONG_TAP);
       Send(CreateGesture(long_tap_details, e));
       return true;
     }
 
     return false;
   }
 
-  // GestureDetector::DoubleTapListener implementation.
+  // 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;
 
@@ skipping 356 matching lines @@
   // 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_;
   gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
 }
 
 }  //  namespace ui