Remove most remaining webcore points and sizes.

cc/layer_tree_host_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.h"
 
 #include "base/synchronization/lock.h"
 #include "cc/content_layer.h"
@@ skipping 1166 matching lines @@
 public:
     LayerTreeHostTestOpacityChange()
         : m_testOpacityChangeDelegate()
         , m_updateCheckLayer(ContentLayerWithUpdateTracking::create(&m_testOpacityChangeDelegate))
     {
         m_testOpacityChangeDelegate.setTestLayer(m_updateCheckLayer.get());
     }
 
     virtual void beginTest() OVERRIDE
     {
-        m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10));
+        m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
         m_layerTreeHost->rootLayer()->addChild(m_updateCheckLayer);
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         endTest();
     }
 
@@ skipping 93 matching lines @@
     {
         m_layerTreeHost->setViewportSize(gfx::Size(40, 40), gfx::Size(60, 60));
         m_layerTreeHost->setDeviceScaleFactor(1.5);
         EXPECT_EQ(gfx::Size(40, 40), m_layerTreeHost->layoutViewportSize());
         EXPECT_EQ(gfx::Size(60, 60), m_layerTreeHost->deviceViewportSize());
 
         m_rootLayer->addChild(m_childLayer);
 
         m_rootLayer->setIsDrawable(true);
         m_rootLayer->setBounds(gfx::Size(30, 30));
-        m_rootLayer->setAnchorPoint(FloatPoint(0, 0));
+        m_rootLayer->setAnchorPoint(gfx::PointF(0, 0));
 
         m_childLayer->setIsDrawable(true);
         m_childLayer->setPosition(gfx::Point(2, 2));
         m_childLayer->setBounds(gfx::Size(10, 10));
-        m_childLayer->setAnchorPoint(FloatPoint(0, 0));
+        m_childLayer->setAnchorPoint(gfx::PointF(0, 0));
 
         m_layerTreeHost->setRootLayer(m_rootLayer);
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         // Get access to protected methods.
         MockLayerTreeHostImpl* mockImpl = static_cast<MockLayerTreeHostImpl*>(impl);
 
         // Should only do one commit.
@@ skipping 908 matching lines @@
         : m_deviceScaleFactor(deviceScaleFactor)
         , m_initialScroll(IntPoint(10, 20))
         , m_secondScroll(IntPoint(40, 5))
         , m_scrollAmount(2, -1)
         , m_rootScrolls(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        IntSize viewportSize(10, 10);
-        IntSize deviceViewportSize = viewportSize;
-        deviceViewportSize.scale(m_deviceScaleFactor, m_deviceScaleFactor);
+        gfx::Size viewportSize(10, 10);
+        gfx::Size deviceViewportSize = gfx::ToCeiledSize(viewportSize.Scale(m_deviceScaleFactor));
         m_layerTreeHost->setViewportSize(viewportSize, deviceViewportSize);
 
         m_layerTreeHost->setDeviceScaleFactor(m_deviceScaleFactor);
 
         m_rootScrollLayer = ContentLayer::create(&m_mockDelegate);
-        m_rootScrollLayer->setBounds(IntSize(110, 110));
+        m_rootScrollLayer->setBounds(gfx::Size(110, 110));
 
-        m_rootScrollLayer->setPosition(FloatPoint(0, 0));
-        m_rootScrollLayer->setAnchorPoint(FloatPoint(0, 0));
+        m_rootScrollLayer->setPosition(gfx::PointF(0, 0));
+        m_rootScrollLayer->setAnchorPoint(gfx::PointF(0, 0));
 
         m_rootScrollLayer->setIsDrawable(true);
         m_rootScrollLayer->setScrollable(true);
         m_rootScrollLayer->setMaxScrollPosition(IntSize(100, 100));
         m_layerTreeHost->rootLayer()->addChild(m_rootScrollLayer);
 
         m_childLayer = ContentLayer::create(&m_mockDelegate);
         m_childLayer->setLayerScrollClient(this);
-        m_childLayer->setBounds(IntSize(110, 110));
+        m_childLayer->setBounds(gfx::Size(110, 110));
 
         // The scrolls will happen at 5, 5. If they are treated like device pixels, then
         // they will be at 2.5, 2.5 in logical pixels, and will miss this layer.
-        m_childLayer->setPosition(FloatPoint(5, 5));
-        m_childLayer->setAnchorPoint(FloatPoint(0, 0));
+        m_childLayer->setPosition(gfx::PointF(5, 5));
+        m_childLayer->setAnchorPoint(gfx::PointF(0, 0));
 
         m_childLayer->setIsDrawable(true);
         m_childLayer->setScrollable(true);
         m_childLayer->setMaxScrollPosition(IntSize(100, 100));
         m_rootScrollLayer->addChild(m_childLayer);
 
         m_childLayer->setScrollPosition(m_initialScroll);
 
         postSetNeedsCommitToMainThread();
     }
@@ skipping 39 matching lines @@
         EXPECT_SIZE_EQ(root->scrollDelta(), IntSize());
         EXPECT_SIZE_EQ(rootScrollLayer->scrollDelta(), IntSize());
         EXPECT_EQ(rootScrollLayer->bounds().width() * m_deviceScaleFactor, rootScrollLayer->contentBounds().width());
         EXPECT_EQ(rootScrollLayer->bounds().height() * m_deviceScaleFactor, rootScrollLayer->contentBounds().height());
         EXPECT_EQ(childLayer->bounds().width() * m_deviceScaleFactor, childLayer->contentBounds().width());
         EXPECT_EQ(childLayer->bounds().height() * m_deviceScaleFactor, childLayer->contentBounds().height());
 
         switch (impl->sourceFrameNumber()) {
         case 0:
             // Gesture scroll on impl thread.
-            EXPECT_EQ(impl->scrollBegin(IntPoint(5, 5), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
-            impl->scrollBy(IntPoint(), m_scrollAmount);
+            EXPECT_EQ(impl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
+            impl->scrollBy(gfx::Point(), m_scrollAmount);
             impl->scrollEnd();
 
             EXPECT_POINT_EQ(m_initialScroll, childLayer->scrollPosition());
             EXPECT_SIZE_EQ(m_scrollAmount, childLayer->scrollDelta());
             break;
         case 1:
             // Wheel scroll on impl thread.
-            EXPECT_EQ(impl->scrollBegin(IntPoint(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-            impl->scrollBy(IntPoint(), m_scrollAmount);
+            EXPECT_EQ(impl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+            impl->scrollBy(gfx::Point(), m_scrollAmount);
             impl->scrollEnd();
 
             EXPECT_POINT_EQ(m_secondScroll, childLayer->scrollPosition());
             EXPECT_SIZE_EQ(m_scrollAmount, childLayer->scrollDelta());
             break;
         case 2:
             EXPECT_POINT_EQ(m_secondScroll + m_scrollAmount, childLayer->scrollPosition());
             EXPECT_SIZE_EQ(IntSize(0, 0), childLayer->scrollDelta());
 
             endTest();
@@ skipping 45 matching lines @@
         : m_deviceScaleFactor(deviceScaleFactor)
         , m_initialScroll(IntPoint(10, 20))
         , m_secondScroll(IntPoint(40, 5))
         , m_scrollAmount(2, -1)
         , m_rootScrolls(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        IntSize viewportSize(10, 10);
-        IntSize deviceViewportSize = viewportSize;
-        deviceViewportSize.scale(m_deviceScaleFactor, m_deviceScaleFactor);
+        gfx::Size viewportSize(10, 10);
+        gfx::Size deviceViewportSize = gfx::ToCeiledSize(viewportSize.Scale(m_deviceScaleFactor));
         m_layerTreeHost->setViewportSize(viewportSize, deviceViewportSize);
 
         m_layerTreeHost->setDeviceScaleFactor(m_deviceScaleFactor);
 
         m_rootScrollLayer = ContentLayer::create(&m_mockDelegate);
         m_rootScrollLayer->setBounds(IntSize(110, 110));
 
-        m_rootScrollLayer->setPosition(FloatPoint(0, 0));
-        m_rootScrollLayer->setAnchorPoint(FloatPoint(0, 0));
+        m_rootScrollLayer->setPosition(gfx::PointF(0, 0));
+        m_rootScrollLayer->setAnchorPoint(gfx::PointF(0, 0));
 
         m_rootScrollLayer->setIsDrawable(true);
         m_rootScrollLayer->setScrollable(true);
         m_rootScrollLayer->setMaxScrollPosition(IntSize(100, 100));
         m_layerTreeHost->rootLayer()->addChild(m_rootScrollLayer);
 
         m_rootScrollLayer->setScrollPosition(m_initialScroll);
 
         postSetNeedsCommitToMainThread();
     }
@@ skipping 28 matching lines @@
         LayerImpl* root = impl->rootLayer();
         LayerImpl* rootScrollLayer = root->children()[0];
 
         EXPECT_SIZE_EQ(root->scrollDelta(), IntSize());
         EXPECT_EQ(rootScrollLayer->bounds().width() * m_deviceScaleFactor, rootScrollLayer->contentBounds().width());
         EXPECT_EQ(rootScrollLayer->bounds().height() * m_deviceScaleFactor, rootScrollLayer->contentBounds().height());
 
         switch (impl->sourceFrameNumber()) {
         case 0:
             // Gesture scroll on impl thread.
-            EXPECT_EQ(impl->scrollBegin(IntPoint(5, 5), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
-            impl->scrollBy(IntPoint(), m_scrollAmount);
+            EXPECT_EQ(impl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
+            impl->scrollBy(gfx::Point(), m_scrollAmount);
             impl->scrollEnd();
 
             EXPECT_POINT_EQ(m_initialScroll, rootScrollLayer->scrollPosition());
             EXPECT_SIZE_EQ(m_scrollAmount, rootScrollLayer->scrollDelta());
             break;
         case 1:
             // Wheel scroll on impl thread.
-            EXPECT_EQ(impl->scrollBegin(IntPoint(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-            impl->scrollBy(IntPoint(), m_scrollAmount);
+            EXPECT_EQ(impl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+            impl->scrollBy(gfx::Point(), m_scrollAmount);
             impl->scrollEnd();
 
             EXPECT_POINT_EQ(m_secondScroll, rootScrollLayer->scrollPosition());
             EXPECT_SIZE_EQ(m_scrollAmount, rootScrollLayer->scrollDelta());
             break;
         case 2:
             EXPECT_POINT_EQ(m_secondScroll + m_scrollAmount, rootScrollLayer->scrollPosition());
             EXPECT_SIZE_EQ(IntSize(0, 0), rootScrollLayer->scrollDelta());
 
             endTest();
@@ skipping 64 matching lines @@
         : m_rootLayer(ContentLayerWithUpdateTracking::create(&m_mockDelegate))
         , m_surfaceLayer1(ContentLayerWithUpdateTracking::create(&m_mockDelegate))
         , m_replicaLayer1(ContentLayerWithUpdateTracking::create(&m_mockDelegate))
         , m_surfaceLayer2(ContentLayerWithUpdateTracking::create(&m_mockDelegate))
         , m_replicaLayer2(ContentLayerWithUpdateTracking::create(&m_mockDelegate))
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        m_layerTreeHost->setViewportSize(IntSize(100, 100), IntSize(100, 100));
+        m_layerTreeHost->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
 
-        m_rootLayer->setBounds(IntSize(100, 100));
-        m_surfaceLayer1->setBounds(IntSize(100, 100));
+        m_rootLayer->setBounds(gfx::Size(100, 100));
+        m_surfaceLayer1->setBounds(gfx::Size(100, 100));
         m_surfaceLayer1->setForceRenderSurface(true);
         m_surfaceLayer1->setOpacity(0.5);
-        m_surfaceLayer2->setBounds(IntSize(100, 100));
+        m_surfaceLayer2->setBounds(gfx::Size(100, 100));
         m_surfaceLayer2->setForceRenderSurface(true);
         m_surfaceLayer2->setOpacity(0.5);
 
         m_surfaceLayer1->setReplicaLayer(m_replicaLayer1.get());
         m_surfaceLayer2->setReplicaLayer(m_replicaLayer2.get());
 
         m_rootLayer->addChild(m_surfaceLayer1);
         m_surfaceLayer1->addChild(m_surfaceLayer2);
         m_layerTreeHost->setRootLayer(m_rootLayer);
 
@@ skipping 64 matching lines @@
 
 private:
     EvictionTestLayer() : Layer() { }
     virtual ~EvictionTestLayer() { }
 
     void createTextureIfNeeded()
     {
         if (m_texture.get())
             return;
         m_texture = PrioritizedTexture::create(layerTreeHost()->contentsTextureManager());
-        m_texture->setDimensions(IntSize(10, 10), GL_RGBA);
+        m_texture->setDimensions(gfx::Size(10, 10), GL_RGBA);
         m_bitmap.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
     }
 
     scoped_ptr<PrioritizedTexture> m_texture;
     SkBitmap m_bitmap;
 };
 
 class EvictionTestLayerImpl : public LayerImpl {
 public:
     static scoped_ptr<EvictionTestLayerImpl> create(int id)
@@ skipping 56 matching lines @@
     LayerTreeHostTestEvictTextures()
         : m_layer(EvictionTestLayer::create())
         , m_implForEvictTextures(0)
         , m_numCommits(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setRootLayer(m_layer);
-        m_layerTreeHost->setViewportSize(IntSize(10, 20), IntSize(10, 20));
+        m_layerTreeHost->setViewportSize(gfx::Size(10, 20), gfx::Size(10, 20));
 
         WebTransformationMatrix identityMatrix;
-        setLayerPropertiesForTesting(m_layer.get(), 0, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 20), true);
+        setLayerPropertiesForTesting(m_layer.get(), 0, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(10, 20), true);
 
         postSetNeedsCommitToMainThread();
     }
 
     void postEvictTextures()
     {
         DCHECK(implThread());
         implThread()->postTask(base::Bind(&LayerTreeHostTestEvictTextures::evictTexturesOnImplThread,
                                base::Unretained(this)));
     }
@@ skipping 109 matching lines @@
     LayerTreeHostTestLostContextAfterEvictTextures()
         : m_layer(EvictionTestLayer::create())
         , m_implForEvictTextures(0)
         , m_numCommits(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setRootLayer(m_layer);
-        m_layerTreeHost->setViewportSize(IntSize(10, 20), IntSize(10, 20));
+        m_layerTreeHost->setViewportSize(gfx::Size(10, 20), gfx::Size(10, 20));
 
         WebTransformationMatrix identityMatrix;
-        setLayerPropertiesForTesting(m_layer.get(), 0, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 20), true);
+        setLayerPropertiesForTesting(m_layer.get(), 0, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(10, 20), true);
 
         postSetNeedsCommitToMainThread();
     }
 
     void postEvictTextures()
     {
         if (implThread()) {
             implThread()->postTask(base::Bind(&LayerTreeHostTestLostContextAfterEvictTextures::evictTexturesOnImplThread,
                                               base::Unretained(this)));
         } else {
@@ skipping 101 matching lines @@
     }
 
     virtual scoped_ptr<WebKit::WebCompositorOutputSurface> createOutputSurface()
     {
         return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext::create(WebGraphicsContext3D::Attributes()).PassAs<WebKit::WebGraphicsContext3D>()).PassAs<WebKit::WebCompositorOutputSurface>();
     }
 
     virtual void beginTest()
     {
         m_layerTreeHost->setRootLayer(m_parent);
-        m_layerTreeHost->setViewportSize(IntSize(m_numChildren, 1), IntSize(m_numChildren, 1));
+        m_layerTreeHost->setViewportSize(gfx::Size(m_numChildren, 1), gfx::Size(m_numChildren, 1));
 
         WebTransformationMatrix identityMatrix;
-        setLayerPropertiesForTesting(m_parent.get(), 0, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(m_numChildren, 1), true);
+        setLayerPropertiesForTesting(m_parent.get(), 0, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(m_numChildren, 1), true);
         for (int i = 0; i < m_numChildren; i++)
-            setLayerPropertiesForTesting(m_children[i].get(), m_parent.get(), identityMatrix, FloatPoint(0, 0), FloatPoint(i, 0), IntSize(1, 1), false);
+            setLayerPropertiesForTesting(m_children[i].get(), m_parent.get(), identityMatrix, gfx::PointF(0, 0), gfx::PointF(i, 0), gfx::Size(1, 1), false);
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl)
     {
         endTest();
     }
 
     virtual void layout()
@@ skipping 22 matching lines @@
 class LayerTreeHostTestContinuousCommit : public LayerTreeHostTest {
 public:
     LayerTreeHostTestContinuousCommit()
         : m_numCommitComplete(0)
         , m_numDrawLayers(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10));
-        m_layerTreeHost->rootLayer()->setBounds(IntSize(10, 10));
+        m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+        m_layerTreeHost->rootLayer()->setBounds(gfx::Size(10, 10));
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void didCommit() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
@@ skipping 28 matching lines @@
 class LayerTreeHostTestContinuousInvalidate : public LayerTreeHostTest {
 public:
     LayerTreeHostTestContinuousInvalidate()
         : m_numCommitComplete(0)
         , m_numDrawLayers(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10));
-        m_layerTreeHost->rootLayer()->setBounds(IntSize(10, 10));
+        m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+        m_layerTreeHost->rootLayer()->setBounds(gfx::Size(10, 10));
 
         m_contentLayer = ContentLayer::create(&m_mockDelegate);
         m_contentLayer->setBounds(gfx::Size(10, 10));
         m_contentLayer->setPosition(gfx::PointF(0, 0));
         m_contentLayer->setAnchorPoint(gfx::PointF(0, 0));
         m_contentLayer->setIsDrawable(true);
         m_layerTreeHost->rootLayer()->addChild(m_contentLayer);
 
         postSetNeedsCommitToMainThread();
     }
@@ skipping 80 matching lines @@
 class LayerTreeHostTestContinuousAnimate : public LayerTreeHostTest {
 public:
     LayerTreeHostTestContinuousAnimate()
         : m_numCommitComplete(0)
         , m_numDrawLayers(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10));
-        m_layerTreeHost->rootLayer()->setBounds(IntSize(10, 10));
+        m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+        m_layerTreeHost->rootLayer()->setBounds(gfx::Size(10, 10));
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void animate(base::TimeTicks) OVERRIDE
     {
         m_layerTreeHost->setNeedsAnimate();
     }
 
     virtual void layout() OVERRIDE
@@ skipping 77 matching lines @@
     int m_numCommitsDeferred;
     int m_numCompleteCommits;
 };
 
 TEST_F(LayerTreeHostTestDeferCommits, runMultiThread)
 {
     runTest(true);
 }
 
 } // namespace