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

ui/views/view.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 "ui/views/view.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 606 matching lines @@
     if (source != root)
       source->ConvertPointForAncestor(root, point);
   }
 
   if (target != root)
     target->ConvertPointFromAncestor(root, point);
 
   // API defines NULL |source| as returning the point in screen coordinates.
   if (!source) {
     *point = point->Subtract(
-        root->GetWidget()->GetClientAreaBoundsInScreen().origin());
+        root->GetWidget()->GetClientAreaBoundsInScreen().OffsetFromOrigin());
   }
 }
 
 // static
 void View::ConvertPointToWidget(const View* src, gfx::Point* p) {
   DCHECK(src);
   DCHECK(p);
 
   src->ConvertPointForAncestor(NULL, p);
 }
 
 // static
 void View::ConvertPointFromWidget(const View* dest, gfx::Point* p) {
   DCHECK(dest);
   DCHECK(p);
 
   dest->ConvertPointFromAncestor(NULL, p);
 }
 
 // static
 void View::ConvertPointToScreen(const View* src, gfx::Point* p) {
   DCHECK(src);
   DCHECK(p);
 
   // If the view is not connected to a tree, there's nothing we can do.
   const Widget* widget = src->GetWidget();
   if (widget) {
     ConvertPointToWidget(src, p);
-    gfx::Rect r = widget->GetClientAreaBoundsInScreen();
-    p->SetPoint(p->x() + r.x(), p->y() + r.y());
+    *p = p->Add(widget->GetClientAreaBoundsInScreen().OffsetFromOrigin());
   }
 }
 
 // static
 void View::ConvertPointFromScreen(const View* dst, gfx::Point* p) {
   DCHECK(dst);
   DCHECK(p);
 
   const views::Widget* widget = dst->GetWidget();
   if (!widget)
     return;
-  const gfx::Rect r = widget->GetClientAreaBoundsInScreen();
-  p->Offset(-r.x(), -r.y());
+  *p = p->Add(-widget->GetClientAreaBoundsInScreen().OffsetFromOrigin());
   views::View::ConvertPointFromWidget(dst, p);
 }
 
 gfx::Rect View::ConvertRectToParent(const gfx::Rect& rect) const {
   gfx::Rect x_rect = rect;
   GetTransform().TransformRect(&x_rect);
-  x_rect.Offset(GetMirroredPosition());
+  x_rect.Offset(GetMirroredPosition().OffsetFromOrigin());
   return x_rect;
 }
 
 gfx::Rect View::ConvertRectToWidget(const gfx::Rect& rect) const {
   gfx::Rect x_rect = rect;
   for (const View* v = this; v; v = v->parent_)
     x_rect = v->ConvertRectToParent(x_rect);
   return x_rect;
 }
 
@@ skipping 30 matching lines @@
   // we paint our view in its mirrored position if need be.
   gfx::Rect clip_rect = bounds();
   clip_rect.Inset(clip_insets_);
   if (parent_)
     clip_rect.set_x(parent_->GetMirroredXForRect(clip_rect));
   if (!canvas->ClipRect(clip_rect))
     return;
 
   // Non-empty clip, translate the graphics such that 0,0 corresponds to
   // where this view is located (related to its parent).
-  canvas->Translate(GetMirroredPosition());
+  canvas->Translate(GetMirroredPosition().OffsetFromOrigin());
   canvas->Transform(GetTransform());
 
   PaintCommon(canvas);
 }
 
 ui::ThemeProvider* View::GetThemeProvider() const {
   const Widget* widget = GetWidget();
   return widget ? widget->GetThemeProvider() : NULL;
 }
 
@@ skipping 295 matching lines @@
 }
 
 int View::OnPerformDrop(const ui::DropTargetEvent& event) {
   return ui::DragDropTypes::DRAG_NONE;
 }
 
 void View::OnDragDone() {
 }
 
 // static
-bool View::ExceededDragThreshold(int delta_x, int delta_y) {
-  return (abs(delta_x) > GetHorizontalDragThreshold() ||
-          abs(delta_y) > GetVerticalDragThreshold());
+bool View::ExceededDragThreshold(const gfx::Vector2d& delta) {
+  return (abs(delta.x()) > GetHorizontalDragThreshold() ||
+          abs(delta.y()) > GetVerticalDragThreshold());
 }
 
 // Scrolling -------------------------------------------------------------------
 
 void View::ScrollRectToVisible(const gfx::Rect& rect) {
   // We must take RTL UI mirroring into account when adjusting the position of
   // the region.
   if (parent_) {
     gfx::Rect scroll_rect(rect);
     scroll_rect.Offset(GetMirroredX(), y());
@@ skipping 463 matching lines @@
     return;
 
   {
     // If the View we are about to paint requested the canvas to be flipped, we
     // should change the transform appropriately.
     // The canvas mirroring is undone once the View is done painting so that we
     // don't pass the canvas with the mirrored transform to Views that didn't
     // request the canvas to be flipped.
     ScopedCanvas scoped(canvas);
     if (FlipCanvasOnPaintForRTLUI()) {
-      canvas->Translate(gfx::Point(width(), 0));
+      canvas->Translate(gfx::Vector2d(width(), 0));
       canvas->Scale(-1, 1);
     }
 
     OnPaint(canvas);
   }
 
   PaintChildren(canvas);
 }
 
 // Tree operations -------------------------------------------------------------
@@ skipping 391 matching lines @@
   }
   return !!context_menu_controller || result;
 }
 
 bool View::ProcessMouseDragged(const ui::MouseEvent& event,
                                DragInfo* drag_info) {
   // Copy the field, that way if we're deleted after drag and drop no harm is
   // done.
   ContextMenuController* context_menu_controller = context_menu_controller_;
   const bool possible_drag = drag_info->possible_drag;
-  if (possible_drag && ExceededDragThreshold(
-      drag_info->start_pt.x() - event.x(),
-      drag_info->start_pt.y() - event.y())) {
+  if (possible_drag &&
+      ExceededDragThreshold(drag_info->start_pt - event.location())) {
     if (!drag_controller_ ||
         drag_controller_->CanStartDragForView(
             this, drag_info->start_pt, event.location()))
       DoDrag(event, drag_info->start_pt);
   } else {
     if (OnMouseDragged(event))
       return true;
     // Fall through to return value based on context menu controller.
   }
   // WARNING: we may have been deleted.
@@ skipping 174 matching lines @@
   gfx::Point widget_location(event.location());
   ConvertPointToWidget(this, &widget_location);
   GetWidget()->RunShellDrag(this, data, widget_location, drag_operations);
   return true;
 #else
   return false;
 #endif  // !defined(OS_MACOSX)
 }
 
 }  // namespace views