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

cc/layer_tree_host_impl.cc

Index: cc/layer_tree_host_impl.cc
diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc
index 73568ffc3980770b8d8d75d02428522e7cf3552d..2f5ee5ca2fe4953a97a3a188c7e7fe3e190e458d 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();