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

cc/layer_tree_host_impl_unittest.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/bind.h"
 #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"
 #include "cc/layer_impl.h"
 #include "cc/layer_tiling_data.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/scrollbar_geometry_fixed_thumb.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/settings.h"
@@ skipping 10 matching lines @@
 #include "cc/texture_draw_quad.h"
 #include "cc/texture_layer_impl.h"
 #include "cc/tile_draw_quad.h"
 #include "cc/tiled_layer_impl.h"
 #include "cc/video_layer_impl.h"
 #include "media/base/media.h"
 #include "media/base/video_frame.h"
 #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>
 
 using namespace cc;
 using namespace LayerTestCommon;
 using namespace WebKit;
 using namespace WebKitTests;
 
 using media::VideoFrame;
 using ::testing::Mock;
@@ skipping 62 matching lines @@
         root->setBounds(gfx::Size(10, 10));
         root->setContentBounds(gfx::Size(10, 10));
         root->setVisibleContentRect(gfx::Rect(0, 0, 10, 10));
         root->setDrawsContent(true);
         myHostImpl->setRootLayer(root.Pass());
         return myHostImpl.Pass();
     }
 
     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++;
         }
 
         ASSERT_EQ(timesEncountered, 1);
     }
 
     void setupScrollAndContentsLayers(const gfx::Size& contentSize)
     {
         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));
         root->setAnchorPoint(gfx::PointF(0, 0));
 
         scoped_ptr<LayerImpl> contents = LayerImpl::create(2);
         contents->setDrawsContent(true);
         contents->setBounds(contentSize);
         contents->setContentBounds(contentSize);
         contents->setPosition(gfx::PointF(0, 0));
         contents->setAnchorPoint(gfx::PointF(0, 0));
         root->addChild(contents.Pass());
         m_hostImpl->setRootLayer(root.Pass());
     }
 
     static scoped_ptr<LayerImpl> createScrollableLayer(int id, const gfx::Size& size)
     {
         scoped_ptr<LayerImpl> layer = LayerImpl::create(id);
         layer->setScrollable(true);
         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();
     }
 
     void initializeRendererAndDrawFrame()
     {
         m_hostImpl->initializeRenderer(createContext());
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         m_hostImpl->drawLayers(frame);
         m_hostImpl->didDrawAllLayers(frame);
@@ skipping 108 matching lines @@
     ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
     expectClearedScrollDeltasRecursive(root);
 
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
     expectClearedScrollDeltasRecursive(root);
 }
 
 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());
     }
     LayerImpl* root = m_hostImpl->rootLayer();
 
     scoped_ptr<ScrollAndScaleSet> scrollInfo;
 
     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);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollRootCallsCommitAndRedraw)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     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);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollWithoutRootLayer)
 {
     // We should not crash when trying to scroll an empty layer tree.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
 }
@@ skipping 21 matching lines @@
     m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
 
     // We should not crash if the tree is replaced while we are scrolling.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->detachLayerTree();
 
     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();
     expectContains(*scrollInfo, scrollLayerId, scrollDelta);
 }
 
 TEST_P(LayerTreeHostImplTest, clearRootRenderSurfaceAndScroll)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
@@ skipping 42 matching lines @@
     LayerImpl* root = m_hostImpl->rootLayer();
 
     root->setNonFastScrollableRegion(gfx::Rect(0, 0, 50, 50));
 
     // All scroll types inside the non-fast scrollable region should fail.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(25, 25), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(25, 25), InputHandlerClient::Gesture), InputHandlerClient::ScrollOnMainThread);
 
     // 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();
 }
 
 TEST_P(LayerTreeHostImplTest, nonFastScrollableRegionWithOffset)
 {
     setupScrollAndContentsLayers(gfx::Size(200, 200));
     m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
     LayerImpl* root = m_hostImpl->rootLayer();
 
     root->setNonFastScrollableRegion(gfx::Rect(0, 0, 50, 50));
     root->setPosition(gfx::PointF(-25, 0));
     initializeRendererAndDrawFrame();
 
     // 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));
 
     float deviceScaleFactor = 2;
     gfx::Size layoutViewport(25, 25);
     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)
 {
     // This test is specific to the page-scale based pinch zoom.
     if (!Settings::pageScalePinchZoomEnabled())
         return;
 
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
 
     LayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     DCHECK(scrollLayer);
 
     const float minPageScale = 1, maxPageScale = 4;
     const WebTransformationMatrix identityScaleTransform;
 
     // The impl-based pinch zoome should not adjust the max scroll position.
     {
         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);
 
         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
     // have the page scale factor applied.
     {
         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();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, pinchGesture)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
 
     LayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     DCHECK(scrollLayer);
 
     const float minPageScale = Settings::pageScalePinchZoomEnabled() ? 1 : 0.5;
     const float maxPageScale = 4;
     const WebTransformationMatrix identityScaleTransform;
 
     // Basic pinch zoom in gesture
     {
         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);
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
     }
 
     // Zoom-in clamping
     {
         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();
         EXPECT_EQ(scrollInfo->pageScaleDelta, maxPageScale);
     }
 
     // Zoom-out clamping
     {
         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();
         EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
 
         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());
         }
     }
 
     // Two-finger panning
     {
         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));
     }
 }
 
 TEST_P(LayerTreeHostImplTest, pageScaleAnimation)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
 
     LayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     DCHECK(scrollLayer);
 
     const float minPageScale = Settings::pageScalePinchZoomEnabled() ? 1 : 0.5;
     const float maxPageScale = 4;
     const base::TimeTicks startTime = base::TimeTicks() + base::TimeDelta::FromSeconds(1);
     const base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
     const base::TimeTicks halfwayThroughAnimation = startTime + duration / 2;
     const base::TimeTicks endTime = startTime + duration;
     const WebTransformationMatrix identityScaleTransform;
 
     // Non-anchor zoom-in
     {
         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());
         EXPECT_TRUE(m_didRequestCommit);
 
         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);
 
         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));
     }
 }
 
 TEST_P(LayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhilePinchZooming)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
 
     LayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     DCHECK(scrollLayer);
 
     const float minPageScale = Settings::pageScalePinchZoomEnabled() ? 1 : 0.5;
     const float maxPageScale = 4;
 
     // Pinch zoom in.
     {
         // Start a pinch in gesture at the bottom right corner of the viewport.
         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.
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, 1);
         EXPECT_EQ(scrollInfo->scrolls.size(), 0u);
 
         // Once the gesture ends, we get the final scroll and page scale values.
         m_hostImpl->pinchGestureEnd();
         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());
         }
     }
 
     // Pinch zoom out.
     {
         // Start a pinch out gesture at the bottom right corner of the viewport.
         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());
         }
 
         // Once the gesture ends, we get the final scroll and page scale values.
         m_hostImpl->pinchGestureEnd();
         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));
         }
     }
 }
 
 TEST_P(LayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhileAnimatingPageScale)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
 
     LayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     DCHECK(scrollLayer);
 
     const float minPageScale = Settings::pageScalePinchZoomEnabled() ? 1 : 0.5;
     const float maxPageScale = 4;
     const base::TimeTicks startTime = base::TimeTicks() + base::TimeDelta::FromSeconds(1);
     const base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
     const base::TimeTicks halfwayThroughAnimation = startTime + duration / 2;
     const base::TimeTicks endTime = startTime + duration;
     // 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.
     m_hostImpl->animate(halfwayThroughAnimation, base::Time());
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
 
     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();
 
     // The final page scale and scroll deltas should match what we got
     // earlier.
     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 {
 public:
     static scoped_ptr<LayerImpl> create(int id) { return scoped_ptr<LayerImpl>(new DidDrawCheckLayer(id)); }
 
     virtual void didDraw(ResourceProvider*) OVERRIDE
     {
         m_didDrawCalled = true;
     }
@@ skipping 234 matching lines @@
     contentLayer->setUseLCDText(true);
     contentLayer->setDrawsContent(true);
     contentLayer->setPosition(gfx::PointF(0, 0));
     contentLayer->setAnchorPoint(gfx::PointF(0, 0));
     contentLayer->setBounds(surfaceSize);
     contentLayer->setContentBounds(gfx::Size(surfaceSize.width() * 2, surfaceSize.height() * 2));
     contentLayer->setContentsScale(2, 2);
 
     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));
     scrollLayer->setAnchorPoint(gfx::PointF(0, 0));
     scrollLayer->addChild(contentLayer.Pass());
 
     m_hostImpl->setRootLayer(scrollLayer.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     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);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollChildCallsCommitAndRedraw)
 {
     gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     root->setBounds(surfaceSize);
     root->setContentBounds(surfaceSize);
     root->addChild(createScrollableLayer(2, surfaceSize));
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     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);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollMissesChild)
 {
     gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     root->addChild(createScrollableLayer(2, surfaceSize));
@@ skipping 50 matching lines @@
 
 TEST_P(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnMainThread)
 {
     gfx::Size surfaceSize(10, 10);
     float pageScale = 2;
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
     m_hostImpl->setRootLayer(root.Pass());
     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();
 
     // Set new page scale from main thread.
     m_hostImpl->setPageScaleFactorAndLimits(pageScale, pageScale, pageScale);
 
     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());
 }
 
 TEST_P(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnImplThread)
 {
     gfx::Size surfaceSize(10, 10);
     float pageScale = 2;
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     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();
 
     // The scroll delta is not scaled because the main thread did not scale.
     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 should match the new scale on the impl side.
     WebTransformationMatrix expectedScale;
     expectedScale.scale(pageScale);
     EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), expectedScale);
 }
 
 TEST_P(LayerTreeHostImplTest, pageScaleDeltaAppliedToRootScrollLayerOnly)
 {
     gfx::Size surfaceSize(10, 10);
     float defaultPageScale = 1;
     WebTransformationMatrix defaultPageScaleMatrix;
 
     float newPageScale = 2;
     WebTransformationMatrix newPageScaleMatrix;
     newPageScaleMatrix.scale(newPageScale);
 
     // Create a normal scrollable root layer and another scrollable child layer.
     setupScrollAndContentsLayers(surfaceSize);
     LayerImpl* root = m_hostImpl->rootLayer();
     LayerImpl* child = root->children()[0];
 
     scoped_ptr<LayerImpl> scrollableChild = createScrollableLayer(3, surfaceSize);
     child->addChild(scrollableChild.Pass());
     LayerImpl* grandChild = child->children()[0];
 
     // 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();
 
     // The page scale delta should only be applied to the scrollable root layer.
     EXPECT_EQ(root->implTransform(), newPageScaleMatrix);
     EXPECT_EQ(child->implTransform(), defaultPageScaleMatrix);
     EXPECT_EQ(grandChild->implTransform(), defaultPageScaleMatrix);
 
     // Make sure all the layers are drawn with the page scale delta applied, i.e., the page scale
     // delta on the root layer is applied hierarchically.
@@ skipping 19 matching lines @@
     // Also mark the root scrollable so it becomes the root scroll layer.
     root->setScrollable(true);
     int scrollLayerId = 2;
     root->addChild(createScrollableLayer(scrollLayerId, surfaceSize));
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     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();
 
     float pageScale = 2;
     m_hostImpl->setPageScaleFactorAndLimits(pageScale, 1, pageScale);
 
     m_hostImpl->updateRootScrollLayerImplTransform();
 
     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;
     EXPECT_EQ(child->implTransform(), WebTransformationMatrix());
 }
 
 TEST_P(LayerTreeHostImplTest, scrollChildBeyondLimit)
 {
     // Scroll a child layer beyond its maximum scroll range and make sure the
     // parent layer is scrolled on the axis on which the child was unable to
     // scroll.
     gfx::Size surfaceSize(10, 10);
     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());
     m_hostImpl->setRootLayer(root.Pass());
     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();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
 
         // 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));
     }
 }
 
 TEST_P(LayerTreeHostImplTest, scrollEventBubbling)
 {
     // When we try to scroll a non-scrollable child layer, the scroll delta
     // should be applied to one of its ancestors if possible.
     gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
     scoped_ptr<LayerImpl> child = createScrollableLayer(2, surfaceSize);
 
     child->setScrollable(false);
     root->addChild(child.Pass());
 
     m_hostImpl->setRootLayer(root.Pass());
     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();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
 
         // Only the root should have scrolled.
         ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
     }
@@ skipping 21 matching lines @@
     // Rotate the root layer 90 degrees counter-clockwise about its center.
     WebTransformationMatrix rotateTransform;
     rotateTransform.rotate(-90);
     m_hostImpl->rootLayer()->setTransform(rotateTransform);
 
     gfx::Size surfaceSize(50, 50);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     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();
 
     // The layer should have scrolled down in its local coordinates.
     scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), wheelScrollDelta);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollNonAxisAlignedRotatedLayer)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     int childLayerId = 3;
     float childLayerAngle = -20;
 
     // Create a child layer that is rotated to a non-axis-aligned angle.
     scoped_ptr<LayerImpl> child = createScrollableLayer(childLayerId, m_hostImpl->rootLayer()->contentBounds());
     WebTransformationMatrix rotateTransform;
     rotateTransform.translate(-50, -50);
     rotateTransform.rotate(childLayerAngle);
     rotateTransform.translate(50, 50);
     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);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     {
         // 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);
 
         // The root layer should not have scrolled, because the input delta was close to the layer's
         // axis of movement.
         EXPECT_EQ(scrollInfo->scrolls.size(), 1u);
     }
 
     {
         // 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);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, scrollScaledLayer)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // Scale the layer to twice its normal size.
     int scale = 2;
     WebTransformationMatrix scaleTransform;
     scaleTransform.scale(scale);
     m_hostImpl->rootLayer()->setTransform(scaleTransform);
 
     gfx::Size surfaceSize(50, 50);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     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();
 
     // The scale should not have been applied to the scroll delta.
     scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), wheelScrollDelta);
 }
 
 class BlendStateTrackerContext: public FakeWebGraphicsContext3D {
@@ skipping 2889 matching lines @@
         verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
         testCaseIndex++;
     }
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 } // namespace