Add Vector2d classes that represent offsets, instead of using Point.

chrome/browser/ui/views/tabs/tab_drag_controller.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 "chrome/browser/ui/views/tabs/tab_drag_controller.h"
 
 #include <math.h>
 #include <set>
 
 #include "base/auto_reset.h"
@@ skipping 94 matching lines @@
 
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 
     gfx::ImageSkia* high_icon = rb.GetImageSkiaNamed(IDR_DOCK_HIGH);
     gfx::ImageSkia* wide_icon = rb.GetImageSkiaNamed(IDR_DOCK_WIDE);
 
     canvas->Save();
     bool rtl_ui = base::i18n::IsRTL();
     if (rtl_ui) {
       // Flip canvas to draw the mirrored tab images for RTL UI.
-      canvas->Translate(gfx::Point(width(), 0));
+      canvas->Translate(gfx::Vector2d(width(), 0));
       canvas->Scale(-1, 1);
     }
     int x_of_active_tab = width() / 2 + kTabSpacing / 2;
     int x_of_inactive_tab = width() / 2 - high_icon->width() - kTabSpacing / 2;
     switch (type_) {
       case DockInfo::LEFT_OF_WINDOW:
       case DockInfo::LEFT_HALF:
         if (!rtl_ui)
           std::swap(x_of_active_tab, x_of_inactive_tab);
         canvas->DrawImageInt(*high_icon, x_of_active_tab,
@@ skipping 371 matching lines @@
 
   if (!started_drag_) {
     if (!CanStartDrag(real_point_in_screen))
       return;  // User hasn't dragged far enough yet.
 
     started_drag_ = true;
     SaveFocus();
     Attach(source_tabstrip_, gfx::Point());
     if (detach_into_browser_ && static_cast<int>(drag_data_.size()) ==
         GetModel(source_tabstrip_)->count()) {
-      gfx::Point dragged_view_point = GetWindowOffset(point_in_screen);
-      RunMoveLoop(dragged_view_point);
+      RunMoveLoop(GetWindowOffset(point_in_screen));
       return;
     }
   }
 
   ContinueDragging(real_point_in_screen);
 }
 
 void TabDragController::EndDrag(EndDragReason reason) {
   // If we're dragging a window ignore capture lost since it'll ultimately
   // trigger the move loop to end and we'll revert the drag when RunMoveLoop()
@@ skipping 779 matching lines @@
   attached_tabstrip_ = NULL;
 }
 
 void TabDragController::DetachIntoNewBrowserAndRunMoveLoop(
     const gfx::Point& point_in_screen) {
   if (GetModel(attached_tabstrip_)->count() ==
       static_cast<int>(drag_data_.size())) {
     // All the tabs in a browser are being dragged but all the tabs weren't
     // initially being dragged. For this to happen the user would have to
     // start dragging a set of tabs, the other tabs close, then detach.
-    gfx::Point dragged_view_point = GetWindowOffset(point_in_screen);
-    RunMoveLoop(dragged_view_point);
+    RunMoveLoop(GetWindowOffset(point_in_screen));
     return;
   }
 
   // Create a new browser to house the dragged tabs and have the OS run a move
   // loop.
 
   gfx::Point attached_point = GetAttachedDragPoint(point_in_screen);
 
   // Calculate the bounds for the tabs from the attached_tab_strip. We do this
   // so that the tabs don't change size when detached.
   std::vector<gfx::Rect> drag_bounds =
       CalculateBoundsForDraggedTabs(attached_point.x());
 
-  gfx::Point drag_offset;
+  gfx::Vector2d drag_offset;
   Browser* browser = CreateBrowserForDrag(
       attached_tabstrip_, point_in_screen, &drag_offset, &drag_bounds);
   Detach(DONT_RELEASE_CAPTURE);
   BrowserView* dragged_browser_view =
       BrowserView::GetBrowserViewForBrowser(browser);
   dragged_browser_view->GetWidget()->SetVisibilityChangedAnimationsEnabled(
       false);
   Attach(dragged_browser_view->tabstrip(), gfx::Point());
   // TODO: come up with a cleaner way to do this.
   attached_tabstrip_->SetTabBoundsForDrag(drag_bounds);
 
   WindowPositionManagedUpdater updater;
   dragged_browser_view->GetWidget()->AddObserver(&updater);
   browser->window()->Show();
   dragged_browser_view->GetWidget()->RemoveObserver(&updater);
 
   browser->window()->Activate();
   dragged_browser_view->GetWidget()->SetVisibilityChangedAnimationsEnabled(
       true);
   RunMoveLoop(drag_offset);
 }
 
-void TabDragController::RunMoveLoop(const gfx::Point& drag_offset) {
+void TabDragController::RunMoveLoop(const gfx::Vector2d& drag_offset) {
   // If the user drags the whole window we'll assume they are going to attach to
   // another window and therefor want to reorder.
   move_behavior_ = REORDER;
 
   move_loop_widget_ = GetAttachedBrowserWidget();
   DCHECK(move_loop_widget_);
   move_loop_widget_->AddObserver(this);
   is_dragging_window_ = true;
   bool destroyed = false;
   destroyed_ = &destroyed;
@@ skipping 615 matching lines @@
         drag_data_[i].source_model_index) {
       return false;
     }
   }
   return true;
 }
 
 Browser* TabDragController::CreateBrowserForDrag(
     TabStrip* source,
     const gfx::Point& point_in_screen,
-    gfx::Point* drag_offset,
+    gfx::Vector2d* drag_offset,
     std::vector<gfx::Rect>* drag_bounds) {
   gfx::Point center(0, source->height() / 2);
   views::View::ConvertPointToWidget(source, &center);
   gfx::Rect new_bounds(source->GetWidget()->GetWindowBoundsInScreen());
   new_bounds.set_y(point_in_screen.y() - center.y());
   switch (GetDetachPosition(point_in_screen)) {
     case DETACH_BEFORE:
       new_bounds.set_x(point_in_screen.x() - center.x());
       new_bounds.Offset(-mouse_offset_.x(), 0);
       break;
 
     case DETACH_AFTER: {
       gfx::Point right_edge(source->width(), 0);
       views::View::ConvertPointToWidget(source, &right_edge);
       new_bounds.set_x(point_in_screen.x() - right_edge.x());
       new_bounds.Offset(drag_bounds->back().right() - mouse_offset_.x(), 0);
       int delta = (*drag_bounds)[0].x();
       for (size_t i = 0; i < drag_bounds->size(); ++i)
         (*drag_bounds)[i].Offset(-delta, 0);
       break;
     }
 
     default:
       break; // Nothing to do for DETACH_ABOVE_OR_BELOW.
   }
 
-  *drag_offset = point_in_screen.Subtract(new_bounds.origin());
+  *drag_offset = point_in_screen - new_bounds.origin();
 
   Browser::CreateParams create_params(
       Browser::TYPE_TABBED,
       drag_data_[0].contents->profile(),
       host_desktop_type_);
   create_params.initial_bounds = new_bounds;
   Browser* browser = new Browser(create_params);
   SetTrackedByWorkspace(browser->window()->GetNativeWindow(), false);
   SetWindowPositionManaged(browser->window()->GetNativeWindow(), false);
   // If the window is created maximized then the bounds we supplied are ignored.
@@ skipping 13 matching lines @@
     bool got_touch_point = widget_window->GetRootWindow()->
         gesture_recognizer()->GetLastTouchPointForTarget(widget_window,
                                                          &touch_point);
     DCHECK(got_touch_point);
     return touch_point;
   }
 #endif
   return screen_->GetCursorScreenPoint();
 }
 
-gfx::Point TabDragController::GetWindowOffset(
+gfx::Vector2d TabDragController::GetWindowOffset(
     const gfx::Point& point_in_screen) {
   TabStrip* owning_tabstrip = (attached_tabstrip_ && detach_into_browser_) ?
       attached_tabstrip_ : source_tabstrip_;
   views::View* toplevel_view = owning_tabstrip->GetWidget()->GetContentsView();
 
-  gfx::Point offset = point_in_screen;
-  views::View::ConvertPointFromScreen(toplevel_view, &offset);
-  return offset;
+  gfx::Point point = point_in_screen;
+  views::View::ConvertPointFromScreen(toplevel_view, &point);
+  return point.OffsetFromOrigin();
 }