Move SelectionBound from ui/base/touch to ui/gfx to be used by cc

ui/views/touchui/touch_selection_controller_impl_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/aura/client/screen_position_client.h"
@@ skipping 26 matching lines @@
 // Should match kSelectionHandleBarMinHeight in touch_selection_controller.
 const int kBarMinHeight = 5;
 
 // Should match kSelectionHandleBarBottomAllowance in
 // touch_selection_controller.
 const int kBarBottomAllowance = 3;
 
 // For selection bounds |b1| and |b2| in a paragraph of text, returns -1 if |b1|
 // is physically before |b2|, +1 if |b2| is before |b1|, and 0 if they are at
 // the same location.
-int CompareTextSelectionBounds(const ui::SelectionBound& b1,
-                               const ui::SelectionBound& b2) {
+int CompareTextSelectionBounds(const gfx::SelectionBound& b1,
+                               const gfx::SelectionBound& b2) {
   if (b1.edge_top().y() < b2.edge_top().y() ||
       b1.edge_top().x() < b2.edge_top().x()) {
     return -1;
   }
   if (b1 == b2)
     return 0;
   return 1;
 }
 
 }  // namespace
@@ skipping 115 matching lines @@
           grip_location.x(), grip_location.y(), 0, time_stamp, details);
       handle->OnGestureEvent(&scroll_end);
     }
     test_cursor_client_->EnableMouseEvents();
   }
 
   gfx::NativeView GetCursorHandleNativeView() {
     return GetSelectionController()->GetCursorHandleNativeView();
   }
 
-  ui::SelectionBound::Type GetSelectionHandle1Type() {
+  gfx::SelectionBound::Type GetSelectionHandle1Type() {
     return GetSelectionController()->GetSelectionHandle1Type();
   }
 
   gfx::Rect GetSelectionHandle1Bounds() {
     return GetSelectionController()->GetSelectionHandle1Bounds();
   }
 
   gfx::Rect GetSelectionHandle2Bounds() {
     return GetSelectionController()->GetSelectionHandle2Bounds();
   }
 
   gfx::Rect GetCursorHandleBounds() {
     return GetSelectionController()->GetCursorHandleBounds();
   }
 
-  gfx::Rect GetExpectedHandleBounds(const ui::SelectionBound& bound) {
+  gfx::Rect GetExpectedHandleBounds(const gfx::SelectionBound& bound) {
     return GetSelectionController()->GetExpectedHandleBounds(bound);
   }
 
   bool IsSelectionHandle1Visible() {
     return GetSelectionController()->IsSelectionHandle1Visible();
   }
 
   bool IsSelectionHandle2Visible() {
     return GetSelectionController()->IsSelectionHandle2Visible();
   }
@@ skipping 17 matching lines @@
 
   // If textfield has selection, this verifies that the selection handles
   // are visible, at the correct positions (at the end points of selection), and
   // (if |check_direction| is set to true), that they have the correct
   // directionality.
   // |cursor_at_selection_handle_1| is used to decide whether selection
   // handle 1's position is matched against the start of selection or the end.
   void VerifyHandlePositions(bool cursor_at_selection_handle_1,
                              bool check_direction,
                              const tracked_objects::Location& from_here) {
-    ui::SelectionBound anchor, focus;
+    gfx::SelectionBound anchor, focus;
     textfield_->GetSelectionEndPoints(&anchor, &focus);
     std::string from_str = from_here.ToString();
     if (textfield_->HasSelection()) {
       EXPECT_TRUE(IsSelectionHandle1Visible()) << from_str;
       EXPECT_TRUE(IsSelectionHandle2Visible()) << from_str;
       EXPECT_FALSE(IsCursorHandleVisible());
       gfx::Rect sh1_bounds = GetSelectionHandle1Bounds();
       gfx::Rect sh2_bounds = GetSelectionHandle2Bounds();
       if (cursor_at_selection_handle_1) {
         EXPECT_EQ(sh1_bounds, GetExpectedHandleBounds(focus)) << from_str;
         EXPECT_EQ(sh2_bounds, GetExpectedHandleBounds(anchor)) << from_str;
       } else {
         EXPECT_EQ(sh1_bounds, GetExpectedHandleBounds(anchor)) << from_str;
         EXPECT_EQ(sh2_bounds, GetExpectedHandleBounds(focus)) << from_str;
       }
     } else {
       EXPECT_FALSE(IsSelectionHandle1Visible()) << from_str;
       EXPECT_FALSE(IsSelectionHandle2Visible()) << from_str;
       EXPECT_TRUE(IsCursorHandleVisible());
       gfx::Rect cursor_bounds = GetCursorHandleBounds();
       DCHECK(anchor == focus);
       EXPECT_EQ(cursor_bounds, GetExpectedHandleBounds(anchor)) << from_str;
     }
     if (check_direction)  {
       if (CompareTextSelectionBounds(anchor, focus) < 0) {
-        EXPECT_EQ(ui::SelectionBound::LEFT, anchor.type()) << from_str;
-        EXPECT_EQ(ui::SelectionBound::RIGHT, focus.type())  << from_str;
+        EXPECT_EQ(gfx::SelectionBound::LEFT, anchor.type()) << from_str;
+        EXPECT_EQ(gfx::SelectionBound::RIGHT, focus.type()) << from_str;
       } else if (CompareTextSelectionBounds(anchor, focus) > 0) {
-        EXPECT_EQ(ui::SelectionBound::LEFT, focus.type())  << from_str;
-        EXPECT_EQ(ui::SelectionBound::RIGHT, anchor.type())  << from_str;
+        EXPECT_EQ(gfx::SelectionBound::LEFT, focus.type()) << from_str;
+        EXPECT_EQ(gfx::SelectionBound::RIGHT, anchor.type()) << from_str;
       } else {
-        EXPECT_EQ(ui::SelectionBound::CENTER, focus.type()) << from_str;
-        EXPECT_EQ(ui::SelectionBound::CENTER, anchor.type()) << from_str;
+        EXPECT_EQ(gfx::SelectionBound::CENTER, focus.type()) << from_str;
+        EXPECT_EQ(gfx::SelectionBound::CENTER, anchor.type()) << from_str;
       }
     }
   }
 
   // Sets up a textfield with a long text string such that it doesn't all fit
   // into the textfield. Then selects the text - the first handle is expected
   // to be invisible. |selection_start| is the position of the first handle.
   void SetupSelectionInvisibleHandle(uint32_t selection_start) {
     // Create a textfield with lots of text in it.
     CreateTextfield();
@@ skipping 314 matching lines @@
   SetupSelectionInvisibleHandle(selection_start);
 
   // Drag the handle until the selection shrinks such that the other handle
   // becomes visible.
   while (!IsSelectionHandle1Visible()) {
     static const int drag_diff = -10;
     SimulateSelectionHandleDrag(gfx::Vector2d(drag_diff, 0), 2);
   }
 
   // Confirm that the exposed handle maintains the LEFT orientation
-  // (and does not reset to ui::SelectionBound::Type::CENTER).
-  EXPECT_EQ(ui::SelectionBound::Type::LEFT, GetSelectionHandle1Type());
+  // (and does not reset to gfx::SelectionBound::Type::CENTER).
+  EXPECT_EQ(gfx::SelectionBound::Type::LEFT, GetSelectionHandle1Type());
 }
 
 TEST_F(TouchSelectionControllerImplTest,
        DoubleTapInTextfieldWithCursorHandleShouldSelectText) {
   CreateTextfield();
   textfield_->SetText(ASCIIToUTF16("some text"));
   ui::test::EventGenerator generator(
       textfield_->GetWidget()->GetNativeView()->GetRootWindow());
 
   // Tap the textfield to invoke touch selection.
@@ skipping 21 matching lines @@
       : window_(window) {
     DCHECK(window);
   }
 
   void set_bounds(const gfx::Rect& bounds) {
     bounds_ = bounds;
   }
 
   void set_cursor_rect(const gfx::RectF& cursor_rect) {
     cursor_bound_.SetEdge(cursor_rect.origin(), cursor_rect.bottom_left());
-    cursor_bound_.set_type(ui::SelectionBound::Type::CENTER);
+    cursor_bound_.set_type(gfx::SelectionBound::Type::CENTER);
   }
 
   ~TestTouchEditable() override {}
 
  private:
   // Overridden from ui::TouchEditable.
   void SelectRect(const gfx::Point& start, const gfx::Point& end) override {
     NOTREACHED();
   }
   void MoveCaretTo(const gfx::Point& point) override { NOTREACHED(); }
-  void GetSelectionEndPoints(ui::SelectionBound* anchor,
-                             ui::SelectionBound* focus) override {
+  void GetSelectionEndPoints(gfx::SelectionBound* anchor,
+                             gfx::SelectionBound* focus) override {
     *anchor = *focus = cursor_bound_;
   }
   gfx::Rect GetBounds() override { return gfx::Rect(bounds_.size()); }
   gfx::NativeView GetNativeView() const override { return window_; }
   void ConvertPointToScreen(gfx::Point* point) override {
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(window_->GetRootWindow());
     if (screen_position_client)
       screen_position_client->ConvertPointToScreen(window_, point);
   }
@@ skipping 25 matching lines @@
     NOTREACHED();
   }
 
   aura::Window* window_;
 
   // Boundaries of the client view.
   gfx::Rect bounds_;
 
   // Cursor position inside the client view.
   //gfx::Rect cursor_rect_;
-  ui::SelectionBound cursor_bound_;
+  gfx::SelectionBound cursor_bound_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTouchEditable);
 };
 
 // Tests if the touch editing handle is shown or hidden properly according to
 // the cursor position relative to the client boundaries.
 TEST_F(TouchSelectionControllerImplTest,
        VisibilityOfHandleRegardingClientBounds) {
   CreateWidget();
 
@@ skipping 151 matching lines @@
   // Start touch editing; then press a key and ensure it deactivates touch
   // selection.
   StartTouchEditing();
   EXPECT_TRUE(GetSelectionController());
   generator.PressKey(ui::VKEY_A, 0);
   RunPendingMessages();
   EXPECT_FALSE(GetSelectionController());
 }
 
 }  // namespace views