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

ui/views/touchui/touch_selection_controller_impl.cc

 // Copyright (c) 2013 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/views/touchui/touch_selection_controller_impl.h"
 
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
 #include "ui/aura/client/cursor_client.h"
@@ skipping 98 matching lines @@
 gfx::Image* GetRightHandleImage() {
   static gfx::Image* handle_image = nullptr;
   if (!handle_image) {
     handle_image = &ui::ResourceBundle::GetSharedInstance().GetImageNamed(
         IDR_TEXT_SELECTION_HANDLE_RIGHT);
   }
   return handle_image;
 }
 
 // Return the appropriate handle image based on the bound's type
-gfx::Image* GetHandleImage(ui::SelectionBound::Type bound_type) {
+gfx::Image* GetHandleImage(gfx::SelectionBound::Type bound_type) {
   switch(bound_type) {
-    case ui::SelectionBound::LEFT:
+    case gfx::SelectionBound::LEFT:
       return GetLeftHandleImage();
-    case ui::SelectionBound::CENTER:
+    case gfx::SelectionBound::CENTER:
       return GetCenterHandleImage();
-    case ui::SelectionBound::RIGHT:
+    case gfx::SelectionBound::RIGHT:
       return GetRightHandleImage();
     default:
       NOTREACHED() << "Invalid touch handle bound type: " << bound_type;
       return nullptr;
   };
 }
 
 // Calculates the bounds of the widget containing the selection handle based
 // on the SelectionBound's type and location
-gfx::Rect GetSelectionWidgetBounds(const ui::SelectionBound& bound) {
+gfx::Rect GetSelectionWidgetBounds(const gfx::SelectionBound& bound) {
   gfx::Size image_size = GetHandleImage(bound.type())->Size();
   int widget_width = image_size.width() + 2 * kSelectionHandleHorizPadding;
   int widget_height = bound.GetHeight() + image_size.height() +
                       kSelectionHandleVerticalVisualOffset +
                       kSelectionHandleVertPadding;
   // Due to the shape of the handle images, the widget is aligned differently to
   // the selection bound depending on the type of the bound.
   int widget_left = 0;
   switch (bound.type()) {
-    case ui::SelectionBound::LEFT:
+    case gfx::SelectionBound::LEFT:
       widget_left = bound.edge_top_rounded().x() - image_size.width() -
                     kSelectionHandleHorizPadding;
       break;
-    case ui::SelectionBound::RIGHT:
+    case gfx::SelectionBound::RIGHT:
       widget_left = bound.edge_top_rounded().x() - kSelectionHandleHorizPadding;
       break;
-    case ui::SelectionBound::CENTER:
+    case gfx::SelectionBound::CENTER:
       widget_left = bound.edge_top_rounded().x() - widget_width / 2;
       break;
     default:
       NOTREACHED() << "Undefined bound type.";
       break;
   };
   return gfx::Rect(
       widget_left, bound.edge_top_rounded().y(), widget_width, widget_height);
 }
 
 gfx::Size GetMaxHandleImageSize() {
   gfx::Rect center_rect = gfx::Rect(GetCenterHandleImage()->Size());
   gfx::Rect left_rect = gfx::Rect(GetLeftHandleImage()->Size());
   gfx::Rect right_rect = gfx::Rect(GetRightHandleImage()->Size());
   gfx::Rect union_rect = center_rect;
   union_rect.Union(left_rect);
   union_rect.Union(right_rect);
   return union_rect.size();
 }
 
 // Convenience methods to convert a |bound| from screen to the |client|'s
 // coordinate system and vice versa.
 // Note that this is not quite correct because it does not take into account
 // transforms such as rotation and scaling. This should be in TouchEditable.
 // TODO(varunjain): Fix this.
-ui::SelectionBound ConvertFromScreen(ui::TouchEditable* client,
-                                     const ui::SelectionBound& bound) {
-  ui::SelectionBound result = bound;
+gfx::SelectionBound ConvertFromScreen(ui::TouchEditable* client,
+                                      const gfx::SelectionBound& bound) {
+  gfx::SelectionBound result = bound;
   gfx::Point edge_bottom = bound.edge_bottom_rounded();
   gfx::Point edge_top = bound.edge_top_rounded();
   client->ConvertPointFromScreen(&edge_bottom);
   client->ConvertPointFromScreen(&edge_top);
   result.SetEdge(gfx::PointF(edge_top), gfx::PointF(edge_bottom));
   return result;
 }
 
-ui::SelectionBound ConvertToScreen(ui::TouchEditable* client,
-                                   const ui::SelectionBound& bound) {
-  ui::SelectionBound result = bound;
+gfx::SelectionBound ConvertToScreen(ui::TouchEditable* client,
+                                    const gfx::SelectionBound& bound) {
+  gfx::SelectionBound result = bound;
   gfx::Point edge_bottom = bound.edge_bottom_rounded();
   gfx::Point edge_top = bound.edge_top_rounded();
   client->ConvertPointToScreen(&edge_bottom);
   client->ConvertPointToScreen(&edge_top);
   result.SetEdge(gfx::PointF(edge_top), gfx::PointF(edge_bottom));
   return result;
 }
 
-gfx::Rect BoundToRect(const ui::SelectionBound& bound) {
+gfx::Rect BoundToRect(const gfx::SelectionBound& bound) {
   return gfx::BoundingRect(bound.edge_top_rounded(),
                            bound.edge_bottom_rounded());
 }
 
 }  // namespace
 
 namespace views {
 
 typedef TouchSelectionControllerImpl::EditingHandleView EditingHandleView;
 
@@ skipping 31 matching lines @@
     aura::Window* window = widget_->GetNativeWindow();
     window->SetEventTargeter(std::unique_ptr<ui::EventTargeter>(
         new TouchHandleWindowTargeter(window, this)));
 
     // We are owned by the TouchSelectionControllerImpl.
     set_owned_by_client();
   }
 
   ~EditingHandleView() override { SetWidgetVisible(false, false); }
 
-  ui::SelectionBound::Type selection_bound_type() {
+  gfx::SelectionBound::Type selection_bound_type() {
     return selection_bound_.type();
   }
 
   // Overridden from views::WidgetDelegateView:
   bool WidgetHasHitTestMask() const override { return true; }
 
   void GetWidgetHitTestMask(gfx::Path* mask) const override {
     gfx::Size image_size = image_->Size();
     mask->addRect(
         SkIntToScalar(0),
@@ skipping 74 matching lines @@
     if (visible)
       widget_->Show();
     else
       widget_->Hide();
   }
 
   // If |is_visible| is true, this will update the widget and trigger a repaint
   // if necessary. Otherwise this will only update the internal state:
   // |selection_bound_| and |image_|, so that the state is valid for the time
   // this becomes visible.
-  void SetBoundInScreen(const ui::SelectionBound& bound, bool is_visible) {
+  void SetBoundInScreen(const gfx::SelectionBound& bound, bool is_visible) {
     bool update_bound_type = false;
     // Cursor handle should always have the bound type CENTER
-    DCHECK(!is_cursor_handle_ || bound.type() == ui::SelectionBound::CENTER);
+    DCHECK(!is_cursor_handle_ || bound.type() == gfx::SelectionBound::CENTER);
 
     if (bound.type() != selection_bound_.type()) {
       // Unless this is a cursor handle, do not set the type to CENTER -
       // selection handles corresponding to a selection should always use left
       // or right handle image. If selection handles are dragged to be located
       // at the same spot, the |bound|'s type here will be CENTER for both of
       // them. In this case do not update the type of the |selection_bound_|.
-      if (bound.type() != ui::SelectionBound::CENTER || is_cursor_handle_)
+      if (bound.type() != gfx::SelectionBound::CENTER || is_cursor_handle_)
         update_bound_type = true;
     }
     if (update_bound_type) {
       selection_bound_.set_type(bound.type());
       image_ = GetHandleImage(bound.type());
       if (is_visible)
         SchedulePaint();
     }
 
     if (!is_visible)
@@ skipping 16 matching lines @@
       return;
     draw_invisible_ = draw_invisible;
     SchedulePaint();
   }
 
  private:
   std::unique_ptr<Widget> widget_;
   TouchSelectionControllerImpl* controller_;
 
   // In local coordinates
-  ui::SelectionBound selection_bound_;
+  gfx::SelectionBound selection_bound_;
   gfx::Image* image_;
 
   // If true, this is a handle corresponding to the single cursor, otherwise it
   // is a handle corresponding to one of the two selection bounds.
   bool is_cursor_handle_;
 
   // Offset applied to the scroll events location when calling
   // TouchSelectionControllerImpl::SelectionHandleDragged while dragging the
   // handle.
   gfx::Vector2d drag_offset_;
@@ skipping 50 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Event.TouchSelection.EndedWithAction",
                         command_executed_);
   HideQuickMenu();
   aura::Env::GetInstance()->RemovePreTargetHandler(this);
   if (client_widget_)
     client_widget_->RemoveObserver(this);
   client_view_->GetNativeView()->RemoveObserver(this);
 }
 
 void TouchSelectionControllerImpl::SelectionChanged() {
-  ui::SelectionBound anchor, focus;
+  gfx::SelectionBound anchor, focus;
   client_view_->GetSelectionEndPoints(&anchor, &focus);
-  ui::SelectionBound screen_bound_anchor =
+  gfx::SelectionBound screen_bound_anchor =
       ConvertToScreen(client_view_, anchor);
-  ui::SelectionBound screen_bound_focus = ConvertToScreen(client_view_, focus);
+  gfx::SelectionBound screen_bound_focus = ConvertToScreen(client_view_, focus);
   gfx::Rect client_bounds = client_view_->GetBounds();
   if (anchor.edge_top().y() < client_bounds.y()) {
     auto anchor_edge_top = gfx::PointF(anchor.edge_top_rounded());
     anchor_edge_top.set_y(client_bounds.y());
     anchor.SetEdgeTop(anchor_edge_top);
   }
   if (focus.edge_top().y() < client_bounds.y()) {
     auto focus_edge_top = gfx::PointF(focus.edge_top_rounded());
     focus_edge_top.set_y(client_bounds.y());
     focus.SetEdgeTop(focus_edge_top);
   }
-  ui::SelectionBound screen_bound_anchor_clipped =
+  gfx::SelectionBound screen_bound_anchor_clipped =
       ConvertToScreen(client_view_, anchor);
-  ui::SelectionBound screen_bound_focus_clipped =
+  gfx::SelectionBound screen_bound_focus_clipped =
       ConvertToScreen(client_view_, focus);
   if (screen_bound_anchor_clipped == selection_bound_1_clipped_ &&
       screen_bound_focus_clipped == selection_bound_2_clipped_)
     return;
 
   selection_bound_1_ = screen_bound_anchor;
   selection_bound_2_ = screen_bound_focus;
   selection_bound_1_clipped_ = screen_bound_anchor_clipped;
   selection_bound_2_clipped_ = screen_bound_focus_clipped;
 
@@ skipping 77 matching lines @@
   DCHECK(dragging_handle_);
   gfx::Point drag_pos_in_client = drag_pos;
   ConvertPointToClientView(dragging_handle_, &drag_pos_in_client);
 
   if (dragging_handle_ == cursor_handle_.get()) {
     client_view_->MoveCaretTo(drag_pos_in_client);
     return;
   }
 
   // Find the stationary selection handle.
-  ui::SelectionBound anchor_bound =
+  gfx::SelectionBound anchor_bound =
       selection_handle_1_.get() == dragging_handle_ ? selection_bound_2_
                                                     : selection_bound_1_;
 
   // Find selection end points in client_view's coordinate system.
   gfx::Point p2 = anchor_bound.edge_top_rounded();
   p2.Offset(0, anchor_bound.GetHeight() / 2);
   client_view_->ConvertPointFromScreen(&p2);
 
   // Instruct client_view to select the region between p1 and p2. The position
   // of |fixed_handle| is the start and that of |dragging_handle| is the end
   // of selection.
   client_view_->SelectRect(p2, drag_pos_in_client);
 }
 
 void TouchSelectionControllerImpl::ConvertPointToClientView(
     EditingHandleView* source, gfx::Point* point) {
   View::ConvertPointToScreen(source, point);
   client_view_->ConvertPointFromScreen(point);
 }
 
 void TouchSelectionControllerImpl::SetHandleBound(
     EditingHandleView* handle,
-    const ui::SelectionBound& bound,
-    const ui::SelectionBound& bound_in_screen) {
+    const gfx::SelectionBound& bound,
+    const gfx::SelectionBound& bound_in_screen) {
   handle->SetWidgetVisible(ShouldShowHandleFor(bound), false);
   handle->SetBoundInScreen(bound_in_screen, handle->IsWidgetVisible());
 }
 
 bool TouchSelectionControllerImpl::ShouldShowHandleFor(
-    const ui::SelectionBound& bound) const {
+    const gfx::SelectionBound& bound) const {
   if (bound.GetHeight() < kSelectionHandleBarMinHeight)
     return false;
   gfx::Rect client_bounds = client_view_->GetBounds();
   client_bounds.Inset(0, 0, 0, -kSelectionHandleBarBottomAllowance);
   return client_bounds.Contains(BoundToRect(bound));
 }
 
 bool TouchSelectionControllerImpl::IsCommandIdEnabled(int command_id) const {
   return client_view_->IsCommandIdEnabled(command_id);
 }
@@ skipping 89 matching lines @@
 }
 
 void TouchSelectionControllerImpl::HideQuickMenu() {
   if (ui::TouchSelectionMenuRunner::GetInstance()->IsRunning())
     ui::TouchSelectionMenuRunner::GetInstance()->CloseMenu();
   quick_menu_timer_.Stop();
 }
 
 gfx::Rect TouchSelectionControllerImpl::GetQuickMenuAnchorRect() const {
   // Get selection end points in client_view's space.
-  ui::SelectionBound b1_in_screen = selection_bound_1_clipped_;
-  ui::SelectionBound b2_in_screen = cursor_handle_->IsWidgetVisible()
-                                        ? b1_in_screen
-                                        : selection_bound_2_clipped_;
+  gfx::SelectionBound b1_in_screen = selection_bound_1_clipped_;
+  gfx::SelectionBound b2_in_screen = cursor_handle_->IsWidgetVisible()
+                                         ? b1_in_screen
+                                         : selection_bound_2_clipped_;
   // Convert from screen to client.
-  ui::SelectionBound b1 = ConvertFromScreen(client_view_, b1_in_screen);
-  ui::SelectionBound b2 = ConvertFromScreen(client_view_, b2_in_screen);
+  gfx::SelectionBound b1 = ConvertFromScreen(client_view_, b1_in_screen);
+  gfx::SelectionBound b2 = ConvertFromScreen(client_view_, b2_in_screen);
 
   // if selection is completely inside the view, we display the quick menu in
   // the middle of the end points on the top. Else, we show it above the visible
   // handle. If no handle is visible, we do not show the menu.
   gfx::Rect menu_anchor;
   if (ShouldShowHandleFor(b1) && ShouldShowHandleFor(b2))
-    menu_anchor = ui::RectBetweenSelectionBounds(b1_in_screen, b2_in_screen);
+    menu_anchor = gfx::RectBetweenSelectionBounds(b1_in_screen, b2_in_screen);
   else if (ShouldShowHandleFor(b1))
     menu_anchor = BoundToRect(b1_in_screen);
   else if (ShouldShowHandleFor(b2))
     menu_anchor = BoundToRect(b2_in_screen);
   else
     return menu_anchor;
 
   // Enlarge the anchor rect so that the menu is offset from the text at least
   // by the same distance the handles are offset from the text.
   menu_anchor.Inset(0, -kSelectionHandleVerticalVisualOffset);
 
   return menu_anchor;
 }
 
 gfx::NativeView TouchSelectionControllerImpl::GetCursorHandleNativeView() {
   return cursor_handle_->GetWidget()->GetNativeView();
 }
 
-ui::SelectionBound::Type
+gfx::SelectionBound::Type
 TouchSelectionControllerImpl::GetSelectionHandle1Type() {
   return selection_handle_1_->selection_bound_type();
 }
 
 gfx::Rect TouchSelectionControllerImpl::GetSelectionHandle1Bounds() {
   return selection_handle_1_->GetBoundsInScreen();
 }
 
 gfx::Rect TouchSelectionControllerImpl::GetSelectionHandle2Bounds() {
   return selection_handle_2_->GetBoundsInScreen();
 }
 
 gfx::Rect TouchSelectionControllerImpl::GetCursorHandleBounds() {
   return cursor_handle_->GetBoundsInScreen();
 }
 
 bool TouchSelectionControllerImpl::IsSelectionHandle1Visible() {
   return selection_handle_1_->IsWidgetVisible();
 }
 
 bool TouchSelectionControllerImpl::IsSelectionHandle2Visible() {
   return selection_handle_2_->IsWidgetVisible();
 }
 
 bool TouchSelectionControllerImpl::IsCursorHandleVisible() {
   return cursor_handle_->IsWidgetVisible();
 }
 
 gfx::Rect TouchSelectionControllerImpl::GetExpectedHandleBounds(
-    const ui::SelectionBound& bound) {
+    const gfx::SelectionBound& bound) {
   return GetSelectionWidgetBounds(bound);
 }
 
 views::WidgetDelegateView* TouchSelectionControllerImpl::GetHandle1View() {
   return selection_handle_1_.get();
 }
 
 views::WidgetDelegateView* TouchSelectionControllerImpl::GetHandle2View() {
   return selection_handle_2_.get();
 }
 
 }  // namespace views