Migrate most of cc/ from WebKit::WebTransformationMatrix to gfx::Transform

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 "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"
@@ skipping 11 matching lines @@
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 #include <public/WebLayerScrollClient.h>
 #include <public/WebSize.h>
 
 using namespace WebKit;
 using namespace WebKitTests;
 
+using gfx::Transform;
+
 namespace cc {
 namespace {
 
 class LayerTreeHostTest : public ThreadedTest { };
 
 // Shortlived layerTreeHosts shouldn't die.
 class LayerTreeHostTestShortlived1 : public LayerTreeHostTest {
 public:
     LayerTreeHostTestShortlived1() { }
 
@@ skipping 1290 matching lines @@
         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(gfx::Rect(0, 0, 60, 60), root->renderSurface()->contentRect());
 
         // The content bounds of the child should be scaled.
         gfx::Size childBoundsScaled = gfx::ToCeiledSize(gfx::ScaleSize(child->bounds(), 1.5));
         EXPECT_EQ(childBoundsScaled, child->contentBounds());
 
-        WebTransformationMatrix scaleTransform;
-        scaleTransform.scale(impl->deviceScaleFactor());
+        Transform scaleTransform;
+        scaleTransform.PreconcatScale(impl->deviceScaleFactor(), impl->deviceScaleFactor());
 
         // The root layer is scaled by 2x.
-        WebTransformationMatrix rootScreenSpaceTransform = scaleTransform;
-        WebTransformationMatrix rootDrawTransform = scaleTransform;
+        Transform rootScreenSpaceTransform = scaleTransform;
+        Transform rootDrawTransform = scaleTransform;
 
         EXPECT_EQ(rootDrawTransform, root->drawTransform());
         EXPECT_EQ(rootScreenSpaceTransform, root->screenSpaceTransform());
 
         // The child is at position 2,2, which is transformed to 3,3 after the scale
-        WebTransformationMatrix childScreenSpaceTransform;
-        childScreenSpaceTransform.translate(3, 3);
-        WebTransformationMatrix childDrawTransform = childScreenSpaceTransform;
+        Transform childScreenSpaceTransform;
+        childScreenSpaceTransform.PreconcatTranslate(3, 3);
+        Transform childDrawTransform = childScreenSpaceTransform;
 
         EXPECT_EQ(childDrawTransform, child->drawTransform());
         EXPECT_EQ(childScreenSpaceTransform, child->screenSpaceTransform());
 
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
         m_rootLayer = NULL;
@@ skipping 92 matching lines @@
 private:
     FakeContentLayerClient m_client;
     scoped_refptr<ContentLayerWithUpdateTracking> m_layer;
 };
 
 TEST_F(LayerTreeHostTestAtomicCommit, runMultiThread)
 {
     runTest(true);
 }
 
-static void setLayerPropertiesForTesting(Layer* layer, Layer* parent, const WebTransformationMatrix& transform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
+static void setLayerPropertiesForTesting(Layer* layer, Layer* parent, const Transform& transform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
 {
     layer->removeAllChildren();
     if (parent)
         parent->addChild(layer);
     layer->setTransform(transform);
     layer->setAnchorPoint(anchor);
     layer->setPosition(position);
     layer->setBounds(bounds);
     layer->setContentsOpaque(opaque);
 }
 
 class LayerTreeHostTestAtomicCommitWithPartialUpdate : public LayerTreeHostTest {
 public:
     LayerTreeHostTestAtomicCommitWithPartialUpdate()
         : m_parent(ContentLayerWithUpdateTracking::create(&m_client))
         , m_child(ContentLayerWithUpdateTracking::create(&m_client))
         , m_numCommits(0)
     {
         // Allow one partial texture update.
         m_settings.maxPartialTextureUpdates = 1;
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setRootLayer(m_parent);
         m_layerTreeHost->setViewportSize(gfx::Size(10, 20), gfx::Size(10, 20));
 
-        WebTransformationMatrix identityMatrix;
+        Transform identityMatrix;
         setLayerPropertiesForTesting(m_parent.get(), 0, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(10, 20), true);
         setLayerPropertiesForTesting(m_child.get(), m_parent.get(), identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 10), gfx::Size(10, 10), false);
 
         postSetNeedsCommitToMainThread();
         postSetNeedsRedrawToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         CompositorFakeWebGraphicsContext3DWithTextureTracking* context = static_cast<CompositorFakeWebGraphicsContext3DWithTextureTracking*>(impl->context()->context3D());
@@ skipping 123 matching lines @@
     const Region& occludedScreenSpace() const { return m_occludedScreenSpace; }
     void clearOccludedScreenSpace() { m_occludedScreenSpace.Clear(); }
 
 private:
     TestLayer() : Layer() { }
     virtual ~TestLayer() { }
 
     Region m_occludedScreenSpace;
 };
 
-static void setTestLayerPropertiesForTesting(TestLayer* layer, Layer* parent, const WebTransformationMatrix& transform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
+static void setTestLayerPropertiesForTesting(TestLayer* layer, Layer* parent, const Transform& transform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
 {
     setLayerPropertiesForTesting(layer, parent, transform, anchor, position, bounds, opaque);
     layer->clearOccludedScreenSpace();
 }
 
 class LayerTreeHostTestLayerOcclusion : public LayerTreeHostTest {
 public:
     LayerTreeHostTestLayerOcclusion() { }
 
     virtual void beginTest() OVERRIDE
     {
         scoped_refptr<TestLayer> rootLayer = TestLayer::create();
         scoped_refptr<TestLayer> child = TestLayer::create();
         scoped_refptr<TestLayer> child2 = TestLayer::create();
         scoped_refptr<TestLayer> grandChild = TestLayer::create();
         scoped_refptr<TestLayer> mask = TestLayer::create();
 
-        WebTransformationMatrix identityMatrix;
-        WebTransformationMatrix childTransform;
-        childTransform.translate(250, 250);
-        childTransform.rotate(90);
-        childTransform.translate(-250, -250);
+        Transform identityMatrix;
+        Transform childTransform;
+        childTransform.PreconcatTranslate(250, 250);
+        childTransform.PreconcatRotate(90);
+        childTransform.PreconcatTranslate(-250, -250);
 
         child->setMasksToBounds(true);
 
         // See LayerTreeHostCommonTest.layerAddsSelfToOccludedRegionWithRotatedSurface for a nice visual of these layers and how they end up
         // positioned on the screen.
 
         // The child layer is rotated and the grandChild is opaque, but clipped to the child and rootLayer
         setTestLayerPropertiesForTesting(rootLayer.get(), 0, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(200, 200), true);
         setTestLayerPropertiesForTesting(child.get(), rootLayer.get(), childTransform, gfx::PointF(0, 0), gfx::PointF(30, 30), gfx::Size(500, 500), false);
         setTestLayerPropertiesForTesting(grandChild.get(), child.get(), identityMatrix, gfx::PointF(0, 0), gfx::PointF(10, 10), gfx::Size(500, 500), true);
@@ skipping 148 matching lines @@
     LayerTreeHostTestLayerOcclusionWithFilters() { }
 
     virtual void beginTest() OVERRIDE
     {
         scoped_refptr<TestLayer> rootLayer = TestLayer::create();
         scoped_refptr<TestLayer> child = TestLayer::create();
         scoped_refptr<TestLayer> child2 = TestLayer::create();
         scoped_refptr<TestLayer> grandChild = TestLayer::create();
         scoped_refptr<TestLayer> mask = TestLayer::create();
 
-        WebTransformationMatrix identityMatrix;
-        WebTransformationMatrix childTransform;
-        childTransform.translate(250, 250);
-        childTransform.rotate(90);
-        childTransform.translate(-250, -250);
+        Transform identityMatrix;
+        Transform childTransform;
+        childTransform.PreconcatTranslate(250, 250);
+        childTransform.PreconcatRotate(90);
+        childTransform.PreconcatTranslate(-250, -250);
 
         child->setMasksToBounds(true);
 
         // If the child layer has a filter that changes alpha values, and is below child2, then child2 should contribute to occlusion on everything,
         // and child shouldn't contribute to the rootLayer
         setTestLayerPropertiesForTesting(rootLayer.get(), 0, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(200, 200), true);
         setTestLayerPropertiesForTesting(child.get(), rootLayer.get(), childTransform, gfx::PointF(0, 0), gfx::PointF(30, 30), gfx::Size(500, 500), true);
         setTestLayerPropertiesForTesting(grandChild.get(), child.get(), identityMatrix, gfx::PointF(0, 0), gfx::PointF(10, 10), gfx::Size(500, 500), true);
         setTestLayerPropertiesForTesting(child2.get(), rootLayer.get(), identityMatrix, gfx::PointF(0, 0), gfx::PointF(10, 70), gfx::Size(500, 500), true);
 
@@ skipping 54 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestLayerOcclusionWithFilters)
 
 class LayerTreeHostTestManySurfaces : public LayerTreeHostTest {
 public:
     LayerTreeHostTestManySurfaces() { }
 
     virtual void beginTest() OVERRIDE
     {
         // We create enough RenderSurfaces that it will trigger Vector reallocation while computing occlusion.
         Region occluded;
-        const WebTransformationMatrix identityMatrix;
+        const Transform identityMatrix;
         std::vector<scoped_refptr<TestLayer> > layers;
         std::vector<scoped_refptr<TestLayer> > children;
         int numSurfaces = 20;
         scoped_refptr<TestLayer> replica = TestLayer::create();
 
         for (int i = 0; i < numSurfaces; ++i) {
             layers.push_back(TestLayer::create());
             if (!i) {
                 setTestLayerPropertiesForTesting(layers.back().get(), 0, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(200, 200), true);
                 layers.back()->createRenderSurface();
@@ skipping 780 matching lines @@
         , m_implForEvictTextures(0)
         , m_numCommits(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setRootLayer(m_layer);
         m_layerTreeHost->setViewportSize(gfx::Size(10, 20), gfx::Size(10, 20));
 
-        WebTransformationMatrix identityMatrix;
+        Transform identityMatrix;
         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 112 matching lines @@
         , m_implForEvictTextures(0)
         , m_numCommits(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setRootLayer(m_layer);
         m_layerTreeHost->setViewportSize(gfx::Size(10, 20), gfx::Size(10, 20));
 
-        WebTransformationMatrix identityMatrix;
+        Transform identityMatrix;
         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)));
@@ skipping 104 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(gfx::Size(m_numChildren, 1), gfx::Size(m_numChildren, 1));
 
-        WebTransformationMatrix identityMatrix;
+        Transform identityMatrix;
         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, gfx::PointF(0, 0), gfx::PointF(i, 0), gfx::Size(1, 1), false);
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl)
     {
         endTest();
@@ skipping 135 matching lines @@
 }
 
 class LayerTreeHostTestAdjustPointForZoom : public LayerTreeHostTest {
 public:
     LayerTreeHostTestAdjustPointForZoom()
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        WebTransformationMatrix m;
-        m.translate(250, 360);
-        m.scale(2);
+        Transform m;
+        m.PreconcatTranslate(250, 360);
+        m.PreconcatScale(2, 2);
 
         gfx::Point point(400, 550);
         gfx::Point transformedPoint;
 
         // Unit transform, no change expected.
-        m_layerTreeHost->setImplTransform(WebTransformationMatrix());
+        m_layerTreeHost->setImplTransform(Transform());
         transformedPoint = gfx::ToRoundedPoint(m_layerTreeHost->adjustEventPointForPinchZoom(point));
         EXPECT_EQ(point.x(), transformedPoint.x());
         EXPECT_EQ(point.y(), transformedPoint.y());
 
         m_layerTreeHost->setImplTransform(m);
 
         // Apply m^(-1): 75 = (400 - 250) / 2; 95 = (550 - 360) / 2.
         transformedPoint = gfx::ToRoundedPoint(m_layerTreeHost->adjustEventPointForPinchZoom(point));
         EXPECT_EQ(75, transformedPoint.x());
         EXPECT_EQ(95, transformedPoint.y());
@@ skipping 113 matching lines @@
     int m_numCompleteCommits;
 };
 
 TEST_F(LayerTreeHostTestDeferCommits, runMultiThread)
 {
     runTest(true);
 }
 
 }  // namespace
 }  // namespace cc