Support longpress drag selection

ui/touch_selection/touch_handle.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/touch_selection/touch_handle.h"
 
 #include <cmath>
 
 namespace ui {
 
@@ skipping 149 matching lines @@
       const float touch_radius = std::max(
           kMinTouchMajorForHitTesting,
           std::min(kMaxTouchMajorForHitTesting, event.GetTouchMajor())) * 0.5f;
       if (!RectIntersectsCircle(drawable_->GetVisibleBounds(),
                                 touch_point,
                                 touch_radius)) {
         EndDrag();
         return false;
       }
       touch_down_position_ = touch_point;
-      touch_to_focus_offset_ = position_ - touch_down_position_;
+      touch_drag_offset_ = position_ - touch_down_position_;
       touch_down_time_ = event.GetEventTime();
       BeginDrag();
     } break;
 
     case MotionEvent::ACTION_MOVE: {
       gfx::PointF touch_move_position(event.GetX(), event.GetY());
-      if (is_drag_within_tap_region_) {
-        const float tap_slop = client_->GetTapSlop();
-        is_drag_within_tap_region_ =
-            (touch_move_position - touch_down_position_).LengthSquared() <
-            tap_slop * tap_slop;
-      }
+      is_drag_within_tap_region_ &=
+          client_->IsWithinTapSlop(touch_down_position_ - touch_move_position);
 
       // Note that we signal drag update even if we're inside the tap region,
       // as there are cases where characters are narrower than the slop length.
-      client_->OnHandleDragUpdate(*this,
-                                  touch_move_position + touch_to_focus_offset_);
+      client_->OnDragUpdate(*this, touch_move_position + touch_drag_offset_);
     } break;
 
     case MotionEvent::ACTION_UP: {
       if (is_drag_within_tap_region_ &&
           (event.GetEventTime() - touch_down_time_) <
               client_->GetTapTimeout()) {
         client_->OnHandleTapped(*this);
       }
 
       EndDrag();
     } break;
 
     case MotionEvent::ACTION_CANCEL:
       EndDrag();
       break;
 
     default:
       break;
   };
   return true;
 }
 
+bool TouchHandle::IsActive() const {
+  return is_dragging_;
+}
+
 bool TouchHandle::Animate(base::TimeTicks frame_time) {
   if (fade_end_time_ == base::TimeTicks())
     return false;
 
   DCHECK(enabled_);
 
   float time_u =
       1.f - (fade_end_time_ - frame_time).InMillisecondsF() / kFadeDurationMs;
   float position_u =
       (position_ - fade_start_position_).LengthSquared() / kFadeDistanceSquared;
@@ skipping 15 matching lines @@
   return drawable_->GetVisibleBounds();
 }
 
 void TouchHandle::BeginDrag() {
   DCHECK(enabled_);
   if (is_dragging_)
     return;
   EndFade();
   is_dragging_ = true;
   is_drag_within_tap_region_ = true;
-  client_->OnHandleDragBegin(*this);
+  client_->OnDragBegin(*this, position());
 }
 
 void TouchHandle::EndDrag() {
   DCHECK(enabled_);
   if (!is_dragging_)
     return;
 
   is_dragging_ = false;
   is_drag_within_tap_region_ = false;
-  client_->OnHandleDragEnd(*this);
+  client_->OnDragEnd(*this);
 
   if (deferred_orientation_ != TouchHandleOrientation::UNDEFINED) {
     TouchHandleOrientation deferred_orientation = deferred_orientation_;
     deferred_orientation_ = TouchHandleOrientation::UNDEFINED;
     SetOrientation(deferred_orientation);
   }
 
   if (animate_deferred_fade_) {
     BeginFade();
   } else {
@@ skipping 29 matching lines @@
 
 void TouchHandle::SetAlpha(float alpha) {
   alpha = std::max(0.f, std::min(1.f, alpha));
   if (alpha_ == alpha)
     return;
   alpha_ = alpha;
   drawable_->SetAlpha(alpha);
 }
 
 }  // namespace ui