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

ui/gfx/render_text.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/gfx/render_text.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
@@ skipping 388 matching lines @@
   if (directionality_mode_ == DIRECTIONALITY_FROM_TEXT)
     text_direction_ = base::i18n::UNKNOWN_DIRECTION;
 
   UpdateObscuredText();
   ResetLayout();
 }
 
 void RenderText::SetHorizontalAlignment(HorizontalAlignment alignment) {
   if (horizontal_alignment_ != alignment) {
     horizontal_alignment_ = alignment;
-    display_offset_ = Point();
+    display_offset_ = Vector2d();
     cached_bounds_and_offset_valid_ = false;
   }
 }
 
 void RenderText::SetFontList(const FontList& font_list) {
   font_list_ = font_list;
   cached_bounds_and_offset_valid_ = false;
   ResetLayout();
 }
 
@@ skipping 338 matching lines @@
       focused_(false),
       composition_range_(ui::Range::InvalidRange()),
       obscured_(false),
       fade_head_(false),
       fade_tail_(false),
       background_is_transparent_(false),
       clip_to_display_rect_(true),
       cached_bounds_and_offset_valid_(false) {
 }
 
-const Point& RenderText::GetUpdatedDisplayOffset() {
+const Vector2d& RenderText::GetUpdatedDisplayOffset() {
   UpdateCachedBoundsAndOffset();
   return display_offset_;
 }
 
 SelectionModel RenderText::GetAdjacentSelectionModel(
     const SelectionModel& current,
     BreakType break_type,
     VisualCursorDirection direction) {
   EnsureLayout();
 
@@ skipping 61 matching lines @@
 }
 
 Point RenderText::GetTextOrigin() {
   Point origin = display_rect().origin();
   origin = origin.Add(GetUpdatedDisplayOffset());
   origin = origin.Add(GetAlignmentOffset());
   return origin;
 }
 
 Point RenderText::ToTextPoint(const Point& point) {
-  return point.Subtract(GetTextOrigin());
+  return point.Subtract(GetTextOrigin().DistanceFromOrigin());
 }
 
 Point RenderText::ToViewPoint(const Point& point) {
-  return point.Add(GetTextOrigin());
+  return point.Add(GetTextOrigin().DistanceFromOrigin());
 }
 
 int RenderText::GetContentWidth() {
   return GetStringSize().width() + (cursor_enabled_ ? 1 : 0);
 }
 
-Point RenderText::GetAlignmentOffset() {
+Vector2d RenderText::GetAlignmentOffset() {
   if (horizontal_alignment() != ALIGN_LEFT) {
     int x_offset = display_rect().width() - GetContentWidth();
     if (horizontal_alignment() == ALIGN_CENTER)
       x_offset /= 2;
-    return Point(x_offset, 0);
+    return Vector2d(x_offset, 0);
   }
-  return Point();
+  return Vector2d();
 }
 
 Point RenderText::GetOriginForDrawing() {
   Point origin(GetTextOrigin());
   const int height = GetStringSize().height();
   // Center the text vertically in the display area.
   origin.Offset(0, (display_rect().height() - height) / 2);
   return origin;
 }
 
@@ skipping 115 matching lines @@
     delta_offset = display_rect_.x() - cursor_bounds_.x();
   } else if (display_offset_.x() != 0) {
     // Reduce the pan offset to show additional overflow text when the display
     // width increases.
     const int negate_rtl = horizontal_alignment_ == ALIGN_RIGHT ? -1 : 1;
     const int offset = negate_rtl * display_offset_.x();
     if (display_width > (content_width + offset))
       delta_offset = negate_rtl * (display_width - (content_width + offset));
   }
 
-  display_offset_.Offset(delta_offset, 0);
+  display_offset_.Grow(delta_offset, 0);
   cursor_bounds_.Offset(delta_offset, 0);
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   const SkColor color = focused() ? selection_background_focused_color_ :
                                     selection_background_unfocused_color_;
   const std::vector<Rect> sel = GetSubstringBounds(selection());
   for (std::vector<Rect>::const_iterator i = sel.begin(); i < sel.end(); ++i)
     canvas->FillRect(*i, color);
 }
 
 void RenderText::DrawCursor(Canvas* canvas) {
   // Paint cursor. Replace cursor is drawn as rectangle for now.
   // TODO(msw): Draw a better cursor with a better indication of association.
   if (cursor_enabled() && cursor_visible() && focused()) {
     const Rect& bounds = GetUpdatedCursorBounds();
     if (bounds.width() != 0)
       canvas->FillRect(bounds, cursor_color_);
     else
       canvas->DrawRect(bounds, cursor_color_);
   }
 }
 
 }  // namespace gfx