Separate out Touch Selection Orientation enum

ui/touch_selection/touch_handle_unittest.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 "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/test/motion_event_test_utils.h"
 #include "ui/gfx/geometry/rect_f.h"
+#include "ui/touch_selection/touch_handle_orientation.h"
 
 using ui::test::MockMotionEvent;
 
 namespace ui {
 namespace {
 
 const int kDefaultTapTimeoutMs = 200;
 const float kDefaultTapSlop = 10.f;
 const float kDefaultDrawableSize = 10.f;
 
 struct MockDrawableData {
   MockDrawableData()
-      : orientation(TOUCH_HANDLE_ORIENTATION_UNDEFINED),
+      : orientation(TouchHandleOrientation::UNDEFINED),
         alpha(0.f),
         enabled(false),
         visible(false),
         rect(0, 0, kDefaultDrawableSize, kDefaultDrawableSize) {}
   TouchHandleOrientation orientation;
   float alpha;
   bool enabled;
   bool visible;
   gfx::RectF rect;
 };
@@ skipping 103 matching lines @@
   gfx::PointF drag_position_;
   bool dragging_;
   bool dragged_;
   bool tapped_;
   bool needs_animate_;
 
   MockDrawableData drawable_data_;
 };
 
 TEST_F(TouchHandleTest, Visibility) {
-  TouchHandle handle(this, TOUCH_HANDLE_CENTER);
+  TouchHandle handle(this, TouchHandleOrientation::CENTER);
   EXPECT_FALSE(drawable().visible);
 
   handle.SetVisible(true, TouchHandle::ANIMATION_NONE);
   EXPECT_TRUE(drawable().visible);
   EXPECT_EQ(1.f, drawable().alpha);
 
   handle.SetVisible(false, TouchHandle::ANIMATION_NONE);
   EXPECT_FALSE(drawable().visible);
 
   handle.SetVisible(true, TouchHandle::ANIMATION_NONE);
   EXPECT_TRUE(drawable().visible);
   EXPECT_EQ(1.f, drawable().alpha);
 }
 
 TEST_F(TouchHandleTest, VisibilityAnimation) {
-  TouchHandle handle(this, TOUCH_HANDLE_CENTER);
+  TouchHandle handle(this, TouchHandleOrientation::CENTER);
   ASSERT_FALSE(NeedsAnimate());
   ASSERT_FALSE(drawable().visible);
   ASSERT_EQ(0.f, drawable().alpha);
 
   handle.SetVisible(true, TouchHandle::ANIMATION_SMOOTH);
   EXPECT_TRUE(NeedsAnimate());
   EXPECT_FALSE(drawable().visible);
   EXPECT_EQ(0.f, drawable().alpha);
 
   Animate(handle);
@@ skipping 15 matching lines @@
   EXPECT_FALSE(GetAndResetNeedsAnimate());
   handle.SetVisible(false, TouchHandle::ANIMATION_SMOOTH);
   EXPECT_EQ(1.f, drawable().alpha);
   EXPECT_TRUE(GetAndResetNeedsAnimate());
   handle.SetVisible(true, TouchHandle::ANIMATION_SMOOTH);
   EXPECT_EQ(1.f, drawable().alpha);
   EXPECT_FALSE(GetAndResetNeedsAnimate());
 }
 
 TEST_F(TouchHandleTest, Orientation) {
-  TouchHandle handle(this, TOUCH_HANDLE_CENTER);
-  EXPECT_EQ(TOUCH_HANDLE_CENTER, drawable().orientation);
+  TouchHandle handle(this, TouchHandleOrientation::CENTER);
+  EXPECT_EQ(TouchHandleOrientation::CENTER, drawable().orientation);
 
-  handle.SetOrientation(TOUCH_HANDLE_LEFT);
-  EXPECT_EQ(TOUCH_HANDLE_LEFT, drawable().orientation);
+  handle.SetOrientation(TouchHandleOrientation::LEFT);
+  EXPECT_EQ(TouchHandleOrientation::LEFT, drawable().orientation);
 
-  handle.SetOrientation(TOUCH_HANDLE_RIGHT);
-  EXPECT_EQ(TOUCH_HANDLE_RIGHT, drawable().orientation);
+  handle.SetOrientation(TouchHandleOrientation::RIGHT);
+  EXPECT_EQ(TouchHandleOrientation::RIGHT, drawable().orientation);
 
-  handle.SetOrientation(TOUCH_HANDLE_CENTER);
-  EXPECT_EQ(TOUCH_HANDLE_CENTER, drawable().orientation);
+  handle.SetOrientation(TouchHandleOrientation::CENTER);
+  EXPECT_EQ(TouchHandleOrientation::CENTER, drawable().orientation);
 }
 
 TEST_F(TouchHandleTest, Position) {
-  TouchHandle handle(this, TOUCH_HANDLE_CENTER);
+  TouchHandle handle(this, TouchHandleOrientation::CENTER);
   handle.SetVisible(true, TouchHandle::ANIMATION_NONE);
 
   gfx::PointF position;
   EXPECT_EQ(gfx::PointF(), drawable().rect.origin());
 
   position = gfx::PointF(7.3f, -3.7f);
   handle.SetPosition(position);
   EXPECT_EQ(position, drawable().rect.origin());
 
   position = gfx::PointF(-7.3f, 3.7f);
   handle.SetPosition(position);
   EXPECT_EQ(position, drawable().rect.origin());
 }
 
 TEST_F(TouchHandleTest, PositionNotUpdatedWhileFadingOrInvisible) {
-  TouchHandle handle(this, TOUCH_HANDLE_CENTER);
+  TouchHandle handle(this, TouchHandleOrientation::CENTER);
 
   handle.SetVisible(true, TouchHandle::ANIMATION_NONE);
   ASSERT_TRUE(drawable().visible);
   ASSERT_FALSE(NeedsAnimate());
 
   gfx::PointF old_position(7.3f, -3.7f);
   handle.SetPosition(old_position);
   ASSERT_EQ(old_position, drawable().rect.origin());
 
   handle.SetVisible(false, TouchHandle::ANIMATION_SMOOTH);
@@ skipping 14 matching lines @@
   // Even after the animation terminates, the new position will not be pushed.
   EXPECT_EQ(old_position, drawable().rect.origin());
 
   // As soon as the handle becomes visible, the new position will be pushed.
   handle.SetVisible(true, TouchHandle::ANIMATION_SMOOTH);
   EXPECT_EQ(new_position, drawable().rect.origin());
 }
 
 TEST_F(TouchHandleTest, Enabled) {
   // A newly created handle defaults to enabled.
-  TouchHandle handle(this, TOUCH_HANDLE_CENTER);
+  TouchHandle handle(this, TouchHandleOrientation::CENTER);
   EXPECT_TRUE(drawable().enabled);
 
   handle.SetVisible(true, TouchHandle::ANIMATION_SMOOTH);
   EXPECT_TRUE(GetAndResetNeedsAnimate());
   EXPECT_EQ(0.f, drawable().alpha);
   handle.SetEnabled(false);
   EXPECT_FALSE(drawable().enabled);
 
   // Dragging should not be allowed while the handle is disabled.
   base::TimeTicks event_time = base::TimeTicks::Now();
@@ skipping 16 matching lines @@
   handle.SetEnabled(true);
   handle.SetVisible(true, TouchHandle::ANIMATION_NONE);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   EXPECT_TRUE(IsDragging());
   handle.SetEnabled(false);
   EXPECT_FALSE(IsDragging());
   EXPECT_FALSE(handle.WillHandleTouchEvent(event));
 }
 
 TEST_F(TouchHandleTest, Drag) {
-  TouchHandle handle(this, TOUCH_HANDLE_CENTER);
+  TouchHandle handle(this, TouchHandleOrientation::CENTER);
 
   base::TimeTicks event_time = base::TimeTicks::Now();
   const float kOffset = kDefaultDrawableSize / 2.f;
 
   // The handle must be visible to trigger drag.
   MockMotionEvent event(
       MockMotionEvent::ACTION_DOWN, event_time, kOffset, kOffset);
   EXPECT_FALSE(handle.WillHandleTouchEvent(event));
   EXPECT_FALSE(IsDragging());
   handle.SetVisible(true, TouchHandle::ANIMATION_NONE);
@@ skipping 33 matching lines @@
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   EXPECT_FALSE(GetAndResetHandleDragged());
   EXPECT_FALSE(IsDragging());
 
   // Non-ACTION_DOWN events after the drag has terminated should not be handled.
   event = MockMotionEvent(MockMotionEvent::ACTION_CANCEL);
   EXPECT_FALSE(handle.WillHandleTouchEvent(event));
 }
 
 TEST_F(TouchHandleTest, DragDefersOrientationChange) {
-  TouchHandle handle(this, TOUCH_HANDLE_RIGHT);
-  ASSERT_EQ(drawable().orientation, TOUCH_HANDLE_RIGHT);
+  TouchHandle handle(this, TouchHandleOrientation::RIGHT);
+  ASSERT_EQ(drawable().orientation, TouchHandleOrientation::RIGHT);
   handle.SetVisible(true, TouchHandle::ANIMATION_NONE);
 
   MockMotionEvent event(MockMotionEvent::ACTION_DOWN);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   EXPECT_TRUE(IsDragging());
 
   // Orientation changes will be deferred until the drag ends.
-  handle.SetOrientation(TOUCH_HANDLE_LEFT);
-  EXPECT_EQ(TOUCH_HANDLE_RIGHT, drawable().orientation);
+  handle.SetOrientation(TouchHandleOrientation::LEFT);
+  EXPECT_EQ(TouchHandleOrientation::RIGHT, drawable().orientation);
 
   event = MockMotionEvent(MockMotionEvent::ACTION_MOVE);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   EXPECT_TRUE(GetAndResetHandleDragged());
   EXPECT_TRUE(IsDragging());
-  EXPECT_EQ(TOUCH_HANDLE_RIGHT, drawable().orientation);
+  EXPECT_EQ(TouchHandleOrientation::RIGHT, drawable().orientation);
 
   event = MockMotionEvent(MockMotionEvent::ACTION_UP);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   EXPECT_FALSE(GetAndResetHandleDragged());
   EXPECT_FALSE(IsDragging());
-  EXPECT_EQ(TOUCH_HANDLE_LEFT, drawable().orientation);
+  EXPECT_EQ(TouchHandleOrientation::LEFT, drawable().orientation);
 }
 
 TEST_F(TouchHandleTest, DragDefersFade) {
-  TouchHandle handle(this, TOUCH_HANDLE_CENTER);
+  TouchHandle handle(this, TouchHandleOrientation::CENTER);
   handle.SetVisible(true, TouchHandle::ANIMATION_NONE);
 
   MockMotionEvent event(MockMotionEvent::ACTION_DOWN);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   EXPECT_TRUE(IsDragging());
 
   // Fade will be deferred until the drag ends.
   handle.SetVisible(false, TouchHandle::ANIMATION_SMOOTH);
   EXPECT_FALSE(NeedsAnimate());
   EXPECT_TRUE(drawable().visible);
   EXPECT_EQ(1.f, drawable().alpha);
 
   event = MockMotionEvent(MockMotionEvent::ACTION_MOVE);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   EXPECT_FALSE(NeedsAnimate());
   EXPECT_TRUE(drawable().visible);
 
   event = MockMotionEvent(MockMotionEvent::ACTION_UP);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   EXPECT_FALSE(IsDragging());
   EXPECT_TRUE(NeedsAnimate());
 
   Animate(handle);
   EXPECT_FALSE(drawable().visible);
   EXPECT_EQ(0.f, drawable().alpha);
 }
 
 TEST_F(TouchHandleTest, DragTargettingUsesTouchSize) {
-  TouchHandle handle(this, TOUCH_HANDLE_CENTER);
+  TouchHandle handle(this, TouchHandleOrientation::CENTER);
   handle.SetVisible(true, TouchHandle::ANIMATION_NONE);
 
   base::TimeTicks event_time = base::TimeTicks::Now();
   const float kTouchSize = 24.f;
   const float kOffset = kDefaultDrawableSize + kTouchSize / 2.001f;
 
   MockMotionEvent event(
       MockMotionEvent::ACTION_DOWN, event_time, kOffset, 0);
   event.SetTouchMajor(0.f);
   EXPECT_FALSE(handle.WillHandleTouchEvent(event));
@@ skipping 30 matching lines @@
   event = MockMotionEvent(MockMotionEvent::ACTION_DOWN,
                           event_time,
                           kDefaultDrawableSize / 2.f,
                           kDefaultDrawableSize / 2.f);
   event.SetTouchMajor(0);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   EXPECT_TRUE(IsDragging());
 }
 
 TEST_F(TouchHandleTest, Tap) {
-  TouchHandle handle(this, TOUCH_HANDLE_CENTER);
+  TouchHandle handle(this, TouchHandleOrientation::CENTER);
   handle.SetVisible(true, TouchHandle::ANIMATION_NONE);
 
   base::TimeTicks event_time = base::TimeTicks::Now();
 
   // ACTION_CANCEL shouldn't trigger a tap.
   MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   event_time += base::TimeDelta::FromMilliseconds(50);
   event = MockMotionEvent(MockMotionEvent::ACTION_CANCEL, event_time, 0, 0);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
@@ skipping 26 matching lines @@
   event = MockMotionEvent(
       MockMotionEvent::ACTION_MOVE, event_time, kDefaultTapSlop * 2.f, 0);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   event = MockMotionEvent(
       MockMotionEvent::ACTION_UP, event_time, kDefaultTapSlop * 2.f, 0);
   EXPECT_TRUE(handle.WillHandleTouchEvent(event));
   EXPECT_FALSE(GetAndResetHandleTapped());
 }
 
 }  // namespace ui