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

cc/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/layer_tree_host_impl.h"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "cc/append_quads_data.h"
 #include "cc/damage_tracker.h"
 #include "cc/debug_rect_history.h"
 #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"
 #include "cc/layer_tree_host.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/math_util.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/page_scale_animation.h"
 #include "cc/prioritized_texture_manager.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/rendering_stats.h"
 #include "cc/scrollbar_animation_controller.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/settings.h"
 #include "cc/single_thread_proxy.h"
 #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;
 
 namespace {
 
 void didVisibilityChange(cc::LayerTreeHostImpl* id, bool visible)
 {
     if (visible) {
         TRACE_EVENT_ASYNC_BEGIN1("webkit", "LayerTreeHostImpl::setVisible", id, "LayerTreeHostImpl", id);
@@ skipping 49 matching lines @@
     m_pageScaleFactor = pageScaleFactor;
     return true;
 }
 
 gfx::RectF PinchZoomViewport::bounds() const
 {
     gfx::SizeF scaledViewportSize = m_layoutViewportSize;
     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();
 
     pinchedBounds.Offset(delta);
     if (pinchedBounds.x() < 0) {
         overflow.set_x(pinchedBounds.x());
         pinchedBounds.set_x(0);
     }
 
     if (pinchedBounds.y() < 0) {
         overflow.set_y(pinchedBounds.y());
         pinchedBounds.set_y(0);
     }
 
     if (pinchedBounds.right() > m_layoutViewportSize.width()) {
         overflow.set_x(pinchedBounds.right() - m_layoutViewportSize.width());
         pinchedBounds.Offset(m_layoutViewportSize.width() - pinchedBounds.right(), 0);
     }
 
     if (pinchedBounds.bottom() > m_layoutViewportSize.height()) {
         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
 {
     WebTransformationMatrix transform;
     transform.scale(m_pageScaleDelta);
 
     // If the pinch state is applied in the impl, then push it to the
     // impl transform, otherwise the scale is handled by WebCore.
     if (Settings::pageScalePinchZoomEnabled()) {
@@ skipping 95 matching lines @@
 
 void LayerTreeHostImpl::beginCommit()
 {
 }
 
 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();
 }
 
 bool LayerTreeHostImpl::canDraw()
 {
     // Note: If you are changing this function or any other function that might
     // affect the result of canDraw, make sure to call m_client->onCanDrawStateChanged
     // in the proper places and update the notifyIfCanDrawChanged test.
 
     if (!m_rootLayerImpl) {
@@ skipping 20 matching lines @@
     return m_context.get();
 }
 
 void LayerTreeHostImpl::animate(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
     animatePageScale(monotonicTime);
     animateLayers(monotonicTime, wallClockTime);
     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();
 }
 
 void LayerTreeHostImpl::scheduleAnimation()
 {
     m_client->setNeedsRedrawOnImplThread();
 }
 
@@ skipping 560 matching lines @@
 }
 
 void LayerTreeHostImpl::setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize)
 {
     if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_deviceViewportSize)
         return;
 
     m_layoutViewportSize = layoutViewportSize;
     m_deviceViewportSize = deviceViewportSize;
 
-    m_pinchZoomViewport.setLayoutViewportSize(FloatSize(layoutViewportSize));
+    m_pinchZoomViewport.setLayoutViewportSize(layoutViewportSize);
 
-    updateMaxScrollPosition();
+    updateMaxScrollOffset();
 
     if (m_renderer)
         m_renderer->viewportChanged();
 
     m_client->onCanDrawStateChanged(canDraw());
 }
 
 static void adjustScrollsForPageScaleChange(LayerImpl* layerImpl, float pageScaleChange)
 {
     if (!layerImpl)
         return;
 
     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);
     }
 
     for (size_t i = 0; i < layerImpl->children().size(); ++i)
         adjustScrollsForPageScaleChange(layerImpl->children()[i], pageScaleChange);
 }
 
 void LayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor)
 {
     if (deviceScaleFactor == m_deviceScaleFactor)
         return;
     m_deviceScaleFactor = deviceScaleFactor;
 
-    updateMaxScrollPosition();
+    updateMaxScrollOffset();
 }
 
 float LayerTreeHostImpl::pageScaleFactor() const
 {
     return m_pinchZoomViewport.pageScaleFactor();
 }
 
 void LayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
 {
     if (!pageScaleFactor)
       return;
 
     float pageScaleChange = pageScaleFactor / m_pinchZoomViewport.pageScaleFactor();
     m_pinchZoomViewport.setPageScaleFactorAndLimits(pageScaleFactor, minPageScaleFactor, maxPageScaleFactor);
 
     if (!Settings::pageScalePinchZoomEnabled()) {
         if (pageScaleChange != 1)
             adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange);
     }
 
     // Clamp delta to limits and refresh display matrix.
     setPageScaleDelta(m_pinchZoomViewport.pageScaleDelta() / m_pinchZoomViewport.sentPageScaleDelta());
     m_pinchZoomViewport.setSentPageScaleDelta(1);
 }
 
 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;
 
     gfx::SizeF viewBounds = m_deviceViewportSize;
     if (LayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) {
         // Compensate for non-overlay scrollbars.
         if (clipLayer->masksToBounds()) {
             viewBounds = clipLayer->bounds();
             viewBounds = viewBounds.Scale(m_deviceScaleFactor);
         }
     }
 
     gfx::Size contentBounds = contentSize();
     if (Settings::pageScalePinchZoomEnabled()) {
         // Pinch with pageScale scrolls entirely in layout space.  contentSize
         // returns the bounds including the page scale factor, so calculate the
         // pre page-scale layout size here.
         float pageScaleFactor = m_pinchZoomViewport.pageScaleFactor();
         contentBounds.set_width(contentBounds.width() / pageScaleFactor);
         contentBounds.set_height(contentBounds.height() / pageScaleFactor);
     } else {
         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()
 {
     m_client->setNeedsRedrawOnImplThread();
 }
 
 bool LayerTreeHostImpl::ensureRenderSurfaceLayerList()
 {
     if (!m_rootLayerImpl)
         return false;
     if (!m_renderer)
         return false;
 
     // We need both a non-empty render surface layer list and a root render
     // surface to be able to iterate over the visible layers.
     if (m_renderSurfaceLayerList.size() && m_rootLayerImpl->renderSurface())
         return true;
 
     // If we are called after setRootLayer() but before prepareToDraw(), we need
     // to recalculate the visible layers. This prevents being unable to scroll
     // during part of a commit.
     m_renderSurfaceLayerList.clear();
     calculateRenderSurfaceLayerList(m_renderSurfaceLayerList);
 
     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");
 
     DCHECK(!m_currentlyScrollingLayerImpl);
     clearCurrentlyScrollingLayer();
 
     if (!ensureRenderSurfaceLayerList())
         return ScrollIgnored;
 
     gfx::PointF deviceViewportPoint = viewportPoint.Scale(m_deviceScaleFactor);
@@ skipping 32 matching lines @@
         // Gesture events need to be transformed from viewport coordinates to local layer coordinates
         // so that the scrolling contents exactly follow the user's finger. In contrast, wheel
         // events are already in local layer coordinates so we can just apply them directly.
         m_scrollDeltaIsInViewportSpace = (type == Gesture);
         m_numImplThreadScrolls++;
         return ScrollStarted;
     }
     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.
     DCHECK(layerImpl.screenSpaceTransform().isInvertible());
     WebTransformationMatrix inverseScreenSpaceTransform = layerImpl.screenSpaceTransform().inverse();
 
     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.
     bool startClipped, endClipped;
     gfx::PointF screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta;
     gfx::PointF localStartPoint = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, startClipped);
     gfx::PointF localEndPoint = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpaceEndPoint, endClipped);
 
     // In general scroll point coordinates should not get clipped.
     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();
     float heightScale = 1 / layerImpl.contentsScaleY();
     localStartPoint = localStartPoint.Scale(widthScale, heightScale);
     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);
 
     // Get the end point in the layer's content space so we can apply its screenSpaceTransform.
     gfx::PointF actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() - previousDelta;
     gfx::PointF actualLocalContentEndPoint = actualLocalEndPoint.Scale(1 / widthScale, 1 / heightScale);
 
     // Calculate the applied scroll delta in viewport space coordinates.
     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);
         } else
             appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta);
 
         // 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();
     }
 }
 
 void LayerTreeHostImpl::clearCurrentlyScrollingLayer()
 {
     m_currentlyScrollingLayerImpl = 0;
     m_scrollingLayerIdFromPreviousTree = -1;
 }
 
 void LayerTreeHostImpl::scrollEnd()
 {
     clearCurrentlyScrollingLayer();
 }
 
 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();
 
     m_client->setNeedsCommitOnImplThread();
     m_client->setNeedsRedrawOnImplThread();
 }
 
 void LayerTreeHostImpl::pinchGestureEnd()
 {
     m_pinchGestureActive = false;
 
     if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationController())
         m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureEnd();
 
     m_client->setNeedsCommitOnImplThread();
 }
 
 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)
 {
     if (!m_rootScrollLayerImpl)
         return;
 
     // Only send fake scroll/zoom deltas if we're pinch zooming out by a
     // significant amount. This also ensures only one fake delta set will be
     // sent.
     const float pinchZoomOutSensitivity = 0.95f;
     if (m_pinchZoomViewport.pageScaleDelta() > pinchZoomOutSensitivity)
         return;
 
     // 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();
     m_pinchZoomViewport.setSentPageScaleDelta(scrollInfo->pageScaleDelta);
 }
 
 static void collectScrollDeltas(ScrollAndScaleSet* scrollInfo, LayerImpl* layerImpl)
 {
     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;
         scrollInfo->scrolls.push_back(scroll);
         layerImpl->setSentScrollDelta(scrollDelta);
     }
 
     for (size_t i = 0; i < layerImpl->children().size(); ++i)
         collectScrollDeltas(scrollInfo, layerImpl->children()[i]);
 }
@@ skipping 36 matching lines @@
             renderSurface->damageTracker()->forceFullDamageNextUpdate();
     }
 }
 
 void LayerTreeHostImpl::animatePageScale(base::TimeTicks time)
 {
     if (!m_pageScaleAnimation || !m_rootScrollLayerImpl)
         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();
 
     if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) {
         m_pageScaleAnimation.reset();
         m_client->setNeedsCommitOnImplThread();
     }
 }
 
 void LayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
@@ skipping 94 matching lines @@
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc