Separate out Touch Selection Orientation enum

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 "ui/touch_selection/touch_selection_controller.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 
 namespace ui {
 namespace {
 
 gfx::Vector2dF ComputeLineOffsetFromBottom(const SelectionBound& bound) {
   gfx::Vector2dF line_offset =
       gfx::ScaleVector2d(bound.edge_top() - bound.edge_bottom(), 0.5f);
   // An offset of 5 DIPs is sufficient for most line sizes. For small lines,
   // using half the line height avoids synthesizing a point on a line above
   // (or below) the intended line.
   const gfx::Vector2dF kMaxLineOffset(5.f, 5.f);
   line_offset.SetToMin(kMaxLineOffset);
   line_offset.SetToMax(-kMaxLineOffset);
   return line_offset;
 }
 
 TouchHandleOrientation ToTouchHandleOrientation(SelectionBound::Type type) {
   switch (type) {
     case SelectionBound::LEFT:
-      return TOUCH_HANDLE_LEFT;
+      return TouchHandleOrientation::LEFT;
     case SelectionBound::RIGHT:
-      return TOUCH_HANDLE_RIGHT;
+      return TouchHandleOrientation::RIGHT;
     case SelectionBound::CENTER:
-      return TOUCH_HANDLE_CENTER;
+      return TouchHandleOrientation::CENTER;
     case SelectionBound::EMPTY:
-      return TOUCH_HANDLE_ORIENTATION_UNDEFINED;
+      return TouchHandleOrientation::UNDEFINED;
   }
   NOTREACHED() << "Invalid selection bound type: " << type;
-  return TOUCH_HANDLE_ORIENTATION_UNDEFINED;
+  return TouchHandleOrientation::UNDEFINED;
 }
 
 }  // namespace
 
 TouchSelectionController::TouchSelectionController(
     TouchSelectionControllerClient* client,
     base::TimeDelta tap_timeout,
     float tap_slop,
     bool show_on_tap_for_empty_editable)
     : client_(client),
       tap_timeout_(tap_timeout),
       tap_slop_(tap_slop),
       show_on_tap_for_empty_editable_(show_on_tap_for_empty_editable),
       response_pending_input_event_(INPUT_EVENT_TYPE_NONE),
-      start_orientation_(TOUCH_HANDLE_ORIENTATION_UNDEFINED),
-      end_orientation_(TOUCH_HANDLE_ORIENTATION_UNDEFINED),
+      start_orientation_(TouchHandleOrientation::UNDEFINED),
+      end_orientation_(TouchHandleOrientation::UNDEFINED),
       is_insertion_active_(false),
       activate_insertion_automatically_(false),
       is_selection_active_(false),
       activate_selection_automatically_(false),
       selection_empty_(false),
       selection_editable_(false),
       temporarily_hidden_(false),
       selection_handle_dragged_(false) {
   DCHECK(client_);
   HideAndDisallowShowingAutomatically();
@@ skipping 31 matching lines @@
       is_selection_active_ && (start_selection_handle_->is_dragging() ||
                                end_selection_handle_->is_dragging());
 
   // It's possible that the bounds temporarily overlap while a selection handle
   // is being dragged, incorrectly reporting a CENTER orientation.
   // TODO(jdduke): This safeguard is racy, as it's possible the delayed response
   // from handle positioning occurs *after* the handle dragging has ceased.
   // Instead, prevent selection -> insertion transitions without an intervening
   // action or selection clearing of some sort, crbug.com/392696.
   if (is_selection_dragging) {
-    if (start_orientation_ == TOUCH_HANDLE_CENTER)
+    if (start_orientation_ == TouchHandleOrientation::CENTER)
       start_orientation_ = start_selection_handle_->orientation();
-    if (end_orientation_ == TOUCH_HANDLE_CENTER)
+    if (end_orientation_ == TouchHandleOrientation::CENTER)
       end_orientation_ = end_selection_handle_->orientation();
   }
 
   if (GetStartPosition() != GetEndPosition() ||
       (is_selection_dragging &&
-       start_orientation_ != TOUCH_HANDLE_ORIENTATION_UNDEFINED &&
-       end_orientation_ != TOUCH_HANDLE_ORIENTATION_UNDEFINED)) {
+       start_orientation_ != TouchHandleOrientation::UNDEFINED &&
+       end_orientation_ != TouchHandleOrientation::UNDEFINED)) {
     OnSelectionChanged();
     return;
   }
 
-  if (start_orientation_ == TOUCH_HANDLE_CENTER && selection_editable_) {
+  if (start_orientation_ == TouchHandleOrientation::CENTER &&
+      selection_editable_) {
     OnInsertionChanged();
     return;
   }
 
   HideAndDisallowShowingAutomatically();
 }
 
 bool TouchSelectionController::WillHandleTouchEvent(const MotionEvent& event) {
   if (is_insertion_active_) {
     DCHECK(insertion_handle_);
@@ skipping 28 matching lines @@
 }
 
 void TouchSelectionController::AllowShowingFromCurrentSelection() {
   if (is_selection_active_ || is_insertion_active_)
     return;
 
   activate_selection_automatically_ = true;
   activate_insertion_automatically_ = true;
   if (GetStartPosition() != GetEndPosition())
     OnSelectionChanged();
-  else if (start_orientation_ == TOUCH_HANDLE_CENTER && selection_editable_)
+  else if (start_orientation_ == TouchHandleOrientation::CENTER &&
+           selection_editable_)
     OnInsertionChanged();
 }
 
 void TouchSelectionController::OnTapEvent() {
   response_pending_input_event_ = TAP;
   ShowInsertionHandleAutomatically();
   if (selection_empty_)
     DeactivateInsertion();
   ResetCachedValuesIfInactive();
 }
@@ skipping 165 matching lines @@
   end_selection_handle_->SetVisible(GetEndVisible(), animation);
 
   start_selection_handle_->SetPosition(GetStartPosition());
   end_selection_handle_->SetPosition(GetEndPosition());
 }
 
 void TouchSelectionController::ActivateInsertion() {
   DCHECK(!is_selection_active_);
 
   if (!insertion_handle_)
-    insertion_handle_.reset(new TouchHandle(this, TOUCH_HANDLE_CENTER));
+    insertion_handle_.reset(
+        new TouchHandle(this, TouchHandleOrientation::CENTER));
 
   if (!is_insertion_active_) {
     is_insertion_active_ = true;
     insertion_handle_->SetEnabled(true);
     client_->OnSelectionEvent(INSERTION_SHOWN, GetStartPosition());
   }
 }
 
 void TouchSelectionController::DeactivateInsertion() {
   if (!is_insertion_active_)
@@ skipping 47 matching lines @@
   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_ = SelectionBound();
   end_ = SelectionBound();
-  start_orientation_ = TOUCH_HANDLE_ORIENTATION_UNDEFINED;
-  end_orientation_ = TOUCH_HANDLE_ORIENTATION_UNDEFINED;
+  start_orientation_ = TouchHandleOrientation::UNDEFINED;
+  end_orientation_ = TouchHandleOrientation::UNDEFINED;
 }
 
 const gfx::PointF& TouchSelectionController::GetStartPosition() const {
   return start_.edge_bottom();
 }
 
 const gfx::PointF& TouchSelectionController::GetEndPosition() const {
   return end_.edge_bottom();
 }
 
@@ skipping 29 matching lines @@
     base::TimeDelta duration = base::TimeTicks::Now() - selection_start_time_;
     UMA_HISTOGRAM_CUSTOM_TIMES("Event.TouchSelection.WasDraggedDuration",
                                duration,
                                base::TimeDelta::FromMilliseconds(500),
                                base::TimeDelta::FromSeconds(60),
                                60);
   }
 }
 
 }  // namespace ui