cc: Use gfx:: Geometry types for positions, bounds, and related things.

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/command_line.h"
 #include "base/hash_tables.h"
@@ skipping 18 matching lines @@
 #include "cc/test/layer_test_common.h"
 #include "cc/test/render_pass_test_common.h"
 #include "cc/test/test_common.h"
 #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 "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/size_conversions.h"
 #include <public/WebVideoFrame.h>
 #include <public/WebVideoFrameProvider.h>
 
 using namespace cc;
 using namespace LayerTestCommon;
 using namespace WebKit;
 using namespace WebKitTests;
 
 using ::testing::Mock;
 using ::testing::Return;
@@ skipping 13 matching lines @@
         , m_didRequestCommit(false)
         , m_didRequestRedraw(false)
         , m_reduceMemoryResult(true)
     {
     }
 
     virtual void SetUp()
     {
         Settings::setPageScalePinchZoomEnabled(GetParam());
         LayerTreeSettings settings;
-        settings.minimumOcclusionTrackingSize = IntSize();
+        settings.minimumOcclusionTrackingSize = gfx::Size();
 
         m_hostImpl = LayerTreeHostImpl::create(settings, this);
         m_hostImpl->initializeRenderer(createContext());
-        m_hostImpl->setViewportSize(IntSize(10, 10), IntSize(10, 10));
+        m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
     }
 
     virtual void TearDown()
     {
     }
 
     virtual void didLoseContextOnImplThread() OVERRIDE { }
     virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE { }
     virtual void onVSyncParametersChanged(double, double) OVERRIDE { }
     virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE { m_onCanDrawStateChangedCalled = true; }
     virtual void setNeedsRedrawOnImplThread() OVERRIDE { m_didRequestRedraw = true; }
     virtual void setNeedsCommitOnImplThread() OVERRIDE { m_didRequestCommit = true; }
     virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector>, double wallClockTime) OVERRIDE { }
     virtual bool reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff) OVERRIDE { return m_reduceMemoryResult; }
 
     void setReduceMemoryResult(bool reduceMemoryResult) { m_reduceMemoryResult = reduceMemoryResult; }
 
     scoped_ptr<LayerTreeHostImpl> createLayerTreeHost(bool partialSwap, scoped_ptr<GraphicsContext> graphicsContext, scoped_ptr<LayerImpl> root)
     {
         Settings::setPartialSwapEnabled(partialSwap);
 
         LayerTreeSettings settings;
-        settings.minimumOcclusionTrackingSize = IntSize();
+        settings.minimumOcclusionTrackingSize = gfx::Size();
 
         scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
 
         myHostImpl->initializeRenderer(graphicsContext.Pass());
-        myHostImpl->setViewportSize(IntSize(10, 10), IntSize(10, 10));
+        myHostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
 
-        root->setAnchorPoint(FloatPoint(0, 0));
-        root->setPosition(FloatPoint(0, 0));
-        root->setBounds(IntSize(10, 10));
-        root->setContentBounds(IntSize(10, 10));
-        root->setVisibleContentRect(IntRect(0, 0, 10, 10));
+        root->setAnchorPoint(gfx::PointF(0, 0));
+        root->setPosition(gfx::PointF(0, 0));
+        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());
         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)
     {
         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());
             timesEncountered++;
         }
 
         ASSERT_EQ(timesEncountered, 1);
     }
 
-    void setupScrollAndContentsLayers(const IntSize& contentSize)
+    void setupScrollAndContentsLayers(const gfx::Size& contentSize)
     {
         scoped_ptr<LayerImpl> root = LayerImpl::create(1);
         root->setScrollable(true);
         root->setScrollPosition(IntPoint(0, 0));
-        root->setMaxScrollPosition(contentSize);
+        root->setMaxScrollPosition(cc::IntSize(contentSize));
         root->setBounds(contentSize);
         root->setContentBounds(contentSize);
-        root->setPosition(FloatPoint(0, 0));
-        root->setAnchorPoint(FloatPoint(0, 0));
+        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(FloatPoint(0, 0));
-        contents->setAnchorPoint(FloatPoint(0, 0));
+        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 IntSize& size)
+    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));
         return layer.Pass();
     }
 
@@ skipping 29 matching lines @@
 };
 
 TEST_P(LayerTreeHostImplTest, notifyIfCanDrawChanged)
 {
     // Note: It is not possible to disable the renderer once it has been set,
     // so we do not need to test that disabling the renderer notifies us
     // that canDraw changed.
     EXPECT_FALSE(m_hostImpl->canDraw());
     m_onCanDrawStateChangedCalled = false;
 
-    setupScrollAndContentsLayers(IntSize(100, 100));
+    setupScrollAndContentsLayers(gfx::Size(100, 100));
     EXPECT_TRUE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
     m_onCanDrawStateChangedCalled = false;
 
     // Toggle the root layer to make sure it toggles canDraw
     m_hostImpl->setRootLayer(scoped_ptr<LayerImpl>());
     EXPECT_FALSE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
     m_onCanDrawStateChangedCalled = false;
 
-    setupScrollAndContentsLayers(IntSize(100, 100));
+    setupScrollAndContentsLayers(gfx::Size(100, 100));
     EXPECT_TRUE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
     m_onCanDrawStateChangedCalled = false;
 
     // Toggle the device viewport size to make sure it toggles canDraw.
-    m_hostImpl->setViewportSize(IntSize(100, 100), IntSize(0, 0));
+    m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(0, 0));
     EXPECT_FALSE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
     m_onCanDrawStateChangedCalled = false;
 
-    m_hostImpl->setViewportSize(IntSize(100, 100), IntSize(100, 100));
+    m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
     EXPECT_TRUE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
     m_onCanDrawStateChangedCalled = false;
 
     // Toggle contents textures purged without causing any evictions,
     // and make sure that it does not change canDraw.
     setReduceMemoryResult(false);
     m_hostImpl->setManagedMemoryPolicy(ManagedMemoryPolicy(
         m_hostImpl->memoryAllocationLimitBytes() - 1));
     EXPECT_TRUE(m_hostImpl->canDraw());
@@ skipping 76 matching lines @@
     EXPECT_EQ(root->sentScrollDelta(), scrollDelta + scrollDelta2);
     expectContains(*scrollInfo, root->id(), scrollDelta + scrollDelta2);
 
     root->scrollBy(IntSize());
     scrollInfo = m_hostImpl->processScrollDeltas();
     EXPECT_EQ(root->sentScrollDelta(), scrollDelta + scrollDelta2);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollRootCallsCommitAndRedraw)
 {
-    setupScrollAndContentsLayers(IntSize(100, 100));
-    m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
+    setupScrollAndContentsLayers(gfx::Size(100, 100));
+    m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(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(IntPoint(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollWithoutRenderer)
 {
     LayerTreeSettings settings;
     m_hostImpl = LayerTreeHostImpl::create(settings, this);
 
     // Initialization will fail here.
     m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DMakeCurrentFails)).PassAs<GraphicsContext>());
-    m_hostImpl->setViewportSize(IntSize(10, 10), IntSize(10, 10));
+    m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
 
-    setupScrollAndContentsLayers(IntSize(100, 100));
+    setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // We should not crash when trying to scroll after the renderer initialization fails.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
 }
 
 TEST_P(LayerTreeHostImplTest, replaceTreeWhileScrolling)
 {
     const int scrollLayerId = 1;
 
-    setupScrollAndContentsLayers(IntSize(100, 100));
-    m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
+    setupScrollAndContentsLayers(gfx::Size(100, 100));
+    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(IntPoint(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->detachLayerTree();
 
-    setupScrollAndContentsLayers(IntSize(100, 100));
+    setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // We should still be scrolling, because the scrolled layer also exists in the new tree.
     IntSize scrollDelta(0, 10);
     m_hostImpl->scrollBy(IntPoint(), scrollDelta);
     m_hostImpl->scrollEnd();
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo, scrollLayerId, scrollDelta);
 }
 
 TEST_P(LayerTreeHostImplTest, clearRootRenderSurfaceAndScroll)
 {
-    setupScrollAndContentsLayers(IntSize(100, 100));
-    m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
+    setupScrollAndContentsLayers(gfx::Size(100, 100));
+    m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
 
     // We should be able to scroll even if the root layer loses its render surface after the most
     // recent render.
     m_hostImpl->rootLayer()->clearRenderSurface();
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
 }
 
 TEST_P(LayerTreeHostImplTest, wheelEventHandlers)
 {
-    setupScrollAndContentsLayers(IntSize(100, 100));
-    m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
+    setupScrollAndContentsLayers(gfx::Size(100, 100));
+    m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
     LayerImpl* root = m_hostImpl->rootLayer();
 
     root->setHaveWheelEventHandlers(true);
 
     // With registered event handlers, wheel scrolls have to go to the main thread.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
 
     // But gesture scrolls can still be handled.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
 }
 
 TEST_P(LayerTreeHostImplTest, shouldScrollOnMainThread)
 {
-    setupScrollAndContentsLayers(IntSize(100, 100));
-    m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
+    setupScrollAndContentsLayers(gfx::Size(100, 100));
+    m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
     LayerImpl* root = m_hostImpl->rootLayer();
 
     root->setShouldScrollOnMainThread(true);
 
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollOnMainThread);
 }
 
 TEST_P(LayerTreeHostImplTest, nonFastScrollableRegionBasic)
 {
-    setupScrollAndContentsLayers(IntSize(200, 200));
-    m_hostImpl->setViewportSize(IntSize(100, 100), IntSize(100, 100));
+    setupScrollAndContentsLayers(gfx::Size(200, 200));
+    m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
     initializeRendererAndDrawFrame();
     LayerImpl* root = m_hostImpl->rootLayer();
 
     root->setNonFastScrollableRegion(IntRect(0, 0, 50, 50));
 
     // All scroll types inside the non-fast scrollable region should fail.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(25, 25), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(25, 25), InputHandlerClient::Gesture), InputHandlerClient::ScrollOnMainThread);
 
     // All scroll types outside this region should succeed.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(75, 75), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(75, 75), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(0, 10));
     m_hostImpl->scrollEnd();
 }
 
 TEST_P(LayerTreeHostImplTest, nonFastScrollableRegionWithOffset)
 {
-    setupScrollAndContentsLayers(IntSize(200, 200));
-    m_hostImpl->setViewportSize(IntSize(100, 100), IntSize(100, 100));
+    setupScrollAndContentsLayers(gfx::Size(200, 200));
+    m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
     LayerImpl* root = m_hostImpl->rootLayer();
 
     root->setNonFastScrollableRegion(IntRect(0, 0, 50, 50));
-    root->setPosition(FloatPoint(-25, 0));
+    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(IntPoint(40, 10), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(0, 1));
     m_hostImpl->scrollEnd();
 
     // This point is still inside the non-fast region.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(10, 10), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
 }
 
 TEST_P(LayerTreeHostImplTest, maxScrollPositionChangedByDeviceScaleFactor)
 {
-    setupScrollAndContentsLayers(IntSize(100, 100));
+    setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     float deviceScaleFactor = 2;
-    IntSize layoutViewport(25, 25);
-    IntSize deviceViewport(layoutViewport);
-    deviceViewport.scale(deviceScaleFactor);
+    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));
 
     deviceScaleFactor = 1;
     m_hostImpl->setViewportSize(layoutViewport, layoutViewport);
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), IntSize(75, 75));
 }
 
 TEST_P(LayerTreeHostImplTest, implPinchZoom)
 {
     // This test is specific to the page-scale based pinch zoom.
     if (!Settings::pageScalePinchZoomEnabled())
         return;
 
-    setupScrollAndContentsLayers(IntSize(100, 100));
-    m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
+    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.
     {
@@ skipping 31 matching lines @@
         m_hostImpl->scrollBy(IntPoint(), scrollDelta);
         m_hostImpl->scrollEnd();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, pinchGesture)
 {
-    setupScrollAndContentsLayers(IntSize(100, 100));
-    m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
+    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
@@ skipping 65 matching lines @@
         m_hostImpl->pinchGestureEnd();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
         expectContains(*scrollInfo, scrollLayer->id(), IntSize(-10, -10));
     }
 }
 
 TEST_P(LayerTreeHostImplTest, pageScaleAnimation)
 {
-    setupScrollAndContentsLayers(IntSize(100, 100));
-    m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
+    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 double startTime = 1;
     const double duration = 0.1;
     const double halfwayThroughAnimation = startTime + duration / 2;
@@ skipping 30 matching lines @@
 
         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));
     }
 }
 
 TEST_P(LayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhilePinchZooming)
 {
-    setupScrollAndContentsLayers(IntSize(100, 100));
-    m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
+    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.
     {
@@ skipping 47 matching lines @@
             expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
         } else {
             EXPECT_EQ(scrollInfo->pageScaleDelta, zoomOutDelta);
             expectContains(*scrollInfo, scrollLayer->id(), IntSize(8, 8));
         }
     }
 }
 
 TEST_P(LayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhileAnimatingPageScale)
 {
-    setupScrollAndContentsLayers(IntSize(100, 100));
-    m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
+    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 double startTime = 1;
     const double duration = 0.1;
     const double halfwayThroughAnimation = startTime + duration / 2;
@@ skipping 53 matching lines @@
         m_didDrawCalled = false;
         m_willDrawCalled = false;
     }
 
 protected:
     explicit DidDrawCheckLayer(int id)
         : TiledLayerImpl(id)
         , m_didDrawCalled(false)
         , m_willDrawCalled(false)
     {
-        setAnchorPoint(FloatPoint(0, 0));
-        setBounds(IntSize(10, 10));
-        setContentBounds(IntSize(10, 10));
+        setAnchorPoint(gfx::PointF(0, 0));
+        setBounds(gfx::Size(10, 10));
+        setContentBounds(gfx::Size(10, 10));
         setDrawsContent(true);
         setSkipsDraw(false);
-        setVisibleContentRect(IntRect(0, 0, 10, 10));
+        setVisibleContentRect(gfx::Rect(0, 0, 10, 10));
 
-        scoped_ptr<LayerTilingData> tiler = LayerTilingData::create(IntSize(100, 100), LayerTilingData::HasBorderTexels);
+        scoped_ptr<LayerTilingData> tiler = LayerTilingData::create(gfx::Size(100, 100), LayerTilingData::HasBorderTexels);
         tiler->setBounds(contentBounds());
         setTilingData(*tiler.get());
     }
 
 private:
     bool m_didDrawCalled;
     bool m_willDrawCalled;
 };
 
 TEST_P(LayerTreeHostImplTest, didDrawNotCalledOnHiddenLayer)
 {
     // The root layer is always drawn, so run this test on a child layer that
     // will be masked out by the root layer's bounds.
     m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->setMasksToBounds(true);
 
     root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* layer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
     // Ensure visibleContentRect for layer is empty
-    layer->setPosition(FloatPoint(100, 100));
-    layer->setBounds(IntSize(10, 10));
-    layer->setContentBounds(IntSize(10, 10));
+    layer->setPosition(gfx::PointF(100, 100));
+    layer->setBounds(gfx::Size(10, 10));
+    layer->setContentBounds(gfx::Size(10, 10));
 
     LayerTreeHostImpl::FrameData frame;
 
     EXPECT_FALSE(layer->willDrawCalled());
     EXPECT_FALSE(layer->didDrawCalled());
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 
     EXPECT_FALSE(layer->willDrawCalled());
     EXPECT_FALSE(layer->didDrawCalled());
 
-    EXPECT_TRUE(layer->visibleContentRect().isEmpty());
+    EXPECT_TRUE(layer->visibleContentRect().IsEmpty());
 
     // Ensure visibleContentRect for layer layer is not empty
-    layer->setPosition(FloatPoint(0, 0));
+    layer->setPosition(gfx::PointF(0, 0));
 
     EXPECT_FALSE(layer->willDrawCalled());
     EXPECT_FALSE(layer->didDrawCalled());
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 
     EXPECT_TRUE(layer->willDrawCalled());
     EXPECT_TRUE(layer->didDrawCalled());
 
-    EXPECT_FALSE(layer->visibleContentRect().isEmpty());
+    EXPECT_FALSE(layer->visibleContentRect().IsEmpty());
 }
 
 TEST_P(LayerTreeHostImplTest, willDrawNotCalledOnOccludedLayer)
 {
-    IntSize bigSize(1000, 1000);
+    gfx::Size bigSize(1000, 1000);
     m_hostImpl->setViewportSize(bigSize, bigSize);
 
     m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
 
     root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* occludedLayer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
     root->addChild(DidDrawCheckLayer::create(3));
     DidDrawCheckLayer* topLayer = static_cast<DidDrawCheckLayer*>(root->children()[1]);
@@ skipping 54 matching lines @@
 public:
     static scoped_ptr<LayerImpl> create(int id, bool tileMissing, bool skipsDraw, bool animating, ResourceProvider* resourceProvider)
     {
         return scoped_ptr<LayerImpl>(new MissingTextureAnimatingLayer(id, tileMissing, skipsDraw, animating, resourceProvider));
     }
 
 private:
     explicit MissingTextureAnimatingLayer(int id, bool tileMissing, bool skipsDraw, bool animating, ResourceProvider* resourceProvider)
         : DidDrawCheckLayer(id)
     {
-        scoped_ptr<LayerTilingData> tilingData = LayerTilingData::create(IntSize(10, 10), LayerTilingData::NoBorderTexels);
+        scoped_ptr<LayerTilingData> tilingData = LayerTilingData::create(gfx::Size(10, 10), LayerTilingData::NoBorderTexels);
         tilingData->setBounds(bounds());
         setTilingData(*tilingData.get());
         setSkipsDraw(skipsDraw);
         if (!tileMissing) {
-            ResourceProvider::ResourceId resource = resourceProvider->createResource(Renderer::ContentPool, IntSize(), GL_RGBA, ResourceProvider::TextureUsageAny);
-            pushTileProperties(0, 0, resource, IntRect(), false);
+            ResourceProvider::ResourceId resource = resourceProvider->createResource(Renderer::ContentPool, gfx::Size(), GL_RGBA, ResourceProvider::TextureUsageAny);
+            pushTileProperties(0, 0, resource, gfx::Rect(), false);
         }
         if (animating)
             addAnimatedTransformToLayer(*this, 10, 3, 0);
     }
 };
 
 TEST_P(LayerTreeHostImplTest, prepareToDrawFailsWhenAnimationUsesCheckerboard)
 {
     // When the texture is not missing, we draw as usual.
     m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
@@ skipping 44 matching lines @@
     // Scroll event is ignored because layer is not scrollable.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
     EXPECT_FALSE(m_didRequestRedraw);
     EXPECT_FALSE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollNonCompositedRoot)
 {
     // Test the configuration where a non-composited root layer is embedded in a
     // scrollable outer layer.
-    IntSize surfaceSize(10, 10);
+    gfx::Size surfaceSize(10, 10);
 
     scoped_ptr<LayerImpl> contentLayer = LayerImpl::create(1);
     contentLayer->setUseLCDText(true);
     contentLayer->setDrawsContent(true);
-    contentLayer->setPosition(FloatPoint(0, 0));
-    contentLayer->setAnchorPoint(FloatPoint(0, 0));
+    contentLayer->setPosition(gfx::PointF(0, 0));
+    contentLayer->setAnchorPoint(gfx::PointF(0, 0));
     contentLayer->setBounds(surfaceSize);
-    contentLayer->setContentBounds(IntSize(surfaceSize.width() * 2, surfaceSize.height() * 2));
+    contentLayer->setContentBounds(gfx::Size(surfaceSize.width() * 2, surfaceSize.height() * 2));
 
     scoped_ptr<LayerImpl> scrollLayer = LayerImpl::create(2);
     scrollLayer->setScrollable(true);
-    scrollLayer->setMaxScrollPosition(surfaceSize);
+    scrollLayer->setMaxScrollPosition(cc::IntSize(surfaceSize));
     scrollLayer->setBounds(surfaceSize);
     scrollLayer->setContentBounds(surfaceSize);
-    scrollLayer->setPosition(FloatPoint(0, 0));
-    scrollLayer->setAnchorPoint(FloatPoint(0, 0));
+    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(IntPoint(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollChildCallsCommitAndRedraw)
 {
-    IntSize surfaceSize(10, 10);
+    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(IntPoint(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollMissesChild)
 {
-    IntSize surfaceSize(10, 10);
+    gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     root->addChild(createScrollableLayer(2, surfaceSize));
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     // Scroll event is ignored because the input coordinate is outside the layer boundaries.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(15, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
     EXPECT_FALSE(m_didRequestRedraw);
     EXPECT_FALSE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollMissesBackfacingChild)
 {
-    IntSize surfaceSize(10, 10);
+    gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     scoped_ptr<LayerImpl> child = createScrollableLayer(2, surfaceSize);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
 
     WebTransformationMatrix matrix;
     matrix.rotate3d(180, 0, 0);
     child->setTransform(matrix);
     child->setDoubleSided(false);
 
     root->addChild(child.Pass());
     m_hostImpl->setRootLayer(root.Pass());
     initializeRendererAndDrawFrame();
 
     // Scroll event is ignored because the scrollable layer is not facing the viewer and there is
     // nothing scrollable behind it.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
     EXPECT_FALSE(m_didRequestRedraw);
     EXPECT_FALSE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollBlockedByContentLayer)
 {
-    IntSize surfaceSize(10, 10);
+    gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> contentLayer = createScrollableLayer(1, surfaceSize);
     contentLayer->setShouldScrollOnMainThread(true);
     contentLayer->setScrollable(false);
 
     scoped_ptr<LayerImpl> scrollLayer = createScrollableLayer(2, surfaceSize);
     scrollLayer->addChild(contentLayer.Pass());
 
     m_hostImpl->setRootLayer(scrollLayer.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     // Scrolling fails because the content layer is asking to be scrolled on the main thread.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnMainThread)
 {
-    IntSize surfaceSize(10, 10);
+    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());
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
@@ skipping 12 matching lines @@
 
     // The scroll range should also have been updated.
     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), 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)
 {
-    IntSize surfaceSize(10, 10);
+    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());
@@ skipping 15 matching lines @@
     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), 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)
 {
-    IntSize surfaceSize(10, 10);
+    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();
@@ skipping 24 matching lines @@
     EXPECT_EQ(root->drawTransform().m11(), newPageScale);
     EXPECT_EQ(root->drawTransform().m22(), newPageScale);
     EXPECT_EQ(child->drawTransform().m11(), newPageScale);
     EXPECT_EQ(child->drawTransform().m22(), newPageScale);
     EXPECT_EQ(grandChild->drawTransform().m11(), newPageScale);
     EXPECT_EQ(grandChild->drawTransform().m22(), newPageScale);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollChildAndChangePageScaleOnMainThread)
 {
-    IntSize surfaceSize(10, 10);
+    gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     root->setBounds(surfaceSize);
     root->setContentBounds(surfaceSize);
     // 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();
@@ skipping 25 matching lines @@
     // 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.
-    IntSize surfaceSize(10, 10);
+    gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
 
     scoped_ptr<LayerImpl> grandChild = createScrollableLayer(3, surfaceSize);
     grandChild->setScrollPosition(IntPoint(0, 5));
 
     scoped_ptr<LayerImpl> child = createScrollableLayer(2, surfaceSize);
     child->setScrollPosition(IntPoint(3, 0));
     child->addChild(grandChild.Pass());
 
     root->addChild(child.Pass());
@@ skipping 15 matching lines @@
 
         // The child should have only scrolled on the other axis.
         expectContains(*scrollInfo.get(), child->id(), IntSize(-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.
-    IntSize surfaceSize(10, 10);
+    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);
         EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(IntPoint(), 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);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, scrollBeforeRedraw)
 {
-    IntSize surfaceSize(10, 10);
+    gfx::Size surfaceSize(10, 10);
     m_hostImpl->setRootLayer(createScrollableLayer(1, surfaceSize));
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
 
     // Draw one frame and then immediately rebuild the layer tree to mimic a tree synchronization.
     initializeRendererAndDrawFrame();
     m_hostImpl->detachLayerTree();
     m_hostImpl->setRootLayer(createScrollableLayer(2, surfaceSize));
 
     // Scrolling should still work even though we did not draw yet.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollAxisAlignedRotatedLayer)
 {
-    setupScrollAndContentsLayers(IntSize(100, 100));
+    setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // Rotate the root layer 90 degrees counter-clockwise about its center.
     WebTransformationMatrix rotateTransform;
     rotateTransform.rotate(-90);
     m_hostImpl->rootLayer()->setTransform(rotateTransform);
 
-    IntSize surfaceSize(50, 50);
+    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);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), 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()));
 
     // Reset and scroll down with the wheel.
     m_hostImpl->rootLayer()->setScrollDelta(FloatSize());
     IntSize wheelScrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), 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(IntSize(100, 100));
+    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()));
     m_hostImpl->rootLayer()->addChild(child.Pass());
 
-    IntSize surfaceSize(50, 50);
+    gfx::Size surfaceSize(50, 50);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     {
         // Scroll down in screen coordinates with a gesture.
         IntSize gestureScrollDelta(0, 10);
         EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(IntPoint(), gestureScrollDelta);
         m_hostImpl->scrollEnd();
 
@@ skipping 24 matching lines @@
 
         // 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);
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedRootScrollDelta);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, scrollScaledLayer)
 {
-    setupScrollAndContentsLayers(IntSize(100, 100));
+    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);
 
-    IntSize surfaceSize(50, 50);
+    gfx::Size surfaceSize(50, 50);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     // Scroll down in screen coordinates with a gesture.
     IntSize scrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // The layer should have scrolled down in its local coordinates, but half he amount.
@@ skipping 35 matching lines @@
 };
 
 class BlendStateCheckLayer : public LayerImpl {
 public:
     static scoped_ptr<LayerImpl> create(int id, ResourceProvider* resourceProvider) { return scoped_ptr<LayerImpl>(new BlendStateCheckLayer(id, resourceProvider)); }
 
     virtual void appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData) OVERRIDE
     {
         m_quadsAppended = true;
 
-        IntRect opaqueRect;
+        gfx::Rect opaqueRect;
         if (contentsOpaque())
             opaqueRect = m_quadRect;
         else
             opaqueRect = m_opaqueContentRect;
 
         SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
-        scoped_ptr<TileDrawQuad> testBlendingDrawQuad = TileDrawQuad::create(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, IntPoint(), IntSize(1, 1), 0, false, false, false, false, false);
+        scoped_ptr<TileDrawQuad> testBlendingDrawQuad = TileDrawQuad::create(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, gfx::Vector2d(), gfx::Size(1, 1), 0, false, false, false, false, false);
         testBlendingDrawQuad->setQuadVisibleRect(m_quadVisibleRect);
         EXPECT_EQ(m_blend, testBlendingDrawQuad->needsBlending());
         EXPECT_EQ(m_hasRenderSurface, !!renderSurface());
         quadSink.append(testBlendingDrawQuad.PassAs<DrawQuad>(), appendQuadsData);
     }
 
     void setExpectation(bool blend, bool hasRenderSurface)
     {
         m_blend = blend;
         m_hasRenderSurface = hasRenderSurface;
         m_quadsAppended = false;
     }
 
     bool quadsAppended() const { return m_quadsAppended; }
 
-    void setQuadRect(const IntRect& rect) { m_quadRect = rect; }
-    void setQuadVisibleRect(const IntRect& rect) { m_quadVisibleRect = rect; }
-    void setOpaqueContentRect(const IntRect& rect) { m_opaqueContentRect = rect; }
+    void setQuadRect(const gfx::Rect& rect) { m_quadRect = rect; }
+    void setQuadVisibleRect(const gfx::Rect& rect) { m_quadVisibleRect = rect; }
+    void setOpaqueContentRect(const gfx::Rect& rect) { m_opaqueContentRect = rect; }
 
 private:
     explicit BlendStateCheckLayer(int id, ResourceProvider* resourceProvider)
         : LayerImpl(id)
         , m_blend(false)
         , m_hasRenderSurface(false)
         , m_quadsAppended(false)
         , m_quadRect(5, 5, 5, 5)
         , m_quadVisibleRect(5, 5, 5, 5)
-        , m_resourceId(resourceProvider->createResource(Renderer::ContentPool, IntSize(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny))
+        , m_resourceId(resourceProvider->createResource(Renderer::ContentPool, gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny))
     {
-        setAnchorPoint(FloatPoint(0, 0));
-        setBounds(IntSize(10, 10));
-        setContentBounds(IntSize(10, 10));
+        setAnchorPoint(gfx::PointF(0, 0));
+        setBounds(gfx::Size(10, 10));
+        setContentBounds(gfx::Size(10, 10));
         setDrawsContent(true);
     }
 
     bool m_blend;
     bool m_hasRenderSurface;
     bool m_quadsAppended;
-    IntRect m_quadRect;
-    IntRect m_opaqueContentRect;
-    IntRect m_quadVisibleRect;
+    gfx::Rect m_quadRect;
+    gfx::Rect m_opaqueContentRect;
+    gfx::Rect m_quadVisibleRect;
     ResourceProvider::ResourceId m_resourceId;
 };
 
 TEST_P(LayerTreeHostImplTest, blendingOffWhenDrawingOpaqueLayers)
 {
     {
         scoped_ptr<LayerImpl> root = LayerImpl::create(1);
-        root->setAnchorPoint(FloatPoint(0, 0));
-        root->setBounds(IntSize(10, 10));
+        root->setAnchorPoint(gfx::PointF(0, 0));
+        root->setBounds(gfx::Size(10, 10));
         root->setContentBounds(root->bounds());
         root->setDrawsContent(false);
         m_hostImpl->setRootLayer(root.Pass());
     }
     LayerImpl* root = m_hostImpl->rootLayer();
 
     root->addChild(BlendStateCheckLayer::create(2, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* layer1 = static_cast<BlendStateCheckLayer*>(root->children()[0]);
-    layer1->setPosition(FloatPoint(2, 2));
+    layer1->setPosition(gfx::PointF(2, 2));
 
     LayerTreeHostImpl::FrameData frame;
 
     // Opaque layer, drawn without blending.
     layer1->setContentsOpaque(true);
     layer1->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
@@ skipping 19 matching lines @@
     layer1->setContentsOpaque(true);
     layer1->setOpacity(0.5);
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     layer1->addChild(BlendStateCheckLayer::create(3, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* layer2 = static_cast<BlendStateCheckLayer*>(layer1->children()[0]);
-    layer2->setPosition(FloatPoint(4, 4));
+    layer2->setPosition(gfx::PointF(4, 4));
 
     // 2 opaque layers, drawn without blending.
     layer1->setContentsOpaque(true);
     layer1->setOpacity(1);
     layer1->setExpectation(false, false);
     layer2->setContentsOpaque(true);
     layer2->setOpacity(1);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
@@ skipping 73 matching lines @@
     layer2->setOpacity(1);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Layer with partially opaque contents, drawn with blending.
     layer1->setContentsOpaque(false);
-    layer1->setQuadRect(IntRect(5, 5, 5, 5));
-    layer1->setQuadVisibleRect(IntRect(5, 5, 5, 5));
-    layer1->setOpaqueContentRect(IntRect(5, 5, 2, 5));
+    layer1->setQuadRect(gfx::Rect(5, 5, 5, 5));
+    layer1->setQuadVisibleRect(gfx::Rect(5, 5, 5, 5));
+    layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Layer with partially opaque contents partially culled, drawn with blending.
     layer1->setContentsOpaque(false);
-    layer1->setQuadRect(IntRect(5, 5, 5, 5));
-    layer1->setQuadVisibleRect(IntRect(5, 5, 5, 2));
-    layer1->setOpaqueContentRect(IntRect(5, 5, 2, 5));
+    layer1->setQuadRect(gfx::Rect(5, 5, 5, 5));
+    layer1->setQuadVisibleRect(gfx::Rect(5, 5, 5, 2));
+    layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Layer with partially opaque contents culled, drawn with blending.
     layer1->setContentsOpaque(false);
-    layer1->setQuadRect(IntRect(5, 5, 5, 5));
-    layer1->setQuadVisibleRect(IntRect(7, 5, 3, 5));
-    layer1->setOpaqueContentRect(IntRect(5, 5, 2, 5));
+    layer1->setQuadRect(gfx::Rect(5, 5, 5, 5));
+    layer1->setQuadVisibleRect(gfx::Rect(7, 5, 3, 5));
+    layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Layer with partially opaque contents and translucent contents culled, drawn without blending.
     layer1->setContentsOpaque(false);
-    layer1->setQuadRect(IntRect(5, 5, 5, 5));
-    layer1->setQuadVisibleRect(IntRect(5, 5, 2, 5));
-    layer1->setOpaqueContentRect(IntRect(5, 5, 2, 5));
+    layer1->setQuadRect(gfx::Rect(5, 5, 5, 5));
+    layer1->setQuadVisibleRect(gfx::Rect(5, 5, 2, 5));
+    layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
     layer1->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
 }
 
 TEST_P(LayerTreeHostImplTest, viewportCovered)
 {
     m_hostImpl->initializeRenderer(createContext());
     m_hostImpl->setBackgroundColor(SK_ColorGRAY);
 
-    IntSize viewportSize(1000, 1000);
+    gfx::Size viewportSize(1000, 1000);
     m_hostImpl->setViewportSize(viewportSize, viewportSize);
 
     m_hostImpl->setRootLayer(BlendStateCheckLayer::create(1, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* root = static_cast<BlendStateCheckLayer*>(m_hostImpl->rootLayer());
     root->setExpectation(false, true);
     root->setContentsOpaque(true);
 
     // No gutter rects
     {
-        IntRect layerRect(0, 0, 1000, 1000);
-        root->setPosition(layerRect.location());
+        gfx::Rect layerRect(0, 0, 1000, 1000);
+        root->setPosition(layerRect.origin());
         root->setBounds(layerRect.size());
         root->setContentBounds(layerRect.size());
-        root->setQuadRect(IntRect(IntPoint(), layerRect.size()));
-        root->setQuadVisibleRect(IntRect(IntPoint(), layerRect.size()));
+        root->setQuadRect(gfx::Rect(gfx::Point(), layerRect.size()));
+        root->setQuadVisibleRect(gfx::Rect(gfx::Point(), layerRect.size()));
 
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         ASSERT_EQ(1u, frame.renderPasses.size());
 
         size_t numGutterQuads = 0;
         for (size_t i = 0; i < frame.renderPasses[0]->quadList().size(); ++i)
             numGutterQuads += (frame.renderPasses[0]->quadList()[i]->material() == DrawQuad::SolidColor) ? 1 : 0;
         EXPECT_EQ(0u, numGutterQuads);
         EXPECT_EQ(1u, frame.renderPasses[0]->quadList().size());
 
-        verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), IntRect(-layerRect.location(), viewportSize));
+        gfx::Rect expectedRect(gfx::Point(-layerRect.x(), -layerRect.y()), viewportSize);
+        verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), expectedRect);
         m_hostImpl->didDrawAllLayers(frame);
     }
 
     // Empty visible content area (fullscreen gutter rect)
     {
-        IntRect layerRect(0, 0, 0, 0);
-        root->setPosition(layerRect.location());
+        gfx::Rect layerRect(0, 0, 0, 0);
+        root->setPosition(layerRect.origin());
         root->setBounds(layerRect.size());
         root->setContentBounds(layerRect.size());
-        root->setQuadRect(IntRect(IntPoint(), layerRect.size()));
-        root->setQuadVisibleRect(IntRect(IntPoint(), layerRect.size()));
+        root->setQuadRect(gfx::Rect(gfx::Point(), layerRect.size()));
+        root->setQuadVisibleRect(gfx::Rect(gfx::Point(), layerRect.size()));
 
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         ASSERT_EQ(1u, frame.renderPasses.size());
         m_hostImpl->didDrawAllLayers(frame);
 
         size_t numGutterQuads = 0;
         for (size_t i = 0; i < frame.renderPasses[0]->quadList().size(); ++i)
             numGutterQuads += (frame.renderPasses[0]->quadList()[i]->material() == DrawQuad::SolidColor) ? 1 : 0;
         EXPECT_EQ(1u, numGutterQuads);
         EXPECT_EQ(1u, frame.renderPasses[0]->quadList().size());
 
-        verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), IntRect(-layerRect.location(), viewportSize));
+        gfx::Rect expectedRect(gfx::Point(-layerRect.x(), -layerRect.y()), viewportSize);
+        verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), expectedRect);
         m_hostImpl->didDrawAllLayers(frame);
     }
 
     // Content area in middle of clip rect (four surrounding gutter rects)
     {
-        IntRect layerRect(500, 500, 200, 200);
-        root->setPosition(layerRect.location());
+        gfx::Rect layerRect(500, 500, 200, 200);
+        root->setPosition(layerRect.origin());
         root->setBounds(layerRect.size());
         root->setContentBounds(layerRect.size());
-        root->setQuadRect(IntRect(IntPoint(), layerRect.size()));
-        root->setQuadVisibleRect(IntRect(IntPoint(), layerRect.size()));
+        root->setQuadRect(gfx::Rect(gfx::Point(), layerRect.size()));
+        root->setQuadVisibleRect(gfx::Rect(gfx::Point(), layerRect.size()));
 
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         ASSERT_EQ(1u, frame.renderPasses.size());
 
         size_t numGutterQuads = 0;
         for (size_t i = 0; i < frame.renderPasses[0]->quadList().size(); ++i)
             numGutterQuads += (frame.renderPasses[0]->quadList()[i]->material() == DrawQuad::SolidColor) ? 1 : 0;
         EXPECT_EQ(4u, numGutterQuads);
         EXPECT_EQ(5u, frame.renderPasses[0]->quadList().size());
 
-        verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), IntRect(-layerRect.location(), viewportSize));
+        gfx::Rect expectedRect(gfx::Point(-layerRect.x(), -layerRect.y()), viewportSize);
+        verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), expectedRect);
         m_hostImpl->didDrawAllLayers(frame);
     }
 
 }
 
 
 class ReshapeTrackerContext: public FakeWebGraphicsContext3D {
 public:
     ReshapeTrackerContext() : m_reshapeCalled(false) { }
 
@@ skipping 18 matching lines @@
 // Only reshape when we know we are going to draw. Otherwise, the reshape
 // can leave the window at the wrong size if we never draw and the proper
 // viewport size is never set.
 TEST_P(LayerTreeHostImplTest, reshapeNotCalledUntilDraw)
 {
     scoped_ptr<GraphicsContext> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new ReshapeTrackerContext)).PassAs<GraphicsContext>();
     ReshapeTrackerContext* reshapeTracker = static_cast<ReshapeTrackerContext*>(outputSurface->context3D());
     m_hostImpl->initializeRenderer(outputSurface.Pass());
 
     scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(1);
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setBounds(IntSize(10, 10));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setBounds(gfx::Size(10, 10));
     root->setDrawsContent(true);
     m_hostImpl->setRootLayer(root.Pass());
     EXPECT_FALSE(reshapeTracker->reshapeCalled());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(reshapeTracker->reshapeCalled());
     m_hostImpl->didDrawAllLayers(frame);
 }
 
 class PartialSwapTrackerContext : public FakeWebGraphicsContext3D {
 public:
     virtual void postSubBufferCHROMIUM(int x, int y, int width, int height)
     {
-        m_partialSwapRect = IntRect(x, y, width, height);
+        m_partialSwapRect = gfx::Rect(x, y, width, height);
     }
 
     virtual WebString getString(WGC3Denum name)
     {
         if (name == GL_EXTENSIONS)
             return WebString("GL_CHROMIUM_post_sub_buffer GL_CHROMIUM_set_visibility");
 
         return WebString();
     }
 
-    IntRect partialSwapRect() const { return m_partialSwapRect; }
+    gfx::Rect partialSwapRect() const { return m_partialSwapRect; }
 
 private:
-    IntRect m_partialSwapRect;
+    gfx::Rect m_partialSwapRect;
 };
 
 // Make sure damage tracking propagates all the way to the graphics context,
 // where it should request to swap only the subBuffer that is damaged.
 TEST_P(LayerTreeHostImplTest, partialSwapReceivesDamageRect)
 {
     scoped_ptr<GraphicsContext> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapTrackerContext)).PassAs<GraphicsContext>();
     PartialSwapTrackerContext* partialSwapTracker = static_cast<PartialSwapTrackerContext*>(outputSurface->context3D());
 
     // This test creates its own LayerTreeHostImpl, so
     // that we can force partial swap enabled.
     LayerTreeSettings settings;
     Settings::setPartialSwapEnabled(true);
     scoped_ptr<LayerTreeHostImpl> layerTreeHostImpl = LayerTreeHostImpl::create(settings, this);
     layerTreeHostImpl->initializeRenderer(outputSurface.Pass());
-    layerTreeHostImpl->setViewportSize(IntSize(500, 500), IntSize(500, 500));
+    layerTreeHostImpl->setViewportSize(gfx::Size(500, 500), gfx::Size(500, 500));
 
     scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(1);
     scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::create(2);
-    child->setPosition(FloatPoint(12, 13));
-    child->setAnchorPoint(FloatPoint(0, 0));
-    child->setBounds(IntSize(14, 15));
-    child->setContentBounds(IntSize(14, 15));
+    child->setPosition(gfx::PointF(12, 13));
+    child->setAnchorPoint(gfx::PointF(0, 0));
+    child->setBounds(gfx::Size(14, 15));
+    child->setContentBounds(gfx::Size(14, 15));
     child->setDrawsContent(true);
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setBounds(IntSize(500, 500));
-    root->setContentBounds(IntSize(500, 500));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setBounds(gfx::Size(500, 500));
+    root->setContentBounds(gfx::Size(500, 500));
     root->setDrawsContent(true);
     root->addChild(child.Pass());
     layerTreeHostImpl->setRootLayer(root.Pass());
 
     LayerTreeHostImpl::FrameData frame;
 
     // First frame, the entire screen should get swapped.
     EXPECT_TRUE(layerTreeHostImpl->prepareToDraw(frame));
     layerTreeHostImpl->drawLayers(frame);
     layerTreeHostImpl->didDrawAllLayers(frame);
     layerTreeHostImpl->swapBuffers();
-    IntRect actualSwapRect = partialSwapTracker->partialSwapRect();
-    IntRect expectedSwapRect = IntRect(IntPoint::zero(), IntSize(500, 500));
+    gfx::Rect actualSwapRect = partialSwapTracker->partialSwapRect();
+    gfx::Rect expectedSwapRect = gfx::Rect(gfx::Point(), gfx::Size(500, 500));
     EXPECT_EQ(expectedSwapRect.x(), actualSwapRect.x());
     EXPECT_EQ(expectedSwapRect.y(), actualSwapRect.y());
     EXPECT_EQ(expectedSwapRect.width(), actualSwapRect.width());
     EXPECT_EQ(expectedSwapRect.height(), actualSwapRect.height());
 
     // Second frame, only the damaged area should get swapped. Damage should be the union
     // of old and new child rects.
-    // expected damage rect: IntRect(IntPoint::zero(), IntSize(26, 28));
+    // expected damage rect: gfx::Rect(gfx::Point(), gfx::Size(26, 28));
     // expected swap rect: vertically flipped, with origin at bottom left corner.
-    layerTreeHostImpl->rootLayer()->children()[0]->setPosition(FloatPoint(0, 0));
+    layerTreeHostImpl->rootLayer()->children()[0]->setPosition(gfx::PointF(0, 0));
     EXPECT_TRUE(layerTreeHostImpl->prepareToDraw(frame));
     layerTreeHostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     layerTreeHostImpl->swapBuffers();
     actualSwapRect = partialSwapTracker->partialSwapRect();
-    expectedSwapRect = IntRect(IntPoint(0, 500-28), IntSize(26, 28));
+    expectedSwapRect = gfx::Rect(gfx::Point(0, 500-28), gfx::Size(26, 28));
     EXPECT_EQ(expectedSwapRect.x(), actualSwapRect.x());
     EXPECT_EQ(expectedSwapRect.y(), actualSwapRect.y());
     EXPECT_EQ(expectedSwapRect.width(), actualSwapRect.width());
     EXPECT_EQ(expectedSwapRect.height(), actualSwapRect.height());
 
     // Make sure that partial swap is constrained to the viewport dimensions
-    // expected damage rect: IntRect(IntPoint::zero(), IntSize(500, 500));
+    // expected damage rect: gfx::Rect(gfx::Point(), gfx::Size(500, 500));
     // expected swap rect: flipped damage rect, but also clamped to viewport
-    layerTreeHostImpl->setViewportSize(IntSize(10, 10), IntSize(10, 10));
+    layerTreeHostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
     layerTreeHostImpl->rootLayer()->setOpacity(0.7f); // this will damage everything
     EXPECT_TRUE(layerTreeHostImpl->prepareToDraw(frame));
     layerTreeHostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     layerTreeHostImpl->swapBuffers();
     actualSwapRect = partialSwapTracker->partialSwapRect();
-    expectedSwapRect = IntRect(IntPoint::zero(), IntSize(10, 10));
+    expectedSwapRect = gfx::Rect(gfx::Point(), gfx::Size(10, 10));
     EXPECT_EQ(expectedSwapRect.x(), actualSwapRect.x());
     EXPECT_EQ(expectedSwapRect.y(), actualSwapRect.y());
     EXPECT_EQ(expectedSwapRect.width(), actualSwapRect.width());
     EXPECT_EQ(expectedSwapRect.height(), actualSwapRect.height());
 }
 
 TEST_P(LayerTreeHostImplTest, rootLayerDoesntCreateExtraSurface)
 {
     scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(1);
     scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::create(2);
-    child->setAnchorPoint(FloatPoint(0, 0));
-    child->setBounds(IntSize(10, 10));
-    child->setContentBounds(IntSize(10, 10));
+    child->setAnchorPoint(gfx::PointF(0, 0));
+    child->setBounds(gfx::Size(10, 10));
+    child->setContentBounds(gfx::Size(10, 10));
     child->setDrawsContent(true);
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setBounds(IntSize(10, 10));
-    root->setContentBounds(IntSize(10, 10));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setBounds(gfx::Size(10, 10));
+    root->setContentBounds(gfx::Size(10, 10));
     root->setDrawsContent(true);
     root->setOpacity(0.7f);
     root->addChild(child.Pass());
 
     m_hostImpl->setRootLayer(root.Pass());
 
     LayerTreeHostImpl::FrameData frame;
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     EXPECT_EQ(1u, frame.renderSurfaceLayerList->size());
     EXPECT_EQ(1u, frame.renderPasses.size());
     m_hostImpl->didDrawAllLayers(frame);
 }
 
 } // namespace
 
 class FakeLayerWithQuads : public LayerImpl {
 public:
     static scoped_ptr<LayerImpl> create(int id) { return scoped_ptr<LayerImpl>(new FakeLayerWithQuads(id)); }
 
     virtual void appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData) OVERRIDE
     {
         SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
 
         SkColor gray = SkColorSetRGB(100, 100, 100);
-        IntRect quadRect(IntPoint(0, 0), contentBounds());
+        gfx::Rect quadRect(gfx::Point(0, 0), contentBounds());
         scoped_ptr<SolidColorDrawQuad> myQuad = SolidColorDrawQuad::create(sharedQuadState, quadRect, gray);
         quadSink.append(myQuad.PassAs<DrawQuad>(), appendQuadsData);
     }
 
 private:
     FakeLayerWithQuads(int id)
         : LayerImpl(id)
     {
     }
 };
@@ skipping 122 matching lines @@
     harness.mustDrawSolidQuad();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 
     // Damage a portion of the frame.
-    myHostImpl->rootLayer()->setUpdateRect(IntRect(0, 0, 2, 3));
+    myHostImpl->rootLayer()->setUpdateRect(gfx::Rect(0, 0, 2, 3));
 
     // The second frame will be partially-swapped (the y coordinates are flipped).
     harness.mustSetScissor(0, 7, 2, 3);
     harness.mustDrawSolidQuad();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
@@ skipping 24 matching lines @@
 
 static scoped_ptr<LayerTreeHostImpl> setupLayersForOpacity(bool partialSwap, LayerTreeHostImplClient* client)
 {
     Settings::setPartialSwapEnabled(partialSwap);
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     LayerTreeSettings settings;
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, client);
     myHostImpl->initializeRenderer(context.Pass());
-    myHostImpl->setViewportSize(IntSize(100, 100), IntSize(100, 100));
+    myHostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
 
     /*
       Layers are created as follows:
 
          +--------------------+
          |                  1 |
          |  +-----------+     |
          |  |         2 |     |
          |  | +-------------------+
          |  | |   3               |
          |  | +-------------------+
          |  |           |     |
          |  +-----------+     |
          |                    |
          |                    |
          +--------------------+
 
          Layers 1, 2 have render surfaces
      */
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     scoped_ptr<LayerImpl> child = LayerImpl::create(2);
     scoped_ptr<LayerImpl> grandChild = FakeLayerWithQuads::create(3);
 
-    IntRect rootRect(0, 0, 100, 100);
-    IntRect childRect(10, 10, 50, 50);
-    IntRect grandChildRect(5, 5, 150, 150);
+    gfx::Rect rootRect(0, 0, 100, 100);
+    gfx::Rect childRect(10, 10, 50, 50);
+    gfx::Rect grandChildRect(5, 5, 150, 150);
 
     root->createRenderSurface();
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setPosition(FloatPoint(rootRect.x(), rootRect.y()));
-    root->setBounds(IntSize(rootRect.width(), rootRect.height()));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setPosition(gfx::PointF(rootRect.x(), rootRect.y()));
+    root->setBounds(gfx::Size(rootRect.width(), rootRect.height()));
     root->setContentBounds(root->bounds());
     root->setVisibleContentRect(rootRect);
     root->setDrawsContent(false);
-    root->renderSurface()->setContentRect(IntRect(IntPoint(), IntSize(rootRect.width(), rootRect.height())));
+    root->renderSurface()->setContentRect(gfx::Rect(gfx::Point(), gfx::Size(rootRect.width(), rootRect.height())));
 
-    child->setAnchorPoint(FloatPoint(0, 0));
-    child->setPosition(FloatPoint(childRect.x(), childRect.y()));
+    child->setAnchorPoint(gfx::PointF(0, 0));
+    child->setPosition(gfx::PointF(childRect.x(), childRect.y()));
     child->setOpacity(0.5f);
-    child->setBounds(IntSize(childRect.width(), childRect.height()));
+    child->setBounds(gfx::Size(childRect.width(), childRect.height()));
     child->setContentBounds(child->bounds());
     child->setVisibleContentRect(childRect);
     child->setDrawsContent(false);
 
-    grandChild->setAnchorPoint(FloatPoint(0, 0));
-    grandChild->setPosition(IntPoint(grandChildRect.x(), grandChildRect.y()));
-    grandChild->setBounds(IntSize(grandChildRect.width(), grandChildRect.height()));
+    grandChild->setAnchorPoint(gfx::PointF(0, 0));
+    grandChild->setPosition(gfx::Point(grandChildRect.x(), grandChildRect.y()));
+    grandChild->setBounds(gfx::Size(grandChildRect.width(), grandChildRect.height()));
     grandChild->setContentBounds(grandChild->bounds());
     grandChild->setVisibleContentRect(grandChildRect);
     grandChild->setDrawsContent(true);
 
     child->addChild(grandChild.Pass());
     root->addChild(child.Pass());
 
     myHostImpl->setRootLayer(root.Pass());
     return myHostImpl.Pass();
 }
@@ skipping 320 matching lines @@
 public:
     static scoped_ptr<FakeScrollbarLayerImpl> create(int id)
     {
         return make_scoped_ptr(new FakeScrollbarLayerImpl(id));
     }
 
     void createResources(ResourceProvider* provider)
     {
         DCHECK(provider);
         int pool = 0;
-        IntSize size(10, 10);
+        gfx::Size size(10, 10);
         GLenum format = GL_RGBA;
         ResourceProvider::TextureUsageHint hint = ResourceProvider::TextureUsageAny;
         setScrollbarGeometry(ScrollbarGeometryFixedThumb::create(FakeWebScrollbarThemeGeometryNonEmpty::create()));
 
         setBackTrackResourceId(provider->createResource(pool, size, format, hint));
         setForeTrackResourceId(provider->createResource(pool, size, format, hint));
         setThumbResourceId(provider->createResource(pool, size, format, hint));
     }
 
 protected:
     explicit FakeScrollbarLayerImpl(int id)
         : ScrollbarLayerImpl(id)
     {
     }
 };
 
 static inline scoped_ptr<RenderPass> createRenderPassWithResource(ResourceProvider* provider)
 {
-    ResourceProvider::ResourceId resourceId = provider->createResource(0, IntSize(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId resourceId = provider->createResource(0, gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny);
 
-    scoped_ptr<TestRenderPass> pass = TestRenderPass::create(RenderPass::Id(1, 1), IntRect(0, 0, 1, 1), WebTransformationMatrix());
-    scoped_ptr<SharedQuadState> sharedState = SharedQuadState::create(WebTransformationMatrix(), IntRect(0, 0, 1, 1), IntRect(0, 0, 1, 1), 1, false);
-    scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::create(sharedState.get(), IntRect(0, 0, 1, 1), resourceId, false, FloatRect(0, 0, 1, 1), false);
+    scoped_ptr<TestRenderPass> pass = TestRenderPass::create(RenderPass::Id(1, 1), gfx::Rect(0, 0, 1, 1), WebTransformationMatrix());
+    scoped_ptr<SharedQuadState> sharedState = SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), 1, false);
+    scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::create(sharedState.get(), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), false);
 
     pass->appendSharedQuadState(sharedState.Pass());
     pass->appendQuad(quad.PassAs<DrawQuad>());
 
     return pass.PassAs<RenderPass>();
 }
 
 TEST_P(LayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
 {
     int layerId = 1;
 
     scoped_ptr<LayerImpl> rootLayer(LayerImpl::create(layerId++));
-    rootLayer->setBounds(IntSize(10, 10));
-    rootLayer->setAnchorPoint(FloatPoint(0, 0));
+    rootLayer->setBounds(gfx::Size(10, 10));
+    rootLayer->setAnchorPoint(gfx::PointF(0, 0));
 
     scoped_ptr<TiledLayerImpl> tileLayer = TiledLayerImpl::create(layerId++);
-    tileLayer->setBounds(IntSize(10, 10));
-    tileLayer->setAnchorPoint(FloatPoint(0, 0));
-    tileLayer->setContentBounds(IntSize(10, 10));
+    tileLayer->setBounds(gfx::Size(10, 10));
+    tileLayer->setAnchorPoint(gfx::PointF(0, 0));
+    tileLayer->setContentBounds(gfx::Size(10, 10));
     tileLayer->setDrawsContent(true);
     tileLayer->setSkipsDraw(false);
-    scoped_ptr<LayerTilingData> tilingData(LayerTilingData::create(IntSize(10, 10), LayerTilingData::NoBorderTexels));
-    tilingData->setBounds(IntSize(10, 10));
+    scoped_ptr<LayerTilingData> tilingData(LayerTilingData::create(gfx::Size(10, 10), LayerTilingData::NoBorderTexels));
+    tilingData->setBounds(gfx::Size(10, 10));
     tileLayer->setTilingData(*tilingData);
-    tileLayer->pushTileProperties(0, 0, 1, IntRect(0, 0, 10, 10), false);
+    tileLayer->pushTileProperties(0, 0, 1, gfx::Rect(0, 0, 10, 10), false);
     rootLayer->addChild(tileLayer.PassAs<LayerImpl>());
 
     scoped_ptr<TextureLayerImpl> textureLayer = TextureLayerImpl::create(layerId++);
-    textureLayer->setBounds(IntSize(10, 10));
-    textureLayer->setAnchorPoint(FloatPoint(0, 0));
-    textureLayer->setContentBounds(IntSize(10, 10));
+    textureLayer->setBounds(gfx::Size(10, 10));
+    textureLayer->setAnchorPoint(gfx::PointF(0, 0));
+    textureLayer->setContentBounds(gfx::Size(10, 10));
     textureLayer->setDrawsContent(true);
     textureLayer->setTextureId(1);
     rootLayer->addChild(textureLayer.PassAs<LayerImpl>());
 
     scoped_ptr<TiledLayerImpl> maskLayer = TiledLayerImpl::create(layerId++);
-    maskLayer->setBounds(IntSize(10, 10));
-    maskLayer->setAnchorPoint(FloatPoint(0, 0));
-    maskLayer->setContentBounds(IntSize(10, 10));
+    maskLayer->setBounds(gfx::Size(10, 10));
+    maskLayer->setAnchorPoint(gfx::PointF(0, 0));
+    maskLayer->setContentBounds(gfx::Size(10, 10));
     maskLayer->setDrawsContent(true);
     maskLayer->setSkipsDraw(false);
     maskLayer->setTilingData(*tilingData);
-    maskLayer->pushTileProperties(0, 0, 1, IntRect(0, 0, 10, 10), false);
+    maskLayer->pushTileProperties(0, 0, 1, gfx::Rect(0, 0, 10, 10), false);
 
     scoped_ptr<TextureLayerImpl> textureLayerWithMask = TextureLayerImpl::create(layerId++);
-    textureLayerWithMask->setBounds(IntSize(10, 10));
-    textureLayerWithMask->setAnchorPoint(FloatPoint(0, 0));
-    textureLayerWithMask->setContentBounds(IntSize(10, 10));
+    textureLayerWithMask->setBounds(gfx::Size(10, 10));
+    textureLayerWithMask->setAnchorPoint(gfx::PointF(0, 0));
+    textureLayerWithMask->setContentBounds(gfx::Size(10, 10));
     textureLayerWithMask->setDrawsContent(true);
     textureLayerWithMask->setTextureId(1);
     textureLayerWithMask->setMaskLayer(maskLayer.PassAs<LayerImpl>());
     rootLayer->addChild(textureLayerWithMask.PassAs<LayerImpl>());
 
     FakeVideoFrame videoFrame;
     FakeVideoFrameProvider provider;
     provider.setFrame(&videoFrame);
     scoped_ptr<VideoLayerImpl> videoLayer = VideoLayerImpl::create(layerId++, &provider);
-    videoLayer->setBounds(IntSize(10, 10));
-    videoLayer->setAnchorPoint(FloatPoint(0, 0));
-    videoLayer->setContentBounds(IntSize(10, 10));
+    videoLayer->setBounds(gfx::Size(10, 10));
+    videoLayer->setAnchorPoint(gfx::PointF(0, 0));
+    videoLayer->setContentBounds(gfx::Size(10, 10));
     videoLayer->setDrawsContent(true);
     videoLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(videoLayer.PassAs<LayerImpl>());
 
     FakeVideoFrame hwVideoFrame;
     FakeVideoFrameProvider hwProvider;
     hwProvider.setFrame(&hwVideoFrame);
     scoped_ptr<VideoLayerImpl> hwVideoLayer = VideoLayerImpl::create(layerId++, &hwProvider);
-    hwVideoLayer->setBounds(IntSize(10, 10));
-    hwVideoLayer->setAnchorPoint(FloatPoint(0, 0));
-    hwVideoLayer->setContentBounds(IntSize(10, 10));
+    hwVideoLayer->setBounds(gfx::Size(10, 10));
+    hwVideoLayer->setAnchorPoint(gfx::PointF(0, 0));
+    hwVideoLayer->setContentBounds(gfx::Size(10, 10));
     hwVideoLayer->setDrawsContent(true);
     hwVideoLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(hwVideoLayer.PassAs<LayerImpl>());
 
     scoped_ptr<IOSurfaceLayerImpl> ioSurfaceLayer = IOSurfaceLayerImpl::create(layerId++);
-    ioSurfaceLayer->setBounds(IntSize(10, 10));
-    ioSurfaceLayer->setAnchorPoint(FloatPoint(0, 0));
-    ioSurfaceLayer->setContentBounds(IntSize(10, 10));
+    ioSurfaceLayer->setBounds(gfx::Size(10, 10));
+    ioSurfaceLayer->setAnchorPoint(gfx::PointF(0, 0));
+    ioSurfaceLayer->setContentBounds(gfx::Size(10, 10));
     ioSurfaceLayer->setDrawsContent(true);
-    ioSurfaceLayer->setIOSurfaceProperties(1, IntSize(10, 10));
+    ioSurfaceLayer->setIOSurfaceProperties(1, gfx::Size(10, 10));
     ioSurfaceLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(ioSurfaceLayer.PassAs<LayerImpl>());
 
     scoped_ptr<HeadsUpDisplayLayerImpl> hudLayer = HeadsUpDisplayLayerImpl::create(layerId++);
-    hudLayer->setBounds(IntSize(10, 10));
-    hudLayer->setAnchorPoint(FloatPoint(0, 0));
-    hudLayer->setContentBounds(IntSize(10, 10));
+    hudLayer->setBounds(gfx::Size(10, 10));
+    hudLayer->setAnchorPoint(gfx::PointF(0, 0));
+    hudLayer->setContentBounds(gfx::Size(10, 10));
     hudLayer->setDrawsContent(true);
     hudLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(hudLayer.PassAs<LayerImpl>());
 
     scoped_ptr<FakeScrollbarLayerImpl> scrollbarLayer(FakeScrollbarLayerImpl::create(layerId++));
-    scrollbarLayer->setBounds(IntSize(10, 10));
-    scrollbarLayer->setContentBounds(IntSize(10, 10));
+    scrollbarLayer->setBounds(gfx::Size(10, 10));
+    scrollbarLayer->setContentBounds(gfx::Size(10, 10));
     scrollbarLayer->setDrawsContent(true);
     scrollbarLayer->setLayerTreeHostImpl(m_hostImpl.get());
     scrollbarLayer->createResources(m_hostImpl->resourceProvider());
     rootLayer->addChild(scrollbarLayer.PassAs<LayerImpl>());
 
     scoped_ptr<DelegatedRendererLayerImpl> delegatedRendererLayer(DelegatedRendererLayerImpl::create(layerId++));
-    delegatedRendererLayer->setBounds(IntSize(10, 10));
-    delegatedRendererLayer->setContentBounds(IntSize(10, 10));
+    delegatedRendererLayer->setBounds(gfx::Size(10, 10));
+    delegatedRendererLayer->setContentBounds(gfx::Size(10, 10));
     delegatedRendererLayer->setDrawsContent(true);
     delegatedRendererLayer->setLayerTreeHostImpl(m_hostImpl.get());
     ScopedPtrVector<RenderPass> passList;
     passList.append(createRenderPassWithResource(m_hostImpl->resourceProvider()));
     delegatedRendererLayer->setRenderPasses(passList);
     EXPECT_TRUE(passList.isEmpty());
     rootLayer->addChild(delegatedRendererLayer.PassAs<LayerImpl>());
 
     // Use a context that supports IOSurfaces
     m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DWithIOSurface)).PassAs<GraphicsContext>());
@@ skipping 74 matching lines @@
     unsigned numTextures() const { return m_numTextures; }
 
 private:
     base::hash_map<WebGLId, bool> m_textures;
     unsigned m_numTextures;
 };
 
 TEST_P(LayerTreeHostImplTest, layersFreeTextures)
 {
     scoped_ptr<LayerImpl> rootLayer(LayerImpl::create(1));
-    rootLayer->setBounds(IntSize(10, 10));
-    rootLayer->setAnchorPoint(FloatPoint(0, 0));
+    rootLayer->setBounds(gfx::Size(10, 10));
+    rootLayer->setAnchorPoint(gfx::PointF(0, 0));
 
     scoped_ptr<TiledLayerImpl> tileLayer = TiledLayerImpl::create(2);
-    tileLayer->setBounds(IntSize(10, 10));
-    tileLayer->setAnchorPoint(FloatPoint(0, 0));
-    tileLayer->setContentBounds(IntSize(10, 10));
+    tileLayer->setBounds(gfx::Size(10, 10));
+    tileLayer->setAnchorPoint(gfx::PointF(0, 0));
+    tileLayer->setContentBounds(gfx::Size(10, 10));
     tileLayer->setDrawsContent(true);
     tileLayer->setSkipsDraw(false);
-    scoped_ptr<LayerTilingData> tilingData(LayerTilingData::create(IntSize(10, 10), LayerTilingData::NoBorderTexels));
-    tilingData->setBounds(IntSize(10, 10));
+    scoped_ptr<LayerTilingData> tilingData(LayerTilingData::create(gfx::Size(10, 10), LayerTilingData::NoBorderTexels));
+    tilingData->setBounds(gfx::Size(10, 10));
     tileLayer->setTilingData(*tilingData);
-    tileLayer->pushTileProperties(0, 0, 1, IntRect(0, 0, 10, 10), false);
+    tileLayer->pushTileProperties(0, 0, 1, gfx::Rect(0, 0, 10, 10), false);
     rootLayer->addChild(tileLayer.PassAs<LayerImpl>());
 
     scoped_ptr<TextureLayerImpl> textureLayer = TextureLayerImpl::create(3);
-    textureLayer->setBounds(IntSize(10, 10));
-    textureLayer->setAnchorPoint(FloatPoint(0, 0));
-    textureLayer->setContentBounds(IntSize(10, 10));
+    textureLayer->setBounds(gfx::Size(10, 10));
+    textureLayer->setAnchorPoint(gfx::PointF(0, 0));
+    textureLayer->setContentBounds(gfx::Size(10, 10));
     textureLayer->setDrawsContent(true);
     textureLayer->setTextureId(1);
     rootLayer->addChild(textureLayer.PassAs<LayerImpl>());
 
     FakeVideoFrameProvider provider;
     scoped_ptr<VideoLayerImpl> videoLayer = VideoLayerImpl::create(4, &provider);
-    videoLayer->setBounds(IntSize(10, 10));
-    videoLayer->setAnchorPoint(FloatPoint(0, 0));
-    videoLayer->setContentBounds(IntSize(10, 10));
+    videoLayer->setBounds(gfx::Size(10, 10));
+    videoLayer->setAnchorPoint(gfx::PointF(0, 0));
+    videoLayer->setContentBounds(gfx::Size(10, 10));
     videoLayer->setDrawsContent(true);
     videoLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(videoLayer.PassAs<LayerImpl>());
 
     scoped_ptr<IOSurfaceLayerImpl> ioSurfaceLayer = IOSurfaceLayerImpl::create(5);
-    ioSurfaceLayer->setBounds(IntSize(10, 10));
-    ioSurfaceLayer->setAnchorPoint(FloatPoint(0, 0));
-    ioSurfaceLayer->setContentBounds(IntSize(10, 10));
+    ioSurfaceLayer->setBounds(gfx::Size(10, 10));
+    ioSurfaceLayer->setAnchorPoint(gfx::PointF(0, 0));
+    ioSurfaceLayer->setContentBounds(gfx::Size(10, 10));
     ioSurfaceLayer->setDrawsContent(true);
-    ioSurfaceLayer->setIOSurfaceProperties(1, IntSize(10, 10));
+    ioSurfaceLayer->setIOSurfaceProperties(1, gfx::Size(10, 10));
     ioSurfaceLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(ioSurfaceLayer.PassAs<LayerImpl>());
 
     // Lose the context, replacing it with a TrackingWebGraphicsContext3D (which the LayerTreeHostImpl takes ownership of).
     scoped_ptr<GraphicsContext> outputSurface(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new TrackingWebGraphicsContext3D)));
     TrackingWebGraphicsContext3D* trackingWebGraphicsContext = static_cast<TrackingWebGraphicsContext3D*>(outputSurface->context3D());
     m_hostImpl->initializeRenderer(outputSurface.Pass());
 
     m_hostImpl->setRootLayer(rootLayer.Pass());
 
@@ skipping 39 matching lines @@
     Mock::VerifyAndClearExpectations(&mockContext);
 
     // Verify no quads are drawn when transparent background is set.
     myHostImpl->setHasTransparentBackground(true);
     EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
     myHostImpl->drawLayers(frame);
     myHostImpl->didDrawAllLayers(frame);
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
-static void addDrawingLayerTo(LayerImpl* parent, int id, const IntRect& layerRect, LayerImpl** result)
+static void addDrawingLayerTo(LayerImpl* parent, int id, const gfx::Rect& layerRect, LayerImpl** result)
 {
     scoped_ptr<LayerImpl> layer = FakeLayerWithQuads::create(id);
     LayerImpl* layerPtr = layer.get();
-    layerPtr->setAnchorPoint(FloatPoint(0, 0));
-    layerPtr->setPosition(FloatPoint(layerRect.location()));
+    layerPtr->setAnchorPoint(gfx::PointF(0, 0));
+    layerPtr->setPosition(gfx::PointF(layerRect.origin()));
     layerPtr->setBounds(layerRect.size());
     layerPtr->setContentBounds(layerRect.size());
     layerPtr->setDrawsContent(true); // only children draw content
     layerPtr->setContentsOpaque(true);
     parent->addChild(layer.Pass());
     if (result)
         *result = layerPtr;
 }
 
-static void setupLayersForTextureCaching(LayerTreeHostImpl* layerTreeHostImpl, LayerImpl*& rootPtr, LayerImpl*& intermediateLayerPtr, LayerImpl*& surfaceLayerPtr, LayerImpl*& childPtr, const IntSize& rootSize)
+static void setupLayersForTextureCaching(LayerTreeHostImpl* layerTreeHostImpl, LayerImpl*& rootPtr, LayerImpl*& intermediateLayerPtr, LayerImpl*& surfaceLayerPtr, LayerImpl*& childPtr, const gfx::Size& rootSize)
 {
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     layerTreeHostImpl->initializeRenderer(context.Pass());
     layerTreeHostImpl->setViewportSize(rootSize, rootSize);
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setPosition(FloatPoint(0, 0));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     layerTreeHostImpl->setRootLayer(root.Pass());
 
-    addDrawingLayerTo(rootPtr, 2, IntRect(10, 10, rootSize.width(), rootSize.height()), &intermediateLayerPtr);
+    addDrawingLayerTo(rootPtr, 2, gfx::Rect(10, 10, rootSize.width(), rootSize.height()), &intermediateLayerPtr);
     intermediateLayerPtr->setDrawsContent(false); // only children draw content
 
     // Surface layer is the layer that changes its opacity
     // It will contain other layers that draw content.
-    addDrawingLayerTo(intermediateLayerPtr, 3, IntRect(10, 10, rootSize.width(), rootSize.height()), &surfaceLayerPtr);
+    addDrawingLayerTo(intermediateLayerPtr, 3, gfx::Rect(10, 10, rootSize.width(), rootSize.height()), &surfaceLayerPtr);
     surfaceLayerPtr->setDrawsContent(false); // only children draw content
     surfaceLayerPtr->setOpacity(0.5f); // This will cause it to have a surface
 
     // Child of the surface layer will produce some quads
-    addDrawingLayerTo(surfaceLayerPtr, 4, IntRect(5, 5, rootSize.width() - 25, rootSize.height() - 25), &childPtr);
+    addDrawingLayerTo(surfaceLayerPtr, 4, gfx::Rect(5, 5, rootSize.width() - 25, rootSize.height() - 25), &childPtr);
 }
 
 class GLRendererWithReleaseTextures : public GLRenderer {
 public:
     using GLRenderer::releaseRenderPassTextures;
 };
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithClipping)
 {
     Settings::setPartialSwapEnabled(true);
 
     LayerTreeSettings settings;
-    settings.minimumOcclusionTrackingSize = IntSize();
+    settings.minimumOcclusionTrackingSize = gfx::Size();
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
 
     LayerImpl* rootPtr;
     LayerImpl* surfaceLayerPtr;
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
-    IntSize rootSize(100, 100);
+    gfx::Size rootSize(100, 100);
 
     myHostImpl->initializeRenderer(context.Pass());
-    myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
+    myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setPosition(FloatPoint(0, 0));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
-    addDrawingLayerTo(rootPtr, 3, IntRect(0, 0, rootSize.width(), rootSize.height()), &surfaceLayerPtr);
+    addDrawingLayerTo(rootPtr, 3, gfx::Rect(0, 0, rootSize.width(), rootSize.height()), &surfaceLayerPtr);
     surfaceLayerPtr->setDrawsContent(false);
 
     // Surface layer is the layer that changes its opacity
     // It will contain other layers that draw content.
     surfaceLayerPtr->setOpacity(0.5f); // This will cause it to have a surface
 
-    addDrawingLayerTo(surfaceLayerPtr, 4, IntRect(0, 0, 100, 3), 0);
-    addDrawingLayerTo(surfaceLayerPtr, 5, IntRect(0, 97, 100, 3), 0);
+    addDrawingLayerTo(surfaceLayerPtr, 4, gfx::Rect(0, 0, 100, 3), 0);
+    addDrawingLayerTo(surfaceLayerPtr, 5, gfx::Rect(0, 97, 100, 3), 0);
 
     // Rotation will put part of the child ouside the bounds of the root layer.
     // Nevertheless, the child layers should be drawn.
     WebTransformationMatrix transform = surfaceLayerPtr->transform();
     transform.translate(50, 50);
     transform.rotate(35);
     transform.translate(-50, -50);
     surfaceLayerPtr->setTransform(transform);
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive two render passes, each with one quad
         ASSERT_EQ(2U, frame.renderPasses.size());
         EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
         ASSERT_EQ(1U, frame.renderPasses[1]->quadList().size());
 
         // Verify that the child layers are being clipped.
         gfx::Rect quadVisibleRect = frame.renderPasses[0]->quadList()[0]->quadVisibleRect();
         EXPECT_LT(quadVisibleRect.width(), 100);
 
         quadVisibleRect = frame.renderPasses[0]->quadList()[1]->quadVisibleRect();
         EXPECT_LT(quadVisibleRect.width(), 100);
 
         // Verify that the render surface texture is *not* clipped.
-        EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), frame.renderPasses[0]->outputRect());
+        EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), frame.renderPasses[0]->outputRect());
 
         EXPECT_EQ(DrawQuad::RenderPass, frame.renderPasses[1]->quadList()[0]->material());
         RenderPassDrawQuad* quad = static_cast<RenderPassDrawQuad*>(frame.renderPasses[1]->quadList()[0]);
         EXPECT_FALSE(quad->contentsChangedSinceLastFrame().IsEmpty());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     transform = surfaceLayerPtr->transform();
@@ skipping 17 matching lines @@
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusion)
 {
     Settings::setPartialSwapEnabled(false);
 
     LayerTreeSettings settings;
-    settings.minimumOcclusionTrackingSize = IntSize();
+    settings.minimumOcclusionTrackingSize = gfx::Size();
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning)
     //    |      +- L11
     //    |      +- L12
     //    |
     //    +-- S2 +- L20 (owning)
     //           +- L21
     //
     // Occlusion:
     // L12 occludes L11 (internal)
     // L20 occludes L10 (external)
     // L21 occludes L20 (internal)
 
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
-    IntSize rootSize(1000, 1000);
+    gfx::Size rootSize(1000, 1000);
 
     myHostImpl->initializeRenderer(context.Pass());
-    myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
+    myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setPosition(FloatPoint(0, 0));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
-    addDrawingLayerTo(rootPtr, 2, IntRect(300, 300, 300, 300), &layerS1Ptr);
+    addDrawingLayerTo(rootPtr, 2, gfx::Rect(300, 300, 300, 300), &layerS1Ptr);
     layerS1Ptr->setForceRenderSurface(true);
 
-    addDrawingLayerTo(layerS1Ptr, 3, IntRect(10, 10, 10, 10), 0); // L11
-    addDrawingLayerTo(layerS1Ptr, 4, IntRect(0, 0, 30, 30), 0); // L12
+    addDrawingLayerTo(layerS1Ptr, 3, gfx::Rect(10, 10, 10, 10), 0); // L11
+    addDrawingLayerTo(layerS1Ptr, 4, gfx::Rect(0, 0, 30, 30), 0); // L12
 
-    addDrawingLayerTo(rootPtr, 5, IntRect(550, 250, 300, 400), &layerS2Ptr);
+    addDrawingLayerTo(rootPtr, 5, gfx::Rect(550, 250, 300, 400), &layerS2Ptr);
     layerS2Ptr->setForceRenderSurface(true);
 
-    addDrawingLayerTo(layerS2Ptr, 6, IntRect(20, 20, 5, 5), 0); // L21
+    addDrawingLayerTo(layerS2Ptr, 6, gfx::Rect(20, 20, 5, 5), 0); // L21
 
     // Initial draw - must receive all quads
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive 3 render passes.
         // For Root, there are 2 quads; for S1, there are 2 quads (1 is occluded); for S2, there is 2 quads.
         ASSERT_EQ(3U, frame.renderPasses.size());
 
@@ skipping 47 matching lines @@
         myHostImpl->didDrawAllLayers(frame);
     }
 
 }
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionEarlyOut)
 {
     Settings::setPartialSwapEnabled(false);
 
     LayerTreeSettings settings;
-    settings.minimumOcclusionTrackingSize = IntSize();
+    settings.minimumOcclusionTrackingSize = gfx::Size();
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning, non drawing)
     //    |      +- L11 (corner, unoccluded)
     //    |      +- L12 (corner, unoccluded)
     //    |      +- L13 (corner, unoccluded)
     //    |      +- L14 (corner, entirely occluded)
     //    |
     //    +-- S2 +- L20 (owning, drawing)
     //
 
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
-    IntSize rootSize(1000, 1000);
+    gfx::Size rootSize(1000, 1000);
 
     myHostImpl->initializeRenderer(context.Pass());
-    myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
+    myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setPosition(FloatPoint(0, 0));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
-    addDrawingLayerTo(rootPtr, 2, IntRect(0, 0, 800, 800), &layerS1Ptr);
+    addDrawingLayerTo(rootPtr, 2, gfx::Rect(0, 0, 800, 800), &layerS1Ptr);
     layerS1Ptr->setForceRenderSurface(true);
     layerS1Ptr->setDrawsContent(false);
 
-    addDrawingLayerTo(layerS1Ptr, 3, IntRect(0, 0, 300, 300), 0); // L11
-    addDrawingLayerTo(layerS1Ptr, 4, IntRect(0, 500, 300, 300), 0); // L12
-    addDrawingLayerTo(layerS1Ptr, 5, IntRect(500, 0, 300, 300), 0); // L13
-    addDrawingLayerTo(layerS1Ptr, 6, IntRect(500, 500, 300, 300), 0); // L14
-    addDrawingLayerTo(layerS1Ptr, 9, IntRect(500, 500, 300, 300), 0); // L14
+    addDrawingLayerTo(layerS1Ptr, 3, gfx::Rect(0, 0, 300, 300), 0); // L11
+    addDrawingLayerTo(layerS1Ptr, 4, gfx::Rect(0, 500, 300, 300), 0); // L12
+    addDrawingLayerTo(layerS1Ptr, 5, gfx::Rect(500, 0, 300, 300), 0); // L13
+    addDrawingLayerTo(layerS1Ptr, 6, gfx::Rect(500, 500, 300, 300), 0); // L14
+    addDrawingLayerTo(layerS1Ptr, 9, gfx::Rect(500, 500, 300, 300), 0); // L14
 
-    addDrawingLayerTo(rootPtr, 7, IntRect(450, 450, 450, 450), &layerS2Ptr);
+    addDrawingLayerTo(rootPtr, 7, gfx::Rect(450, 450, 450, 450), &layerS2Ptr);
     layerS2Ptr->setForceRenderSurface(true);
 
     // Initial draw - must receive all quads
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive 3 render passes.
         // For Root, there are 2 quads; for S1, there are 3 quads; for S2, there is 1 quad.
         ASSERT_EQ(3U, frame.renderPasses.size());
@@ skipping 49 matching lines @@
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionExternalOverInternal)
 {
     Settings::setPartialSwapEnabled(false);
 
     LayerTreeSettings settings;
-    settings.minimumOcclusionTrackingSize = IntSize();
+    settings.minimumOcclusionTrackingSize = gfx::Size();
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
 
     // Layers are structured as follows:
     //
     //  R +-- S1 +- L10 (owning, drawing)
     //    |      +- L11 (corner, occluded by L12)
     //    |      +- L12 (opposite corner)
     //    |
     //    +-- S2 +- L20 (owning, drawing)
     //
 
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
-    IntSize rootSize(1000, 1000);
+    gfx::Size rootSize(1000, 1000);
 
     myHostImpl->initializeRenderer(context.Pass());
-    myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
+    myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setPosition(FloatPoint(0, 0));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
-    addDrawingLayerTo(rootPtr, 2, IntRect(0, 0, 400, 400), &layerS1Ptr);
+    addDrawingLayerTo(rootPtr, 2, gfx::Rect(0, 0, 400, 400), &layerS1Ptr);
     layerS1Ptr->setForceRenderSurface(true);
 
-    addDrawingLayerTo(layerS1Ptr, 3, IntRect(0, 0, 300, 300), 0); // L11
-    addDrawingLayerTo(layerS1Ptr, 4, IntRect(100, 0, 300, 300), 0); // L12
+    addDrawingLayerTo(layerS1Ptr, 3, gfx::Rect(0, 0, 300, 300), 0); // L11
+    addDrawingLayerTo(layerS1Ptr, 4, gfx::Rect(100, 0, 300, 300), 0); // L12
 
-    addDrawingLayerTo(rootPtr, 7, IntRect(200, 0, 300, 300), &layerS2Ptr);
+    addDrawingLayerTo(rootPtr, 7, gfx::Rect(200, 0, 300, 300), &layerS2Ptr);
     layerS2Ptr->setForceRenderSurface(true);
 
     // Initial draw - must receive all quads
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive 3 render passes.
         // For Root, there are 2 quads; for S1, there are 3 quads; for S2, there is 1 quad.
         ASSERT_EQ(3U, frame.renderPasses.size());
@@ skipping 40 matching lines @@
     // Layers are structured as follows:
     //
     //  R +-- S1 +- L10 (rotated, drawing)
     //           +- L11 (occupies half surface)
 
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
-    IntSize rootSize(1000, 1000);
+    gfx::Size rootSize(1000, 1000);
 
     myHostImpl->initializeRenderer(context.Pass());
-    myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
+    myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setPosition(FloatPoint(0, 0));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
-    addDrawingLayerTo(rootPtr, 2, IntRect(0, 0, 400, 400), &layerS1Ptr);
+    addDrawingLayerTo(rootPtr, 2, gfx::Rect(0, 0, 400, 400), &layerS1Ptr);
     layerS1Ptr->setForceRenderSurface(true);
     WebTransformationMatrix transform = layerS1Ptr->transform();
     transform.translate(200, 200);
     transform.rotate(45);
     transform.translate(-200, -200);
     layerS1Ptr->setTransform(transform);
 
-    addDrawingLayerTo(layerS1Ptr, 3, IntRect(200, 0, 200, 400), 0); // L11
+    addDrawingLayerTo(layerS1Ptr, 3, gfx::Rect(200, 0, 200, 400), 0); // L11
 
     // Initial draw - must receive all quads
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive 2 render passes.
         ASSERT_EQ(2U, frame.renderPasses.size());
 
         EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
@@ skipping 17 matching lines @@
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionPartialSwap)
 {
     Settings::setPartialSwapEnabled(true);
 
     LayerTreeSettings settings;
-    settings.minimumOcclusionTrackingSize = IntSize();
+    settings.minimumOcclusionTrackingSize = gfx::Size();
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning)
     //    |      +- L11
     //    |      +- L12
     //    |
     //    +-- S2 +- L20 (owning)
     //           +- L21
     //
     // Occlusion:
     // L12 occludes L11 (internal)
     // L20 occludes L10 (external)
     // L21 occludes L20 (internal)
 
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
-    IntSize rootSize(1000, 1000);
+    gfx::Size rootSize(1000, 1000);
 
     myHostImpl->initializeRenderer(context.Pass());
-    myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
+    myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setPosition(FloatPoint(0, 0));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
-    addDrawingLayerTo(rootPtr, 2, IntRect(300, 300, 300, 300), &layerS1Ptr);
+    addDrawingLayerTo(rootPtr, 2, gfx::Rect(300, 300, 300, 300), &layerS1Ptr);
     layerS1Ptr->setForceRenderSurface(true);
 
-    addDrawingLayerTo(layerS1Ptr, 3, IntRect(10, 10, 10, 10), 0); // L11
-    addDrawingLayerTo(layerS1Ptr, 4, IntRect(0, 0, 30, 30), 0); // L12
+    addDrawingLayerTo(layerS1Ptr, 3, gfx::Rect(10, 10, 10, 10), 0); // L11
+    addDrawingLayerTo(layerS1Ptr, 4, gfx::Rect(0, 0, 30, 30), 0); // L12
 
-    addDrawingLayerTo(rootPtr, 5, IntRect(550, 250, 300, 400), &layerS2Ptr);
+    addDrawingLayerTo(rootPtr, 5, gfx::Rect(550, 250, 300, 400), &layerS2Ptr);
     layerS2Ptr->setForceRenderSurface(true);
 
-    addDrawingLayerTo(layerS2Ptr, 6, IntRect(20, 20, 5, 5), 0); // L21
+    addDrawingLayerTo(layerS2Ptr, 6, gfx::Rect(20, 20, 5, 5), 0); // L21
 
     // Initial draw - must receive all quads
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive 3 render passes.
         // For Root, there are 2 quads; for S1, there are 2 quads (one is occluded); for S2, there is 2 quads.
         ASSERT_EQ(3U, frame.renderPasses.size());
 
@@ skipping 44 matching lines @@
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithScissor)
 {
     Settings::setPartialSwapEnabled(false);
 
     LayerTreeSettings settings;
-    settings.minimumOcclusionTrackingSize = IntSize();
+    settings.minimumOcclusionTrackingSize = gfx::Size();
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
 
     /*
       Layers are created as follows:
 
          +--------------------+
          |                  1 |
          |  +-----------+     |
          |  |         2 |     |
          |  | +-------------------+
          |  | |   3               |
          |  | +-------------------+
          |  |           |     |
          |  +-----------+     |
          |                    |
          |                    |
          +--------------------+
 
          Layers 1, 2 have render surfaces
      */
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     scoped_ptr<TiledLayerImpl> child = TiledLayerImpl::create(2);
     scoped_ptr<LayerImpl> grandChild = LayerImpl::create(3);
 
-    IntRect rootRect(0, 0, 100, 100);
-    IntRect childRect(10, 10, 50, 50);
-    IntRect grandChildRect(5, 5, 150, 150);
+    gfx::Rect rootRect(0, 0, 100, 100);
+    gfx::Rect childRect(10, 10, 50, 50);
+    gfx::Rect grandChildRect(5, 5, 150, 150);
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
     myHostImpl->initializeRenderer(context.Pass());
 
-    root->setAnchorPoint(FloatPoint(0, 0));
-    root->setPosition(FloatPoint(rootRect.x(), rootRect.y()));
-    root->setBounds(IntSize(rootRect.width(), rootRect.height()));
+    root->setAnchorPoint(gfx::PointF(0, 0));
+    root->setPosition(gfx::PointF(rootRect.x(), rootRect.y()));
+    root->setBounds(gfx::Size(rootRect.width(), rootRect.height()));
     root->setContentBounds(root->bounds());
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
 
-    child->setAnchorPoint(FloatPoint(0, 0));
-    child->setPosition(FloatPoint(childRect.x(), childRect.y()));
+    child->setAnchorPoint(gfx::PointF(0, 0));
+    child->setPosition(gfx::PointF(childRect.x(), childRect.y()));
     child->setOpacity(0.5);
-    child->setBounds(IntSize(childRect.width(), childRect.height()));
+    child->setBounds(gfx::Size(childRect.width(), childRect.height()));
     child->setContentBounds(child->bounds());
     child->setDrawsContent(true);
     child->setSkipsDraw(false);
 
     // child layer has 10x10 tiles.
-    scoped_ptr<LayerTilingData> tiler = LayerTilingData::create(IntSize(10, 10), LayerTilingData::HasBorderTexels);
+    scoped_ptr<LayerTilingData> tiler = LayerTilingData::create(gfx::Size(10, 10), LayerTilingData::HasBorderTexels);
     tiler->setBounds(child->contentBounds());
     child->setTilingData(*tiler.get());
 
-    grandChild->setAnchorPoint(FloatPoint(0, 0));
-    grandChild->setPosition(IntPoint(grandChildRect.x(), grandChildRect.y()));
-    grandChild->setBounds(IntSize(grandChildRect.width(), grandChildRect.height()));
+    grandChild->setAnchorPoint(gfx::PointF(0, 0));
+    grandChild->setPosition(gfx::Point(grandChildRect.x(), grandChildRect.y()));
+    grandChild->setBounds(gfx::Size(grandChildRect.width(), grandChildRect.height()));
     grandChild->setContentBounds(grandChild->bounds());
     grandChild->setDrawsContent(true);
 
     TiledLayerImpl* childPtr = child.get();
     RenderPass::Id childPassId(childPtr->id(), 0);
 
     child->addChild(grandChild.Pass());
     root->addChild(child.PassAs<LayerImpl>());
     myHostImpl->setRootLayer(root.Pass());
     myHostImpl->setViewportSize(rootRect.size(), rootRect.size());
@@ skipping 14 matching lines @@
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // We should still have cached textures for surface 2 after drawing with no damage.
     EXPECT_TRUE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(childPassId));
 
     // Damage a single tile of surface 2.
-    childPtr->setUpdateRect(IntRect(10, 10, 10, 10));
+    childPtr->setUpdateRect(gfx::Rect(10, 10, 10, 10));
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // We should have a cached texture for surface 2 again even though it was damaged.
     EXPECT_TRUE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(childPassId));
 }
 
 TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
 {
     Settings::setPartialSwapEnabled(true);
 
     LayerTreeSettings settings;
-    settings.minimumOcclusionTrackingSize = IntSize();
+    settings.minimumOcclusionTrackingSize = gfx::Size();
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
 
     LayerImpl* rootPtr;
     LayerImpl* intermediateLayerPtr;
     LayerImpl* surfaceLayerPtr;
     LayerImpl* childPtr;
 
-    setupLayersForTextureCaching(myHostImpl.get(), rootPtr, intermediateLayerPtr, surfaceLayerPtr, childPtr, IntSize(100, 100));
+    setupLayersForTextureCaching(myHostImpl.get(), rootPtr, intermediateLayerPtr, surfaceLayerPtr, childPtr, gfx::Size(100, 100));
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive two render passes, each with one quad
         ASSERT_EQ(2U, frame.renderPasses.size());
         EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
         EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
 
@@ skipping 132 matching lines @@
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
 {
     Settings::setPartialSwapEnabled(false);
 
     LayerTreeSettings settings;
-    settings.minimumOcclusionTrackingSize = IntSize();
+    settings.minimumOcclusionTrackingSize = gfx::Size();
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
 
     LayerImpl* rootPtr;
     LayerImpl* intermediateLayerPtr;
     LayerImpl* surfaceLayerPtr;
     LayerImpl* childPtr;
 
-    setupLayersForTextureCaching(myHostImpl.get(), rootPtr, intermediateLayerPtr, surfaceLayerPtr, childPtr, IntSize(100, 100));
+    setupLayersForTextureCaching(myHostImpl.get(), rootPtr, intermediateLayerPtr, surfaceLayerPtr, childPtr, gfx::Size(100, 100));
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive two render passes, each with one quad
         ASSERT_EQ(2U, frame.renderPasses.size());
         EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
         EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
 
@@ skipping 179 matching lines @@
 
         return renderer.Pass();
     }
 
     void clearCachedTextures() { m_textures.clear(); }
     void setHaveCachedResourcesForRenderPassId(RenderPass::Id id) { m_textures.insert(id); }
 
     virtual bool haveCachedResourcesForRenderPassId(RenderPass::Id id) const OVERRIDE { return m_textures.count(id); }
 
     // RendererClient implementation.
-    virtual const IntSize& deviceViewportSize() const OVERRIDE { return m_viewportSize; }
+    virtual const gfx::Size& deviceViewportSize() const OVERRIDE { return m_viewportSize; }
     virtual const LayerTreeSettings& settings() const OVERRIDE { return m_settings; }
     virtual void didLoseContext() OVERRIDE { }
     virtual void onSwapBuffersComplete() OVERRIDE { }
     virtual void setFullRootLayerDamage() OVERRIDE { }
     virtual void setManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { }
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { }
 
 protected:
     TestRenderer(ResourceProvider* resourceProvider) : GLRenderer(this, resourceProvider) { }
 
 private:
     LayerTreeSettings m_settings;
-    IntSize m_viewportSize;
+    gfx::Size m_viewportSize;
     base::hash_set<RenderPass::Id> m_textures;
 };
 
 static void configureRenderPassTestData(const char* testScript, RenderPassRemovalTestData& testData, TestRenderer* renderer)
 {
     renderer->clearCachedTextures();
 
     // One shared state for all quads - we don't need the correct details
-    testData.sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), IntRect(), IntRect(), 1.0, true);
+    testData.sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(), gfx::Rect(), 1.0, true);
 
     const char* currentChar = testScript;
 
     // Pre-create root pass
     RenderPass::Id rootRenderPassId = RenderPass::Id(testScript[0], testScript[1]);
-    testData.renderPassCache.add(rootRenderPassId, TestRenderPass::create(rootRenderPassId, IntRect(), WebTransformationMatrix()));
+    testData.renderPassCache.add(rootRenderPassId, TestRenderPass::create(rootRenderPassId, gfx::Rect(), WebTransformationMatrix()));
     while (*currentChar) {
         int layerId = *currentChar;
         currentChar++;
         ASSERT_TRUE(currentChar);
         int index = *currentChar;
         currentChar++;
 
         RenderPass::Id renderPassId = RenderPass::Id(layerId, index);
 
         bool isReplica = false;
         if (!testData.renderPassCache.contains(renderPassId))
             isReplica = true;
 
         scoped_ptr<TestRenderPass> renderPass = testData.renderPassCache.take(renderPassId);
 
         // Cycle through quad data and create all quads
         while (*currentChar && *currentChar != '\n') {
             if (*currentChar == 's') {
                 // Solid color draw quad
-                scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::create(testData.sharedQuadState.get(), IntRect(0, 0, 10, 10), SK_ColorWHITE);
+                scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::create(testData.sharedQuadState.get(), gfx::Rect(0, 0, 10, 10), SK_ColorWHITE);
                 
                 renderPass->appendQuad(quad.PassAs<DrawQuad>());
                 currentChar++;
             } else if ((*currentChar >= 'A') && (*currentChar <= 'Z')) {
                 // RenderPass draw quad
                 int layerId = *currentChar;
                 currentChar++;
                 ASSERT_TRUE(currentChar);
                 int index = *currentChar;
                 currentChar++;
@@ skipping 16 matching lines @@
                         currentChar++;
                     }
                     if (*currentChar == ']')
                         currentChar++;
                 }
 
                 if (testData.renderPassCache.find(newRenderPassId) == testData.renderPassCache.end()) {
                     if (hasTexture)
                         renderer->setHaveCachedResourcesForRenderPassId(newRenderPassId);
 
-                    testData.renderPassCache.add(newRenderPassId, TestRenderPass::create(newRenderPassId, IntRect(), WebTransformationMatrix()));
+                    testData.renderPassCache.add(newRenderPassId, TestRenderPass::create(newRenderPassId, gfx::Rect(), WebTransformationMatrix()));
                 }
 
-                IntRect quadRect = IntRect(0, 0, 1, 1);
-                IntRect contentsChangedRect = contentsChanged ? quadRect : IntRect();
+                gfx::Rect quadRect = gfx::Rect(0, 0, 1, 1);
+                gfx::Rect contentsChangedRect = contentsChanged ? quadRect : gfx::Rect();
                 scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::create(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, 1, 1, 0, 0);
                 renderPass->appendQuad(quad.PassAs<DrawQuad>());
             }
         }
         testData.renderPasses.insert(testData.renderPasses.begin(), renderPass.get());
         testData.renderPassesById.add(renderPassId, renderPass.PassAs<RenderPass>());
         if (*currentChar)
             currentChar++;
     }
 }
@@ skipping 200 matching lines @@
         verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
         testCaseIndex++;
     }
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 } // namespace