Reland: Move TouchSelectionController from content to ui

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 "content/browser/renderer_host/input/touch_handle.h"
+#include "ui/touch_selection/touch_handle.h"
 
 #include <cmath>
 
-namespace content {
+namespace ui {
 
 namespace {
 
 // Maximum duration of a fade sequence.
 const double kFadeDurationMs = 200;
 
 // Maximum amount of travel for a fade sequence. This avoids handle "ghosting"
 // when the handle is moving rapidly while the fade is active.
 const double kFadeDistanceSquared = 20.f * 20.f;
 
@@ skipping 86 matching lines @@
     return;
   }
   DCHECK_EQ(deferred_orientation_, TOUCH_HANDLE_ORIENTATION_UNDEFINED);
   if (orientation_ == orientation)
     return;
 
   orientation_ = orientation;
   drawable_->SetOrientation(orientation);
 }
 
-bool TouchHandle::WillHandleTouchEvent(const ui::MotionEvent& event) {
+bool TouchHandle::WillHandleTouchEvent(const MotionEvent& event) {
   if (!enabled_)
     return false;
 
-  if (!is_dragging_ && event.GetAction() != ui::MotionEvent::ACTION_DOWN)
+  if (!is_dragging_ && event.GetAction() != MotionEvent::ACTION_DOWN)
     return false;
 
   switch (event.GetAction()) {
-    case ui::MotionEvent::ACTION_DOWN: {
+    case MotionEvent::ACTION_DOWN: {
       if (!is_visible_)
         return false;
       const float touch_size = std::max(
           kMinTouchMajorForHitTesting,
           std::min(kMaxTouchMajorForHitTesting, event.GetTouchMajor()));
       const gfx::RectF touch_rect(event.GetX() - touch_size * .5f,
                                   event.GetY() - touch_size * .5f,
                                   touch_size,
                                   touch_size);
       if (!drawable_->IntersectsWith(touch_rect))
         return false;
       touch_down_position_ = gfx::PointF(event.GetX(), event.GetY());
       touch_to_focus_offset_ = position_ - touch_down_position_;
       touch_down_time_ = event.GetEventTime();
       BeginDrag();
     } break;
 
-    case ui::MotionEvent::ACTION_MOVE: {
+    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;
       }
 
       // 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_);
     } break;
 
-    case ui::MotionEvent::ACTION_UP: {
+    case MotionEvent::ACTION_UP: {
       if (is_drag_within_tap_region_ &&
           (event.GetEventTime() - touch_down_time_) <
               client_->GetTapTimeout()) {
         client_->OnHandleTapped(*this);
       }
 
       EndDrag();
     } break;
 
-    case ui::MotionEvent::ACTION_CANCEL:
+    case MotionEvent::ACTION_CANCEL:
       EndDrag();
       break;
 
     default:
       break;
   };
   return true;
 }
 
 bool TouchHandle::Animate(base::TimeTicks frame_time) {
@@ skipping 76 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 content
+}  // namespace ui