cc: Remove all remaining use of WebCore Rect/Point/Size types from the compositor.

This change removes all IntPoint/FloatRect/IntSize/etc from the compositor.
There remains an indirect dependency on these types through the
WebCore::Region class, which we wrap but need to replace. However, the wrapper
there hides the WebCore types inside it, so there are now no references to the
types from anywhere else in the compositor.

I went back and forth on how to deal with scroll "positions". The name suggested
that they should be Points, and that the deltas should be Vectors. However this
lent itself to super awkward math at times. In the end, it was much cleaner to
make all scroll "positions" into scroll "offsets" and represent everything as
Vectors.

Covered by existing tests; no change in behaviour.

R=enne
BUG=147395
Relanding: https://codereview.chromium.org/11367080/

Review URL: https://codereview.chromium.org/11366089

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@166027 0039d316-1c4b-4281-b951-d872f2087c98

57 files changed, 596 insertions, 852 deletions

diff --git a/cc/DEPS b/cc/DEPS
index cf10e4c..56c6cf7 100644
--- a/cc/DEPS
+++ b/cc/DEPS
@@ -5,22 +5,7 @@ include_rules = [
   "+third_party/khronos/GLES2/gl2ext.h",
   "+ui/gfx",
   "+media",
-# http://crbug.com/144542
-  "+third_party/WebKit/Source/WebCore/platform/graphics/FloatPoint.h",
-  "+third_party/WebKit/Source/WebCore/platform/graphics/FloatQuad.h",
-  "+third_party/WebKit/Source/WebCore/platform/graphics/FloatRect.h",
-  "+third_party/WebKit/Source/WebCore/platform/graphics/FloatSize.h",
-  "+third_party/WebKit/Source/WebCore/platform/graphics/IntPoint.h",
-  "+third_party/WebKit/Source/WebCore/platform/graphics/IntRect.h",
-  "+third_party/WebKit/Source/WebCore/platform/graphics/IntSize.h",
-  "+Source/WebCore/platform/graphics/FloatPoint.h",
-  "+Source/WebCore/platform/graphics/FloatQuad.h",
-  "+Source/WebCore/platform/graphics/FloatRect.h",
-  "+Source/WebCore/platform/graphics/FloatSize.h",
-  "+Source/WebCore/platform/graphics/IntPoint.h",
-  "+Source/WebCore/platform/graphics/IntRect.h",
-  "+Source/WebCore/platform/graphics/IntSize.h",
-# http://crbug.com/144540
+# http://crbug.com/147395
   "+third_party/WebKit/Source/WebCore/platform/graphics/Region.h",
   "+Source/WebCore/platform/graphics/Region.h",
 # TODO(jamesr): Resolve these
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 5944570..fde2598 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -257,18 +257,10 @@
       ],
       'sources': [
         '<@(cc_source_files)',
-        'stubs/FloatPoint.h',
-        'stubs/FloatSize.h',
-        'stubs/IntPoint.h',
-        'stubs/IntSize.h',
         'stubs/Region.h',
         'stubs/UnitBezier.h',
 
         'stubs/config.h',
-        'stubs/float_point.h',
-        'stubs/float_size.h',
-        'stubs/int_point.h',
-        'stubs/int_size.h',
         'stubs/unit_bezier.h',
       ],
     },
diff --git a/cc/geometry.h b/cc/geometry.h
index 1e5e25a..9198927 100644
--- a/cc/geometry.h
+++ b/cc/geometry.h
@@ -5,9 +5,10 @@
 #ifndef CC_GEOMETRY_H_
 #define CC_GEOMETRY_H_
 
-#include "ui/gfx/size.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/rect_f.h"
+#include "ui/gfx/vector2d.h"
 #include "ui/gfx/vector2d_f.h"
-#include <cmath>
 
 namespace cc {
 
@@ -16,6 +17,67 @@ inline gfx::Size ClampSizeFromAbove(gfx::Size s, gfx::Size other) {
                    s.height() < other.height() ? s.height() : other.height());
 }
 
+inline gfx::Vector2dF ClampFromAbove(gfx::Vector2dF s, gfx::Vector2dF max) {
+  return gfx::Vector2dF(s.x() < max.x() ? s.x() : max.x(),
+                        s.y() < max.y() ? s.y() : max.y());
+}
+
+inline gfx::Vector2dF ClampFromBelow(gfx::Vector2dF s, gfx::Vector2dF min) {
+  return gfx::Vector2dF(s.x() > min.x() ? s.x() : min.x(),
+                        s.y() > min.y() ? s.y() : min.y());
+}
+
+inline gfx::Vector2d ClampFromAbove(gfx::Vector2d s, gfx::Vector2d max) {
+  return gfx::Vector2d(s.x() < max.x() ? s.x() : max.x(),
+                       s.y() < max.y() ? s.y() : max.y());
+}
+
+inline gfx::Vector2d ClampFromBelow(gfx::Vector2d s, gfx::Vector2d min) {
+  return gfx::Vector2d(s.x() > min.x() ? s.x() : min.x(),
+                       s.y() > min.y() ? s.y() : min.y());
+}
+
+inline gfx::PointF ClampFromAbove(gfx::PointF s, gfx::PointF max) {
+  return gfx::PointF(s.x() < max.x() ? s.x() : max.x(),
+                     s.y() < max.y() ? s.y() : max.y());
+}
+
+inline gfx::PointF ClampFromBelow(gfx::PointF s, gfx::PointF min) {
+  return gfx::PointF(s.x() > min.x() ? s.x() : min.x(),
+                     s.y() > min.y() ? s.y() : min.y());
+}
+
+inline gfx::Point ClampFromAbove(gfx::Point s, gfx::Point max) {
+  return gfx::Point(s.x() < max.x() ? s.x() : max.x(),
+                    s.y() < max.y() ? s.y() : max.y());
+}
+
+inline gfx::Point ClampFromBelow(gfx::Point s, gfx::Point min) {
+  return gfx::Point(s.x() > min.x() ? s.x() : min.x(),
+                    s.y() > min.y() ? s.y() : min.y());
+}
+
+inline gfx::Point BottomRight(gfx::Rect rect) {
+  return gfx::Point(rect.right(), rect.bottom());
+}
+
+inline gfx::PointF BottomRight(gfx::RectF rect) {
+  return gfx::PointF(rect.right(), rect.bottom());
+}
+
+// Return a vector that is |v| scaled by the given scale factors along each
+// axis.
+inline gfx::Vector2dF ScaleVector2d(gfx::Vector2dF v, float x_scale, float y_scale) {
+  gfx::Vector2dF scaled = v;
+  scaled.Scale(x_scale, y_scale);
+  return scaled;
+}
+
+// Return a vector that is |v| scaled by the given scale factor.
+inline gfx::Vector2dF ScaleVector2d(gfx::Vector2dF v, float scale) {
+  return ScaleVector2d(v, scale, scale);
+}
+
 }  // namespace cc
 
 #endif  // CC_GEOMETRY_H_
diff --git a/cc/input_handler.h b/cc/input_handler.h
index 5f6a706..6898c1f 100644
--- a/cc/input_handler.h
+++ b/cc/input_handler.h
@@ -11,13 +11,11 @@
 
 namespace gfx {
 class Point;
+class Vector2d;
 }
 
 namespace cc {
 
-class IntPoint;
-class IntSize;
-
 // The InputHandler is a way for the embedders to interact with
 // the impl thread side of the compositor implementation.
 //
@@ -36,7 +34,7 @@ public:
     // can be scrolled, ScrollOnMainThread if the scroll event should instead be
     // delegated to the main thread, or ScrollIgnored if there is nothing to be
     // scrolled at the given coordinates.
-    virtual ScrollStatus scrollBegin(const gfx::Point&, ScrollInputType) = 0;
+    virtual ScrollStatus scrollBegin(gfx::Point, ScrollInputType) = 0;
 
     // Scroll the selected layer starting at the given position. If the scroll
     // type given to scrollBegin was a gesture, then the scroll point and delta
@@ -45,17 +43,17 @@ public:
     // layer in the requested direction, its first ancestor layer that can be
     // scrolled will be moved instead. Should only be called if scrollBegin()
     // returned ScrollStarted.
-    virtual void scrollBy(const gfx::Point&, const IntSize&) = 0;
+    virtual void scrollBy(gfx::Point, gfx::Vector2d) = 0;
 
     // Stop scrolling the selected layer. Should only be called if scrollBegin()
     // returned ScrollStarted.
     virtual void scrollEnd() = 0;
 
     virtual void pinchGestureBegin() = 0;
-    virtual void pinchGestureUpdate(float magnifyDelta, const IntPoint& anchor) = 0;
+    virtual void pinchGestureUpdate(float magnifyDelta, gfx::Point anchor) = 0;
     virtual void pinchGestureEnd() = 0;
 
-    virtual void startPageScaleAnimation(const IntSize& targetPosition,
+    virtual void startPageScaleAnimation(gfx::Vector2d targetOffset,
                                          bool anchorPoint,
                                          float pageScale,
                                          base::TimeTicks startTime,
diff --git a/cc/layer.cc b/cc/layer.cc
index c5bbbb2..490fe5d 100644
--- a/cc/layer.cc
+++ b/cc/layer.cc
@@ -408,21 +408,21 @@ bool Layer::transformIsAnimating() const
     return m_layerAnimationController->isAnimatingProperty(ActiveAnimation::Transform);
 }
 
-void Layer::setScrollPosition(const IntPoint& scrollPosition)
+void Layer::setScrollOffset(gfx::Vector2d scrollOffset)
 {
-    if (m_scrollPosition == scrollPosition)
+    if (m_scrollOffset == scrollOffset)
         return;
-    m_scrollPosition = scrollPosition;
+    m_scrollOffset = scrollOffset;
     if (m_layerScrollClient)
         m_layerScrollClient->didScroll();
     setNeedsCommit();
 }
 
-void Layer::setMaxScrollPosition(const IntSize& maxScrollPosition)
+void Layer::setMaxScrollOffset(gfx::Vector2d maxScrollOffset)
 {
-    if (m_maxScrollPosition == maxScrollPosition)
+    if (m_maxScrollOffset == maxScrollOffset)
         return;
-    m_maxScrollPosition = maxScrollPosition;
+    m_maxScrollOffset = maxScrollOffset;
     setNeedsCommit();
 }
 
@@ -587,8 +587,8 @@ void Layer::pushPropertiesTo(LayerImpl* layer)
     layer->setFixedToContainerLayer(m_fixedToContainerLayer);
     layer->setPreserves3D(preserves3D());
     layer->setUseParentBackfaceVisibility(m_useParentBackfaceVisibility);
-    layer->setScrollPosition(m_scrollPosition);
-    layer->setMaxScrollPosition(m_maxScrollPosition);
+    layer->setScrollOffset(m_scrollOffset);
+    layer->setMaxScrollOffset(m_maxScrollOffset);
     layer->setSublayerTransform(m_sublayerTransform);
     if (!transformIsAnimating())
         layer->setTransform(m_transform);
@@ -600,7 +600,7 @@ void Layer::pushPropertiesTo(LayerImpl* layer)
     layer->setUpdateRect(m_updateRect);
 
     layer->setScrollDelta(layer->scrollDelta() - layer->sentScrollDelta());
-    layer->setSentScrollDelta(IntSize());
+    layer->setSentScrollDelta(gfx::Vector2d());
 
     layer->setStackingOrderChanged(m_stackingOrderChanged);
 
diff --git a/cc/layer.h b/cc/layer.h
index d827ed4..3375b65 100644
--- a/cc/layer.h
+++ b/cc/layer.h
@@ -5,7 +5,6 @@
 #ifndef CC_LAYER_H_
 #define CC_LAYER_H_
 
-#include "IntPoint.h"
 #include "Region.h"
 #include "base/memory/ref_counted.h"
 #include "cc/cc_export.h"
@@ -129,11 +128,11 @@ public:
     const gfx::Rect& visibleContentRect() const { return m_visibleContentRect; }
     void setVisibleContentRect(const gfx::Rect& visibleContentRect) { m_visibleContentRect = visibleContentRect; }
 
-    void setScrollPosition(const IntPoint&);
-    const IntPoint& scrollPosition() const { return m_scrollPosition; }
+    void setScrollOffset(gfx::Vector2d);
+    gfx::Vector2d scrollOffset() const { return m_scrollOffset; }
 
-    void setMaxScrollPosition(const IntSize&);
-    const IntSize& maxScrollPosition() const { return m_maxScrollPosition; }
+    void setMaxScrollOffset(gfx::Vector2d);
+    gfx::Vector2d maxScrollOffset() const { return m_maxScrollOffset; }
 
     void setScrollable(bool);
     bool scrollable() const { return m_scrollable; }
@@ -156,7 +155,7 @@ public:
     bool forceRenderSurface() const { return m_forceRenderSurface; }
     void setForceRenderSurface(bool);
 
-    IntSize scrollDelta() const { return IntSize(); }
+    gfx::Vector2d scrollDelta() const { return gfx::Vector2d(); }
 
     void setImplTransform(const WebKit::WebTransformationMatrix&);
     const WebKit::WebTransformationMatrix& implTransform() const { return m_implTransform; }
@@ -344,8 +343,8 @@ private:
     // Uses layer's content space.
     gfx::Rect m_visibleContentRect;
 
-    IntPoint m_scrollPosition;
-    IntSize m_maxScrollPosition;
+    gfx::Vector2d m_scrollOffset;
+    gfx::Vector2d m_maxScrollOffset;
     bool m_scrollable;
     bool m_shouldScrollOnMainThread;
     bool m_haveWheelEventHandlers;
diff --git a/cc/layer_impl.cc b/cc/layer_impl.cc
index 4161311..6db7af7 100644
--- a/cc/layer_impl.cc
+++ b/cc/layer_impl.cc
@@ -9,6 +9,7 @@
 #include "base/debug/trace_event.h"
 #include "base/stringprintf.h"
 #include "cc/debug_border_draw_quad.h"
+#include "cc/geometry.h"
 #include "cc/layer_sorter.h"
 #include "cc/math_util.h"
 #include "cc/proxy.h"
@@ -179,13 +180,15 @@ ResourceProvider::ResourceId LayerImpl::contentsResourceId() const
     return 0;
 }
 
-FloatSize LayerImpl::scrollBy(const FloatSize& scroll)
+gfx::Vector2dF LayerImpl::scrollBy(const gfx::Vector2dF& scroll)
 {
-    IntSize minDelta = -toSize(m_scrollPosition);
-    IntSize maxDelta = m_maxScrollPosition - toSize(m_scrollPosition);
+    gfx::Vector2dF minDelta = -m_scrollOffset;
+    gfx::Vector2dF maxDelta = m_maxScrollOffset - m_scrollOffset;
     // Clamp newDelta so that position + delta stays within scroll bounds.
-    FloatSize newDelta = (m_scrollDelta + scroll).expandedTo(minDelta).shrunkTo(maxDelta);
-    FloatSize unscrolled = m_scrollDelta + scroll - newDelta;
+    gfx::Vector2dF newDelta = (m_scrollDelta + scroll);
+    newDelta = ClampFromBelow(newDelta, minDelta);
+    newDelta = ClampFromAbove(newDelta, maxDelta);
+    gfx::Vector2dF unscrolled = m_scrollDelta + scroll - newDelta;
 
     if (m_scrollDelta == newDelta)
         return unscrolled;
@@ -623,16 +626,16 @@ void LayerImpl::setContentsScale(float contentsScaleX, float contentsScaleY)
     m_layerPropertyChanged = true;
 }
 
-void LayerImpl::setScrollPosition(const IntPoint& scrollPosition)
+void LayerImpl::setScrollOffset(gfx::Vector2d scrollOffset)
 {
-    if (m_scrollPosition == scrollPosition)
+    if (m_scrollOffset == scrollOffset)
         return;
 
-    m_scrollPosition = scrollPosition;
+    m_scrollOffset = scrollOffset;
     noteLayerPropertyChangedForSubtree();
 }
 
-void LayerImpl::setScrollDelta(const FloatSize& scrollDelta)
+void LayerImpl::setScrollDelta(const gfx::Vector2dF& scrollDelta)
 {
     if (m_scrollDelta == scrollDelta)
         return;
@@ -670,9 +673,9 @@ void LayerImpl::didLoseContext()
 {
 }
 
-void LayerImpl::setMaxScrollPosition(const IntSize& maxScrollPosition)
+void LayerImpl::setMaxScrollOffset(gfx::Vector2d maxScrollOffset)
 {
-    m_maxScrollPosition = maxScrollPosition;
+    m_maxScrollOffset = maxScrollOffset;
 
     if (!m_scrollbarAnimationController)
         return;
diff --git a/cc/layer_impl.h b/cc/layer_impl.h
index d51f3d0..c467d82 100644
--- a/cc/layer_impl.h
+++ b/cc/layer_impl.h
@@ -7,8 +7,6 @@
 
 #include <string>
 
-#include "FloatSize.h"
-#include "IntPoint.h"
 #include "Region.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ -187,23 +185,23 @@ public:
     float contentsScaleY() const { return m_contentsScaleY; }
     void setContentsScale(float contentsScaleX, float contentsScaleY);
 
-    const IntPoint& scrollPosition() const { return m_scrollPosition; }
-    void setScrollPosition(const IntPoint&);
+    gfx::Vector2d scrollOffset() const { return m_scrollOffset; }
+    void setScrollOffset(gfx::Vector2d);
 
-    const IntSize& maxScrollPosition() const {return m_maxScrollPosition; }
-    void setMaxScrollPosition(const IntSize&);
+    gfx::Vector2d maxScrollOffset() const {return m_maxScrollOffset; }
+    void setMaxScrollOffset(gfx::Vector2d);
 
-    const FloatSize& scrollDelta() const { return m_scrollDelta; }
-    void setScrollDelta(const FloatSize&);
+    const gfx::Vector2dF& scrollDelta() const { return m_scrollDelta; }
+    void setScrollDelta(const gfx::Vector2dF&);
 
     const WebKit::WebTransformationMatrix& implTransform() const { return m_implTransform; }
     void setImplTransform(const WebKit::WebTransformationMatrix& transform);
 
-    const IntSize& sentScrollDelta() const { return m_sentScrollDelta; }
-    void setSentScrollDelta(const IntSize& sentScrollDelta) { m_sentScrollDelta = sentScrollDelta; }
+    const gfx::Vector2d& sentScrollDelta() const { return m_sentScrollDelta; }
+    void setSentScrollDelta(const gfx::Vector2d& sentScrollDelta) { m_sentScrollDelta = sentScrollDelta; }
 
     // Returns the delta of the scroll that was outside of the bounds of the initial scroll
-    FloatSize scrollBy(const FloatSize& scroll);
+    gfx::Vector2dF scrollBy(const gfx::Vector2dF& scroll);
 
     bool scrollable() const { return m_scrollable; }
     void setScrollable(bool scrollable) { m_scrollable = scrollable; }
@@ -316,7 +314,7 @@ private:
     gfx::Size m_contentBounds;
     float m_contentsScaleX;
     float m_contentsScaleY;
-    IntPoint m_scrollPosition;
+    gfx::Vector2d m_scrollOffset;
     bool m_scrollable;
     bool m_shouldScrollOnMainThread;
     bool m_haveWheelEventHandlers;
@@ -356,9 +354,9 @@ private:
     // This is true if the layer should be fixed to the closest ancestor container.
     bool m_fixedToContainerLayer;
 
-    FloatSize m_scrollDelta;
-    IntSize m_sentScrollDelta;
-    IntSize m_maxScrollPosition;
+    gfx::Vector2dF m_scrollDelta;
+    gfx::Vector2d m_sentScrollDelta;
+    gfx::Vector2d m_maxScrollOffset;
     WebKit::WebTransformationMatrix m_implTransform;
 
     // The layer whose coordinate space this layer draws into. This can be
diff --git a/cc/layer_impl_unittest.cc b/cc/layer_impl_unittest.cc
index 7dbcc24..aad5583 100644
--- a/cc/layer_impl_unittest.cc
+++ b/cc/layer_impl_unittest.cc
@@ -76,6 +76,7 @@ TEST(LayerImplTest, verifyLayerChangesAreTrackedProperly)
     float arbitraryNumber = 0.352f;
     gfx::Size arbitrarySize = gfx::Size(111, 222);
     gfx::Point arbitraryPoint = gfx::Point(333, 444);
+    gfx::Vector2d arbitraryVector2d = gfx::Vector2d(111, 222);
     gfx::Rect arbitraryRect = gfx::Rect(arbitraryPoint, arbitrarySize);
     gfx::RectF arbitraryRectF = gfx::RectF(arbitraryPointF, gfx::SizeF(1.234f, 5.678f));
     SkColor arbitraryColor = SkColorSetRGB(10, 20, 30);
@@ -94,7 +95,7 @@ TEST(LayerImplTest, verifyLayerChangesAreTrackedProperly)
     EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setDrawableContentRect(arbitraryRect));
     EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setUpdateRect(arbitraryRectF));
     EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setVisibleContentRect(arbitraryRect));
-    EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setMaxScrollPosition(cc::IntSize(arbitrarySize)));
+    EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setMaxScrollOffset(arbitraryVector2d));
 
     // Changing these properties affects the entire subtree of layers.
     EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setAnchorPoint(arbitraryPointF));
@@ -109,9 +110,9 @@ TEST(LayerImplTest, verifyLayerChangesAreTrackedProperly)
     EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setPosition(arbitraryPointF));
     EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setPreserves3D(true));
     EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setDoubleSided(false)); // constructor initializes it to "true".
-    EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->scrollBy(cc::IntSize(arbitrarySize)));
-    EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setScrollDelta(cc::IntSize()));
-    EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setScrollPosition(cc::IntPoint(arbitraryPoint)));
+    EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->scrollBy(arbitraryVector2d));
+    EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setScrollDelta(gfx::Vector2d()));
+    EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setScrollOffset(arbitraryVector2d));
     EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setImplTransform(arbitraryTransform));
 
     // Changing these properties only affects the layer itself.
@@ -149,8 +150,8 @@ TEST(LayerImplTest, verifyLayerChangesAreTrackedProperly)
     EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setPreserves3D(true));
     EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setTransform(arbitraryTransform));
     EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setDoubleSided(false)); // constructor initializes it to "true".
-    EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setScrollDelta(cc::IntSize()));
-    EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setScrollPosition(cc::IntPoint(arbitraryPoint)));
+    EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setScrollDelta(gfx::Vector2d()));
+    EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setScrollOffset(arbitraryVector2d));
     EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setImplTransform(arbitraryTransform));
     EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setContentBounds(arbitrarySize));
     EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setContentsScale(arbitraryNumber, arbitraryNumber));
diff --git a/cc/layer_tree_host.cc b/cc/layer_tree_host.cc
index 9e5fcc5..92e4435 100644
--- a/cc/layer_tree_host.cc
+++ b/cc/layer_tree_host.cc
@@ -451,9 +451,9 @@ void LayerTreeHost::setVisible(bool visible)
     m_proxy->setVisible(visible);
 }
 
-void LayerTreeHost::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, base::TimeDelta duration)
+void LayerTreeHost::startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration)
 {
-    m_proxy->startPageScaleAnimation(targetPosition, useAnchor, scale, duration);
+    m_proxy->startPageScaleAnimation(targetOffset, useAnchor, scale, duration);
 }
 
 void LayerTreeHost::loseContext(int numTimes)
@@ -694,7 +694,7 @@ void LayerTreeHost::applyScrollAndScale(const ScrollAndScaleSet& info)
         return;
 
     Layer* rootScrollLayer = findFirstScrollableLayer(m_rootLayer.get());
-    IntSize rootScrollDelta;
+    gfx::Vector2d rootScrollDelta;
 
     for (size_t i = 0; i < info.scrolls.size(); ++i) {
         Layer* layer = LayerTreeHostCommon::findLayerInSubtree(m_rootLayer.get(), info.scrolls[i].layerId);
@@ -703,9 +703,9 @@ void LayerTreeHost::applyScrollAndScale(const ScrollAndScaleSet& info)
         if (layer == rootScrollLayer)
             rootScrollDelta += info.scrolls[i].scrollDelta;
         else
-            layer->setScrollPosition(layer->scrollPosition() + info.scrolls[i].scrollDelta);
+            layer->setScrollOffset(layer->scrollOffset() + info.scrolls[i].scrollDelta);
     }
-    if (!rootScrollDelta.isZero() || info.pageScaleDelta != 1)
+    if (!rootScrollDelta.IsZero() || info.pageScaleDelta != 1)
         m_client->applyScrollAndScale(rootScrollDelta, info.pageScaleDelta);
 }
 
diff --git a/cc/layer_tree_host.h b/cc/layer_tree_host.h
index 7dd334c..74e999b 100644
--- a/cc/layer_tree_host.h
+++ b/cc/layer_tree_host.h
@@ -190,7 +190,7 @@ public:
     bool visible() const { return m_visible; }
     void setVisible(bool);
 
-    void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, base::TimeDelta duration);
+    void startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration);
 
     void applyScrollAndScale(const ScrollAndScaleSet&);
     gfx::PointF adjustEventPointForPinchZoom(const gfx::PointF&) const;
diff --git a/cc/layer_tree_host_client.h b/cc/layer_tree_host_client.h
index 3bec0328..f6cb702 100644
--- a/cc/layer_tree_host_client.h
+++ b/cc/layer_tree_host_client.h
@@ -7,13 +7,16 @@
 
 #include "base/memory/scoped_ptr.h"
 
+namespace gfx {
+class Vector2d;
+}
+
 namespace WebKit {
 class WebCompositorOutputSurface;
 }
 
 namespace cc {
 class InputHandler;
-class IntSize;
 
 class LayerTreeHostClient {
 public:
@@ -22,7 +25,7 @@ public:
     virtual void didBeginFrame() = 0;
     virtual void animate(double frameBeginTime) = 0;
     virtual void layout() = 0;
-    virtual void applyScrollAndScale(const IntSize& scrollDelta, float pageScale) = 0;
+    virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float pageScale) = 0;
     virtual scoped_ptr<WebKit::WebCompositorOutputSurface> createOutputSurface() = 0;
     virtual void didRecreateOutputSurface(bool success) = 0;
     virtual scoped_ptr<InputHandler> createInputHandler() = 0;
diff --git a/cc/layer_tree_host_common.cc b/cc/layer_tree_host_common.cc
index dd10225..662d5d8 100644
--- a/cc/layer_tree_host_common.cc
+++ b/cc/layer_tree_host_common.cc
@@ -289,7 +289,7 @@ WebTransformationMatrix computeScrollCompensationForThisLayer(LayerImpl* scrolli
     partialLayerOriginTransform.multiply(scrollingLayer->implTransform());
 
     WebTransformationMatrix scrollCompensationForThisLayer = partialLayerOriginTransform; // Step 3
-    scrollCompensationForThisLayer.translate(scrollingLayer->scrollDelta().width(), scrollingLayer->scrollDelta().height()); // Step 2
+    scrollCompensationForThisLayer.translate(scrollingLayer->scrollDelta().x(), scrollingLayer->scrollDelta().y()); // Step 2
     scrollCompensationForThisLayer.multiply(partialLayerOriginTransform.inverse()); // Step 1
     return scrollCompensationForThisLayer;
 }
@@ -320,7 +320,7 @@ WebTransformationMatrix computeScrollCompensationMatrixForChildren(LayerImpl* la
     //
 
     // Avoid the overheads (including stack allocation and matrix initialization/copy) if we know that the scroll compensation doesn't need to be reset or adjusted.
-    if (!layer->isContainerForFixedPositionLayers() && layer->scrollDelta().isZero() && !layer->renderSurface())
+    if (!layer->isContainerForFixedPositionLayers() && layer->scrollDelta().IsZero() && !layer->renderSurface())
         return currentScrollCompensationMatrix;
 
     // Start as identity matrix.
@@ -332,7 +332,7 @@ WebTransformationMatrix computeScrollCompensationMatrixForChildren(LayerImpl* la
 
     // If the current layer has a non-zero scrollDelta, then we should compute its local scrollCompensation
     // and accumulate it to the nextScrollCompensationMatrix.
-    if (!layer->scrollDelta().isZero()) {
+    if (!layer->scrollDelta().IsZero()) {
         WebTransformationMatrix scrollCompensationForThisLayer = computeScrollCompensationForThisLayer(layer, parentMatrix);
         nextScrollCompensationMatrix.multiply(scrollCompensationForThisLayer);
     }
@@ -491,7 +491,7 @@ static void calculateDrawTransformsInternal(LayerType* layer, const WebTransform
 
     gfx::Size bounds = layer->bounds();
     gfx::PointF anchorPoint = layer->anchorPoint();
-    gfx::PointF position = layer->position() - gfx::Vector2d(layer->scrollDelta().width(), layer->scrollDelta().height());
+    gfx::PointF position = layer->position() - layer->scrollDelta();
 
     WebTransformationMatrix layerLocalTransform;
     // LT = Tr[origin] * Tr[origin2anchor]
diff --git a/cc/layer_tree_host_common.h b/cc/layer_tree_host_common.h
index 78ec5e4..cc5e621 100644
--- a/cc/layer_tree_host_common.h
+++ b/cc/layer_tree_host_common.h
@@ -9,7 +9,7 @@
 #include "cc/cc_export.h"
 #include "cc/scoped_ptr_vector.h"
 #include "ui/gfx/rect.h"
-#include "IntSize.h"
+#include "ui/gfx/vector2d.h"
 #include <public/WebTransformationMatrix.h>
 
 namespace cc {
@@ -46,7 +46,7 @@ public:
 
     struct ScrollUpdateInfo {
         int layerId;
-        IntSize scrollDelta;
+        gfx::Vector2d scrollDelta;
     };
 };
 
diff --git a/cc/layer_tree_host_common_unittest.cc b/cc/layer_tree_host_common_unittest.cc
index d5521d0..228ce2b 100644
--- a/cc/layer_tree_host_common_unittest.cc
+++ b/cc/layer_tree_host_common_unittest.cc
@@ -801,7 +801,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD
     grandChild->setFixedToContainerLayer(true);
 
     // Case 1: scrollDelta of 0, 0
-    child->setScrollDelta(IntSize(0, 0));
+    child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     WebTransformationMatrix expectedChildTransform;
@@ -811,7 +811,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 10
-    child->setScrollDelta(IntSize(10, 10));
+    child->setScrollDelta(gfx::Vector2d(10, 10));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the child is affected by scrollDelta, but the fixed position grandChild should not be affected.
@@ -847,7 +847,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithT
     grandChild->setFixedToContainerLayer(true);
 
     // Case 1: scrollDelta of 0, 0
-    child->setScrollDelta(IntSize(0, 0));
+    child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     WebTransformationMatrix expectedChildTransform;
@@ -859,7 +859,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithT
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 20
-    child->setScrollDelta(IntSize(10, 20));
+    child->setScrollDelta(gfx::Vector2d(10, 20));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // The child should be affected by scrollDelta, but the fixed position grandChild should not be affected.
@@ -887,7 +887,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD
     greatGrandChild->setFixedToContainerLayer(true);
 
     // Case 1: scrollDelta of 0, 0
-    child->setScrollDelta(IntSize(0, 0));
+    child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     WebTransformationMatrix expectedChildTransform;
@@ -901,7 +901,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 10
-    child->setScrollDelta(IntSize(10, 10));
+    child->setScrollDelta(gfx::Vector2d(10, 10));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the child and grandChild are affected by scrollDelta, but the fixed position greatGrandChild should not be affected.
@@ -936,7 +936,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD
     greatGrandChild->setFixedToContainerLayer(true); // greatGrandChild is positioned upside-down with respect to the renderTarget.
 
     // Case 1: scrollDelta of 0, 0
-    child->setScrollDelta(IntSize(0, 0));
+    child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     WebTransformationMatrix expectedChildTransform;
@@ -954,7 +954,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 20
-    child->setScrollDelta(IntSize(10, 20));
+    child->setScrollDelta(gfx::Vector2d(10, 20));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the child and grandChild are affected by scrollDelta, but the fixed position greatGrandChild should not be affected.
@@ -998,7 +998,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM
     greatGrandChild->setFixedToContainerLayer(true); // greatGrandChild is positioned upside-down with respect to the renderTarget.
 
     // Case 1: scrollDelta of 0, 0
-    child->setScrollDelta(IntSize(0, 0));
+    child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     WebTransformationMatrix expectedChildTransform;
@@ -1016,8 +1016,8 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 20
-    child->setScrollDelta(IntSize(10, 0));
-    grandChild->setScrollDelta(IntSize(5, 0));
+    child->setScrollDelta(gfx::Vector2d(10, 0));
+    grandChild->setScrollDelta(gfx::Vector2d(5, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the child and grandChild are affected by scrollDelta, but the fixed position greatGrandChild should not be affected.
@@ -1061,7 +1061,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithI
     grandChild->setTransform(rotationAboutZ);
 
     // Case 1: scrollDelta of 0, 0
-    child->setScrollDelta(IntSize(0, 0));
+    child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     WebTransformationMatrix expectedChildTransform;
@@ -1077,7 +1077,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithI
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 30
-    child->setScrollDelta(IntSize(10, 30));
+    child->setScrollDelta(gfx::Vector2d(10, 30));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the grandChild remains unchanged, because it scrolls along with the
@@ -1153,7 +1153,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM
     greatGrandChild->setTransform(rotationAboutZ);
 
     // Case 1: scrollDelta of 0, 0
-    child->setScrollDelta(IntSize(0, 0));
+    child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     WebTransformationMatrix expectedChildTransform;
@@ -1182,7 +1182,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedFixedPositionChildTransform, fixedPositionChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 30
-    child->setScrollDelta(IntSize(10, 30));
+    child->setScrollDelta(gfx::Vector2d(10, 30));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     expectedChildTransform.makeIdentity();
@@ -1239,7 +1239,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithC
     grandChild->setDrawsContent(true);
 
     // Case 1: scrollDelta of 0, 0
-    child->setScrollDelta(IntSize(0, 0));
+    child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     WebTransformationMatrix expectedSurfaceDrawTransform;
@@ -1252,7 +1252,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithC
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 10
-    child->setScrollDelta(IntSize(10, 10));
+    child->setScrollDelta(gfx::Vector2d(10, 10));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // The surface is translated by scrollDelta, the child transform doesn't change
@@ -1287,7 +1287,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatI
     grandChild->setIsContainerForFixedPositionLayers(true);
 
     // Case 1: scrollDelta of 0, 0
-    child->setScrollDelta(IntSize(0, 0));
+    child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     WebTransformationMatrix expectedChildTransform;
@@ -1296,7 +1296,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatI
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 10
-    child->setScrollDelta(IntSize(10, 10));
+    child->setScrollDelta(gfx::Vector2d(10, 10));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the child is affected by scrollDelta, but the fixed position grandChild should not be affected.
@@ -1324,7 +1324,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatH
     grandChild->setFixedToContainerLayer(true);
 
     // Case 1: root scrollDelta of 0, 0
-    root->setScrollDelta(IntSize(0, 0));
+    root->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     WebTransformationMatrix identityMatrix;
@@ -1333,7 +1333,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatH
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->drawTransform());
 
     // Case 2: root scrollDelta of 10, 10
-    root->setScrollDelta(IntSize(10, 20));
+    root->setScrollDelta(gfx::Vector2d(10, 20));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // The child is affected by scrollDelta, but it is already implcitly accounted for by
diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc
index 73568ff..2f5ee5c 100644
--- a/cc/layer_tree_host_impl.cc
+++ b/cc/layer_tree_host_impl.cc
@@ -14,6 +14,7 @@
 #include "cc/delay_based_time_source.h"
 #include "cc/font_atlas.h"
 #include "cc/frame_rate_counter.h"
+#include "cc/geometry.h"
 #include "cc/gl_renderer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer_iterator.h"
@@ -32,6 +33,7 @@
 #include "cc/software_renderer.h"
 #include "cc/texture_uploader.h"
 #include "ui/gfx/size_conversions.h"
+#include "ui/gfx/vector2d_conversions.h"
 #include <algorithm>
 
 using WebKit::WebTransformationMatrix;
@@ -101,12 +103,12 @@ gfx::RectF PinchZoomViewport::bounds() const
     scaledViewportSize = scaledViewportSize.Scale(1 / totalPageScaleFactor());
 
     gfx::RectF bounds(gfx::PointF(), scaledViewportSize);
-    bounds.set_origin(m_pinchViewportScrollDelta);
+    bounds.Offset(m_pinchViewportScrollDelta);
 
     return bounds;
 }
 
-FloatSize PinchZoomViewport::applyScroll(const gfx::Vector2dF& delta)
+gfx::Vector2dF PinchZoomViewport::applyScroll(const gfx::Vector2dF& delta)
 {
     gfx::Vector2dF overflow;
     gfx::RectF pinchedBounds = bounds();
@@ -131,9 +133,9 @@ FloatSize PinchZoomViewport::applyScroll(const gfx::Vector2dF& delta)
         overflow.set_y(pinchedBounds.bottom() - m_layoutViewportSize.height());
         pinchedBounds.Offset(0, m_layoutViewportSize.height() - pinchedBounds.bottom());
     }
-    m_pinchViewportScrollDelta = cc::FloatPoint(pinchedBounds.origin());
+    m_pinchViewportScrollDelta = pinchedBounds.OffsetFromOrigin();
 
-    return cc::FloatSize(overflow);
+    return overflow;
 }
 
 WebTransformationMatrix PinchZoomViewport::implTransform() const
@@ -249,7 +251,7 @@ void LayerTreeHostImpl::commitComplete()
     TRACE_EVENT0("cc", "LayerTreeHostImpl::commitComplete");
     // Recompute max scroll position; must be after layer content bounds are
     // updated.
-    updateMaxScrollPosition();
+    updateMaxScrollOffset();
     m_client->sendManagedMemoryStats();
 }
 
@@ -290,26 +292,26 @@ void LayerTreeHostImpl::animate(base::TimeTicks monotonicTime, base::Time wallCl
     animateScrollbars(monotonicTime);
 }
 
-void LayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)
+void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetOffset, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)
 {
     if (!m_rootScrollLayerImpl)
         return;
 
-    IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
-    scrollTotal.scale(m_pinchZoomViewport.pageScaleDelta());
+    gfx::Vector2dF scrollTotal = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();
+    scrollTotal.Scale(m_pinchZoomViewport.pageScaleDelta());
     float scaleTotal = m_pinchZoomViewport.totalPageScaleFactor();
     gfx::Size scaledContentSize = gfx::ToFlooredSize(contentSize().Scale(m_pinchZoomViewport.pageScaleDelta()));
 
     double startTimeSeconds = (startTime - base::TimeTicks()).InSecondsF();
-    m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, scaleTotal, cc::IntSize(m_deviceViewportSize), scaledContentSize, startTimeSeconds);
+    m_pageScaleAnimation = PageScaleAnimation::create(gfx::ToFlooredVector2d(scrollTotal), scaleTotal, m_deviceViewportSize, scaledContentSize, startTimeSeconds);
 
     if (anchorPoint) {
-        IntSize windowAnchor(targetPosition);
-        windowAnchor.scale(scaleTotal / pageScale);
+        gfx::Vector2dF windowAnchor = targetOffset;
+        windowAnchor.Scale(scaleTotal / pageScale);
         windowAnchor -= scrollTotal;
-        m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration.InSecondsF());
+        m_pageScaleAnimation->zoomWithAnchor(gfx::ToFlooredVector2d(windowAnchor), pageScale, duration.InSecondsF());
     } else
-        m_pageScaleAnimation->zoomTo(targetPosition, pageScale, duration.InSecondsF());
+        m_pageScaleAnimation->zoomTo(targetOffset, pageScale, duration.InSecondsF());
 
     m_client->setNeedsRedrawOnImplThread();
     m_client->setNeedsCommitOnImplThread();
@@ -890,9 +892,9 @@ void LayerTreeHostImpl::setViewportSize(const gfx::Size& layoutViewportSize, con
     m_layoutViewportSize = layoutViewportSize;
     m_deviceViewportSize = deviceViewportSize;
 
-    m_pinchZoomViewport.setLayoutViewportSize(FloatSize(layoutViewportSize));
+    m_pinchZoomViewport.setLayoutViewportSize(layoutViewportSize);
 
-    updateMaxScrollPosition();
+    updateMaxScrollOffset();
 
     if (m_renderer)
         m_renderer->viewportChanged();
@@ -907,8 +909,8 @@ static void adjustScrollsForPageScaleChange(LayerImpl* layerImpl, float pageScal
 
     if (layerImpl->scrollable()) {
         // We need to convert impl-side scroll deltas to pageScale space.
-        FloatSize scrollDelta = layerImpl->scrollDelta();
-        scrollDelta.scale(pageScaleChange);
+        gfx::Vector2dF scrollDelta = layerImpl->scrollDelta();
+        scrollDelta.Scale(pageScaleChange);
         layerImpl->setScrollDelta(scrollDelta);
     }
 
@@ -922,7 +924,7 @@ void LayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor)
         return;
     m_deviceScaleFactor = deviceScaleFactor;
 
-    updateMaxScrollPosition();
+    updateMaxScrollOffset();
 }
 
 float LayerTreeHostImpl::pageScaleFactor() const
@@ -952,10 +954,10 @@ void LayerTreeHostImpl::setPageScaleDelta(float delta)
 {
     m_pinchZoomViewport.setPageScaleDelta(delta);
 
-    updateMaxScrollPosition();
+    updateMaxScrollOffset();
 }
 
-void LayerTreeHostImpl::updateMaxScrollPosition()
+void LayerTreeHostImpl::updateMaxScrollOffset()
 {
     if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size())
         return;
@@ -981,14 +983,14 @@ void LayerTreeHostImpl::updateMaxScrollPosition()
         viewBounds = viewBounds.Scale(1 / m_pinchZoomViewport.pageScaleDelta());
     }
 
-    IntSize maxScroll = cc::IntSize(contentBounds) - expandedIntSize(cc::FloatSize(viewBounds));
-    maxScroll.scale(1 / m_deviceScaleFactor);
+    gfx::Vector2dF maxScroll = BottomRight(gfx::Rect(contentBounds)) - BottomRight(gfx::RectF(viewBounds));
+    maxScroll.Scale(1 / m_deviceScaleFactor);
 
     // The viewport may be larger than the contents in some cases, such as
     // having a vertical scrollbar but no horizontal overflow.
-    maxScroll.clampNegativeToZero();
+    maxScroll = ClampFromBelow(maxScroll, gfx::Vector2dF());
 
-    m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll);
+    m_rootScrollLayerImpl->setMaxScrollOffset(gfx::ToFlooredVector2d(maxScroll));
 }
 
 void LayerTreeHostImpl::setNeedsRedraw()
@@ -1017,7 +1019,7 @@ bool LayerTreeHostImpl::ensureRenderSurfaceLayerList()
     return m_renderSurfaceLayerList.size();
 }
 
-InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(const gfx::Point& viewportPoint, InputHandlerClient::ScrollInputType type)
+InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(gfx::Point viewportPoint, InputHandlerClient::ScrollInputType type)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBegin");
 
@@ -1070,7 +1072,7 @@ InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(const gfx::Point
     return ScrollIgnored;
 }
 
-static FloatSize scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport, LayerImpl& layerImpl, float scaleFromViewportToScreenSpace, const gfx::PointF& viewportPoint, const FloatSize& viewportDelta)
+static gfx::Vector2dF scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport, LayerImpl& layerImpl, float scaleFromViewportToScreenSpace, gfx::PointF viewportPoint, gfx::Vector2dF viewportDelta)
 {
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
     // test in the first place.
@@ -1079,8 +1081,8 @@ static FloatSize scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport,
 
     gfx::PointF screenSpacePoint = viewportPoint.Scale(scaleFromViewportToScreenSpace);
 
-    FloatSize screenSpaceDelta = viewportDelta;
-    screenSpaceDelta.scale(scaleFromViewportToScreenSpace, scaleFromViewportToScreenSpace);
+    gfx::Vector2dF screenSpaceDelta = viewportDelta;
+    screenSpaceDelta.Scale(scaleFromViewportToScreenSpace);
 
     // First project the scroll start and end points to local layer space to find the scroll delta
     // in layer coordinates.
@@ -1093,7 +1095,7 @@ static FloatSize scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport,
     DCHECK(!startClipped);
     DCHECK(!endClipped);
     if (startClipped || endClipped)
-        return FloatSize();
+        return gfx::Vector2dF();
 
     // localStartPoint and localEndPoint are in content space but we want to move them to layer space for scrolling.
     float widthScale = 1 / layerImpl.contentsScaleX();
@@ -1102,8 +1104,8 @@ static FloatSize scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport,
     localEndPoint = localEndPoint.Scale(widthScale, heightScale);
 
     // Apply the scroll delta.
-    FloatSize previousDelta(layerImpl.scrollDelta());
-    FloatSize unscrolled = layerImpl.scrollBy(cc::FloatSize(localEndPoint - localStartPoint));
+    gfx::Vector2dF previousDelta = layerImpl.scrollDelta();
+    gfx::Vector2dF unscrolled = layerImpl.scrollBy(localEndPoint - localStartPoint);
 
     if (viewport)
         viewport->applyScroll(unscrolled);
@@ -1116,32 +1118,32 @@ static FloatSize scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport,
     gfx::PointF actualScreenSpaceEndPoint = MathUtil::mapPoint(layerImpl.screenSpaceTransform(), actualLocalContentEndPoint, endClipped);
     DCHECK(!endClipped);
     if (endClipped)
-        return FloatSize();
+        return gfx::Vector2dF();
     gfx::PointF actualViewportEndPoint = actualScreenSpaceEndPoint.Scale(1 / scaleFromViewportToScreenSpace);
-    return cc::FloatSize(actualViewportEndPoint - viewportPoint);
+    return actualViewportEndPoint - viewportPoint;
 }
 
-static FloatSize scrollLayerWithLocalDelta(LayerImpl& layerImpl, const FloatSize& localDelta)
+static gfx::Vector2dF scrollLayerWithLocalDelta(LayerImpl& layerImpl, gfx::Vector2dF localDelta)
 {
-    FloatSize previousDelta(layerImpl.scrollDelta());
+    gfx::Vector2dF previousDelta(layerImpl.scrollDelta());
     layerImpl.scrollBy(localDelta);
     return layerImpl.scrollDelta() - previousDelta;
 }
 
-void LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint, const IntSize& scrollDelta)
+void LayerTreeHostImpl::scrollBy(gfx::Point viewportPoint, gfx::Vector2d scrollDelta)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBy");
     if (!m_currentlyScrollingLayerImpl)
         return;
 
-    FloatSize pendingDelta(scrollDelta);
+    gfx::Vector2dF pendingDelta = scrollDelta;
 
     for (LayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl; layerImpl = layerImpl->parent()) {
         if (!layerImpl->scrollable())
             continue;
 
         PinchZoomViewport* viewport = layerImpl == m_rootScrollLayerImpl ? &m_pinchZoomViewport : 0;
-        FloatSize appliedDelta;
+        gfx::Vector2dF appliedDelta;
         if (m_scrollDeltaIsInViewportSpace) {
             float scaleFromViewportToScreenSpace = m_deviceScaleFactor;
             appliedDelta = scrollLayerWithViewportSpaceDelta(viewport, *layerImpl, scaleFromViewportToScreenSpace, viewportPoint, pendingDelta);
@@ -1150,27 +1152,27 @@ void LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint, const IntSize&
 
         // If the layer wasn't able to move, try the next one in the hierarchy.
         float moveThresholdSquared = 0.1f * 0.1f;
-        if (appliedDelta.diagonalLengthSquared() < moveThresholdSquared)
+        if (appliedDelta.LengthSquared() < moveThresholdSquared)
             continue;
 
         // If the applied delta is within 45 degrees of the input delta, bail out to make it easier
         // to scroll just one layer in one direction without affecting any of its parents.
         float angleThreshold = 45;
         if (MathUtil::smallestAngleBetweenVectors(appliedDelta, pendingDelta) < angleThreshold) {
-            pendingDelta = FloatSize();
+            pendingDelta = gfx::Vector2d();
             break;
         }
 
         // Allow further movement only on an axis perpendicular to the direction in which the layer
         // moved.
-        FloatSize perpendicularAxis(-appliedDelta.height(), appliedDelta.width());
+        gfx::Vector2dF perpendicularAxis(-appliedDelta.y(), appliedDelta.x());
         pendingDelta = MathUtil::projectVector(pendingDelta, perpendicularAxis);
 
-        if (flooredIntSize(pendingDelta).isZero())
+        if (gfx::ToFlooredVector2d(pendingDelta).IsZero())
             break;
     }
 
-    if (!scrollDelta.isZero() && flooredIntSize(pendingDelta).isEmpty()) {
+    if (!scrollDelta.IsZero() && gfx::ToFlooredVector2d(pendingDelta).IsZero()) {
         m_client->setNeedsCommitOnImplThread();
         m_client->setNeedsRedrawOnImplThread();
     }
@@ -1190,42 +1192,40 @@ void LayerTreeHostImpl::scrollEnd()
 void LayerTreeHostImpl::pinchGestureBegin()
 {
     m_pinchGestureActive = true;
-    m_previousPinchAnchor = IntPoint();
+    m_previousPinchAnchor = gfx::Point();
 
     if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationController())
         m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureBegin();
 }
 
-void LayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta,
-                                           const IntPoint& anchor)
+void LayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta, gfx::Point anchor)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::pinchGestureUpdate");
 
     if (!m_rootScrollLayerImpl)
         return;
 
-    if (m_previousPinchAnchor == IntPoint::zero())
+    if (m_previousPinchAnchor == gfx::Point())
         m_previousPinchAnchor = anchor;
 
     // Keep the center-of-pinch anchor specified by (x, y) in a stable
     // position over the course of the magnify.
     float pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
-    FloatPoint previousScaleAnchor(m_previousPinchAnchor.x() / pageScaleDelta,
-                                   m_previousPinchAnchor.y() / pageScaleDelta);
+    gfx::PointF previousScaleAnchor = m_previousPinchAnchor.Scale(1 / pageScaleDelta);
     setPageScaleDelta(pageScaleDelta * magnifyDelta);
     pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
-    FloatPoint newScaleAnchor(anchor.x() / pageScaleDelta, anchor.y() / pageScaleDelta);
-    FloatSize move = previousScaleAnchor - newScaleAnchor;
+    gfx::PointF newScaleAnchor = anchor.Scale(1 / pageScaleDelta);
+    gfx::Vector2dF move = previousScaleAnchor - newScaleAnchor;
 
     m_previousPinchAnchor = anchor;
 
     if (Settings::pageScalePinchZoomEnabled()) {
         // Compute the application of the delta with respect to the current page zoom of the page.
-        move.scale(1 / (m_pinchZoomViewport.pageScaleFactor() * m_deviceScaleFactor));
+        move.Scale(1 / (m_pinchZoomViewport.pageScaleFactor() * m_deviceScaleFactor));
     }
 
-    FloatSize scrollOverflow = Settings::pageScalePinchZoomEnabled() ? m_pinchZoomViewport.applyScroll(move) : move;
-    m_rootScrollLayerImpl->scrollBy(roundedIntSize(scrollOverflow));
+    gfx::Vector2dF scrollOverflow = Settings::pageScalePinchZoomEnabled() ? m_pinchZoomViewport.applyScroll(move) : move;
+    m_rootScrollLayerImpl->scrollBy(scrollOverflow);
 
     if (m_rootScrollLayerImpl->scrollbarAnimationController())
         m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUpdate();
@@ -1247,9 +1247,9 @@ void LayerTreeHostImpl::pinchGestureEnd()
 void LayerTreeHostImpl::computeDoubleTapZoomDeltas(ScrollAndScaleSet* scrollInfo)
 {
     float pageScale = m_pageScaleAnimation->finalPageScale();
-    IntSize scrollOffset = m_pageScaleAnimation->finalScrollOffset();
-    scrollOffset.scale(m_pinchZoomViewport.pageScaleFactor() / pageScale);
-    makeScrollAndScaleSet(scrollInfo, scrollOffset, pageScale);
+    gfx::Vector2dF scrollOffset = m_pageScaleAnimation->finalScrollOffset();
+    scrollOffset.Scale(m_pinchZoomViewport.pageScaleFactor() / pageScale);
+    makeScrollAndScaleSet(scrollInfo, gfx::ToRoundedVector2d(scrollOffset), pageScale);
 }
 
 void LayerTreeHostImpl::computePinchZoomDeltas(ScrollAndScaleSet* scrollInfo)
@@ -1266,31 +1266,32 @@ void LayerTreeHostImpl::computePinchZoomDeltas(ScrollAndScaleSet* scrollInfo)
 
     // Compute where the scroll offset/page scale would be if fully pinch-zoomed
     // out from the anchor point.
-    IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
-    scrollBegin.scale(m_pinchZoomViewport.pageScaleDelta());
+    gfx::Vector2dF scrollBegin = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();
+    scrollBegin.Scale(m_pinchZoomViewport.pageScaleDelta());
     float scaleBegin = m_pinchZoomViewport.totalPageScaleFactor();
     float pageScaleDeltaToSend = m_pinchZoomViewport.minPageScaleFactor() / m_pinchZoomViewport.pageScaleFactor();
     gfx::SizeF scaledContentsSize = contentSize().Scale(pageScaleDeltaToSend);
 
-    FloatSize anchor = toSize(m_previousPinchAnchor);
-    FloatSize scrollEnd = scrollBegin + anchor;
-    scrollEnd.scale(m_pinchZoomViewport.minPageScaleFactor() / scaleBegin);
-    scrollEnd -= anchor;
-    scrollEnd = scrollEnd.shrunkTo(roundedIntSize(cc::FloatSize(scaledContentsSize) - cc::IntSize(m_deviceViewportSize))).expandedTo(FloatSize(0, 0));
-    scrollEnd.scale(1 / pageScaleDeltaToSend);
-    scrollEnd.scale(m_deviceScaleFactor);
+    gfx::Vector2d anchorOffset = m_previousPinchAnchor.OffsetFromOrigin();
+    gfx::Vector2dF scrollEnd = scrollBegin + anchorOffset;
+    scrollEnd.Scale(m_pinchZoomViewport.minPageScaleFactor() / scaleBegin);
+    scrollEnd -= anchorOffset;
+    scrollEnd = ClampFromAbove(scrollEnd, BottomRight(gfx::RectF(scaledContentsSize)) - BottomRight(gfx::Rect(m_deviceViewportSize)));
+    scrollEnd = ClampFromBelow(scrollEnd, gfx::Vector2d());
+    scrollEnd.Scale(1 / pageScaleDeltaToSend);
+    scrollEnd.Scale(m_deviceScaleFactor);
 
-    makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_pinchZoomViewport.minPageScaleFactor());
+    makeScrollAndScaleSet(scrollInfo, gfx::ToRoundedVector2d(scrollEnd), m_pinchZoomViewport.minPageScaleFactor());
 }
 
-void LayerTreeHostImpl::makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale)
+void LayerTreeHostImpl::makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, gfx::Vector2d scrollOffset, float pageScale)
 {
     if (!m_rootScrollLayerImpl)
         return;
 
     LayerTreeHostCommon::ScrollUpdateInfo scroll;
     scroll.layerId = m_rootScrollLayerImpl->id();
-    scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosition());
+    scroll.scrollDelta = scrollOffset - m_rootScrollLayerImpl->scrollOffset();
     scrollInfo->scrolls.push_back(scroll);
     m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);
     scrollInfo->pageScaleDelta = pageScale / m_pinchZoomViewport.pageScaleFactor();
@@ -1302,8 +1303,8 @@ static void collectScrollDeltas(ScrollAndScaleSet* scrollInfo, LayerImpl* layerI
     if (!layerImpl)
         return;
 
-    if (!layerImpl->scrollDelta().isZero()) {
-        IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta());
+    if (!layerImpl->scrollDelta().IsZero()) {
+        gfx::Vector2d scrollDelta = gfx::ToFlooredVector2d(layerImpl->scrollDelta());
         LayerTreeHostCommon::ScrollUpdateInfo scroll;
         scroll.layerId = layerImpl->id();
         scroll.scrollDelta = scrollDelta;
@@ -1360,11 +1361,11 @@ void LayerTreeHostImpl::animatePageScale(base::TimeTicks time)
         return;
 
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
-    IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
+    gfx::Vector2dF scrollTotal = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();
 
     setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_pinchZoomViewport.pageScaleFactor());
-    IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);
-    nextScroll.scale(1 / m_pinchZoomViewport.pageScaleDelta());
+    gfx::Vector2dF nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);
+    nextScroll.Scale(1 / m_pinchZoomViewport.pageScaleDelta());
     m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal);
     m_client->setNeedsRedrawOnImplThread();
 
diff --git a/cc/layer_tree_host_impl.h b/cc/layer_tree_host_impl.h
index bfbef47..9af0553 100644
--- a/cc/layer_tree_host_impl.h
+++ b/cc/layer_tree_host_impl.h
@@ -5,7 +5,6 @@
 #ifndef CC_LAYER_TREE_HOST_IMPL_H_
 #define CC_LAYER_TREE_HOST_IMPL_H_
 
-#include "FloatPoint.h"
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
@@ -78,14 +77,14 @@ public:
 
     // Returns the bounds and offset of the scaled and translated viewport to use for pinch-zoom.
     gfx::RectF bounds() const;
-    const FloatPoint& scrollDelta() const { return m_pinchViewportScrollDelta; }
+    const gfx::Vector2dF& scrollDelta() const { return m_pinchViewportScrollDelta; }
 
     void setLayoutViewportSize(const gfx::SizeF& size) { m_layoutViewportSize = size; }
 
     // Apply the scroll offset in layout space to the offset of the pinch-zoom viewport. The viewport cannot be
     // scrolled outside of the layout viewport bounds. Returns the component of the scroll that is un-applied due to
     // this constraint.
-    FloatSize applyScroll(const gfx::Vector2dF&);
+    gfx::Vector2dF applyScroll(const gfx::Vector2dF&);
 
     WebKit::WebTransformationMatrix implTransform() const;
 
@@ -96,7 +95,7 @@ private:
     float m_maxPageScaleFactor;
     float m_minPageScaleFactor;
 
-    FloatPoint m_pinchViewportScrollDelta;
+    gfx::Vector2dF m_pinchViewportScrollDelta;
     gfx::SizeF m_layoutViewportSize;
 };
 
@@ -111,13 +110,13 @@ public:
     virtual ~LayerTreeHostImpl();
 
     // InputHandlerClient implementation
-    virtual InputHandlerClient::ScrollStatus scrollBegin(const gfx::Point&, InputHandlerClient::ScrollInputType) OVERRIDE;
-    virtual void scrollBy(const gfx::Point&, const IntSize&) OVERRIDE;
+    virtual InputHandlerClient::ScrollStatus scrollBegin(gfx::Point, InputHandlerClient::ScrollInputType) OVERRIDE;
+    virtual void scrollBy(gfx::Point, gfx::Vector2d) OVERRIDE;
     virtual void scrollEnd() OVERRIDE;
     virtual void pinchGestureBegin() OVERRIDE;
-    virtual void pinchGestureUpdate(float, const IntPoint&) OVERRIDE;
+    virtual void pinchGestureUpdate(float, gfx::Point) OVERRIDE;
     virtual void pinchGestureEnd() OVERRIDE;
-    virtual void startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration) OVERRIDE;
+    virtual void startPageScaleAnimation(gfx::Vector2d targetOffset, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration) OVERRIDE;
     virtual void scheduleAnimation() OVERRIDE;
 
     struct CC_EXPORT FrameData : public RenderPassSink {
@@ -213,7 +212,7 @@ public:
     scoped_ptr<ScrollAndScaleSet> processScrollDeltas();
     WebKit::WebTransformationMatrix implTransform() const;
 
-    void startPageScaleAnimation(const IntSize& tragetPosition, bool useAnchor, float scale, base::TimeDelta duration);
+    void startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration);
 
     SkColor backgroundColor() const { return m_backgroundColor; }
     void setBackgroundColor(SkColor color) { m_backgroundColor = color; }
@@ -285,10 +284,10 @@ protected:
 private:
     void computeDoubleTapZoomDeltas(ScrollAndScaleSet* scrollInfo);
     void computePinchZoomDeltas(ScrollAndScaleSet* scrollInfo);
-    void makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale);
+    void makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, gfx::Vector2d scrollOffset, float pageScale);
 
     void setPageScaleDelta(float);
-    void updateMaxScrollPosition();
+    void updateMaxScrollOffset();
     void trackDamageForAllSurfaces(LayerImpl* rootDrawLayer, const LayerList& renderSurfaceLayerList);
 
     // Returns false if the frame should not be displayed. This function should
@@ -331,7 +330,7 @@ private:
     // If this is true, it is necessary to traverse the layer tree ticking the animators.
     bool m_needsAnimateLayers;
     bool m_pinchGestureActive;
-    IntPoint m_previousPinchAnchor;
+    gfx::Point m_previousPinchAnchor;
 
     scoped_ptr<PageScaleAnimation> m_pageScaleAnimation;
 
diff --git a/cc/layer_tree_host_impl_unittest.cc b/cc/layer_tree_host_impl_unittest.cc
index 5126b46..ddd393d 100644
--- a/cc/layer_tree_host_impl_unittest.cc
+++ b/cc/layer_tree_host_impl_unittest.cc
@@ -10,6 +10,7 @@
 #include "base/command_line.h"
 #include "base/hash_tables.h"
 #include "cc/delegated_renderer_layer_impl.h"
+#include "cc/geometry.h"
 #include "cc/gl_renderer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/io_surface_layer_impl.h"
@@ -40,6 +41,7 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/size_conversions.h"
+#include "ui/gfx/vector2d_conversions.h"
 #include <public/WebVideoFrame.h>
 #include <public/WebVideoFrameProvider.h>
 
@@ -122,20 +124,19 @@ public:
 
     static void expectClearedScrollDeltasRecursive(LayerImpl* layer)
     {
-        ASSERT_EQ(layer->scrollDelta(), IntSize());
+        ASSERT_EQ(layer->scrollDelta(), gfx::Vector2d());
         for (size_t i = 0; i < layer->children().size(); ++i)
             expectClearedScrollDeltasRecursive(layer->children()[i]);
     }
 
-    static void expectContains(const ScrollAndScaleSet& scrollInfo, int id, const IntSize& scrollDelta)
+    static void expectContains(const ScrollAndScaleSet& scrollInfo, int id, const gfx::Vector2d& scrollDelta)
     {
         int timesEncountered = 0;
 
         for (size_t i = 0; i < scrollInfo.scrolls.size(); ++i) {
             if (scrollInfo.scrolls[i].layerId != id)
                 continue;
-            EXPECT_EQ(scrollDelta.width(), scrollInfo.scrolls[i].scrollDelta.width());
-            EXPECT_EQ(scrollDelta.height(), scrollInfo.scrolls[i].scrollDelta.height());
+            EXPECT_VECTOR_EQ(scrollDelta, scrollInfo.scrolls[i].scrollDelta);
             timesEncountered++;
         }
 
@@ -146,8 +147,8 @@ public:
     {
         scoped_ptr<LayerImpl> root = LayerImpl::create(1);
         root->setScrollable(true);
-        root->setScrollPosition(IntPoint(0, 0));
-        root->setMaxScrollPosition(cc::IntSize(contentSize));
+        root->setScrollOffset(gfx::Vector2d(0, 0));
+        root->setMaxScrollOffset(gfx::Vector2d(contentSize.width(), contentSize.height()));
         root->setBounds(contentSize);
         root->setContentBounds(contentSize);
         root->setPosition(gfx::PointF(0, 0));
@@ -170,7 +171,7 @@ public:
         layer->setDrawsContent(true);
         layer->setBounds(size);
         layer->setContentBounds(size);
-        layer->setMaxScrollPosition(IntSize(size.width() * 2, size.height() * 2));
+        layer->setMaxScrollOffset(gfx::Vector2d(size.width() * 2, size.height() * 2));
         return layer.Pass();
     }
 
@@ -299,13 +300,13 @@ TEST_P(LayerTreeHostImplTest, scrollDeltaTreeButNoChanges)
 
 TEST_P(LayerTreeHostImplTest, scrollDeltaRepeatedScrolls)
 {
-    IntPoint scrollPosition(20, 30);
-    IntSize scrollDelta(11, -15);
+    gfx::Vector2d scrollOffset(20, 30);
+    gfx::Vector2d scrollDelta(11, -15);
     {
         scoped_ptr<LayerImpl> root = LayerImpl::create(1);
-        root->setScrollPosition(scrollPosition);
+        root->setScrollOffset(scrollOffset);
         root->setScrollable(true);
-        root->setMaxScrollPosition(IntSize(100, 100));
+        root->setMaxScrollOffset(gfx::Vector2d(100, 100));
         root->scrollBy(scrollDelta);
         m_hostImpl->setRootLayer(root.Pass());
     }
@@ -315,17 +316,17 @@ TEST_P(LayerTreeHostImplTest, scrollDeltaRepeatedScrolls)
 
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
-    EXPECT_EQ(root->sentScrollDelta(), scrollDelta);
+    EXPECT_VECTOR_EQ(root->sentScrollDelta(), scrollDelta);
     expectContains(*scrollInfo, root->id(), scrollDelta);
 
-    IntSize scrollDelta2(-5, 27);
+    gfx::Vector2d scrollDelta2(-5, 27);
     root->scrollBy(scrollDelta2);
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
-    EXPECT_EQ(root->sentScrollDelta(), scrollDelta + scrollDelta2);
+    EXPECT_VECTOR_EQ(root->sentScrollDelta(), scrollDelta + scrollDelta2);
     expectContains(*scrollInfo, root->id(), scrollDelta + scrollDelta2);
 
-    root->scrollBy(IntSize());
+    root->scrollBy(gfx::Vector2d());
     scrollInfo = m_hostImpl->processScrollDeltas();
     EXPECT_EQ(root->sentScrollDelta(), scrollDelta + scrollDelta2);
 }
@@ -337,7 +338,7 @@ TEST_P(LayerTreeHostImplTest, scrollRootCallsCommitAndRedraw)
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), IntSize(0, 10));
+    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
@@ -379,7 +380,7 @@ TEST_P(LayerTreeHostImplTest, replaceTreeWhileScrolling)
     setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // We should still be scrolling, because the scrolled layer also exists in the new tree.
-    IntSize scrollDelta(0, 10);
+    gfx::Vector2d scrollDelta(0, 10);
     m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
@@ -442,10 +443,10 @@ TEST_P(LayerTreeHostImplTest, nonFastScrollableRegionBasic)
 
     // All scroll types outside this region should succeed.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(75, 75), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), IntSize(0, 10));
+    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(75, 75), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), IntSize(0, 10));
+    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
 }
 
@@ -461,14 +462,14 @@ TEST_P(LayerTreeHostImplTest, nonFastScrollableRegionWithOffset)
 
     // This point would fall into the non-fast scrollable region except that we've moved the layer down by 25 pixels.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(40, 10), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), IntSize(0, 1));
+    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 1));
     m_hostImpl->scrollEnd();
 
     // This point is still inside the non-fast region.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(10, 10), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
 }
 
-TEST_P(LayerTreeHostImplTest, maxScrollPositionChangedByDeviceScaleFactor)
+TEST_P(LayerTreeHostImplTest, maxScrollOffsetChangedByDeviceScaleFactor)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
 
@@ -477,12 +478,12 @@ TEST_P(LayerTreeHostImplTest, maxScrollPositionChangedByDeviceScaleFactor)
     gfx::Size deviceViewport(gfx::ToFlooredSize(layoutViewport.Scale(deviceScaleFactor)));
     m_hostImpl->setViewportSize(layoutViewport, deviceViewport);
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
-    EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), IntSize(25, 25));
+    EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollOffset(), gfx::Vector2d(25, 25));
 
     deviceScaleFactor = 1;
     m_hostImpl->setViewportSize(layoutViewport, layoutViewport);
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
-    EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), IntSize(75, 75));
+    EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollOffset(), gfx::Vector2d(75, 75));
 }
 
 TEST_P(LayerTreeHostImplTest, implPinchZoom)
@@ -505,11 +506,11 @@ TEST_P(LayerTreeHostImplTest, implPinchZoom)
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
-        scrollLayer->setScrollDelta(IntSize());
+        scrollLayer->setScrollDelta(gfx::Vector2d());
 
         float pageScaleDelta = 2;
         m_hostImpl->pinchGestureBegin();
-        m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(50, 50));
+        m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(50, 50));
         m_hostImpl->pinchGestureEnd();
         EXPECT_TRUE(m_didRequestRedraw);
         EXPECT_TRUE(m_didRequestCommit);
@@ -517,7 +518,7 @@ TEST_P(LayerTreeHostImplTest, implPinchZoom)
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
 
-        EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), IntSize(50, 50));
+        EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollOffset(), gfx::Vector2d(50, 50));
     }
 
     // Scrolling after a pinch gesture should always be in local space.  The scroll deltas do not
@@ -525,14 +526,14 @@ TEST_P(LayerTreeHostImplTest, implPinchZoom)
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
-        scrollLayer->setScrollDelta(IntSize());
+        scrollLayer->setScrollDelta(gfx::Vector2d());
 
         float pageScaleDelta = 2;
         m_hostImpl->pinchGestureBegin();
-        m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(0, 0));
+        m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(0, 0));
         m_hostImpl->pinchGestureEnd();
 
-        IntSize scrollDelta(0, 10);
+        gfx::Vector2d scrollDelta(0, 10);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
         m_hostImpl->scrollEnd();
@@ -559,11 +560,11 @@ TEST_P(LayerTreeHostImplTest, pinchGesture)
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
-        scrollLayer->setScrollDelta(IntSize());
+        scrollLayer->setScrollDelta(gfx::Vector2d());
 
         float pageScaleDelta = 2;
         m_hostImpl->pinchGestureBegin();
-        m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(50, 50));
+        m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(50, 50));
         m_hostImpl->pinchGestureEnd();
         EXPECT_TRUE(m_didRequestRedraw);
         EXPECT_TRUE(m_didRequestCommit);
@@ -576,11 +577,11 @@ TEST_P(LayerTreeHostImplTest, pinchGesture)
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
-        scrollLayer->setScrollDelta(IntSize());
+        scrollLayer->setScrollDelta(gfx::Vector2d());
         float pageScaleDelta = 10;
 
         m_hostImpl->pinchGestureBegin();
-        m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(50, 50));
+        m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(50, 50));
         m_hostImpl->pinchGestureEnd();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
@@ -591,12 +592,12 @@ TEST_P(LayerTreeHostImplTest, pinchGesture)
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
-        scrollLayer->setScrollDelta(IntSize());
-        scrollLayer->setScrollPosition(IntPoint(50, 50));
+        scrollLayer->setScrollDelta(gfx::Vector2d());
+        scrollLayer->setScrollOffset(gfx::Vector2d(50, 50));
 
         float pageScaleDelta = 0.1f;
         m_hostImpl->pinchGestureBegin();
-        m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(0, 0));
+        m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(0, 0));
         m_hostImpl->pinchGestureEnd();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
@@ -604,7 +605,7 @@ TEST_P(LayerTreeHostImplTest, pinchGesture)
 
         if (!Settings::pageScalePinchZoomEnabled()) {
             // Pushed to (0,0) via clamping against contents layer size.
-            expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50));
+            expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(-50, -50));
         } else {
             EXPECT_TRUE(scrollInfo->scrolls.empty());
         }
@@ -614,18 +615,18 @@ TEST_P(LayerTreeHostImplTest, pinchGesture)
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
-        scrollLayer->setScrollDelta(IntSize());
-        scrollLayer->setScrollPosition(IntPoint(20, 20));
+        scrollLayer->setScrollDelta(gfx::Vector2d());
+        scrollLayer->setScrollOffset(gfx::Vector2d(20, 20));
 
         float pageScaleDelta = 1;
         m_hostImpl->pinchGestureBegin();
-        m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(10, 10));
-        m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(20, 20));
+        m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(10, 10));
+        m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(20, 20));
         m_hostImpl->pinchGestureEnd();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
-        expectContains(*scrollInfo, scrollLayer->id(), IntSize(-10, -10));
+        expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(-10, -10));
     }
 }
 
@@ -650,9 +651,9 @@ TEST_P(LayerTreeHostImplTest, pageScaleAnimation)
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
-        scrollLayer->setScrollPosition(IntPoint(50, 50));
+        scrollLayer->setScrollOffset(gfx::Vector2d(50, 50));
 
-        m_hostImpl->startPageScaleAnimation(IntSize(0, 0), false, 2, startTime, duration);
+        m_hostImpl->startPageScaleAnimation(gfx::Vector2d(0, 0), false, 2, startTime, duration);
         m_hostImpl->animate(halfwayThroughAnimation, base::Time());
         EXPECT_TRUE(m_didRequestRedraw);
         m_hostImpl->animate(endTime, base::Time());
@@ -660,16 +661,16 @@ TEST_P(LayerTreeHostImplTest, pageScaleAnimation)
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, 2);
-        expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50));
+        expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(-50, -50));
     }
 
     // Anchor zoom-out
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
-        scrollLayer->setScrollPosition(IntPoint(50, 50));
+        scrollLayer->setScrollOffset(gfx::Vector2d(50, 50));
 
-        m_hostImpl->startPageScaleAnimation(IntSize(25, 25), true, minPageScale, startTime, duration);
+        m_hostImpl->startPageScaleAnimation(gfx::Vector2d(25, 25), true, minPageScale, startTime, duration);
         m_hostImpl->animate(endTime, base::Time());
         EXPECT_TRUE(m_didRequestRedraw);
         EXPECT_TRUE(m_didRequestCommit);
@@ -677,7 +678,7 @@ TEST_P(LayerTreeHostImplTest, pageScaleAnimation)
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
         // Pushed to (0,0) via clamping against contents layer size.
-        expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50));
+        expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(-50, -50));
     }
 }
 
@@ -699,7 +700,7 @@ TEST_P(LayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhilePinchZooming)
         const float zoomInDelta = 2;
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         m_hostImpl->pinchGestureBegin();
-        m_hostImpl->pinchGestureUpdate(zoomInDelta, IntPoint(50, 50));
+        m_hostImpl->pinchGestureUpdate(zoomInDelta, gfx::Point(50, 50));
 
         // Because we are pinch zooming in, we shouldn't get any scroll or page
         // scale deltas.
@@ -712,7 +713,7 @@ TEST_P(LayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhilePinchZooming)
         scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, zoomInDelta);
         if (!Settings::pageScalePinchZoomEnabled()) {
-            expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
+            expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(25, 25));
         } else {
             EXPECT_TRUE(scrollInfo->scrolls.empty());
         }
@@ -724,14 +725,14 @@ TEST_P(LayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhilePinchZooming)
         const float zoomOutDelta = 0.75;
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         m_hostImpl->pinchGestureBegin();
-        m_hostImpl->pinchGestureUpdate(zoomOutDelta, IntPoint(50, 50));
+        m_hostImpl->pinchGestureUpdate(zoomOutDelta, gfx::Point(50, 50));
 
         // Since we are pinch zooming out, we should get an update to zoom all
         // the way out to the minimum page scale.
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         if (!Settings::pageScalePinchZoomEnabled()) {
             EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
-            expectContains(*scrollInfo, scrollLayer->id(), IntSize(0, 0));
+            expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(0, 0));
         } else {
             EXPECT_EQ(scrollInfo->pageScaleDelta, 1);
             EXPECT_TRUE(scrollInfo->scrolls.empty());
@@ -742,10 +743,10 @@ TEST_P(LayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhilePinchZooming)
         scrollInfo = m_hostImpl->processScrollDeltas();
         if (Settings::pageScalePinchZoomEnabled()) {
             EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
-            expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
+            expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(25, 25));
         } else {
             EXPECT_EQ(scrollInfo->pageScaleDelta, zoomOutDelta);
-            expectContains(*scrollInfo, scrollLayer->id(), IntSize(8, 8));
+            expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(8, 8));
         }
     }
 }
@@ -768,7 +769,7 @@ TEST_P(LayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhileAnimatingPage
     // Start a page scale animation.
     const float pageScaleDelta = 2;
     m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
-    m_hostImpl->startPageScaleAnimation(IntSize(50, 50), false, pageScaleDelta, startTime, duration);
+    m_hostImpl->startPageScaleAnimation(gfx::Vector2d(50, 50), false, pageScaleDelta, startTime, duration);
 
     // We should immediately get the final zoom and scroll values for the
     // animation.
@@ -777,14 +778,14 @@ TEST_P(LayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhileAnimatingPage
 
     if (!Settings::pageScalePinchZoomEnabled()) {
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
-        expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
+        expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(25, 25));
     } else {
         EXPECT_EQ(scrollInfo->pageScaleDelta, 1);
         EXPECT_TRUE(scrollInfo->scrolls.empty());
     }
 
     // Scrolling during the animation is ignored.
-    const IntSize scrollDelta(0, 10);
+    const gfx::Vector2d scrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(25, 25), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
@@ -794,7 +795,7 @@ TEST_P(LayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhileAnimatingPage
     m_hostImpl->animate(endTime, base::Time());
     scrollInfo = m_hostImpl->processScrollDeltas();
     EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
-    expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
+    expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(25, 25));
 }
 
 class DidDrawCheckLayer : public TiledLayerImpl {
@@ -1049,7 +1050,7 @@ TEST_P(LayerTreeHostImplTest, scrollNonCompositedRoot)
 
     scoped_ptr<LayerImpl> scrollLayer = LayerImpl::create(2);
     scrollLayer->setScrollable(true);
-    scrollLayer->setMaxScrollPosition(cc::IntSize(surfaceSize));
+    scrollLayer->setMaxScrollOffset(gfx::Vector2d(surfaceSize.width(), surfaceSize.height()));
     scrollLayer->setBounds(surfaceSize);
     scrollLayer->setContentBounds(surfaceSize);
     scrollLayer->setPosition(gfx::PointF(0, 0));
@@ -1061,7 +1062,7 @@ TEST_P(LayerTreeHostImplTest, scrollNonCompositedRoot)
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), IntSize(0, 10));
+    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
@@ -1079,7 +1080,7 @@ TEST_P(LayerTreeHostImplTest, scrollChildCallsCommitAndRedraw)
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), IntSize(0, 10));
+    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
@@ -1150,9 +1151,9 @@ TEST_P(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnMainThread)
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
-    IntSize scrollDelta(0, 10);
-    IntSize expectedScrollDelta(scrollDelta);
-    IntSize expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollPosition());
+    gfx::Vector2d scrollDelta(0, 10);
+    gfx::Vector2d expectedScrollDelta(scrollDelta);
+    gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
@@ -1162,13 +1163,13 @@ TEST_P(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnMainThread)
 
     if (!Settings::pageScalePinchZoomEnabled()) {
         // The scale should apply to the scroll delta.
-        expectedScrollDelta.scale(pageScale);
+        expectedScrollDelta = gfx::ToFlooredVector2d(cc::ScaleVector2d(expectedScrollDelta, pageScale));
     }
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
 
     // The scroll range should also have been updated.
-    EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), expectedMaxScroll);
+    EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollOffset(), expectedMaxScroll);
 
     // The page scale delta remains constant because the impl thread did not scale.
     EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), WebTransformationMatrix());
@@ -1184,16 +1185,16 @@ TEST_P(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnImplThread)
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
-    IntSize scrollDelta(0, 10);
-    IntSize expectedScrollDelta(scrollDelta);
-    IntSize expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollPosition());
+    gfx::Vector2d scrollDelta(0, 10);
+    gfx::Vector2d expectedScrollDelta(scrollDelta);
+    gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
-    m_hostImpl->pinchGestureUpdate(pageScale, IntPoint());
+    m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     m_hostImpl->updateRootScrollLayerImplTransform();
 
@@ -1202,7 +1203,7 @@ TEST_P(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnImplThread)
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
 
     // The scroll range should also have been updated.
-    EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), expectedMaxScroll);
+    EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollOffset(), expectedMaxScroll);
 
     // The page scale delta should match the new scale on the impl side.
     WebTransformationMatrix expectedScale;
@@ -1231,7 +1232,7 @@ TEST_P(LayerTreeHostImplTest, pageScaleDeltaAppliedToRootScrollLayerOnly)
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
-    m_hostImpl->pinchGestureUpdate(newPageScale, IntPoint());
+    m_hostImpl->pinchGestureUpdate(newPageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     m_hostImpl->updateRootScrollLayerImplTransform();
 
@@ -1271,9 +1272,9 @@ TEST_P(LayerTreeHostImplTest, scrollChildAndChangePageScaleOnMainThread)
 
     LayerImpl* child = m_hostImpl->rootLayer()->children()[0];
 
-    IntSize scrollDelta(0, 10);
-    IntSize expectedScrollDelta(scrollDelta);
-    IntSize expectedMaxScroll(child->maxScrollPosition());
+    gfx::Vector2d scrollDelta(0, 10);
+    gfx::Vector2d expectedScrollDelta(scrollDelta);
+    gfx::Vector2d expectedMaxScroll(child->maxScrollOffset());
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
@@ -1285,13 +1286,13 @@ TEST_P(LayerTreeHostImplTest, scrollChildAndChangePageScaleOnMainThread)
 
     if (!Settings::pageScalePinchZoomEnabled()) {
         // The scale should apply to the scroll delta.
-        expectedScrollDelta.scale(pageScale);
+        expectedScrollDelta = gfx::ToFlooredVector2d(cc::ScaleVector2d(expectedScrollDelta, pageScale));
     }
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), scrollLayerId, expectedScrollDelta);
 
     // The scroll range should not have changed.
-    EXPECT_EQ(child->maxScrollPosition(), expectedMaxScroll);
+    EXPECT_EQ(child->maxScrollOffset(), expectedMaxScroll);
 
     // The page scale delta remains constant because the impl thread did not scale.
     WebTransformationMatrix identityTransform;
@@ -1307,10 +1308,10 @@ TEST_P(LayerTreeHostImplTest, scrollChildBeyondLimit)
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
 
     scoped_ptr<LayerImpl> grandChild = createScrollableLayer(3, surfaceSize);
-    grandChild->setScrollPosition(IntPoint(0, 5));
+    grandChild->setScrollOffset(gfx::Vector2d(0, 5));
 
     scoped_ptr<LayerImpl> child = createScrollableLayer(2, surfaceSize);
-    child->setScrollPosition(IntPoint(3, 0));
+    child->setScrollOffset(gfx::Vector2d(3, 0));
     child->addChild(grandChild.Pass());
 
     root->addChild(child.Pass());
@@ -1318,7 +1319,7 @@ TEST_P(LayerTreeHostImplTest, scrollChildBeyondLimit)
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
     {
-        IntSize scrollDelta(-8, -7);
+        gfx::Vector2d scrollDelta(-8, -7);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
         m_hostImpl->scrollEnd();
@@ -1328,10 +1329,10 @@ TEST_P(LayerTreeHostImplTest, scrollChildBeyondLimit)
         // The grand child should have scrolled up to its limit.
         LayerImpl* child = m_hostImpl->rootLayer()->children()[0];
         LayerImpl* grandChild = child->children()[0];
-        expectContains(*scrollInfo.get(), grandChild->id(), IntSize(0, -5));
+        expectContains(*scrollInfo.get(), grandChild->id(), gfx::Vector2d(0, -5));
 
         // The child should have only scrolled on the other axis.
-        expectContains(*scrollInfo.get(), child->id(), IntSize(-3, 0));
+        expectContains(*scrollInfo.get(), child->id(), gfx::Vector2d(-3, 0));
     }
 }
 
@@ -1350,7 +1351,7 @@ TEST_P(LayerTreeHostImplTest, scrollEventBubbling)
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
     {
-        IntSize scrollDelta(0, 4);
+        gfx::Vector2d scrollDelta(0, 4);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
         m_hostImpl->scrollEnd();
@@ -1392,18 +1393,18 @@ TEST_P(LayerTreeHostImplTest, scrollAxisAlignedRotatedLayer)
     initializeRendererAndDrawFrame();
 
     // Scroll to the right in screen coordinates with a gesture.
-    IntSize gestureScrollDelta(10, 0);
+    gfx::Vector2d gestureScrollDelta(10, 0);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), gestureScrollDelta);
     m_hostImpl->scrollEnd();
 
     // The layer should have scrolled down in its local coordinates.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
-    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), IntSize(0, gestureScrollDelta.width()));
+    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), gfx::Vector2d(0, gestureScrollDelta.x()));
 
     // Reset and scroll down with the wheel.
-    m_hostImpl->rootLayer()->setScrollDelta(FloatSize());
-    IntSize wheelScrollDelta(0, 10);
+    m_hostImpl->rootLayer()->setScrollDelta(gfx::Vector2dF());
+    gfx::Vector2d wheelScrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), wheelScrollDelta);
     m_hostImpl->scrollEnd();
@@ -1428,7 +1429,7 @@ TEST_P(LayerTreeHostImplTest, scrollNonAxisAlignedRotatedLayer)
     child->setTransform(rotateTransform);
 
     // Only allow vertical scrolling.
-    child->setMaxScrollPosition(IntSize(0, child->contentBounds().height()));
+    child->setMaxScrollOffset(gfx::Vector2d(0, child->contentBounds().height()));
     m_hostImpl->rootLayer()->addChild(child.Pass());
 
     gfx::Size surfaceSize(50, 50);
@@ -1437,14 +1438,14 @@ TEST_P(LayerTreeHostImplTest, scrollNonAxisAlignedRotatedLayer)
 
     {
         // Scroll down in screen coordinates with a gesture.
-        IntSize gestureScrollDelta(0, 10);
+        gfx::Vector2d gestureScrollDelta(0, 10);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(gfx::Point(), gestureScrollDelta);
         m_hostImpl->scrollEnd();
 
         // The child layer should have scrolled down in its local coordinates an amount proportional to
         // the angle between it and the input scroll delta.
-        IntSize expectedScrollDelta(0, gestureScrollDelta.height() * cosf(deg2rad(childLayerAngle)));
+        gfx::Vector2d expectedScrollDelta(0, gestureScrollDelta.y() * cosf(deg2rad(childLayerAngle)));
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         expectContains(*scrollInfo.get(), childLayerId, expectedScrollDelta);
 
@@ -1455,21 +1456,21 @@ TEST_P(LayerTreeHostImplTest, scrollNonAxisAlignedRotatedLayer)
 
     {
         // Now reset and scroll the same amount horizontally.
-        m_hostImpl->rootLayer()->children()[1]->setScrollDelta(FloatSize());
-        IntSize gestureScrollDelta(10, 0);
+        m_hostImpl->rootLayer()->children()[1]->setScrollDelta(gfx::Vector2dF());
+        gfx::Vector2d gestureScrollDelta(10, 0);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(gfx::Point(), gestureScrollDelta);
         m_hostImpl->scrollEnd();
 
         // The child layer should have scrolled down in its local coordinates an amount proportional to
         // the angle between it and the input scroll delta.
-        IntSize expectedScrollDelta(0, -gestureScrollDelta.width() * sinf(deg2rad(childLayerAngle)));
+        gfx::Vector2d expectedScrollDelta(0, -gestureScrollDelta.x() * sinf(deg2rad(childLayerAngle)));
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         expectContains(*scrollInfo.get(), childLayerId, expectedScrollDelta);
 
         // The root layer should have scrolled more, since the input scroll delta was mostly
         // orthogonal to the child layer's vertical scroll axis.
-        IntSize expectedRootScrollDelta(gestureScrollDelta.width() * pow(cosf(deg2rad(childLayerAngle)), 2), 0);
+        gfx::Vector2d expectedRootScrollDelta(gestureScrollDelta.x() * pow(cosf(deg2rad(childLayerAngle)), 2), 0);
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedRootScrollDelta);
     }
 }
@@ -1489,18 +1490,18 @@ TEST_P(LayerTreeHostImplTest, scrollScaledLayer)
     initializeRendererAndDrawFrame();
 
     // Scroll down in screen coordinates with a gesture.
-    IntSize scrollDelta(0, 10);
+    gfx::Vector2d scrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // The layer should have scrolled down in its local coordinates, but half he amount.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
-    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), IntSize(0, scrollDelta.height() / scale));
+    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), gfx::Vector2d(0, scrollDelta.y() / scale));
 
     // Reset and scroll down with the wheel.
-    m_hostImpl->rootLayer()->setScrollDelta(FloatSize());
-    IntSize wheelScrollDelta(0, 10);
+    m_hostImpl->rootLayer()->setScrollDelta(gfx::Vector2dF());
+    gfx::Vector2d wheelScrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), wheelScrollDelta);
     m_hostImpl->scrollEnd();
diff --git a/cc/layer_tree_host_unittest.cc b/cc/layer_tree_host_unittest.cc
index bbb2b22..1b414a1 100644
--- a/cc/layer_tree_host_unittest.cc
+++ b/cc/layer_tree_host_unittest.cc
@@ -24,6 +24,7 @@
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/size_conversions.h"
+#include "ui/gfx/vector2d_conversions.h"
 #include <public/WebLayerScrollClient.h>
 #include <public/WebSize.h>
 
@@ -834,8 +835,8 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestAnimationFinishedEvents)
 class LayerTreeHostTestScrollSimple : public LayerTreeHostTest {
 public:
     LayerTreeHostTestScrollSimple()
-        : m_initialScroll(IntPoint(10, 20))
-        , m_secondScroll(IntPoint(40, 5))
+        : m_initialScroll(10, 20)
+        , m_secondScroll(40, 5)
         , m_scrollAmount(2, -1)
         , m_scrolls(0)
     {
@@ -844,7 +845,7 @@ public:
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->rootLayer()->setScrollable(true);
-        m_layerTreeHost->rootLayer()->setScrollPosition(m_initialScroll);
+        m_layerTreeHost->rootLayer()->setScrollOffset(m_initialScroll);
         postSetNeedsCommitToMainThread();
     }
 
@@ -852,39 +853,39 @@ public:
     {
         Layer* root = m_layerTreeHost->rootLayer();
         if (!m_layerTreeHost->commitNumber())
-            EXPECT_EQ(root->scrollPosition(), m_initialScroll);
+            EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll);
         else {
-            EXPECT_EQ(root->scrollPosition(), m_initialScroll + m_scrollAmount);
+            EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll + m_scrollAmount);
 
             // Pretend like Javascript updated the scroll position itself.
-            root->setScrollPosition(m_secondScroll);
+            root->setScrollOffset(m_secondScroll);
         }
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         LayerImpl* root = impl->rootLayer();
-        EXPECT_EQ(root->scrollDelta(), IntSize());
+        EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d());
 
         root->setScrollable(true);
-        root->setMaxScrollPosition(IntSize(100, 100));
+        root->setMaxScrollOffset(gfx::Vector2d(100, 100));
         root->scrollBy(m_scrollAmount);
 
         if (!impl->sourceFrameNumber()) {
-            EXPECT_EQ(root->scrollPosition(), m_initialScroll);
-            EXPECT_EQ(root->scrollDelta(), m_scrollAmount);
+            EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll);
+            EXPECT_VECTOR_EQ(root->scrollDelta(), m_scrollAmount);
             postSetNeedsCommitToMainThread();
         } else if (impl->sourceFrameNumber() == 1) {
-            EXPECT_EQ(root->scrollPosition(), m_secondScroll);
-            EXPECT_EQ(root->scrollDelta(), m_scrollAmount);
+            EXPECT_VECTOR_EQ(root->scrollOffset(), m_secondScroll);
+            EXPECT_VECTOR_EQ(root->scrollDelta(), m_scrollAmount);
             endTest();
         }
     }
 
-    virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale) OVERRIDE
+    virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
     {
-        IntPoint position = m_layerTreeHost->rootLayer()->scrollPosition();
-        m_layerTreeHost->rootLayer()->setScrollPosition(position + scrollDelta);
+        gfx::Vector2d offset = m_layerTreeHost->rootLayer()->scrollOffset();
+        m_layerTreeHost->rootLayer()->setScrollOffset(offset + scrollDelta);
         m_scrolls++;
     }
 
@@ -893,9 +894,9 @@ public:
         EXPECT_EQ(1, m_scrolls);
     }
 private:
-    IntPoint m_initialScroll;
-    IntPoint m_secondScroll;
-    IntSize m_scrollAmount;
+    gfx::Vector2d m_initialScroll;
+    gfx::Vector2d m_secondScroll;
+    gfx::Vector2d m_scrollAmount;
     int m_scrolls;
 };
 
@@ -907,7 +908,7 @@ TEST_F(LayerTreeHostTestScrollSimple, runMultiThread)
 class LayerTreeHostTestScrollMultipleRedraw : public LayerTreeHostTest {
 public:
     LayerTreeHostTestScrollMultipleRedraw()
-        : m_initialScroll(IntPoint(40, 10))
+        : m_initialScroll(40, 10)
         , m_scrollAmount(-3, 17)
         , m_scrolls(0)
     {
@@ -916,7 +917,7 @@ public:
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->rootLayer()->setScrollable(true);
-        m_layerTreeHost->rootLayer()->setScrollPosition(m_initialScroll);
+        m_layerTreeHost->rootLayer()->setScrollOffset(m_initialScroll);
         postSetNeedsCommitToMainThread();
     }
 
@@ -924,48 +925,48 @@ public:
     {
         Layer* root = m_layerTreeHost->rootLayer();
         if (!m_layerTreeHost->commitNumber())
-            EXPECT_EQ(root->scrollPosition(), m_initialScroll);
+            EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll);
         else if (m_layerTreeHost->commitNumber() == 1)
-            EXPECT_EQ(root->scrollPosition(), m_initialScroll + m_scrollAmount + m_scrollAmount);
+            EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll + m_scrollAmount + m_scrollAmount);
         else if (m_layerTreeHost->commitNumber() == 2)
-            EXPECT_EQ(root->scrollPosition(), m_initialScroll + m_scrollAmount + m_scrollAmount);
+            EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll + m_scrollAmount + m_scrollAmount);
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         LayerImpl* root = impl->rootLayer();
         root->setScrollable(true);
-        root->setMaxScrollPosition(IntSize(100, 100));
+        root->setMaxScrollOffset(gfx::Vector2d(100, 100));
 
         if (!impl->sourceFrameNumber() && impl->sourceAnimationFrameNumber() == 1) {
             // First draw after first commit.
-            EXPECT_EQ(root->scrollDelta(), IntSize());
+            EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d());
             root->scrollBy(m_scrollAmount);
-            EXPECT_EQ(root->scrollDelta(), m_scrollAmount);
+            EXPECT_VECTOR_EQ(root->scrollDelta(), m_scrollAmount);
 
-            EXPECT_EQ(root->scrollPosition(), m_initialScroll);
+            EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll);
             postSetNeedsRedrawToMainThread();
         } else if (!impl->sourceFrameNumber() && impl->sourceAnimationFrameNumber() == 2) {
             // Second draw after first commit.
             EXPECT_EQ(root->scrollDelta(), m_scrollAmount);
             root->scrollBy(m_scrollAmount);
-            EXPECT_EQ(root->scrollDelta(), m_scrollAmount + m_scrollAmount);
+            EXPECT_VECTOR_EQ(root->scrollDelta(), m_scrollAmount + m_scrollAmount);
 
-            EXPECT_EQ(root->scrollPosition(), m_initialScroll);
+            EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll);
             postSetNeedsCommitToMainThread();
         } else if (impl->sourceFrameNumber() == 1) {
             // Third or later draw after second commit.
             EXPECT_GE(impl->sourceAnimationFrameNumber(), 3);
-            EXPECT_EQ(root->scrollDelta(), IntSize());
-            EXPECT_EQ(root->scrollPosition(), m_initialScroll + m_scrollAmount + m_scrollAmount);
+            EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d());
+            EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll + m_scrollAmount + m_scrollAmount);
             endTest();
         }
     }
 
-    virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale) OVERRIDE
+    virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
     {
-        IntPoint position = m_layerTreeHost->rootLayer()->scrollPosition();
-        m_layerTreeHost->rootLayer()->setScrollPosition(position + scrollDelta);
+        gfx::Vector2d offset = m_layerTreeHost->rootLayer()->scrollOffset();
+        m_layerTreeHost->rootLayer()->setScrollOffset(offset + scrollDelta);
         m_scrolls++;
     }
 
@@ -974,8 +975,8 @@ public:
         EXPECT_EQ(1, m_scrolls);
     }
 private:
-    IntPoint m_initialScroll;
-    IntSize m_scrollAmount;
+    gfx::Vector2d m_initialScroll;
+    gfx::Vector2d m_scrollAmount;
     int m_scrolls;
 };
 
@@ -1029,20 +1030,20 @@ public:
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->rootLayer()->setScrollable(true);
-        m_layerTreeHost->rootLayer()->setScrollPosition(IntPoint());
+        m_layerTreeHost->rootLayer()->setScrollOffset(gfx::Vector2d());
         postSetNeedsCommitToMainThread();
         postSetNeedsRedrawToMainThread();
     }
 
     void requestStartPageScaleAnimation()
     {
-        layerTreeHost()->startPageScaleAnimation(IntSize(), false, 1.25, base::TimeDelta());
+        layerTreeHost()->startPageScaleAnimation(gfx::Vector2d(), false, 1.25, base::TimeDelta());
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         impl->rootLayer()->setScrollable(true);
-        impl->rootLayer()->setScrollPosition(IntPoint());
+        impl->rootLayer()->setScrollOffset(gfx::Vector2d());
         impl->setPageScaleFactorAndLimits(impl->pageScaleFactor(), 0.5, 2);
 
         // We request animation only once.
@@ -1052,10 +1053,10 @@ public:
         }
     }
 
-    virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale) OVERRIDE
+    virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
     {
-        IntPoint position = m_layerTreeHost->rootLayer()->scrollPosition();
-        m_layerTreeHost->rootLayer()->setScrollPosition(position + scrollDelta);
+        gfx::Vector2d offset = m_layerTreeHost->rootLayer()->scrollOffset();
+        m_layerTreeHost->rootLayer()->setScrollOffset(offset + scrollDelta);
         m_layerTreeHost->setPageScaleFactorAndLimits(scale, 0.5, 2);
     }
 
@@ -2090,36 +2091,36 @@ public:
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         LayerImpl* root = impl->rootLayer();
-        root->setMaxScrollPosition(IntSize(100, 100));
+        root->setMaxScrollOffset(gfx::Vector2d(100, 100));
 
         // Check that a fractional scroll delta is correctly accumulated over multiple commits.
         if (!impl->sourceFrameNumber()) {
-            EXPECT_EQ(root->scrollPosition(), IntPoint(0, 0));
-            EXPECT_EQ(root->scrollDelta(), FloatSize(0, 0));
+            EXPECT_VECTOR_EQ(root->scrollOffset(), gfx::Vector2d(0, 0));
+            EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d(0, 0));
             postSetNeedsCommitToMainThread();
         } else if (impl->sourceFrameNumber() == 1) {
-            EXPECT_EQ(root->scrollPosition(), flooredIntPoint(m_scrollAmount));
-            EXPECT_EQ(root->scrollDelta(), FloatSize(fmod(m_scrollAmount.width(), 1), 0));
+            EXPECT_VECTOR_EQ(root->scrollOffset(), gfx::ToFlooredVector2d(m_scrollAmount));
+            EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2dF(fmod(m_scrollAmount.x(), 1), 0));
             postSetNeedsCommitToMainThread();
         } else if (impl->sourceFrameNumber() == 2) {
-            EXPECT_EQ(root->scrollPosition(), flooredIntPoint(m_scrollAmount + m_scrollAmount));
-            EXPECT_EQ(root->scrollDelta(), FloatSize(fmod(2 * m_scrollAmount.width(), 1), 0));
+            EXPECT_VECTOR_EQ(root->scrollOffset(), gfx::ToFlooredVector2d(m_scrollAmount + m_scrollAmount));
+            EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2dF(fmod(2 * m_scrollAmount.x(), 1), 0));
             endTest();
         }
         root->scrollBy(m_scrollAmount);
     }
 
-    virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale) OVERRIDE
+    virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
     {
-        IntPoint position = m_layerTreeHost->rootLayer()->scrollPosition();
-        m_layerTreeHost->rootLayer()->setScrollPosition(position + scrollDelta);
+        gfx::Vector2d offset = m_layerTreeHost->rootLayer()->scrollOffset();
+        m_layerTreeHost->rootLayer()->setScrollOffset(offset + scrollDelta);
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 private:
-    FloatSize m_scrollAmount;
+    gfx::Vector2dF m_scrollAmount;
 };
 
 TEST_F(LayerTreeHostTestFractionalScroll, runMultiThread)
@@ -2223,8 +2224,8 @@ class LayerTreeHostTestScrollChildLayer : public LayerTreeHostTest, public WebLa
 public:
     LayerTreeHostTestScrollChildLayer(float deviceScaleFactor)
         : m_deviceScaleFactor(deviceScaleFactor)
-        , m_initialScroll(IntPoint(10, 20))
-        , m_secondScroll(IntPoint(40, 5))
+        , m_initialScroll(10, 20)
+        , m_secondScroll(40, 5)
         , m_scrollAmount(2, -1)
         , m_rootScrolls(0)
     {
@@ -2246,7 +2247,7 @@ public:
 
         m_rootScrollLayer->setIsDrawable(true);
         m_rootScrollLayer->setScrollable(true);
-        m_rootScrollLayer->setMaxScrollPosition(IntSize(100, 100));
+        m_rootScrollLayer->setMaxScrollOffset(gfx::Vector2d(100, 100));
         m_layerTreeHost->rootLayer()->addChild(m_rootScrollLayer);
 
         m_childLayer = ContentLayer::create(&m_mockDelegate);
@@ -2260,42 +2261,42 @@ public:
 
         m_childLayer->setIsDrawable(true);
         m_childLayer->setScrollable(true);
-        m_childLayer->setMaxScrollPosition(IntSize(100, 100));
+        m_childLayer->setMaxScrollOffset(gfx::Vector2d(100, 100));
         m_rootScrollLayer->addChild(m_childLayer);
 
-        m_childLayer->setScrollPosition(m_initialScroll);
+        m_childLayer->setScrollOffset(m_initialScroll);
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void didScroll() OVERRIDE
     {
-        m_finalScrollPosition = m_childLayer->scrollPosition();
+        m_finalScrollOffset = m_childLayer->scrollOffset();
     }
 
-    virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale) OVERRIDE
+    virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
     {
-        IntPoint position = m_rootScrollLayer->scrollPosition();
-        m_rootScrollLayer->setScrollPosition(position + scrollDelta);
+        gfx::Vector2d offset = m_rootScrollLayer->scrollOffset();
+        m_rootScrollLayer->setScrollOffset(offset + scrollDelta);
         m_rootScrolls++;
     }
 
     virtual void layout() OVERRIDE
     {
-        EXPECT_EQ(IntPoint(), m_rootScrollLayer->scrollPosition());
+        EXPECT_VECTOR_EQ(gfx::Vector2d(), m_rootScrollLayer->scrollOffset());
 
         switch (m_layerTreeHost->commitNumber()) {
         case 0:
-            EXPECT_POINT_EQ(m_initialScroll, m_childLayer->scrollPosition());
+            EXPECT_VECTOR_EQ(m_initialScroll, m_childLayer->scrollOffset());
             break;
         case 1:
-            EXPECT_POINT_EQ(m_initialScroll + m_scrollAmount, m_childLayer->scrollPosition());
+            EXPECT_VECTOR_EQ(m_initialScroll + m_scrollAmount, m_childLayer->scrollOffset());
 
             // Pretend like Javascript updated the scroll position itself.
-            m_childLayer->setScrollPosition(m_secondScroll);
+            m_childLayer->setScrollOffset(m_secondScroll);
             break;
         case 2:
-            EXPECT_POINT_EQ(m_secondScroll + m_scrollAmount, m_childLayer->scrollPosition());
+            EXPECT_VECTOR_EQ(m_secondScroll + m_scrollAmount, m_childLayer->scrollOffset());
             break;
         }
     }
@@ -2306,8 +2307,8 @@ public:
         LayerImpl* rootScrollLayer = root->children()[0];
         LayerImpl* childLayer = rootScrollLayer->children()[0];
 
-        EXPECT_SIZE_EQ(root->scrollDelta(), IntSize());
-        EXPECT_SIZE_EQ(rootScrollLayer->scrollDelta(), IntSize());
+        EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d());
+        EXPECT_VECTOR_EQ(rootScrollLayer->scrollDelta(), gfx::Vector2d());
         EXPECT_EQ(rootScrollLayer->bounds().width() * m_deviceScaleFactor, rootScrollLayer->contentBounds().width());
         EXPECT_EQ(rootScrollLayer->bounds().height() * m_deviceScaleFactor, rootScrollLayer->contentBounds().height());
         EXPECT_EQ(childLayer->bounds().width() * m_deviceScaleFactor, childLayer->contentBounds().width());
@@ -2320,8 +2321,8 @@ public:
             impl->scrollBy(gfx::Point(), m_scrollAmount);
             impl->scrollEnd();
 
-            EXPECT_POINT_EQ(m_initialScroll, childLayer->scrollPosition());
-            EXPECT_SIZE_EQ(m_scrollAmount, childLayer->scrollDelta());
+            EXPECT_VECTOR_EQ(m_initialScroll, childLayer->scrollOffset());
+            EXPECT_VECTOR_EQ(m_scrollAmount, childLayer->scrollDelta());
             break;
         case 1:
             // Wheel scroll on impl thread.
@@ -2329,12 +2330,12 @@ public:
             impl->scrollBy(gfx::Point(), m_scrollAmount);
             impl->scrollEnd();
 
-            EXPECT_POINT_EQ(m_secondScroll, childLayer->scrollPosition());
-            EXPECT_SIZE_EQ(m_scrollAmount, childLayer->scrollDelta());
+            EXPECT_VECTOR_EQ(m_secondScroll, childLayer->scrollOffset());
+            EXPECT_VECTOR_EQ(m_scrollAmount, childLayer->scrollDelta());
             break;
         case 2:
-            EXPECT_POINT_EQ(m_secondScroll + m_scrollAmount, childLayer->scrollPosition());
-            EXPECT_SIZE_EQ(IntSize(0, 0), childLayer->scrollDelta());
+            EXPECT_VECTOR_EQ(m_secondScroll + m_scrollAmount, childLayer->scrollOffset());
+            EXPECT_VECTOR_EQ(gfx::Vector2d(0, 0), childLayer->scrollDelta());
 
             endTest();
         }
@@ -2343,16 +2344,16 @@ public:
     virtual void afterTest() OVERRIDE
     {
         EXPECT_EQ(0, m_rootScrolls);
-        EXPECT_POINT_EQ(m_secondScroll + m_scrollAmount, m_finalScrollPosition);
+        EXPECT_VECTOR_EQ(m_secondScroll + m_scrollAmount, m_finalScrollOffset);
     }
 
 private:
     float m_deviceScaleFactor;
-    IntPoint m_initialScroll;
-    IntPoint m_secondScroll;
-    IntSize m_scrollAmount;
+    gfx::Vector2d m_initialScroll;
+    gfx::Vector2d m_secondScroll;
+    gfx::Vector2d m_scrollAmount;
     int m_rootScrolls;
-    IntPoint m_finalScrollPosition;
+    gfx::Vector2d m_finalScrollOffset;
 
     MockContentLayerClient m_mockDelegate;
     scoped_refptr<Layer> m_rootScrollLayer;
@@ -2383,8 +2384,8 @@ class LayerTreeHostTestScrollRootScrollLayer : public LayerTreeHostTest {
 public:
     LayerTreeHostTestScrollRootScrollLayer(float deviceScaleFactor)
         : m_deviceScaleFactor(deviceScaleFactor)
-        , m_initialScroll(IntPoint(10, 20))
-        , m_secondScroll(IntPoint(40, 5))
+        , m_initialScroll(10, 20)
+        , m_secondScroll(40, 5)
         , m_scrollAmount(2, -1)
         , m_rootScrolls(0)
     {
@@ -2399,25 +2400,25 @@ public:
         m_layerTreeHost->setDeviceScaleFactor(m_deviceScaleFactor);
 
         m_rootScrollLayer = ContentLayer::create(&m_mockDelegate);
-        m_rootScrollLayer->setBounds(IntSize(110, 110));
+        m_rootScrollLayer->setBounds(gfx::Size(110, 110));
 
         m_rootScrollLayer->setPosition(gfx::PointF(0, 0));
         m_rootScrollLayer->setAnchorPoint(gfx::PointF(0, 0));
 
         m_rootScrollLayer->setIsDrawable(true);
         m_rootScrollLayer->setScrollable(true);
-        m_rootScrollLayer->setMaxScrollPosition(IntSize(100, 100));
+        m_rootScrollLayer->setMaxScrollOffset(gfx::Vector2d(100, 100));
         m_layerTreeHost->rootLayer()->addChild(m_rootScrollLayer);
 
-        m_rootScrollLayer->setScrollPosition(m_initialScroll);
+        m_rootScrollLayer->setScrollOffset(m_initialScroll);
 
         postSetNeedsCommitToMainThread();
     }
 
-    virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale) OVERRIDE
+    virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
     {
-        IntPoint position = m_rootScrollLayer->scrollPosition();
-        m_rootScrollLayer->setScrollPosition(position + scrollDelta);
+        gfx::Vector2d offset = m_rootScrollLayer->scrollOffset();
+        m_rootScrollLayer->setScrollOffset(offset + scrollDelta);
         m_rootScrolls++;
     }
 
@@ -2425,16 +2426,16 @@ public:
     {
         switch (m_layerTreeHost->commitNumber()) {
         case 0:
-            EXPECT_POINT_EQ(m_initialScroll, m_rootScrollLayer->scrollPosition());
+            EXPECT_VECTOR_EQ(m_initialScroll, m_rootScrollLayer->scrollOffset());
             break;
         case 1:
-            EXPECT_POINT_EQ(m_initialScroll + m_scrollAmount, m_rootScrollLayer->scrollPosition());
+            EXPECT_VECTOR_EQ(m_initialScroll + m_scrollAmount, m_rootScrollLayer->scrollOffset());
 
             // Pretend like Javascript updated the scroll position itself.
-            m_rootScrollLayer->setScrollPosition(m_secondScroll);
+            m_rootScrollLayer->setScrollOffset(m_secondScroll);
             break;
         case 2:
-            EXPECT_POINT_EQ(m_secondScroll + m_scrollAmount, m_rootScrollLayer->scrollPosition());
+            EXPECT_VECTOR_EQ(m_secondScroll + m_scrollAmount, m_rootScrollLayer->scrollOffset());
             break;
         }
     }
@@ -2444,7 +2445,7 @@ public:
         LayerImpl* root = impl->rootLayer();
         LayerImpl* rootScrollLayer = root->children()[0];
 
-        EXPECT_SIZE_EQ(root->scrollDelta(), IntSize());
+        EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d());
         EXPECT_EQ(rootScrollLayer->bounds().width() * m_deviceScaleFactor, rootScrollLayer->contentBounds().width());
         EXPECT_EQ(rootScrollLayer->bounds().height() * m_deviceScaleFactor, rootScrollLayer->contentBounds().height());
 
@@ -2455,8 +2456,8 @@ public:
             impl->scrollBy(gfx::Point(), m_scrollAmount);
             impl->scrollEnd();
 
-            EXPECT_POINT_EQ(m_initialScroll, rootScrollLayer->scrollPosition());
-            EXPECT_SIZE_EQ(m_scrollAmount, rootScrollLayer->scrollDelta());
+            EXPECT_VECTOR_EQ(m_initialScroll, rootScrollLayer->scrollOffset());
+            EXPECT_VECTOR_EQ(m_scrollAmount, rootScrollLayer->scrollDelta());
             break;
         case 1:
             // Wheel scroll on impl thread.
@@ -2464,12 +2465,12 @@ public:
             impl->scrollBy(gfx::Point(), m_scrollAmount);
             impl->scrollEnd();
 
-            EXPECT_POINT_EQ(m_secondScroll, rootScrollLayer->scrollPosition());
-            EXPECT_SIZE_EQ(m_scrollAmount, rootScrollLayer->scrollDelta());
+            EXPECT_VECTOR_EQ(m_secondScroll, rootScrollLayer->scrollOffset());
+            EXPECT_VECTOR_EQ(m_scrollAmount, rootScrollLayer->scrollDelta());
             break;
         case 2:
-            EXPECT_POINT_EQ(m_secondScroll + m_scrollAmount, rootScrollLayer->scrollPosition());
-            EXPECT_SIZE_EQ(IntSize(0, 0), rootScrollLayer->scrollDelta());
+            EXPECT_VECTOR_EQ(m_secondScroll + m_scrollAmount, rootScrollLayer->scrollOffset());
+            EXPECT_VECTOR_EQ(gfx::Vector2d(0, 0), rootScrollLayer->scrollDelta());
 
             endTest();
         }
@@ -2482,9 +2483,9 @@ public:
 
 private:
     float m_deviceScaleFactor;
-    IntPoint m_initialScroll;
-    IntPoint m_secondScroll;
-    IntSize m_scrollAmount;
+    gfx::Vector2d m_initialScroll;
+    gfx::Vector2d m_secondScroll;
+    gfx::Vector2d m_scrollAmount;
     int m_rootScrolls;
 
     MockContentLayerClient m_mockDelegate;
diff --git a/cc/layer_unittest.cc b/cc/layer_unittest.cc
index d85a855..2bbbef4 100644
--- a/cc/layer_unittest.cc
+++ b/cc/layer_unittest.cc
@@ -511,7 +511,7 @@ TEST_F(LayerTest, checkPropertyChangeCausesCorrectBehavior)
     EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setShouldScrollOnMainThread(true));
     EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNonFastScrollableRegion(gfx::Rect(1, 1, 2, 2)));
     EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setHaveWheelEventHandlers(true));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setScrollPosition(IntPoint(10, 10)));
+    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setScrollOffset(gfx::Vector2d(10, 10)));
     EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setTransform(WebTransformationMatrix(0, 0, 0, 0, 0, 0)));
     EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setDoubleSided(false));
     EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setDebugName("Test Layer"));
diff --git a/cc/math_util.cc b/cc/math_util.cc
index 6ae41e6..83d156c 100644
--- a/cc/math_util.cc
+++ b/cc/math_util.cc
@@ -6,12 +6,14 @@
 
 #include "cc/math_util.h"
 
-#include "FloatSize.h"
+#include <cmath>
+#include <limits>
+
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/rect_f.h"
-#include <cmath>
+#include "ui/gfx/vector2d_f.h"
 #include <public/WebTransformationMatrix.h>
 
 using WebKit::WebTransformationMatrix;
@@ -378,19 +380,24 @@ gfx::Vector2dF MathUtil::computeTransform2dScaleComponents(const WebTransformati
     return gfx::Vector2dF(xScale, yScale);
 }
 
-float MathUtil::smallestAngleBetweenVectors(const FloatSize& v1, const FloatSize& v2)
+static inline double rad2deg(double r)
+{
+  double pi = 3.14159265358979323846;
+  return r * 180.0 / pi;
+}
+
+float MathUtil::smallestAngleBetweenVectors(gfx::Vector2dF v1, gfx::Vector2dF v2)
 {
-    float dotProduct = (v1.width() * v2.width() + v1.height() * v2.height()) / (v1.diagonalLength() * v2.diagonalLength());
+    double dotProduct = gfx::DotProduct(v1, v2) / v1.Length() / v2.Length();
     // Clamp to compensate for rounding errors.
-    dotProduct = std::max(-1.f, std::min(1.f, dotProduct));
-    return rad2deg(acosf(dotProduct));
+    dotProduct = std::max(-1.0, std::min(1.0, dotProduct));
+    return static_cast<float>(rad2deg(std::acos(dotProduct)));
 }
 
-FloatSize MathUtil::projectVector(const FloatSize& source, const FloatSize& destination)
+gfx::Vector2dF MathUtil::projectVector(gfx::Vector2dF source, gfx::Vector2dF destination)
 {
-    float sourceDotDestination = source.width() * destination.width() + source.height() * destination.height();
-    float projectedLength = sourceDotDestination / destination.diagonalLengthSquared();
-    return FloatSize(projectedLength * destination.width(), projectedLength * destination.height());
+    float projectedLength = gfx::DotProduct(source, destination) / destination.LengthSquared();
+    return gfx::Vector2dF(projectedLength * destination.x(), projectedLength * destination.y());
 }
 
 }  // namespace cc
diff --git a/cc/math_util.h b/cc/math_util.h
index 7d22c6c..1caf659 100644
--- a/cc/math_util.h
+++ b/cc/math_util.h
@@ -18,12 +18,11 @@ namespace gfx {
 class QuadF;
 class Rect;
 class RectF;
+class Vector2dF;
 }
 
 namespace cc {
 
-class FloatSize;
-
 struct HomogeneousCoordinate {
     HomogeneousCoordinate(double newX, double newY, double newZ, double newW)
         : x(newX)
@@ -104,10 +103,10 @@ public:
 
     // Returns the smallest angle between the given two vectors in degrees. Neither vector is
     // assumed to be normalized.
-    static float smallestAngleBetweenVectors(const FloatSize&, const FloatSize&);
+    static float smallestAngleBetweenVectors(gfx::Vector2dF, gfx::Vector2dF);
 
     // Projects the |source| vector onto |destination|. Neither vector is assumed to be normalized.
-    static FloatSize projectVector(const FloatSize& source, const FloatSize& destination);
+    static gfx::Vector2dF projectVector(gfx::Vector2dF source, gfx::Vector2dF destination);
 };
 
 } // namespace cc
diff --git a/cc/math_util_unittest.cc b/cc/math_util_unittest.cc
index e6270cf..571329c 100644
--- a/cc/math_util_unittest.cc
+++ b/cc/math_util_unittest.cc
@@ -6,7 +6,8 @@
 
 #include "cc/math_util.h"
 
-#include "FloatSize.h"
+#include <cmath>
+
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -136,9 +137,9 @@ TEST(MathUtilTest, verifyEnclosingRectOfVerticesUsesCorrectInitialBounds)
 
 TEST(MathUtilTest, smallestAngleBetweenVectors)
 {
-    FloatSize x(1, 0);
-    FloatSize y(0, 1);
-    FloatSize testVector(0.5, 0.5);
+    gfx::Vector2dF x(1, 0);
+    gfx::Vector2dF y(0, 1);
+    gfx::Vector2dF testVector(0.5, 0.5);
 
     // Orthogonal vectors are at an angle of 90 degress.
     EXPECT_EQ(90, MathUtil::smallestAngleBetweenVectors(x, y));
@@ -154,31 +155,31 @@ TEST(MathUtilTest, smallestAngleBetweenVectors)
     EXPECT_FLOAT_EQ(180, MathUtil::smallestAngleBetweenVectors(testVector, -testVector));
 
     // The test vector is at a known angle.
-    EXPECT_FLOAT_EQ(45, floor(MathUtil::smallestAngleBetweenVectors(testVector, x)));
-    EXPECT_FLOAT_EQ(45, floor(MathUtil::smallestAngleBetweenVectors(testVector, y)));
+    EXPECT_FLOAT_EQ(45, std::floor(MathUtil::smallestAngleBetweenVectors(testVector, x)));
+    EXPECT_FLOAT_EQ(45, std::floor(MathUtil::smallestAngleBetweenVectors(testVector, y)));
 }
 
 TEST(MathUtilTest, vectorProjection)
 {
-    FloatSize x(1, 0);
-    FloatSize y(0, 1);
-    FloatSize testVector(0.3f, 0.7f);
+    gfx::Vector2dF x(1, 0);
+    gfx::Vector2dF y(0, 1);
+    gfx::Vector2dF testVector(0.3f, 0.7f);
 
     // Orthogonal vectors project to a zero vector.
-    EXPECT_EQ(FloatSize(0, 0), MathUtil::projectVector(x, y));
-    EXPECT_EQ(FloatSize(0, 0), MathUtil::projectVector(y, x));
+    EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 0), MathUtil::projectVector(x, y));
+    EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 0), MathUtil::projectVector(y, x));
 
     // Projecting a vector onto the orthonormal basis gives the corresponding component of the
     // vector.
-    EXPECT_EQ(FloatSize(testVector.width(), 0), MathUtil::projectVector(testVector, x));
-    EXPECT_EQ(FloatSize(0, testVector.height()), MathUtil::projectVector(testVector, y));
+    EXPECT_VECTOR_EQ(gfx::Vector2dF(testVector.x(), 0), MathUtil::projectVector(testVector, x));
+    EXPECT_VECTOR_EQ(gfx::Vector2dF(0, testVector.y()), MathUtil::projectVector(testVector, y));
 
     // Finally check than an arbitrary vector projected to another one gives a vector parallel to
     // the second vector.
-    FloatSize targetVector(0.5, 0.2f);
-    FloatSize projectedVector = MathUtil::projectVector(testVector, targetVector);
-    EXPECT_EQ(projectedVector.width() / targetVector.width(),
-              projectedVector.height() / targetVector.height());
+    gfx::Vector2dF targetVector(0.5, 0.2f);
+    gfx::Vector2dF projectedVector = MathUtil::projectVector(testVector, targetVector);
+    EXPECT_EQ(projectedVector.x() / targetVector.x(),
+              projectedVector.y() / targetVector.y());
 }
 
 }  // anonymous namespace
diff --git a/cc/page_scale_animation.cc b/cc/page_scale_animation.cc
index 59424d4..49948ab 100644
--- a/cc/page_scale_animation.cc
+++ b/cc/page_scale_animation.cc
@@ -6,22 +6,21 @@
 
 #include "cc/page_scale_animation.h"
 
-#include "FloatPoint.h"
-#include "FloatSize.h"
-#include "IntPoint.h"
-#include "IntSize.h"
+#include "cc/geometry.h"
 #include "ui/gfx/rect_f.h"
+#include "ui/gfx/vector2d_conversions.h"
+#include "ui/gfx/vector2d_f.h"
 
 #include <math.h>
 
 namespace cc {
 
-scoped_ptr<PageScaleAnimation> PageScaleAnimation::create(const IntSize& scrollStart, float pageScaleStart, const gfx::Size& windowSize, const gfx::Size& contentSize, double startTime)
+scoped_ptr<PageScaleAnimation> PageScaleAnimation::create(gfx::Vector2d scrollStart, float pageScaleStart, const gfx::Size& windowSize, const gfx::Size& contentSize, double startTime)
 {
     return make_scoped_ptr(new PageScaleAnimation(scrollStart, pageScaleStart, windowSize, contentSize, startTime));
 }
 
-PageScaleAnimation::PageScaleAnimation(const IntSize& scrollStart, float pageScaleStart, const gfx::Size& windowSize, const gfx::Size& contentSize, double startTime)
+PageScaleAnimation::PageScaleAnimation(gfx::Vector2d scrollStart, float pageScaleStart, const gfx::Size& windowSize, const gfx::Size& contentSize, double startTime)
     : m_scrollStart(scrollStart)
     , m_pageScaleStart(pageScaleStart)
     , m_windowSize(windowSize)
@@ -38,13 +37,13 @@ PageScaleAnimation::~PageScaleAnimation()
 {
 }
 
-void PageScaleAnimation::zoomTo(const IntSize& finalScroll, float finalPageScale, double duration)
+void PageScaleAnimation::zoomTo(gfx::Vector2d finalScroll, float finalPageScale, double duration)
 {
     if (m_pageScaleStart != finalPageScale) {
         // For uniform-looking zooming, infer the anchor (point that remains in
         // place throughout the zoom) from the start and end rects.
-        gfx::RectF startRect(cc::FloatPoint(cc::IntPoint(m_scrollStart)), m_windowSize);
-        gfx::RectF endRect(cc::FloatPoint(cc::IntPoint(finalScroll)), m_windowSize);
+        gfx::RectF startRect(gfx::PointAtOffsetFromOrigin(m_scrollStart), m_windowSize);
+        gfx::RectF endRect(gfx::PointAtOffsetFromOrigin(finalScroll), m_windowSize);
         endRect.Scale(m_pageScaleStart / finalPageScale);
 
         // The anchor is the point which is at the same ratio of the sides of
@@ -61,7 +60,7 @@ void PageScaleAnimation::zoomTo(const IntSize& finalScroll, float finalPageScale
         float ratioX = (startRect.x() - endRect.x()) / (endRect.width() - startRect.width());
         float ratioY = (startRect.y() - endRect.y()) / (endRect.height() - startRect.height());
 
-        IntSize anchor(m_windowSize.width() * ratioX, m_windowSize.height() * ratioY);
+        gfx::Vector2d anchor(m_windowSize.width() * ratioX, m_windowSize.height() * ratioY);
         zoomWithAnchor(anchor, finalPageScale, duration);
     } else {
         // If this is a pure translation, then there exists no anchor. Linearly
@@ -73,16 +72,17 @@ void PageScaleAnimation::zoomTo(const IntSize& finalScroll, float finalPageScale
     }
 }
 
-void PageScaleAnimation::zoomWithAnchor(const IntSize& anchor, float finalPageScale, double duration)
+void PageScaleAnimation::zoomWithAnchor(gfx::Vector2d anchor, float finalPageScale, double duration)
 {
     m_scrollEnd = m_scrollStart + anchor;
-    m_scrollEnd.scale(finalPageScale / m_pageScaleStart);
+    m_scrollEnd = gfx::ToFlooredVector2d(cc::ScaleVector2d(m_scrollEnd, finalPageScale / m_pageScaleStart));
     m_scrollEnd -= anchor;
 
-    m_scrollEnd.clampNegativeToZero();
+    m_scrollEnd = ClampFromBelow(m_scrollEnd, gfx::Vector2d());
     gfx::SizeF scaledContentSize = m_contentSize.Scale(finalPageScale / m_pageScaleStart);
-    IntSize maxScrollPosition = roundedIntSize(cc::FloatSize(scaledContentSize) - cc::IntSize(m_windowSize));
-    m_scrollEnd = m_scrollEnd.shrunkTo(maxScrollPosition);
+    gfx::Vector2d maxScrollOffset = gfx::ToRoundedVector2d(BottomRight(gfx::RectF(scaledContentSize)) - BottomRight(gfx::Rect(m_windowSize)));
+    m_scrollEnd = m_scrollEnd;
+    m_scrollEnd = ClampFromAbove(m_scrollEnd, maxScrollOffset);
 
     m_anchor = anchor;
     m_pageScaleEnd = finalPageScale;
@@ -90,7 +90,7 @@ void PageScaleAnimation::zoomWithAnchor(const IntSize& anchor, float finalPageSc
     m_anchorMode = true;
 }
 
-IntSize PageScaleAnimation::scrollOffsetAtTime(double time) const
+gfx::Vector2d PageScaleAnimation::scrollOffsetAtTime(double time) const
 {
     return scrollOffsetAtRatio(progressRatioForTime(time));
 }
@@ -113,7 +113,7 @@ float PageScaleAnimation::progressRatioForTime(double time) const
     return (time - m_startTime) / m_duration;
 }
 
-IntSize PageScaleAnimation::scrollOffsetAtRatio(float ratio) const
+gfx::Vector2d PageScaleAnimation::scrollOffsetAtRatio(float ratio) const
 {
     if (ratio <= 0)
         return m_scrollStart;
@@ -121,23 +121,23 @@ IntSize PageScaleAnimation::scrollOffsetAtRatio(float ratio) const
         return m_scrollEnd;
 
     float currentPageScale = pageScaleAtRatio(ratio);
-    IntSize currentScrollOffset;
+    gfx::Vector2d currentScrollOffset;
     if (m_anchorMode) {
         // Keep the anchor stable on the screen at the current scale.
-        IntSize documentAnchor = m_scrollStart + m_anchor;
-        documentAnchor.scale(currentPageScale / m_pageScaleStart);
-        currentScrollOffset = documentAnchor - m_anchor;
+        gfx::Vector2dF documentAnchor = m_scrollStart + m_anchor;
+        documentAnchor.Scale(currentPageScale / m_pageScaleStart);
+        currentScrollOffset = gfx::ToRoundedVector2d(documentAnchor - m_anchor);
     } else {
         // First move both scroll offsets to the current coordinate space.
-        FloatSize scaledStartScroll(m_scrollStart);
-        scaledStartScroll.scale(currentPageScale / m_pageScaleStart);
-        FloatSize scaledEndScroll(m_scrollEnd);
-        scaledEndScroll.scale(currentPageScale / m_pageScaleEnd);
+        gfx::Vector2dF scaledStartScroll(m_scrollStart);
+        scaledStartScroll.Scale(currentPageScale / m_pageScaleStart);
+        gfx::Vector2dF scaledEndScroll(m_scrollEnd);
+        scaledEndScroll.Scale(currentPageScale / m_pageScaleEnd);
 
         // Linearly interpolate between them.
-        FloatSize delta = scaledEndScroll - scaledStartScroll;
-        delta.scale(ratio);
-        currentScrollOffset = roundedIntSize(scaledStartScroll + delta);
+        gfx::Vector2dF delta = scaledEndScroll - scaledStartScroll;
+        delta.Scale(ratio);
+        currentScrollOffset = gfx::ToRoundedVector2d(scaledStartScroll + delta);
     }
 
     return currentScrollOffset;
diff --git a/cc/page_scale_animation.h b/cc/page_scale_animation.h
index 5f4bbac..c4c2940 100644
--- a/cc/page_scale_animation.h
+++ b/cc/page_scale_animation.h
@@ -6,7 +6,8 @@
 #define CC_PAGE_SCALE_ANIMATION_H_
 
 #include "base/memory/scoped_ptr.h"
-#include "IntSize.h"
+#include "ui/gfx/size.h"
+#include "ui/gfx/vector2d.h"
 
 namespace cc {
 
@@ -19,7 +20,7 @@ public:
     // Construct with the starting page scale and scroll offset (which is in
     // pageScaleStart space). The window size is the user-viewable area
     // in pixels.
-    static scoped_ptr<PageScaleAnimation> create(const IntSize& scrollStart, float pageScaleStart, const gfx::Size& windowSize, const gfx::Size& contentSize, double startTime);
+    static scoped_ptr<PageScaleAnimation> create(gfx::Vector2d scrollStart, float pageScaleStart, const gfx::Size& windowSize, const gfx::Size& contentSize, double startTime);
     ~PageScaleAnimation();
 
     // The following methods initialize the animation. Call one of them
@@ -27,16 +28,16 @@ public:
 
     // Zoom while explicitly specifying the top-left scroll position. The
     // scroll offset is in finalPageScale coordinates.
-    void zoomTo(const IntSize& finalScroll, float finalPageScale, double duration);
+    void zoomTo(gfx::Vector2d finalScroll, float finalPageScale, double duration);
 
     // Zoom based on a specified onscreen anchor, which will remain at the same
     // position on the screen throughout the animation. The anchor is in local
     // space relative to scrollStart.
-    void zoomWithAnchor(const IntSize& anchor, float finalPageScale, double duration);
+    void zoomWithAnchor(gfx::Vector2d anchor, float finalPageScale, double duration);
 
     // Call these functions while the animation is in progress to output the
     // current state.
-    IntSize scrollOffsetAtTime(double time) const;
+    gfx::Vector2d scrollOffsetAtTime(double time) const;
     float pageScaleAtTime(double time) const;
     bool isAnimationCompleteAtTime(double time) const;
 
@@ -45,25 +46,25 @@ public:
     double startTime() const { return m_startTime; }
     double duration() const { return m_duration; }
     double endTime() const { return m_startTime + m_duration; }
-    const IntSize& finalScrollOffset() const { return m_scrollEnd; }
+    gfx::Vector2d finalScrollOffset() const { return m_scrollEnd; }
     float finalPageScale() const { return m_pageScaleEnd; }
 
 protected:
-    PageScaleAnimation(const IntSize& scrollStart, float pageScaleStart, const gfx::Size& windowSize, const gfx::Size& contentSize, double startTime);
+    PageScaleAnimation(gfx::Vector2d scrollStart, float pageScaleStart, const gfx::Size& windowSize, const gfx::Size& contentSize, double startTime);
 
 private:
     float progressRatioForTime(double time) const;
-    IntSize scrollOffsetAtRatio(float ratio) const;
+    gfx::Vector2d scrollOffsetAtRatio(float ratio) const;
     float pageScaleAtRatio(float ratio) const;
 
-    IntSize m_scrollStart;
+    gfx::Vector2d m_scrollStart;
     float m_pageScaleStart;
     gfx::Size m_windowSize;
     gfx::Size m_contentSize;
 
     bool m_anchorMode;
-    IntSize m_anchor;
-    IntSize m_scrollEnd;
+    gfx::Vector2d m_anchor;
+    gfx::Vector2d m_scrollEnd;
     float m_pageScaleEnd;
 
     double m_startTime;
diff --git a/cc/proxy.h b/cc/proxy.h
index 8b5287d..ac61540 100644
--- a/cc/proxy.h
+++ b/cc/proxy.h
@@ -13,12 +13,12 @@
 
 namespace gfx {
 class Rect;
+class Vector2d;
 }
 
 namespace cc {
 
 class Thread;
-class IntSize;
 struct RenderingStats;
 struct RendererCapabilities;
 
@@ -40,7 +40,7 @@ public:
 
     virtual bool compositeAndReadback(void *pixels, const gfx::Rect&) = 0;
 
-    virtual void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, base::TimeDelta duration) = 0;
+    virtual void startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration) = 0;
 
     virtual void finishAllRendering() = 0;
 
diff --git a/cc/scrollbar_animation_controller.cc b/cc/scrollbar_animation_controller.cc
index 88c58e2..529884f 100644
--- a/cc/scrollbar_animation_controller.cc
+++ b/cc/scrollbar_animation_controller.cc
@@ -77,20 +77,20 @@ gfx::Size ScrollbarAnimationController::getScrollLayerBounds(const LayerImpl* sc
 
 void ScrollbarAnimationController::updateScrollOffsetAtTime(LayerImpl* scrollLayer, double)
 {
-    m_currentPos = scrollLayer->scrollPosition() + scrollLayer->scrollDelta();
+    m_currentOffset = scrollLayer->scrollOffset() + scrollLayer->scrollDelta();
     m_totalSize = getScrollLayerBounds(scrollLayer);
-    m_maximum = scrollLayer->maxScrollPosition();
+    m_maximum = scrollLayer->maxScrollOffset();
 
     if (m_horizontalScrollbarLayer) {
-        m_horizontalScrollbarLayer->setCurrentPos(m_currentPos.x());
+        m_horizontalScrollbarLayer->setCurrentPos(m_currentOffset.x());
         m_horizontalScrollbarLayer->setTotalSize(m_totalSize.width());
-        m_horizontalScrollbarLayer->setMaximum(m_maximum.width());
+        m_horizontalScrollbarLayer->setMaximum(m_maximum.x());
     }
 
     if (m_verticalScrollbarLayer) {
-        m_verticalScrollbarLayer->setCurrentPos(m_currentPos.y());
+        m_verticalScrollbarLayer->setCurrentPos(m_currentOffset.y());
         m_verticalScrollbarLayer->setTotalSize(m_totalSize.height());
-        m_verticalScrollbarLayer->setMaximum(m_maximum.height());
+        m_verticalScrollbarLayer->setMaximum(m_maximum.y());
     }
 }
 
diff --git a/cc/scrollbar_animation_controller.h b/cc/scrollbar_animation_controller.h
index c26b464..eaf2913 100644
--- a/cc/scrollbar_animation_controller.h
+++ b/cc/scrollbar_animation_controller.h
@@ -7,12 +7,9 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "cc/cc_export.h"
-#include "FloatPoint.h"
-#include "IntSize.h"
-
-namespace gfx {
-class Size;
-}
+#include "ui/gfx/size.h"
+#include "ui/gfx/vector2d.h"
+#include "ui/gfx/vector2d_f.h"
 
 namespace cc {
 
@@ -39,9 +36,9 @@ public:
     void setVerticalScrollbarLayer(ScrollbarLayerImpl* layer) { m_verticalScrollbarLayer = layer; }
     ScrollbarLayerImpl* verticalScrollbarLayer() const { return m_verticalScrollbarLayer; }
 
-    FloatPoint currentPos() const { return m_currentPos; }
+    gfx::Vector2dF currentOffset() const { return m_currentOffset; }
     gfx::Size totalSize() const { return m_totalSize; }
-    IntSize maximum() const { return m_maximum; }
+    gfx::Vector2d maximum() const { return m_maximum; }
 
     virtual void didPinchGestureBeginAtTime(double monotonicTime) { }
     virtual void didPinchGestureUpdateAtTime(double monotonicTime) { }
@@ -58,9 +55,9 @@ private:
     ScrollbarLayerImpl* m_horizontalScrollbarLayer;
     ScrollbarLayerImpl* m_verticalScrollbarLayer;
 
-    FloatPoint m_currentPos;
+    gfx::Vector2dF m_currentOffset;
     gfx::Size m_totalSize;
-    IntSize m_maximum;
+    gfx::Vector2d m_maximum;
 };
 
 } // namespace cc
diff --git a/cc/scrollbar_animation_controller_linear_fade.cc b/cc/scrollbar_animation_controller_linear_fade.cc
index c405f66..0289804 100644
--- a/cc/scrollbar_animation_controller_linear_fade.cc
+++ b/cc/scrollbar_animation_controller_linear_fade.cc
@@ -51,10 +51,10 @@ void ScrollbarAnimationControllerLinearFade::didPinchGestureEndAtTime(double mon
 
 void ScrollbarAnimationControllerLinearFade::updateScrollOffsetAtTime(LayerImpl* scrollLayer, double monotonicTime)
 {
-    FloatPoint previousPos = currentPos();
+    gfx::Vector2dF previousPos = currentOffset();
     ScrollbarAnimationController::updateScrollOffsetAtTime(scrollLayer, monotonicTime);
 
-    if (previousPos == currentPos())
+    if (previousPos == currentOffset())
         return;
 
     m_lastAwakenTime = monotonicTime;
diff --git a/cc/scrollbar_animation_controller_linear_fade_unittest.cc b/cc/scrollbar_animation_controller_linear_fade_unittest.cc
index af7bee4..d6417ab 100644
--- a/cc/scrollbar_animation_controller_linear_fade_unittest.cc
+++ b/cc/scrollbar_animation_controller_linear_fade_unittest.cc
@@ -23,8 +23,8 @@ protected:
         m_contentLayer = m_scrollLayer->children()[0];
         m_scrollbarLayer = ScrollbarLayerImpl::create(3);
 
-        m_scrollLayer->setMaxScrollPosition(IntSize(50, 50));
-        m_contentLayer->setBounds(IntSize(50, 50));
+        m_scrollLayer->setMaxScrollOffset(gfx::Vector2d(50, 50));
+        m_contentLayer->setBounds(gfx::Size(50, 50));
 
         m_scrollbarController = ScrollbarAnimationControllerLinearFade::create(m_scrollLayer.get(), 2, 3);
         m_scrollbarController->setHorizontalScrollbarLayer(m_scrollbarLayer.get());
@@ -50,13 +50,13 @@ TEST_F(ScrollbarAnimationControllerLinearFadeTest, verifyHiddenInBegin)
 
 TEST_F(ScrollbarAnimationControllerLinearFadeTest, verifyAwakenByScroll)
 {
-    m_scrollLayer->setScrollDelta(IntSize(1, 1));
+    m_scrollLayer->setScrollDelta(gfx::Vector2d(1, 1));
     m_scrollbarController->updateScrollOffsetAtTime(m_scrollLayer.get(), 0);
     m_scrollbarController->animate(0);
     EXPECT_FLOAT_EQ(1, m_scrollbarLayer->opacity());
     m_scrollbarController->animate(1);
     EXPECT_FLOAT_EQ(1, m_scrollbarLayer->opacity());
-    m_scrollLayer->setScrollDelta(IntSize(2, 2));
+    m_scrollLayer->setScrollDelta(gfx::Vector2d(2, 2));
     m_scrollbarController->updateScrollOffsetAtTime(m_scrollLayer.get(), 1);
     m_scrollbarController->animate(2);
     EXPECT_FLOAT_EQ(1, m_scrollbarLayer->opacity());
@@ -68,7 +68,7 @@ TEST_F(ScrollbarAnimationControllerLinearFadeTest, verifyAwakenByScroll)
     EXPECT_FLOAT_EQ(2 / 3.0f, m_scrollbarLayer->opacity());
     m_scrollbarController->animate(5);
     EXPECT_FLOAT_EQ(1 / 3.0f, m_scrollbarLayer->opacity());
-    m_scrollLayer->setScrollDelta(IntSize(3, 3));
+    m_scrollLayer->setScrollDelta(gfx::Vector2d(3, 3));
     m_scrollbarController->updateScrollOffsetAtTime(m_scrollLayer.get(), 5);
     m_scrollbarController->animate(6);
     EXPECT_FLOAT_EQ(1, m_scrollbarLayer->opacity());
@@ -90,7 +90,7 @@ TEST_F(ScrollbarAnimationControllerLinearFadeTest, verifyForceAwakenByPinch)
     EXPECT_FLOAT_EQ(1, m_scrollbarLayer->opacity());
     m_scrollbarController->animate(1);
     EXPECT_FLOAT_EQ(1, m_scrollbarLayer->opacity());
-    m_scrollLayer->setScrollDelta(IntSize(1, 1));
+    m_scrollLayer->setScrollDelta(gfx::Vector2d(1, 1));
     m_scrollbarController->updateScrollOffsetAtTime(m_scrollLayer.get(), 1);
     m_scrollbarController->animate(2);
     EXPECT_FLOAT_EQ(1, m_scrollbarLayer->opacity());
diff --git a/cc/scrollbar_geometry_fixed_thumb.cc b/cc/scrollbar_geometry_fixed_thumb.cc
index 9997011..74172ce 100644
--- a/cc/scrollbar_geometry_fixed_thumb.cc
+++ b/cc/scrollbar_geometry_fixed_thumb.cc
@@ -30,9 +30,9 @@ void ScrollbarGeometryFixedThumb::update(WebScrollbar* scrollbar)
     int length = ScrollbarGeometryStub::thumbLength(scrollbar);
 
     if (scrollbar->orientation() == WebScrollbar::Horizontal)
-        m_thumbSize = IntSize(length, scrollbar->size().height);
+        m_thumbSize = gfx::Size(length, scrollbar->size().height);
     else
-        m_thumbSize = IntSize(scrollbar->size().width, length);
+        m_thumbSize = gfx::Size(scrollbar->size().width, length);
 }
 
 WebScrollbarThemeGeometry* ScrollbarGeometryFixedThumb::clone() const
diff --git a/cc/scrollbar_geometry_fixed_thumb.h b/cc/scrollbar_geometry_fixed_thumb.h
index 1deed9d..1480372 100644
--- a/cc/scrollbar_geometry_fixed_thumb.h
+++ b/cc/scrollbar_geometry_fixed_thumb.h
@@ -5,9 +5,9 @@
 #ifndef CC_SCROLLBAR_GEOMETRY_FIXED_THUMB_H_
 #define CC_SCROLLBAR_GEOMETRY_FIXED_THUMB_H_
 
-#include "IntSize.h"
 #include "cc/cc_export.h"
 #include "cc/scrollbar_geometry_stub.h"
+#include "ui/gfx/size.h"
 
 namespace cc {
 
@@ -32,7 +32,7 @@ public:
 private:
     explicit ScrollbarGeometryFixedThumb(scoped_ptr<WebKit::WebScrollbarThemeGeometry>);
 
-    IntSize m_thumbSize;
+    gfx::Size m_thumbSize;
 };
 
 }
diff --git a/cc/scrollbar_layer_unittest.cc b/cc/scrollbar_layer_unittest.cc
index 44ea2e8..07ea242 100644
--- a/cc/scrollbar_layer_unittest.cc
+++ b/cc/scrollbar_layer_unittest.cc
@@ -97,9 +97,9 @@ TEST(ScrollbarLayerTest, scrollOffsetSynchronization)
     layerTreeRoot->addChild(contentLayer);
     layerTreeRoot->addChild(scrollbarLayer);
 
-    layerTreeRoot->setScrollPosition(IntPoint(10, 20));
-    layerTreeRoot->setMaxScrollPosition(IntSize(30, 50));
-    contentLayer->setBounds(IntSize(100, 200));
+    layerTreeRoot->setScrollOffset(gfx::Vector2d(10, 20));
+    layerTreeRoot->setMaxScrollOffset(gfx::Vector2d(30, 50));
+    contentLayer->setBounds(gfx::Size(100, 200));
 
     scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), 0);
 
@@ -109,9 +109,9 @@ TEST(ScrollbarLayerTest, scrollOffsetSynchronization)
     EXPECT_EQ(100, ccScrollbarLayer->totalSize());
     EXPECT_EQ(30, ccScrollbarLayer->maximum());
 
-    layerTreeRoot->setScrollPosition(IntPoint(100, 200));
-    layerTreeRoot->setMaxScrollPosition(IntSize(300, 500));
-    contentLayer->setBounds(IntSize(1000, 2000));
+    layerTreeRoot->setScrollOffset(gfx::Vector2d(100, 200));
+    layerTreeRoot->setMaxScrollOffset(gfx::Vector2d(300, 500));
+    contentLayer->setBounds(gfx::Size(1000, 2000));
 
     ScrollbarAnimationController* scrollbarController = layerImplTreeRoot->scrollbarAnimationController();
     layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), 0);
@@ -121,7 +121,7 @@ TEST(ScrollbarLayerTest, scrollOffsetSynchronization)
     EXPECT_EQ(1000, ccScrollbarLayer->totalSize());
     EXPECT_EQ(300, ccScrollbarLayer->maximum());
 
-    layerImplTreeRoot->scrollBy(FloatSize(12, 34));
+    layerImplTreeRoot->scrollBy(gfx::Vector2d(12, 34));
 
     EXPECT_EQ(112, ccScrollbarLayer->currentPos());
     EXPECT_EQ(1000, ccScrollbarLayer->totalSize());
diff --git a/cc/single_thread_proxy.cc b/cc/single_thread_proxy.cc
index baa0f2a..64b406b 100644
--- a/cc/single_thread_proxy.cc
+++ b/cc/single_thread_proxy.cc
@@ -62,9 +62,9 @@ bool SingleThreadProxy::compositeAndReadback(void *pixels, const gfx::Rect& rect
     return true;
 }
 
-void SingleThreadProxy::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, base::TimeDelta duration)
+void SingleThreadProxy::startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration)
 {
-    m_layerTreeHostImpl->startPageScaleAnimation(targetPosition, useAnchor, scale, base::TimeTicks::Now(), duration);
+    m_layerTreeHostImpl->startPageScaleAnimation(targetOffset, useAnchor, scale, base::TimeTicks::Now(), duration);
 }
 
 void SingleThreadProxy::finishAllRendering()
diff --git a/cc/single_thread_proxy.h b/cc/single_thread_proxy.h
index f91d7b6..db73ee4 100644
--- a/cc/single_thread_proxy.h
+++ b/cc/single_thread_proxy.h
@@ -23,7 +23,7 @@ public:
 
     // Proxy implementation
     virtual bool compositeAndReadback(void *pixels, const gfx::Rect&) OVERRIDE;
-    virtual void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, base::TimeDelta duration) OVERRIDE;
+    virtual void startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration) OVERRIDE;
     virtual void finishAllRendering() OVERRIDE;
     virtual bool isStarted() const OVERRIDE;
     virtual bool initializeContext() OVERRIDE;
diff --git a/cc/stubs/FloatPoint.h b/cc/stubs/FloatPoint.h
deleted file mode 100644
index df1fe9f..0000000
--- a/cc/stubs/FloatPoint.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// Copyright 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.
-
-// Temporary forwarding header
-#include "cc/stubs/float_point.h"
diff --git a/cc/stubs/FloatSize.h b/cc/stubs/FloatSize.h
deleted file mode 100644
index f5d5c4e..0000000
--- a/cc/stubs/FloatSize.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// Copyright 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.
-
-// Temporary forwarding header
-#include "cc/stubs/float_size.h"
diff --git a/cc/stubs/IntPoint.h b/cc/stubs/IntPoint.h
deleted file mode 100644
index d996ea8..0000000
--- a/cc/stubs/IntPoint.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// Copyright 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.
-
-// Temporary forwarding header
-#include "cc/stubs/int_point.h"
diff --git a/cc/stubs/IntSize.h b/cc/stubs/IntSize.h
deleted file mode 100644
index 4508c69..0000000
--- a/cc/stubs/IntSize.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// Copyright 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.
-
-// Temporary forwarding header
-#include "cc/stubs/int_size.h"
diff --git a/cc/stubs/float_point.h b/cc/stubs/float_point.h
deleted file mode 100644
index c5f5191..0000000
--- a/cc/stubs/float_point.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// 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.
-
-#ifndef CC_STUBS_FLOATPOINT_H_
-#define CC_STUBS_FLOATPOINT_H_
-
-#include "FloatSize.h"
-#include "IntPoint.h"
-#if INSIDE_WEBKIT_BUILD
-#include "Source/WebCore/platform/graphics/FloatPoint.h"
-#else
-#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatPoint.h"
-#endif
-#include "ui/gfx/point_f.h"
-
-namespace cc {
-
-class FloatPoint : public WebCore::FloatPoint {
-public:
-    FloatPoint() { }
-
-    FloatPoint(float width, float height)
-        : WebCore::FloatPoint(width, height)
-    {
-    }
-
-    FloatPoint(FloatSize size)
-        : WebCore::FloatPoint(size)
-    {
-    }
-
-    FloatPoint(IntPoint point)
-        : WebCore::FloatPoint(point)
-    {
-    }
-
-    FloatPoint(WebCore::IntPoint point)
-        : WebCore::FloatPoint(point)
-    {
-    }
-
-    FloatPoint(WebCore::FloatPoint point)
-        : WebCore::FloatPoint(point.x(), point.y())
-    {
-    }
-
-    explicit FloatPoint(gfx::PointF point)
-        : WebCore::FloatPoint(point.x(), point.y())
-    {
-    }
-
-    operator gfx::PointF() const { return gfx::PointF(x(), y()); }
-};
-
-}
-
-#endif
diff --git a/cc/stubs/float_size.h b/cc/stubs/float_size.h
deleted file mode 100644
index 2193ac0..0000000
--- a/cc/stubs/float_size.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// 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.
-
-#ifndef CC_STUBS_FLOATSIZE_H_
-#define CC_STUBS_FLOATSIZE_H_
-
-#include "IntSize.h"
-#if INSIDE_WEBKIT_BUILD
-#include "Source/WebCore/platform/graphics/FloatSize.h"
-#else
-#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatSize.h"
-#endif
-#include "ui/gfx/size_f.h"
-#include "ui/gfx/vector2d_f.h"
-
-namespace cc {
-class FloatSize : public WebCore::FloatSize {
-public:
-    FloatSize() { }
-
-    FloatSize(float width, float height)
-        : WebCore::FloatSize(width, height)
-    {
-    }
-
-    FloatSize(IntSize size)
-        : WebCore::FloatSize(size.width(), size.height())
-    {
-    }
-
-    FloatSize(WebCore::FloatSize size)
-        : WebCore::FloatSize(size.width(), size.height())
-    {
-    }
-
-    FloatSize(WebCore::IntSize size)
-        : WebCore::FloatSize(size.width(), size.height())
-    {
-    }
-
-    explicit FloatSize(gfx::SizeF size)
-        : WebCore::FloatSize(size.width(), size.height())
-    {
-    }
-
-    explicit FloatSize(gfx::Vector2dF vector)
-        : WebCore::FloatSize(vector.x(), vector.y())
-    {
-    }
-
-    operator gfx::SizeF() const { return gfx::SizeF(width(), height()); }
-
-    operator gfx::Vector2dF() const { return gfx::Vector2dF(width(), height()); }
-};
-
-}
-
-#endif
diff --git a/cc/stubs/int_point.h b/cc/stubs/int_point.h
deleted file mode 100644
index 068c662..0000000
--- a/cc/stubs/int_point.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// 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.
-
-#ifndef CC_STUBS_INTPOINT_H_
-#define CC_STUBS_INTPOINT_H_
-
-#include "IntSize.h"
-#if INSIDE_WEBKIT_BUILD
-#include "Source/WebCore/platform/graphics/IntPoint.h"
-#else
-#include "third_party/WebKit/Source/WebCore/platform/graphics/IntPoint.h"
-#endif
-#include "ui/gfx/point.h"
-
-namespace cc {
-
-class IntPoint : public WebCore::IntPoint {
-public:
-    IntPoint() { }
-
-    IntPoint(int width, int height)
-        : WebCore::IntPoint(width, height)
-    {
-    }
-
-    IntPoint(IntSize size)
-        : WebCore::IntPoint(size.width(), size.height())
-    {
-    }
-
-    IntPoint(WebCore::IntPoint point)
-        : WebCore::IntPoint(point.x(), point.y())
-    {
-    }
-
-    explicit IntPoint(gfx::Point point)
-        : WebCore::IntPoint(point.x(), point.y())
-    {
-    }
-
-    operator gfx::Point() const { return gfx::Point(x(), y()); }
-};
-
-}
-
-#endif
diff --git a/cc/stubs/int_size.h b/cc/stubs/int_size.h
deleted file mode 100644
index 9e1c3e6..0000000
--- a/cc/stubs/int_size.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// 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.
-
-#ifndef CC_STUBS_INTSIZE_H_
-#define CC_STUBS_INTSIZE_H_
-
-#if INSIDE_WEBKIT_BUILD
-#include "Source/WebCore/platform/graphics/IntSize.h"
-#else
-#include "third_party/WebKit/Source/WebCore/platform/graphics/IntSize.h"
-#endif
-#include "ui/gfx/size.h"
-#include "ui/gfx/vector2d.h"
-
-namespace cc {
-
-class IntSize : public WebCore::IntSize {
-public:
-    IntSize() { }
-
-    IntSize(int width, int height)
-        : WebCore::IntSize(width, height)
-    {
-    }
-
-    IntSize(WebCore::IntSize size)
-        : WebCore::IntSize(size.width(), size.height())
-    {
-
-    }
-
-    explicit IntSize(gfx::Size size)
-        : WebCore::IntSize(size.width(), size.height())
-    {
-    }
-
-    explicit IntSize(gfx::Vector2d vector)
-        : WebCore::IntSize(vector.x(), vector.y())
-    {
-    }
-
-    operator gfx::Size() const { return gfx::Size(width(), height()); }
-
-    operator gfx::Vector2d() const { return gfx::Vector2d(width(), height()); }
-};
-
-}
-
-#endif
diff --git a/cc/test/fake_layer_tree_host_client.h b/cc/test/fake_layer_tree_host_client.h
index 8140495..78e7a8f 100644
--- a/cc/test/fake_layer_tree_host_client.h
+++ b/cc/test/fake_layer_tree_host_client.h
@@ -20,7 +20,7 @@ public:
     virtual void didBeginFrame() OVERRIDE { }
     virtual void animate(double monotonicFrameBeginTime) OVERRIDE { }
     virtual void layout() OVERRIDE { }
-    virtual void applyScrollAndScale(const IntSize& scrollDelta, float pageScale) OVERRIDE { }
+    virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float pageScale) OVERRIDE { }
 
     virtual scoped_ptr<WebKit::WebCompositorOutputSurface> createOutputSurface() OVERRIDE;
     virtual void didRecreateOutputSurface(bool success) OVERRIDE { }
diff --git a/cc/test/geometry_test_utils.h b/cc/test/geometry_test_utils.h
index 7877a64..52cb814 100644
--- a/cc/test/geometry_test_utils.h
+++ b/cc/test/geometry_test_utils.h
@@ -13,32 +13,38 @@ namespace WebKitTests {
 
 // These are macros instead of functions so that we get useful line numbers where a test failed.
 #define EXPECT_FLOAT_RECT_EQ(expected, actual) \
-{ \
+do { \
     EXPECT_FLOAT_EQ((expected).x(), (actual).x()); \
     EXPECT_FLOAT_EQ((expected).y(), (actual).y()); \
     EXPECT_FLOAT_EQ((expected).width(), (actual).width()); \
     EXPECT_FLOAT_EQ((expected).height(), (actual).height()); \
-}
+} while (false)
 
 #define EXPECT_RECT_EQ(expected, actual) \
-{ \
+do { \
     EXPECT_EQ((expected).x(), (actual).x()); \
     EXPECT_EQ((expected).y(), (actual).y()); \
     EXPECT_EQ((expected).width(), (actual).width()); \
     EXPECT_EQ((expected).height(), (actual).height()); \
-}
+} while (false)
 
 #define EXPECT_SIZE_EQ(expected, actual) \
-{ \
+do { \
     EXPECT_EQ((expected).width(), (actual).width()); \
     EXPECT_EQ((expected).height(), (actual).height()); \
-}
+} while (false)
 
 #define EXPECT_POINT_EQ(expected, actual) \
-{ \
+do { \
     EXPECT_EQ((expected).x(), (actual).x()); \
     EXPECT_EQ((expected).y(), (actual).y()); \
-}
+} while (false)
+
+#define EXPECT_VECTOR_EQ(expected, actual) \
+do { \
+    EXPECT_EQ((expected).x(), (actual).x()); \
+    EXPECT_EQ((expected).y(), (actual).y()); \
+} while (false)
 
 // This is a function rather than a macro because when this is included as a macro
 // in bulk, it causes a significant slow-down in compilation time. This problem
diff --git a/cc/test/layer_tree_test_common.cc b/cc/test/layer_tree_test_common.cc
index 65a2904..1842d17 100644
--- a/cc/test/layer_tree_test_common.cc
+++ b/cc/test/layer_tree_test_common.cc
@@ -219,7 +219,7 @@ public:
         m_testHooks->layout();
     }
 
-    virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale) OVERRIDE
+  virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
     {
         m_testHooks->applyScrollAndScale(scrollDelta, scale);
     }
diff --git a/cc/test/layer_tree_test_common.h b/cc/test/layer_tree_test_common.h
index ad044d5..0e02cfa 100644
--- a/cc/test/layer_tree_test_common.h
+++ b/cc/test/layer_tree_test_common.h
@@ -34,7 +34,7 @@ public:
     virtual void drawLayersOnThread(cc::LayerTreeHostImpl*) { }
     virtual void animateLayers(cc::LayerTreeHostImpl*, base::TimeTicks monotonicTime) { }
     virtual void willAnimateLayers(cc::LayerTreeHostImpl*, base::TimeTicks monotonicTime) { }
-    virtual void applyScrollAndScale(const cc::IntSize&, float) { }
+    virtual void applyScrollAndScale(gfx::Vector2d, float) { }
     virtual void animate(base::TimeTicks monotonicTime) { }
     virtual void layout() { }
     virtual void didRecreateOutputSurface(bool succeeded) { }
diff --git a/cc/thread_proxy.cc b/cc/thread_proxy.cc
index ac58216..76272e7 100644
--- a/cc/thread_proxy.cc
+++ b/cc/thread_proxy.cc
@@ -117,17 +117,17 @@ void ThreadProxy::requestReadbackOnImplThread(ReadbackRequest* request)
     m_schedulerOnImplThread->setNeedsForcedRedraw();
 }
 
-void ThreadProxy::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, base::TimeDelta duration)
+void ThreadProxy::startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration)
 {
     DCHECK(Proxy::isMainThread());
-    Proxy::implThread()->postTask(base::Bind(&ThreadProxy::requestStartPageScaleAnimationOnImplThread, base::Unretained(this), targetPosition, useAnchor, scale, duration));
+    Proxy::implThread()->postTask(base::Bind(&ThreadProxy::requestStartPageScaleAnimationOnImplThread, base::Unretained(this), targetOffset, useAnchor, scale, duration));
 }
 
-void ThreadProxy::requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, base::TimeDelta duration)
+void ThreadProxy::requestStartPageScaleAnimationOnImplThread(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration)
 {
     DCHECK(Proxy::isImplThread());
     if (m_layerTreeHostImpl.get())
-        m_layerTreeHostImpl->startPageScaleAnimation(targetPosition, useAnchor, scale, base::TimeTicks::Now(), duration);
+        m_layerTreeHostImpl->startPageScaleAnimation(targetOffset, useAnchor, scale, base::TimeTicks::Now(), duration);
 }
 
 void ThreadProxy::finishAllRendering()
diff --git a/cc/thread_proxy.h b/cc/thread_proxy.h
index 1a24ec5..7e14347 100644
--- a/cc/thread_proxy.h
+++ b/cc/thread_proxy.h
@@ -30,7 +30,7 @@ public:
 
     // Proxy implementation
     virtual bool compositeAndReadback(void *pixels, const gfx::Rect&) OVERRIDE;
-    virtual void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, base::TimeDelta duration) OVERRIDE;
+    virtual void startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration) OVERRIDE;
     virtual void finishAllRendering() OVERRIDE;
     virtual bool isStarted() const OVERRIDE;
     virtual bool initializeContext() OVERRIDE;
@@ -111,7 +111,7 @@ private:
     void beginFrameCompleteOnImplThread(CompletionEvent*, ResourceUpdateQueue*);
     void beginFrameAbortedOnImplThread();
     void requestReadbackOnImplThread(ReadbackRequest*);
-    void requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, base::TimeDelta duration);
+    void requestStartPageScaleAnimationOnImplThread(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration);
     void finishAllRenderingOnImplThread(CompletionEvent*);
     void initializeImplOnImplThread(CompletionEvent*, InputHandler*);
     void setSurfaceReadyOnImplThread();
diff --git a/webkit/compositor_bindings/compositor_bindings.gyp b/webkit/compositor_bindings/compositor_bindings.gyp
index 3b1196b..9f6417c 100644
--- a/webkit/compositor_bindings/compositor_bindings.gyp
+++ b/webkit/compositor_bindings/compositor_bindings.gyp
@@ -86,8 +86,6 @@
       ],
       'sources': [
         '<@(webkit_compositor_bindings_sources)',
-        'webcore_convert.cc',
-        'webcore_convert.h',
       ],
     },
   ],
diff --git a/webkit/compositor_bindings/web_content_layer_impl.cc b/webkit/compositor_bindings/web_content_layer_impl.cc
index af0eecd..b42ca13 100644
--- a/webkit/compositor_bindings/web_content_layer_impl.cc
+++ b/webkit/compositor_bindings/web_content_layer_impl.cc
@@ -12,7 +12,6 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFloatRect.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
-#include "webcore_convert.h"
 
 using namespace cc;
 
diff --git a/webkit/compositor_bindings/web_layer_impl.cc b/webkit/compositor_bindings/web_layer_impl.cc
index c92d989..0fcb74f 100644
--- a/webkit/compositor_bindings/web_layer_impl.cc
+++ b/webkit/compositor_bindings/web_layer_impl.cc
@@ -18,7 +18,6 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebTransformationMatrix.h"
 #include "web_animation_impl.h"
-#include "webcore_convert.h"
 
 using cc::ActiveAnimation;
 using cc::Layer;
@@ -346,22 +345,22 @@ void WebLayerImpl::setForceRenderSurface(bool forceRenderSurface)
 
 void WebLayerImpl::setScrollPosition(WebPoint position)
 {
-    m_layer->setScrollPosition(convert(position));
+    m_layer->setScrollOffset(gfx::Point(position).OffsetFromOrigin());
 }
 
 WebPoint WebLayerImpl::scrollPosition() const
 {
-    return WebPoint(m_layer->scrollPosition().x(), m_layer->scrollPosition().y());
+    return gfx::PointAtOffsetFromOrigin(m_layer->scrollOffset());
 }
 
 void WebLayerImpl::setMaxScrollPosition(WebSize maxScrollPosition)
 {
-    m_layer->setMaxScrollPosition(convert(maxScrollPosition));
+    m_layer->setMaxScrollOffset(maxScrollPosition);
 }
 
 WebSize WebLayerImpl::maxScrollPosition() const
 {
-    return convert(m_layer->maxScrollPosition());
+    return m_layer->maxScrollOffset();
 }
 
 void WebLayerImpl::setScrollable(bool scrollable)
diff --git a/webkit/compositor_bindings/web_layer_tree_view_impl.cc b/webkit/compositor_bindings/web_layer_tree_view_impl.cc
index 9f3e893..02aa48b 100644
--- a/webkit/compositor_bindings/web_layer_tree_view_impl.cc
+++ b/webkit/compositor_bindings/web_layer_tree_view_impl.cc
@@ -16,7 +16,6 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebLayerTreeView.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRenderingStats.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
-#include "webcore_convert.h"
 #include "web_layer_impl.h"
 #include "web_to_ccinput_handler_adapter.h"
 
@@ -130,7 +129,7 @@ void WebLayerTreeViewImpl::setPageScaleFactorAndLimits(float pageScaleFactor, fl
 void WebLayerTreeViewImpl::startPageScaleAnimation(const WebPoint& scroll, bool useAnchor, float newPageScale, double durationSec)
 {
     base::TimeDelta duration = base::TimeDelta::FromMicroseconds(durationSec * base::Time::kMicrosecondsPerSecond);
-    m_layerTreeHost->startPageScaleAnimation(IntSize(scroll.x, scroll.y), useAnchor, newPageScale, duration);
+    m_layerTreeHost->startPageScaleAnimation(gfx::Vector2d(scroll.x, scroll.y), useAnchor, newPageScale, duration);
 }
 
 void WebLayerTreeViewImpl::setNeedsAnimate()
@@ -231,9 +230,9 @@ void WebLayerTreeViewImpl::layout()
     m_client->layout();
 }
 
-void WebLayerTreeViewImpl::applyScrollAndScale(const cc::IntSize& scrollDelta, float pageScale)
+void WebLayerTreeViewImpl::applyScrollAndScale(gfx::Vector2d scrollDelta, float pageScale)
 {
-    m_client->applyScrollAndScale(convert(scrollDelta), pageScale);
+    m_client->applyScrollAndScale(scrollDelta, pageScale);
 }
 
 scoped_ptr<WebCompositorOutputSurface> WebLayerTreeViewImpl::createOutputSurface()
diff --git a/webkit/compositor_bindings/web_layer_tree_view_impl.h b/webkit/compositor_bindings/web_layer_tree_view_impl.h
index 42d4a49..0d7de7f 100644
--- a/webkit/compositor_bindings/web_layer_tree_view_impl.h
+++ b/webkit/compositor_bindings/web_layer_tree_view_impl.h
@@ -58,7 +58,7 @@ public:
     virtual void didBeginFrame() OVERRIDE;
     virtual void animate(double monotonicFrameBeginTime) OVERRIDE;
     virtual void layout() OVERRIDE;
-    virtual void applyScrollAndScale(const cc::IntSize& scrollDelta, float pageScale) OVERRIDE;
+    virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float pageScale) OVERRIDE;
     virtual scoped_ptr<WebCompositorOutputSurface> createOutputSurface() OVERRIDE;
     virtual void didRecreateOutputSurface(bool success) OVERRIDE;
     virtual scoped_ptr<cc::InputHandler> createInputHandler() OVERRIDE;
diff --git a/webkit/compositor_bindings/web_to_ccinput_handler_adapter.cc b/webkit/compositor_bindings/web_to_ccinput_handler_adapter.cc
index 7da1383..b8bb602 100644
--- a/webkit/compositor_bindings/web_to_ccinput_handler_adapter.cc
+++ b/webkit/compositor_bindings/web_to_ccinput_handler_adapter.cc
@@ -6,10 +6,7 @@
 
 #include "web_to_ccinput_handler_adapter.h"
 
-#include "cc/stubs/int_point.h"
-#include "cc/stubs/int_size.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebInputHandlerClient.h"
-#include "webcore_convert.h"
 
 #define COMPILE_ASSERT_MATCHING_ENUM(webkit_name, cc_name) \
     COMPILE_ASSERT(int(WebKit::webkit_name) == int(cc::cc_name), mismatching_enums)
@@ -54,7 +51,7 @@ public:
 
     virtual void scrollBy(WebPoint point, WebSize offset) OVERRIDE
     {
-        m_client->scrollBy(point, convert(offset));
+        m_client->scrollBy(point, offset);
     }
 
     virtual void scrollEnd() OVERRIDE
@@ -69,7 +66,7 @@ public:
 
     virtual void pinchGestureUpdate(float magnifyDelta, WebPoint anchor) OVERRIDE
     {
-        m_client->pinchGestureUpdate(magnifyDelta, convert(anchor));
+        m_client->pinchGestureUpdate(magnifyDelta, anchor);
     }
 
     virtual void pinchGestureEnd() OVERRIDE
@@ -85,7 +82,7 @@ public:
     {
         base::TimeTicks startTime = base::TimeTicks::FromInternalValue(startTimeSec * base::Time::kMicrosecondsPerSecond);
         base::TimeDelta duration = base::TimeDelta::FromMicroseconds(durationSec * base::Time::kMicrosecondsPerSecond);
-        m_client->startPageScaleAnimation(convert(targetPosition), anchorPoint, pageScale, startTime, duration);
+        m_client->startPageScaleAnimation(targetPosition, anchorPoint, pageScale, startTime, duration);
     }
 
     virtual void scheduleAnimation() OVERRIDE
diff --git a/webkit/compositor_bindings/webcore_convert.cc b/webkit/compositor_bindings/webcore_convert.cc
deleted file mode 100644
index 5e887c0..0000000
--- a/webkit/compositor_bindings/webcore_convert.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-// 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 "config.h"
-
-#include "webcore_convert.h"
-
-namespace WebKit {
-
-WebCore::FloatPoint convert(const WebFloatPoint& point)
-{
-    return WebCore::FloatPoint(point.x, point.y);
-}
-
-WebCore::IntPoint convert(const WebPoint& point)
-{
-    return WebCore::IntPoint(point.x, point.y);
-}
-
-WebCore::IntSize convert(const WebSize& size)
-{
-    return WebCore::IntSize(size.width, size.height);
-}
-
-WebSize convert(const WebCore::IntSize& size)
-{
-    return WebSize(size.width(), size.height());
-}
-
-WebFloatPoint convert(const WebCore::FloatPoint& point)
-{
-    return WebFloatPoint(point.x(), point.y());
-}
-
-}
-
-
diff --git a/webkit/compositor_bindings/webcore_convert.h b/webkit/compositor_bindings/webcore_convert.h
deleted file mode 100644
index c81c533..0000000
--- a/webkit/compositor_bindings/webcore_convert.h
+++ /dev/null
@@ -1,26 +0,0 @@
-// 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.
-
-#ifndef WEBKIT_COMPOSITOR_BINDINGS_WEBCORE_CONVERT_H_
-#define WEBKIT_COMPOSITOR_BINDINGS_WEBCORE_CONVERT_H_
-
-#include "FloatPoint.h"
-#include "IntPoint.h"
-#include "IntSize.h"
-#include <public/WebFloatPoint.h>
-#include <public/WebRect.h>
-#include <public/WebPoint.h>
-#include <public/WebSize.h>
-
-namespace WebKit {
-
-WebCore::FloatPoint convert(const WebFloatPoint& point);
-WebCore::IntPoint convert(const WebPoint& point);
-WebCore::IntSize convert(const WebSize& size);
-WebSize convert(const WebCore::IntSize& size);
-WebFloatPoint convert(const WebCore::FloatPoint& point);
-
-}
-
-#endif  // WEBKIT_COMPOSITOR_BINDINGS_WEBCORE_CONVERT_H_