Reland: Move TouchSelectionController from content to ui

ui/touch_selection/touch_selection_controller.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_selection_controller.h"
+#include "ui/touch_selection/touch_selection_controller.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
-#include "third_party/WebKit/public/web/WebInputEvent.h"
 
-namespace content {
+namespace ui {
 namespace {
 
-TouchHandleOrientation ToTouchHandleOrientation(cc::SelectionBoundType type) {
+TouchHandleOrientation ToTouchHandleOrientation(SelectionBound::Type type) {
   switch (type) {
-    case cc::SELECTION_BOUND_LEFT:
+    case SelectionBound::LEFT:
       return TOUCH_HANDLE_LEFT;
-    case cc::SELECTION_BOUND_RIGHT:
+    case SelectionBound::RIGHT:
       return TOUCH_HANDLE_RIGHT;
-    case cc::SELECTION_BOUND_CENTER:
+    case SelectionBound::CENTER:
       return TOUCH_HANDLE_CENTER;
-    case cc::SELECTION_BOUND_EMPTY:
+    case SelectionBound::EMPTY:
       return TOUCH_HANDLE_ORIENTATION_UNDEFINED;
   }
   NOTREACHED() << "Invalid selection bound type: " << type;
   return TOUCH_HANDLE_ORIENTATION_UNDEFINED;
 }
 
 }  // namespace
 
 TouchSelectionController::TouchSelectionController(
     TouchSelectionControllerClient* client,
@@ skipping 13 matching lines @@
       selection_editable_(false),
       temporarily_hidden_(false) {
   DCHECK(client_);
   HideAndDisallowShowingAutomatically();
 }
 
 TouchSelectionController::~TouchSelectionController() {
 }
 
 void TouchSelectionController::OnSelectionBoundsChanged(
-    const cc::ViewportSelectionBound& start,
-    const cc::ViewportSelectionBound& end) {
+    const SelectionBound& start,
+    const SelectionBound& end) {
   if (start == start_ && end_ == end)
     return;
 
   start_ = start;
   end_ = end;
-  start_orientation_ = ToTouchHandleOrientation(start_.type);
-  end_orientation_ = ToTouchHandleOrientation(end_.type);
+  start_orientation_ = ToTouchHandleOrientation(start_.type());
+  end_orientation_ = ToTouchHandleOrientation(end_.type());
 
   if (!activate_selection_automatically_ &&
       !activate_insertion_automatically_) {
     DCHECK_EQ(INPUT_EVENT_TYPE_NONE, response_pending_input_event_);
     return;
   }
 
   // Ensure that |response_pending_input_event_| is cleared after the method
   // completes, while also making its current value available for the duration
   // of the call.
@@ skipping 28 matching lines @@
   }
 
   if (start_orientation_ == TOUCH_HANDLE_CENTER && selection_editable_) {
     OnInsertionChanged();
     return;
   }
 
   HideAndDisallowShowingAutomatically();
 }
 
-bool TouchSelectionController::WillHandleTouchEvent(
-    const ui::MotionEvent& event) {
+bool TouchSelectionController::WillHandleTouchEvent(const MotionEvent& event) {
   if (is_insertion_active_) {
     DCHECK(insertion_handle_);
     return insertion_handle_->WillHandleTouchEvent(event);
   }
 
   if (is_selection_active_) {
     DCHECK(start_selection_handle_);
     DCHECK(end_selection_handle_);
     if (start_selection_handle_->is_dragging())
       return start_selection_handle_->WillHandleTouchEvent(event);
@@ skipping 263 matching lines @@
   DCHECK(end_selection_handle_);
   start_selection_handle_->SetEnabled(false);
   end_selection_handle_->SetEnabled(false);
   is_selection_active_ = false;
   client_->OnSelectionEvent(SELECTION_CLEARED, gfx::PointF());
 }
 
 void TouchSelectionController::ResetCachedValuesIfInactive() {
   if (is_selection_active_ || is_insertion_active_)
     return;
-  start_ = cc::ViewportSelectionBound();
-  end_ = cc::ViewportSelectionBound();
+  start_ = SelectionBound();
+  end_ = SelectionBound();
   start_orientation_ = TOUCH_HANDLE_ORIENTATION_UNDEFINED;
   end_orientation_ = TOUCH_HANDLE_ORIENTATION_UNDEFINED;
 }
 
 const gfx::PointF& TouchSelectionController::GetStartPosition() const {
-  return start_.edge_bottom;
+  return start_.edge_bottom();
 }
 
 const gfx::PointF& TouchSelectionController::GetEndPosition() const {
-  return end_.edge_bottom;
+  return end_.edge_bottom();
 }
 
 gfx::Vector2dF TouchSelectionController::GetStartLineOffset() const {
-  return gfx::ScaleVector2d(start_.edge_top - start_.edge_bottom, 0.5f);
+  return gfx::ScaleVector2d(start_.edge_top() - start_.edge_bottom(), 0.5f);
 }
 
 gfx::Vector2dF TouchSelectionController::GetEndLineOffset() const {
-  return gfx::ScaleVector2d(end_.edge_top - end_.edge_bottom, 0.5f);
+  return gfx::ScaleVector2d(end_.edge_top() - end_.edge_bottom(), 0.5f);
 }
 
 bool TouchSelectionController::GetStartVisible() const {
-  return start_.visible && !temporarily_hidden_;
+  return start_.visible() && !temporarily_hidden_;
 }
 
 bool TouchSelectionController::GetEndVisible() const {
-  return end_.visible && !temporarily_hidden_;
+  return end_.visible() && !temporarily_hidden_;
 }
 
 TouchHandle::AnimationStyle TouchSelectionController::GetAnimationStyle(
     bool was_active) const {
   return was_active && client_->SupportsAnimation()
              ? TouchHandle::ANIMATION_SMOOTH
              : TouchHandle::ANIMATION_NONE;
 }
 
-}  // namespace content
+}  // namespace ui