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

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"
 #include "cc/content_layer_client.h"
 #include "cc/graphics_context.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/settings.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_test_common.h"
 #include "cc/test/occlusion_tracker_test_common.h"
 #include "cc/texture_update_queue.h"
 #include "cc/timing_function.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
+#include "ui/gfx/size_conversions.h"
 #include <public/Platform.h>
 #include <public/WebLayerScrollClient.h>
 #include <public/WebSize.h>
 
 using namespace cc;
 using namespace WebKit;
 using namespace WebKitTests;
 
 namespace {
 
@@ skipping 268 matching lines @@
             // After the first commit, we should not be able to draw.
             EXPECT_FALSE(impl->canDraw());
         }
     }
 
     virtual void didCommit() OVERRIDE
     {
         m_numCommits++;
         if (m_numCommits == 1) {
             // Make the viewport empty so the host says it can't draw.
-            m_layerTreeHost->setViewportSize(IntSize(0, 0), IntSize(0, 0));
+            m_layerTreeHost->setViewportSize(gfx::Size(0, 0), gfx::Size(0, 0));
 
             scoped_array<char> pixels(new char[4]);
             m_layerTreeHost->compositeAndReadback(static_cast<void*>(pixels.get()), IntRect(0, 0, 1, 1));
         } else if (m_numCommits == 2) {
             m_layerTreeHost->setNeedsRedraw();
             m_layerTreeHost->setNeedsCommit();
         } else
             endTest();
     }
 
@@ skipping 443 matching lines @@
 // Ensures that when opacity is being animated, this value does not cause the subtree to be skipped.
 class LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity : public LayerTreeHostTest {
 public:
     LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity()
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->rootLayer()->setDrawOpacity(1);
-        m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10));
+        m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
         m_layerTreeHost->rootLayer()->setOpacity(0);
         postAddAnimationToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         // If the subtree was skipped when preparing to draw, the layer's draw opacity
         // will not have been updated. It should be set to 0 due to the animation.
         // Without the animation, the layer will be skipped since it has zero opacity.
         EXPECT_EQ(0, m_layerTreeHost->rootLayer()->drawOpacity());
@@ skipping 233 matching lines @@
 }
 
 // This test verifies that properties on the layer tree host are commited to the impl side.
 class LayerTreeHostTestCommit : public LayerTreeHostTest {
 public:
 
     LayerTreeHostTestCommit() { }
 
     virtual void beginTest() OVERRIDE
     {
-        m_layerTreeHost->setViewportSize(IntSize(20, 20), IntSize(20, 20));
+        m_layerTreeHost->setViewportSize(gfx::Size(20, 20), gfx::Size(20, 20));
         m_layerTreeHost->setBackgroundColor(SK_ColorGRAY);
         m_layerTreeHost->setPageScaleFactorAndLimits(5, 5, 5);
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
-        EXPECT_EQ(IntSize(20, 20), impl->layoutViewportSize());
+        EXPECT_EQ(gfx::Size(20, 20), impl->layoutViewportSize());
         EXPECT_EQ(SK_ColorGRAY, impl->backgroundColor());
         EXPECT_EQ(5, impl->pageScaleFactor());
 
         endTest();
     }
 
     virtual void afterTest() OVERRIDE { }
 };
 
 TEST_F(LayerTreeHostTestCommit, runTest)
@@ skipping 133 matching lines @@
     {
         ContentLayer::update(queue, occlusion, stats);
         m_paintContentsCount++;
     }
 
 private:
     explicit ContentLayerWithUpdateTracking(ContentLayerClient* client)
         : ContentLayer(client)
         , m_paintContentsCount(0)
     {
-        setAnchorPoint(FloatPoint(0, 0));
-        setBounds(IntSize(10, 10));
+        setAnchorPoint(gfx::PointF(0, 0));
+        setBounds(gfx::Size(10, 10));
         setIsDrawable(true);
     }
     virtual ~ContentLayerWithUpdateTracking()
     {
     }
 
     int m_paintContentsCount;
 };
 
 // Layer opacity change during paint should not prevent compositor resources from being updated during commit.
@@ skipping 69 matching lines @@
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(IntSize(40, 40), IntSize(60, 60));
         m_layerTreeHost->setDeviceScaleFactor(1.5);
         EXPECT_EQ(IntSize(40, 40), m_layerTreeHost->layoutViewportSize());
         EXPECT_EQ(IntSize(60, 60), m_layerTreeHost->deviceViewportSize());
 
         m_rootLayer->addChild(m_childLayer);
 
         m_rootLayer->setIsDrawable(true);
-        m_rootLayer->setBounds(IntSize(30, 30));
+        m_rootLayer->setBounds(gfx::Size(30, 30));
         m_rootLayer->setAnchorPoint(FloatPoint(0, 0));
 
         m_childLayer->setIsDrawable(true);
-        m_childLayer->setPosition(IntPoint(2, 2));
-        m_childLayer->setBounds(IntSize(10, 10));
+        m_childLayer->setPosition(gfx::Point(2, 2));
+        m_childLayer->setBounds(gfx::Size(10, 10));
         m_childLayer->setAnchorPoint(FloatPoint(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.
         EXPECT_EQ(0, impl->sourceFrameNumber());
         // Device scale factor should come over to impl.
         EXPECT_NEAR(impl->deviceScaleFactor(), 1.5, 0.00001);
 
         // Both layers are on impl.
         ASSERT_EQ(1u, impl->rootLayer()->children().size());
 
         // Device viewport is scaled.
         EXPECT_EQ(IntSize(40, 40), impl->layoutViewportSize());
         EXPECT_EQ(IntSize(60, 60), impl->deviceViewportSize());
 
         LayerImpl* root = impl->rootLayer();
         LayerImpl* child = impl->rootLayer()->children()[0];
 
         // Positions remain in layout pixels.
-        EXPECT_EQ(IntPoint(0, 0), root->position());
-        EXPECT_EQ(IntPoint(2, 2), child->position());
+        EXPECT_EQ(gfx::Point(0, 0), root->position());
+        EXPECT_EQ(gfx::Point(2, 2), child->position());
 
         // Compute all the layer transforms for the frame.
         MockLayerTreeHostImpl::LayerList renderSurfaceLayerList;
         mockImpl->calculateRenderSurfaceLayerList(renderSurfaceLayerList);
 
         // Both layers should be drawing into the root render surface.
         ASSERT_EQ(1u, renderSurfaceLayerList.size());
         ASSERT_EQ(root->renderSurface(), renderSurfaceLayerList[0]->renderSurface());
         ASSERT_EQ(2u, root->renderSurface()->layerList().size());
 
         // The root render surface is the size of the viewport.
         EXPECT_RECT_EQ(IntRect(0, 0, 60, 60), root->renderSurface()->contentRect());
 
         // The content bounds of the child should be scaled.
-        IntSize childBoundsScaled = child->bounds();
-        childBoundsScaled.scale(1.5);
+        gfx::Size childBoundsScaled = child->bounds();
+        childBoundsScaled = gfx::ToRoundedSize(childBoundsScaled.Scale(1.5));
         EXPECT_EQ(childBoundsScaled, child->contentBounds());
 
         WebTransformationMatrix scaleTransform;
         scaleTransform.scale(impl->deviceScaleFactor());
 
         // The root layer is scaled by 2x.
         WebTransformationMatrix rootScreenSpaceTransform = scaleTransform;
         WebTransformationMatrix rootDrawTransform = scaleTransform;
 
         EXPECT_EQ(rootDrawTransform, root->drawTransform());
@@ skipping 1728 matching lines @@
         , m_numDrawLayers(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10));
         m_layerTreeHost->rootLayer()->setBounds(IntSize(10, 10));
 
         m_contentLayer = ContentLayer::create(&m_mockDelegate);
-        m_contentLayer->setBounds(IntSize(10, 10));
-        m_contentLayer->setPosition(FloatPoint(0, 0));
-        m_contentLayer->setAnchorPoint(FloatPoint(0, 0));
+        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();
     }
 
     virtual void didCommit() OVERRIDE
     {
         m_contentLayer->setNeedsDisplay();
     }
@@ skipping 81 matching lines @@
     int m_numCommitComplete;
     int m_numDrawLayers;
 };
 
 TEST_F(LayerTreeHostTestContinuousAnimate, runMultiThread)
 {
     runTest(true);
 }
 
 } // namespace