Reland: Move TouchSelectionController from content to ui

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/time/time.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
@@ skipping 132 matching lines @@
       return ALIGN_CENTER;
     default:
       NOTREACHED() << "Undefined bound type for cursor alignment.";
       return ALIGN_LEFT;
   };
 }
 
 // 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) {
-  Alignment cursor_alignment = GetCursorAlignment(bound.type);
-  gfx::Size image_size = GetHandleImage(bound.type)->Size();
+  Alignment cursor_alignment = GetCursorAlignment(bound.type());
+  gfx::Size image_size = GetHandleImage(bound.type())->Size();
   int widget_width =  image_size.width() + 2 * kSelectionHandleHorizPadding;
   int widget_height = bound.GetHeight() + image_size.height() +
       kSelectionHandleVertPadding;
   int widget_left = 0;
   switch (cursor_alignment) {
     case ALIGN_LEFT:
-      widget_left = bound.edge_top.x() - kSelectionHandleHorizPadding;
+      widget_left = bound.edge_top_rounded().x() - kSelectionHandleHorizPadding;
       break;
     case ALIGN_RIGHT:
-      widget_left = bound.edge_top.x() - image_size.width() -
+      widget_left = bound.edge_top_rounded().x() - image_size.width() -
           kSelectionHandleHorizPadding;
       break;
     case ALIGN_CENTER:
-      widget_left = bound.edge_top.x() - widget_width / 2;
+      widget_left = bound.edge_top_rounded().x() - widget_width / 2;
       break;
   };
   return gfx::Rect(
-      widget_left, bound.edge_top.y(), widget_width, widget_height);
+      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::Point edge_bottom = bound.edge_bottom;
-  gfx::Point edge_top = bound.edge_top;
+  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.edge_bottom = edge_bottom;
-  result.edge_top = edge_top;
+  result.SetEdge(edge_top, edge_bottom);
   return result;
 }
 
 ui::SelectionBound ConvertToScreen(ui::TouchEditable* client,
                                    const ui::SelectionBound& bound) {
   ui::SelectionBound result = bound;
-  gfx::Point edge_bottom = bound.edge_bottom;
-  gfx::Point edge_top = bound.edge_top;
+  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.edge_bottom = edge_bottom;
-  result.edge_top = edge_top;
+  result.SetEdge(edge_top, edge_bottom);
   return result;
 }
 
 gfx::Rect BoundToRect(const ui::SelectionBound& bound) {
-  return gfx::BoundingRect(bound.edge_top, bound.edge_bottom);
+  return gfx::BoundingRect(bound.edge_top_rounded(),
+                           bound.edge_bottom_rounded());
 }
 
 }  // namespace
 
 namespace views {
 
 typedef TouchSelectionControllerImpl::EditingHandleView EditingHandleView;
 
 class TouchHandleWindowTargeter : public wm::MaskedWindowTargeter {
  public:
@@ skipping 50 matching lines @@
 
   void DeleteDelegate() override {
     // We are owned and deleted by TouchSelectionController.
   }
 
   // Overridden from views::View:
   void OnPaint(gfx::Canvas* canvas) override {
     if (draw_invisible_)
       return;
 
-    Alignment cursor_alignment = GetCursorAlignment(selection_bound_.type);
+    Alignment cursor_alignment = GetCursorAlignment(selection_bound_.type());
     int cursor_x = 0;
     switch (cursor_alignment) {
       case ALIGN_RIGHT:
-        cursor_x =
-            selection_bound_.edge_top.x() - kSelectionHandleLineWidth + 1;
+        cursor_x = selection_bound_.edge_top_rounded().x() -
+                   kSelectionHandleLineWidth + 1;
         break;
       case ALIGN_LEFT:
-        cursor_x = selection_bound_.edge_top.x() - 1;
+        cursor_x = selection_bound_.edge_top_rounded().x() - 1;
         break;
       case ALIGN_CENTER:
-        cursor_x =
-            selection_bound_.edge_top.x() - kSelectionHandleLineWidth / 2;
+        cursor_x = selection_bound_.edge_top_rounded().x() -
+                   kSelectionHandleLineWidth / 2;
         break;
     };
     // Draw the cursor line.
     canvas->FillRect(gfx::Rect(cursor_x,
                                0,
                                kSelectionHandleLineWidth,
                                selection_bound_.GetHeight()),
                      kSelectionHandleLineColor);
     // Draw the handle image.
     canvas->DrawImageInt(*image_->ToImageSkia(),
         kSelectionHandleHorizPadding, selection_bound_.GetHeight());
   }
 
   void OnGestureEvent(ui::GestureEvent* event) override {
     event->SetHandled();
     switch (event->type()) {
       case ui::ET_GESTURE_SCROLL_BEGIN: {
         widget_->SetCapture(this);
         controller_->SetDraggingHandle(this);
         // Distance from the point which is |kSelectionHandleVerticalDragOffset|
         // pixels above the bottom of the handle's cursor line to the event
         // location (aka the touch-drag point).
-        drag_offset_ = selection_bound_.edge_bottom -
+        drag_offset_ = selection_bound_.edge_bottom_rounded() -
                        gfx::Vector2d(0, kSelectionHandleVerticalDragOffset) -
                        event->location();
         break;
       }
       case ui::ET_GESTURE_SCROLL_UPDATE: {
         controller_->SelectionHandleDragged(event->location() + drag_offset_);
         break;
       }
       case ui::ET_GESTURE_SCROLL_END:
       case ui::ET_SCROLL_FLING_START:
@@ skipping 24 matching lines @@
             quick ? kSelectionHandleQuickFadeDurationMs : 0));
     if (visible)
       widget_->Show();
     else
       widget_->Hide();
   }
 
   void SetBoundInScreen(const ui::SelectionBound& bound) {
     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() == ui::SelectionBound::CENTER);
 
-    if (bound.type != selection_bound_.type) {
+    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() != ui::SelectionBound::CENTER || is_cursor_handle_)
         update_bound_type = true;
     }
     if (update_bound_type) {
-      selection_bound_ = bound;
-      image_ = GetHandleImage(bound.type);
+      selection_bound_.set_type(bound.type());
+      image_ = GetHandleImage(bound.type());
       SchedulePaint();
-    } else {
-      selection_bound_.edge_top = bound.edge_top;
-      selection_bound_.edge_bottom = bound.edge_bottom;
     }
+    selection_bound_.SetEdge(bound.edge_top(), bound.edge_bottom());
 
     widget_->SetBounds(GetSelectionWidgetBounds(selection_bound_));
 
     aura::Window* window = widget_->GetNativeView();
-    wm::ConvertPointFromScreen(window, &selection_bound_.edge_top);
-    wm::ConvertPointFromScreen(window, &selection_bound_.edge_bottom);
+    gfx::Point edge_top = selection_bound_.edge_top_rounded();
+    gfx::Point edge_bottom = selection_bound_.edge_bottom_rounded();
+    wm::ConvertPointFromScreen(window, &edge_top);
+    wm::ConvertPointFromScreen(window, &edge_bottom);
+    selection_bound_.SetEdge(edge_top, edge_bottom);
   }
 
   void SetDrawInvisible(bool draw_invisible) {
     if (draw_invisible_ == draw_invisible)
       return;
     draw_invisible_ = draw_invisible;
     SchedulePaint();
   }
 
  private:
@@ skipping 66 matching lines @@
   client_view_->GetNativeView()->RemoveObserver(this);
 }
 
 void TouchSelectionControllerImpl::SelectionChanged() {
   ui::SelectionBound anchor, focus;
   client_view_->GetSelectionEndPoints(&anchor, &focus);
   ui::SelectionBound screen_bound_anchor =
       ConvertToScreen(client_view_, anchor);
   ui::SelectionBound screen_bound_focus = ConvertToScreen(client_view_, focus);
   gfx::Rect client_bounds = client_view_->GetBounds();
-  if (anchor.edge_top.y() < client_bounds.y())
-    anchor.edge_top.set_y(client_bounds.y());
-  if (focus.edge_top.y() < client_bounds.y())
-    focus.edge_top.set_y(client_bounds.y());
+  if (anchor.edge_top().y() < client_bounds.y()) {
+    gfx::Point anchor_edge_top = 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()) {
+    gfx::Point focus_edge_top = focus.edge_top_rounded();
+    focus_edge_top.set_y(client_bounds.y());
+    focus.SetEdgeTop(focus_edge_top);
+  }
   ui::SelectionBound screen_bound_anchor_clipped =
       ConvertToScreen(client_view_, anchor);
   ui::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;
@@ skipping 33 matching lines @@
         selection_bound_2_ = screen_bound_anchor;
         selection_bound_1_clipped_ = screen_bound_focus_clipped;
         selection_bound_2_clipped_ = screen_bound_anchor_clipped;
       }
       SetHandleBound(non_dragging_handle, anchor, screen_bound_anchor_clipped);
     }
   } else {
     UpdateContextMenu();
 
     // Check if there is any selection at all.
-    if (screen_bound_anchor.edge_top == screen_bound_focus.edge_top &&
-        screen_bound_anchor.edge_bottom == screen_bound_focus.edge_bottom) {
+    if (screen_bound_anchor.edge_top() == screen_bound_focus.edge_top() &&
+        screen_bound_anchor.edge_bottom() == screen_bound_focus.edge_bottom()) {
       selection_handle_1_->SetWidgetVisible(false, false);
       selection_handle_2_->SetWidgetVisible(false, false);
       SetHandleBound(cursor_handle_.get(), anchor, screen_bound_anchor_clipped);
       return;
     }
 
     cursor_handle_->SetWidgetVisible(false, false);
     SetHandleBound(
         selection_handle_1_.get(), anchor, screen_bound_anchor_clipped);
     SetHandleBound(
@@ skipping 30 matching lines @@
     client_view_->MoveCaretTo(drag_pos_in_client);
     return;
   }
 
   // Find the stationary selection handle.
   ui::SelectionBound anchor_bound =
       selection_handle_1_ == 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;
+  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(
@@ skipping 163 matching lines @@
 
 views::WidgetDelegateView* TouchSelectionControllerImpl::GetHandle1View() {
   return selection_handle_1_.get();
 }
 
 views::WidgetDelegateView* TouchSelectionControllerImpl::GetHandle2View() {
   return selection_handle_2_.get();
 }
 
 }  // namespace views