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

cc/occlusion_tracker_unittest.cc

 // Copyright 2012 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/occlusion_tracker.h"
 
+#include <public/WebFilterOperation.h>
+#include <public/WebFilterOperations.h>
+
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/math_util.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/occlusion_tracker_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include <public/WebFilterOperation.h>
-#include <public/WebFilterOperations.h>
-#include <public/WebTransformationMatrix.h>
+#include "ui/gfx/transform.h"
 
 using namespace WebKit;
 using namespace WebKitTests;
 
+using gfx::Transform;
+
 namespace cc {
 namespace {
 
 class TestContentLayer : public Layer {
 public:
     TestContentLayer()
         : Layer()
         , m_overrideOpaqueContentsRect(false)
     {
     }
@@ skipping 154 matching lines @@
     virtual void TearDown()
     {
         Types::destroyLayer(m_root);
         m_renderSurfaceLayerList.clear();
         m_renderSurfaceLayerListImpl.clear();
         m_replicaLayers.clear();
         m_maskLayers.clear();
         LayerTreeHost::setNeedsFilterContext(false);
     }
 
-    typename Types::ContentLayerType* createRoot(const WebTransformationMatrix& transform, const gfx::PointF& position, const gfx::Size& bounds)
+    typename Types::ContentLayerType* createRoot(const Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         typename Types::ContentLayerPtrType layer(Types::createContentLayer());
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
 
         DCHECK(!m_root);
         m_root = Types::passLayerPtr(layer);
         return layerPtr;
     }
 
-    typename Types::LayerType* createLayer(typename Types::LayerType* parent, const WebTransformationMatrix& transform, const gfx::PointF& position, const gfx::Size& bounds)
+    typename Types::LayerType* createLayer(typename Types::LayerType* parent, const Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         typename Types::LayerPtrType layer(Types::createLayer());
         typename Types::LayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
         parent->addChild(Types::passLayerPtr(layer));
         return layerPtr;
     }
 
-    typename Types::LayerType* createSurface(typename Types::LayerType* parent, const WebTransformationMatrix& transform, const gfx::PointF& position, const gfx::Size& bounds)
+    typename Types::LayerType* createSurface(typename Types::LayerType* parent, const Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         typename Types::LayerType* layer = createLayer(parent, transform, position, bounds);
         WebFilterOperations filters;
         filters.append(WebFilterOperation::createGrayscaleFilter(0.5));
         layer->setFilters(filters);
         return layer;
     }
 
-    typename Types::ContentLayerType* createDrawingLayer(typename Types::LayerType* parent, const WebTransformationMatrix& transform, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
+    typename Types::ContentLayerType* createDrawingLayer(typename Types::LayerType* parent, const Transform& transform, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
     {
         typename Types::ContentLayerPtrType layer(Types::createContentLayer());
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
 
         if (m_opaqueLayers)
             layerPtr->setContentsOpaque(opaque);
         else {
             layerPtr->setContentsOpaque(false);
             if (opaque)
                 layerPtr->setOpaqueContentsRect(gfx::Rect(gfx::Point(), bounds));
             else
                 layerPtr->setOpaqueContentsRect(gfx::Rect());
         }
 
         parent->addChild(Types::passLayerPtr(layer));
         return layerPtr;
     }
 
-    typename Types::LayerType* createReplicaLayer(typename Types::LayerType* owningLayer, const WebTransformationMatrix& transform, const gfx::PointF& position, const gfx::Size& bounds)
+    typename Types::LayerType* createReplicaLayer(typename Types::LayerType* owningLayer, const Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         typename Types::ContentLayerPtrType layer(Types::createContentLayer());
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
         setReplica(owningLayer, Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::LayerType* createMaskLayer(typename Types::LayerType* owningLayer, const gfx::Size& bounds)
     {
         typename Types::ContentLayerPtrType layer(Types::createContentLayer());
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, identityMatrix, gfx::PointF(), bounds);
         setMask(owningLayer, Types::passLayerPtr(layer));
         return layerPtr;
     }
 
-    typename Types::ContentLayerType* createDrawingSurface(typename Types::LayerType* parent, const WebTransformationMatrix& transform, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
+    typename Types::ContentLayerType* createDrawingSurface(typename Types::LayerType* parent, const Transform& transform, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
     {
         typename Types::ContentLayerType* layer = createDrawingLayer(parent, transform, position, bounds, opaque);
         WebFilterOperations filters;
         filters.append(WebFilterOperation::createGrayscaleFilter(0.5));
         layer->setFilters(filters);
         return layer;
     }
 
     void calcDrawEtc(TestContentLayerImpl* root)
     {
@@ skipping 64 matching lines @@
     {
         enterContributingSurface(layer, occlusion);
         leaveContributingSurface(layer, occlusion);
     }
 
     void resetLayerIterator()
     {
         m_layerIterator = m_layerIteratorBegin;
     }
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
 
 private:
-    void setBaseProperties(typename Types::LayerType* layer, const WebTransformationMatrix& transform, const gfx::PointF& position, const gfx::Size& bounds)
+    void setBaseProperties(typename Types::LayerType* layer, const Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         layer->setTransform(transform);
-        layer->setSublayerTransform(WebTransformationMatrix());
+        layer->setSublayerTransform(Transform());
         layer->setAnchorPoint(gfx::PointF(0, 0));
         layer->setPosition(position);
         layer->setBounds(bounds);
     }
 
-    void setProperties(Layer* layer, const WebTransformationMatrix& transform, const gfx::PointF& position, const gfx::Size& bounds)
+    void setProperties(Layer* layer, const Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         setBaseProperties(layer, transform, position, bounds);
     }
 
-    void setProperties(LayerImpl* layer, const WebTransformationMatrix& transform, const gfx::PointF& position, const gfx::Size& bounds)
+    void setProperties(LayerImpl* layer, const Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         setBaseProperties(layer, transform, position, bounds);
 
         layer->setContentBounds(layer->bounds());
     }
 
     void setReplica(Layer* owningLayer, scoped_refptr<Layer> layer)
     {
         owningLayer->setReplicaLayer(layer.get());
         m_replicaLayers.push_back(layer);
@@ skipping 116 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestIdentityTransforms);
 
 template<class Types>
 class OcclusionTrackerTestQuadsMismatchLayer : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestQuadsMismatchLayer(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix layerTransform;
-        layerTransform.translate(10, 10);
+        Transform layerTransform;
+        layerTransform.PreconcatTranslate(10, 10);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::Point(0, 0), gfx::Size(100, 100));
         typename Types::ContentLayerType* layer1 = this->createDrawingLayer(parent, layerTransform, gfx::PointF(0, 0), gfx::Size(90, 90), true);
         typename Types::ContentLayerType* layer2 = this->createDrawingLayer(layer1, layerTransform, gfx::PointF(0, 0), gfx::Size(50, 50), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(layer2, occlusion);
         this->enterLayer(layer1, occlusion);
 
         EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(), occlusion.occlusionInScreenSpace().ToString());
         EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(), occlusion.occlusionInTargetSurface().ToString());
 
         // This checks cases where the quads don't match their "containing"
         // layers, e.g. in terms of transforms or clip rect. This is typical for
         // DelegatedRendererLayer.
 
-        WebTransformationMatrix quadTransform;
-        quadTransform.translate(30, 30);
+        Transform quadTransform;
+        quadTransform.PreconcatTranslate(30, 30);
         gfx::Rect clipRectInTarget(0, 0, 100, 100);
 
         EXPECT_TRUE(occlusion.unoccludedContentRect(parent, gfx::Rect(0, 0, 10, 10), quadTransform, false, clipRectInTarget).IsEmpty());
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 10, 10), occlusion.unoccludedContentRect(parent, gfx::Rect(0, 0, 10, 10), quadTransform, true, clipRectInTarget));
         EXPECT_RECT_EQ(gfx::Rect(40, 40, 10, 10), occlusion.unoccludedContentRect(parent, gfx::Rect(40, 40, 10, 10), quadTransform, false, clipRectInTarget));
         EXPECT_RECT_EQ(gfx::Rect(40, 30, 5, 10), occlusion.unoccludedContentRect(parent, gfx::Rect(35, 30, 10, 10), quadTransform, false, clipRectInTarget));
         EXPECT_RECT_EQ(gfx::Rect(40, 40, 5, 5), occlusion.unoccludedContentRect(parent, gfx::Rect(40, 40, 10, 10), quadTransform, false, gfx::Rect(0, 0, 75, 75)));
     }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestQuadsMismatchLayer);
 
 template<class Types>
 class OcclusionTrackerTestRotatedChild : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestRotatedChild(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix layerTransform;
-        layerTransform.translate(250, 250);
-        layerTransform.rotate(90);
-        layerTransform.translate(-250, -250);
+        Transform layerTransform;
+        layerTransform.PreconcatTranslate(250, 250);
+        layerTransform.PreconcatRotate(90);
+        layerTransform.PreconcatTranslate(-250, -250);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, layerTransform, gfx::PointF(30, 30), gfx::Size(500, 500), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
         occlusion.setLayerClipRect(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(layer, occlusion);
         this->enterLayer(parent, occlusion);
@@ skipping 28 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestRotatedChild);
 
 template<class Types>
 class OcclusionTrackerTestTranslatedChild : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestTranslatedChild(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix layerTransform;
-        layerTransform.translate(20, 20);
+        Transform layerTransform;
+        layerTransform.PreconcatTranslate(20, 20);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, layerTransform, gfx::PointF(30, 30), gfx::Size(500, 500), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
         occlusion.setLayerClipRect(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(layer, occlusion);
         this->enterLayer(parent, occlusion);
@@ skipping 40 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestTranslatedChild);
 
 template<class Types>
 class OcclusionTrackerTestChildInRotatedChild : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestChildInRotatedChild(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix childTransform;
-        childTransform.translate(250, 250);
-        childTransform.rotate(90);
-        childTransform.translate(-250, -250);
+        Transform childTransform;
+        childTransform.PreconcatTranslate(250, 250);
+        childTransform.PreconcatRotate(90);
+        childTransform.PreconcatTranslate(-250, -250);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         parent->setMasksToBounds(true);
         typename Types::LayerType* child = this->createLayer(parent, childTransform, gfx::PointF(30, 30), gfx::Size(500, 500));
         child->setMasksToBounds(true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(child, this->identityMatrix, gfx::PointF(10, 10), gfx::Size(500, 500), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
         occlusion.setLayerClipRect(gfx::Rect(0, 0, 1000, 1000));
@@ skipping 56 matching lines @@
 
 template<class Types>
 class OcclusionTrackerTestScaledRenderSurface : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestScaledRenderSurface(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
 
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(200, 200));
 
-        WebTransformationMatrix layer1Matrix;
-        layer1Matrix.scale(2);
+        Transform layer1Matrix;
+        layer1Matrix.PreconcatScale(2, 2);
         typename Types::ContentLayerType* layer1 = this->createDrawingLayer(parent, layer1Matrix, gfx::PointF(0, 0), gfx::Size(100, 100), true);
         layer1->setForceRenderSurface(true);
 
-        WebTransformationMatrix layer2Matrix;
-        layer2Matrix.translate(25, 25);
+        Transform layer2Matrix;
+        layer2Matrix.PreconcatTranslate(25, 25);
         typename Types::ContentLayerType* layer2 = this->createDrawingLayer(layer1, layer2Matrix, gfx::PointF(0, 0), gfx::Size(50, 50), true);
         typename Types::ContentLayerType* occluder = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(100, 100), gfx::Size(500, 500), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(occluder, occlusion);
         this->enterLayer(layer2, occlusion);
 
         EXPECT_EQ(gfx::Rect(100, 100, 100, 100).ToString(), occlusion.occlusionInScreenSpace().ToString());
         EXPECT_EQ(gfx::Rect().ToString(), occlusion.occlusionInTargetSurface().ToString());
 
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 25, 25), occlusion.unoccludedLayerContentRect(layer2, gfx::Rect(0, 0, 25, 25)));
         EXPECT_RECT_EQ(gfx::Rect(10, 25, 15, 25), occlusion.unoccludedLayerContentRect(layer2, gfx::Rect(10, 25, 25, 25)));
         EXPECT_RECT_EQ(gfx::Rect(25, 10, 25, 15), occlusion.unoccludedLayerContentRect(layer2, gfx::Rect(25, 10, 25, 25)));
         EXPECT_TRUE(occlusion.unoccludedLayerContentRect(layer2, gfx::Rect(25, 25, 25, 25)).IsEmpty());
     }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestScaledRenderSurface);
 
 template<class Types>
 class OcclusionTrackerTestVisitTargetTwoTimes : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestVisitTargetTwoTimes(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix childTransform;
-        childTransform.translate(250, 250);
-        childTransform.rotate(90);
-        childTransform.translate(-250, -250);
+        Transform childTransform;
+        childTransform.PreconcatTranslate(250, 250);
+        childTransform.PreconcatRotate(90);
+        childTransform.PreconcatTranslate(-250, -250);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         parent->setMasksToBounds(true);
         typename Types::LayerType* child = this->createLayer(parent, childTransform, gfx::PointF(30, 30), gfx::Size(500, 500));
         child->setMasksToBounds(true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(child, this->identityMatrix, gfx::PointF(10, 10), gfx::Size(500, 500), true);
         // |child2| makes |parent|'s surface get considered by OcclusionTracker first, instead of |child|'s. This exercises different code in
         // leaveToTargetRenderSurface, as the target surface has already been seen.
         typename Types::ContentLayerType* child2 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(30, 30), gfx::Size(60, 20), true);
         this->calcDrawEtc(parent);
@@ skipping 81 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestVisitTargetTwoTimes);
 
 template<class Types>
 class OcclusionTrackerTestSurfaceRotatedOffAxis : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestSurfaceRotatedOffAxis(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix childTransform;
-        childTransform.translate(250, 250);
-        childTransform.rotate(95);
-        childTransform.translate(-250, -250);
+        Transform childTransform;
+        childTransform.PreconcatTranslate(250, 250);
+        childTransform.PreconcatRotate(95);
+        childTransform.PreconcatTranslate(-250, -250);
 
-        WebTransformationMatrix layerTransform;
-        layerTransform.translate(10, 10);
+        Transform layerTransform;
+        layerTransform.PreconcatTranslate(10, 10);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         typename Types::LayerType* child = this->createLayer(parent, childTransform, gfx::PointF(30, 30), gfx::Size(500, 500));
         child->setMasksToBounds(true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(child, layerTransform, gfx::PointF(0, 0), gfx::Size(500, 500), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
         occlusion.setLayerClipRect(gfx::Rect(0, 0, 1000, 1000));
 
@@ skipping 36 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceRotatedOffAxis);
 
 template<class Types>
 class OcclusionTrackerTestSurfaceWithTwoOpaqueChildren : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestSurfaceWithTwoOpaqueChildren(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix childTransform;
-        childTransform.translate(250, 250);
-        childTransform.rotate(90);
-        childTransform.translate(-250, -250);
+        Transform childTransform;
+        childTransform.PreconcatTranslate(250, 250);
+        childTransform.PreconcatRotate(90);
+        childTransform.PreconcatTranslate(-250, -250);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         parent->setMasksToBounds(true);
         typename Types::LayerType* child = this->createLayer(parent, childTransform, gfx::PointF(30, 30), gfx::Size(500, 500));
         child->setMasksToBounds(true);
         typename Types::ContentLayerType* layer1 = this->createDrawingLayer(child, this->identityMatrix, gfx::PointF(10, 10), gfx::Size(500, 500), true);
         typename Types::ContentLayerType* layer2 = this->createDrawingLayer(child, this->identityMatrix, gfx::PointF(10, 450), gfx::Size(500, 60), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
@@ skipping 62 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceWithTwoOpaqueChildren);
 
 template<class Types>
 class OcclusionTrackerTestOverlappingSurfaceSiblings : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestOverlappingSurfaceSiblings(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix childTransform;
-        childTransform.translate(250, 250);
-        childTransform.rotate(90);
-        childTransform.translate(-250, -250);
+        Transform childTransform;
+        childTransform.PreconcatTranslate(250, 250);
+        childTransform.PreconcatRotate(90);
+        childTransform.PreconcatTranslate(-250, -250);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         parent->setMasksToBounds(true);
         typename Types::LayerType* child1 = this->createSurface(parent, childTransform, gfx::PointF(30, 30), gfx::Size(10, 10));
         typename Types::LayerType* child2 = this->createSurface(parent, childTransform, gfx::PointF(20, 40), gfx::Size(10, 10));
         typename Types::ContentLayerType* layer1 = this->createDrawingLayer(child1, this->identityMatrix, gfx::PointF(-10, -10), gfx::Size(510, 510), true);
         typename Types::ContentLayerType* layer2 = this->createDrawingLayer(child2, this->identityMatrix, gfx::PointF(-10, -10), gfx::Size(510, 510), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
@@ skipping 81 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestOverlappingSurfaceSiblings);
 
 template<class Types>
 class OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix child1Transform;
-        child1Transform.translate(250, 250);
-        child1Transform.rotate(-90);
-        child1Transform.translate(-250, -250);
+        Transform child1Transform;
+        child1Transform.PreconcatTranslate(250, 250);
+        child1Transform.PreconcatRotate(-90);
+        child1Transform.PreconcatTranslate(-250, -250);
 
-        WebTransformationMatrix child2Transform;
-        child2Transform.translate(250, 250);
-        child2Transform.rotate(90);
-        child2Transform.translate(-250, -250);
+        Transform child2Transform;
+        child2Transform.PreconcatTranslate(250, 250);
+        child2Transform.PreconcatRotate(90);
+        child2Transform.PreconcatTranslate(-250, -250);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         parent->setMasksToBounds(true);
         typename Types::LayerType* child1 = this->createSurface(parent, child1Transform, gfx::PointF(30, 20), gfx::Size(10, 10));
         typename Types::LayerType* child2 = this->createDrawingSurface(parent, child2Transform, gfx::PointF(20, 40), gfx::Size(10, 10), false);
         typename Types::ContentLayerType* layer1 = this->createDrawingLayer(child1, this->identityMatrix, gfx::PointF(-10, -20), gfx::Size(510, 510), true);
         typename Types::ContentLayerType* layer2 = this->createDrawingLayer(child2, this->identityMatrix, gfx::PointF(-10, -10), gfx::Size(510, 510), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
@@ skipping 74 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms);
 
 template<class Types>
 class OcclusionTrackerTestFilters : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestFilters(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix layerTransform;
-        layerTransform.translate(250, 250);
-        layerTransform.rotate(90);
-        layerTransform.translate(-250, -250);
+        Transform layerTransform;
+        layerTransform.PreconcatTranslate(250, 250);
+        layerTransform.PreconcatRotate(90);
+        layerTransform.PreconcatTranslate(-250, -250);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         parent->setMasksToBounds(true);
         typename Types::ContentLayerType* blurLayer = this->createDrawingLayer(parent, layerTransform, gfx::PointF(30, 30), gfx::Size(500, 500), true);
         typename Types::ContentLayerType* opaqueLayer = this->createDrawingLayer(parent, layerTransform, gfx::PointF(30, 30), gfx::Size(500, 500), true);
         typename Types::ContentLayerType* opacityLayer = this->createDrawingLayer(parent, layerTransform, gfx::PointF(30, 30), gfx::Size(500, 500), true);
 
         WebFilterOperations filters;
         filters.append(WebFilterOperation::createBlurFilter(10));
         blurLayer->setFilters(filters);
@@ skipping 610 matching lines @@
 };
 
 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTestOpaqueContentsRegionNonEmpty);
 
 template<class Types>
 class OcclusionTrackerTest3dTransform : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTest3dTransform(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix transform;
-        transform.rotate3d(0, 30, 0);
+        Transform transform;
+        MathUtil::rotateEulerAngles(&transform, 0, 30, 0);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::LayerType* container = this->createLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(container, transform, gfx::PointF(100, 100), gfx::Size(200, 200), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
         this->enterLayer(layer, occlusion);
 
         // The layer is rotated in 3d but without preserving 3d, so it only gets resized.
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 200, 200), occlusion.unoccludedLayerContentRect(layer, gfx::Rect(0, 0, 200, 200)));
     }
 };
 
 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTest3dTransform);
 
 template<class Types>
 class OcclusionTrackerTestUnsorted3dLayers : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestUnsorted3dLayers(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         // Currently, the main thread layer iterator does not iterate over 3d items in
         // sorted order, because layer sorting is not performed on the main thread.
         // Because of this, the occlusion tracker cannot assume that a 3d layer occludes
         // other layers that have not yet been iterated over. For now, the expected
         // behavior is that a 3d layer simply does not add any occlusion to the occlusion
         // tracker.
 
-        WebTransformationMatrix translationToFront;
-        translationToFront.translate3d(0, 0, -10);
-        WebTransformationMatrix translationToBack;
-        translationToFront.translate3d(0, 0, -100);
+        Transform translationToFront;
+        translationToFront.PreconcatTranslate3d(0, 0, -10);
+        Transform translationToBack;
+        translationToFront.PreconcatTranslate3d(0, 0, -100);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::ContentLayerType* child1 = this->createDrawingLayer(parent, translationToBack, gfx::PointF(0, 0), gfx::Size(100, 100), true);
         typename Types::ContentLayerType* child2 = this->createDrawingLayer(parent, translationToFront, gfx::PointF(50, 50), gfx::Size(100, 100), true);
         parent->setPreserves3D(true);
 
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
         this->visitLayer(child2, occlusion);
         EXPECT_TRUE(occlusion.occlusionInScreenSpace().IsEmpty());
         EXPECT_TRUE(occlusion.occlusionInTargetSurface().IsEmpty());
 
         this->visitLayer(child1, occlusion);
         EXPECT_TRUE(occlusion.occlusionInScreenSpace().IsEmpty());
         EXPECT_TRUE(occlusion.occlusionInTargetSurface().IsEmpty());
     }
 };
 
 // This test will have different layer ordering on the impl thread; the test will only work on the main thread.
 MAIN_THREAD_TEST(OcclusionTrackerTestUnsorted3dLayers);
 
 template<class Types>
 class OcclusionTrackerTestPerspectiveTransform : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestPerspectiveTransform(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix transform;
-        transform.translate(150, 150);
-        transform.applyPerspective(400);
-        transform.rotate3d(1, 0, 0, -30);
-        transform.translate(-150, -150);
+        Transform transform;
+        transform.PreconcatTranslate(150, 150);
+        transform.PreconcatPerspectiveDepth(400);
+        MathUtil::rotateAxisAngle(&transform, 1, 0, 0, -30);
+        transform.PreconcatTranslate(-150, -150);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::LayerType* container = this->createLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(container, transform, gfx::PointF(100, 100), gfx::Size(200, 200), true);
         container->setPreserves3D(true);
         layer->setPreserves3D(true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
         this->enterLayer(layer, occlusion);
 
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 200, 200), occlusion.unoccludedLayerContentRect(layer, gfx::Rect(0, 0, 200, 200)));
     }
 };
 
 // This test requires accumulating occlusion of 3d layers, which are skipped by the occlusion tracker on the main thread. So this test should run on the impl thread.
 IMPL_THREAD_TEST(OcclusionTrackerTestPerspectiveTransform);
 
 template<class Types>
 class OcclusionTrackerTestPerspectiveTransformBehindCamera : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestPerspectiveTransformBehindCamera(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         // This test is based on the platform/chromium/compositing/3d-corners.html layout test.
-        WebTransformationMatrix transform;
-        transform.translate(250, 50);
-        transform.applyPerspective(10);
-        transform.translate(-250, -50);
-        transform.translate(250, 50);
-        transform.rotate3d(1, 0, 0, -167);
-        transform.translate(-250, -50);
+        Transform transform;
+        transform.PreconcatTranslate(250, 50);
+        transform.PreconcatPerspectiveDepth(10);
+        transform.PreconcatTranslate(-250, -50);
+        transform.PreconcatTranslate(250, 50);
+        MathUtil::rotateAxisAngle(&transform, 1, 0, 0, -167);
+        transform.PreconcatTranslate(-250, -50);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(500, 100));
         typename Types::LayerType* container = this->createLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(500, 500));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(container, transform, gfx::PointF(0, 0), gfx::Size(500, 500), true);
         container->setPreserves3D(true);
         layer->setPreserves3D(true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
         this->enterLayer(layer, occlusion);
 
         // The bottom 11 pixel rows of this layer remain visible inside the container, after translation to the target surface. When translated back,
         // this will include many more pixels but must include at least the bottom 11 rows.
         EXPECT_TRUE(occlusion.unoccludedLayerContentRect(layer, gfx::Rect(0, 0, 500, 500)).Contains(gfx::Rect(0, 489, 500, 11)));
     }
 };
 
 // This test requires accumulating occlusion of 3d layers, which are skipped by the occlusion tracker on the main thread. So this test should run on the impl thread.
 IMPL_THREAD_TEST(OcclusionTrackerTestPerspectiveTransformBehindCamera);
 
 template<class Types>
 class OcclusionTrackerTestLayerBehindCameraDoesNotOcclude : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestLayerBehindCameraDoesNotOcclude(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix transform;
-        transform.translate(50, 50);
-        transform.applyPerspective(100);
-        transform.translate3d(0, 0, 110);
-        transform.translate(-50, -50);
+        Transform transform;
+        transform.PreconcatTranslate(50, 50);
+        transform.PreconcatPerspectiveDepth(100);
+        transform.PreconcatTranslate3d(0, 0, 110);
+        transform.PreconcatTranslate(-50, -50);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, transform, gfx::PointF(0, 0), gfx::Size(100, 100), true);
         parent->setPreserves3D(true);
         layer->setPreserves3D(true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         // The |layer| is entirely behind the camera and should not occlude.
         this->visitLayer(layer, occlusion);
         this->enterLayer(parent, occlusion);
         EXPECT_TRUE(occlusion.occlusionInTargetSurface().IsEmpty());
         EXPECT_TRUE(occlusion.occlusionInScreenSpace().IsEmpty());
     }
 };
 
 // This test requires accumulating occlusion of 3d layers, which are skipped by the occlusion tracker on the main thread. So this test should run on the impl thread.
 IMPL_THREAD_TEST(OcclusionTrackerTestLayerBehindCameraDoesNotOcclude);
 
 template<class Types>
 class OcclusionTrackerTestLargePixelsOccludeInsideClipRect : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestLargePixelsOccludeInsideClipRect(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix transform;
-        transform.translate(50, 50);
-        transform.applyPerspective(100);
-        transform.translate3d(0, 0, 99);
-        transform.translate(-50, -50);
+        Transform transform;
+        transform.PreconcatTranslate(50, 50);
+        transform.PreconcatPerspectiveDepth(100);
+        transform.PreconcatTranslate3d(0, 0, 99);
+        transform.PreconcatTranslate(-50, -50);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         parent->setMasksToBounds(true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, transform, gfx::PointF(0, 0), gfx::Size(100, 100), true);
         parent->setPreserves3D(true);
         layer->setPreserves3D(true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
@@ skipping 200 matching lines @@
 };
 
 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationTranslateOnMainThread);
 
 template<class Types>
 class OcclusionTrackerTestSurfaceOcclusionTranslatesToParent : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestSurfaceOcclusionTranslatesToParent(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix surfaceTransform;
-        surfaceTransform.translate(300, 300);
-        surfaceTransform.scale(2);
-        surfaceTransform.translate(-150, -150);
+        Transform surfaceTransform;
+        surfaceTransform.PreconcatTranslate(300, 300);
+        surfaceTransform.PreconcatScale(2, 2);
+        surfaceTransform.PreconcatTranslate(-150, -150);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(500, 500));
         typename Types::ContentLayerType* surface = this->createDrawingSurface(parent, surfaceTransform, gfx::PointF(0, 0), gfx::Size(300, 300), false);
         typename Types::ContentLayerType* surface2 = this->createDrawingSurface(parent, this->identityMatrix, gfx::PointF(50, 50), gfx::Size(300, 300), false);
         surface->setOpaqueContentsRect(gfx::Rect(0, 0, 200, 200));
         surface2->setOpaqueContentsRect(gfx::Rect(0, 0, 200, 200));
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
@@ skipping 290 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceChildOfClippingSurface);
 
 template<class Types>
 class OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix scaleByHalf;
-        scaleByHalf.scale(0.5);
+        Transform scaleByHalf;
+        scaleByHalf.PreconcatScale(0.5, 0.5);
 
         // Make a surface and its replica, each 50x50, that are completely surrounded by opaque layers which are above them in the z-order.
         // The surface is scaled to test that the pixel moving is done in the target space, where the background filter is applied, but the surface
         // appears at 50, 50 and the replica at 200, 50.
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 150));
         typename Types::LayerType* filteredSurface = this->createDrawingLayer(parent, scaleByHalf, gfx::PointF(50, 50), gfx::Size(100, 100), false);
         this->createReplicaLayer(filteredSurface, this->identityMatrix, gfx::PointF(300, 0), gfx::Size());
         typename Types::LayerType* occludingLayer1 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 50), true);
         typename Types::LayerType* occludingLayer2 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 100), gfx::Size(300, 50), true);
         typename Types::LayerType* occludingLayer3 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 50), gfx::Size(50, 50), true);
@@ skipping 109 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter);
 
 template<class Types>
 class OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix scaleByHalf;
-        scaleByHalf.scale(0.5);
+        Transform scaleByHalf;
+        scaleByHalf.PreconcatScale(0.5, 0.5);
 
         // Makes two surfaces that completely cover |parent|. The occlusion both above and below the filters will be reduced by each of them.
         typename Types::ContentLayerType* root = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(75, 75));
         typename Types::LayerType* parent = this->createSurface(root, scaleByHalf, gfx::PointF(0, 0), gfx::Size(150, 150));
         parent->setMasksToBounds(true);
         typename Types::LayerType* filteredSurface1 = this->createDrawingLayer(parent, scaleByHalf, gfx::PointF(0, 0), gfx::Size(300, 300), false);
         typename Types::LayerType* filteredSurface2 = this->createDrawingLayer(parent, scaleByHalf, gfx::PointF(0, 0), gfx::Size(300, 300), false);
         typename Types::LayerType* occludingLayerAbove = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(100, 100), gfx::Size(50, 50), true);
 
         // Filters make the layers own surfaces.
@@ skipping 163 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilterWithClip);
 
 template<class Types>
 class OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix scaleByHalf;
-        scaleByHalf.scale(0.5);
+        Transform scaleByHalf;
+        scaleByHalf.PreconcatScale(0.5, 0.5);
 
         // Make a surface and its replica, each 50x50, with a smaller 30x30 layer centered below each.
         // The surface is scaled to test that the pixel moving is done in the target space, where the background filter is applied, but the surface
         // appears at 50, 50 and the replica at 200, 50.
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 150));
         typename Types::LayerType* behindSurfaceLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(60, 60), gfx::Size(30, 30), true);
         typename Types::LayerType* behindReplicaLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(210, 60), gfx::Size(30, 30), true);
         typename Types::LayerType* filteredSurface = this->createDrawingLayer(parent, scaleByHalf, gfx::PointF(50, 50), gfx::Size(100, 100), false);
         this->createReplicaLayer(filteredSurface, this->identityMatrix, gfx::PointF(300, 0), gfx::Size());
 
@@ skipping 26 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter);
 
 template<class Types>
 class OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix scaleByHalf;
-        scaleByHalf.scale(0.5);
+        Transform scaleByHalf;
+        scaleByHalf.PreconcatScale(0.5, 0.5);
 
         // Make a surface and its replica, each 50x50, that are completely occluded by opaque layers which are above them in the z-order.
         // The surface is scaled to test that the pixel moving is done in the target space, where the background filter is applied, but the surface
         // appears at 50, 50 and the replica at 200, 50.
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 150));
         typename Types::LayerType* filteredSurface = this->createDrawingLayer(parent, scaleByHalf, gfx::PointF(50, 50), gfx::Size(100, 100), false);
         this->createReplicaLayer(filteredSurface, this->identityMatrix, gfx::PointF(300, 0), gfx::Size());
         typename Types::LayerType* aboveSurfaceLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(50, 50), gfx::Size(50, 50), true);
         typename Types::LayerType* aboveReplicaLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(200, 50), gfx::Size(50, 50), true);
 
@@ skipping 25 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded);
 
 template<class Types>
 class OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
-        WebTransformationMatrix scaleByHalf;
-        scaleByHalf.scale(0.5);
+        Transform scaleByHalf;
+        scaleByHalf.PreconcatScale(0.5, 0.5);
 
         // Make a surface and its replica, each 50x50, that are partially occluded by opaque layers which are above them in the z-order.
         // The surface is scaled to test that the pixel moving is done in the target space, where the background filter is applied, but the surface
         // appears at 50, 50 and the replica at 200, 50.
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 150));
         typename Types::LayerType* filteredSurface = this->createDrawingLayer(parent, scaleByHalf, gfx::PointF(50, 50), gfx::Size(100, 100), false);
         this->createReplicaLayer(filteredSurface, this->identityMatrix, gfx::PointF(300, 0), gfx::Size());
         typename Types::LayerType* aboveSurfaceLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(70, 50), gfx::Size(30, 50), true);
         typename Types::LayerType* aboveReplicaLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(200, 50), gfx::Size(30, 50), true);
         typename Types::LayerType* besideSurfaceLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(90, 40), gfx::Size(10, 10), true);
@@ skipping 83 matching lines @@
 
         EXPECT_EQ(gfx::Rect(gfx::Point(), trackingSize).ToString(), occlusion.occlusionInScreenSpace().ToString());
         EXPECT_EQ(gfx::Rect(gfx::Point(), trackingSize).ToString(), occlusion.occlusionInTargetSurface().ToString());
     }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestMinimumTrackingSize);
 
 }  // namespace
 }  // namespace cc