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

cc/layer_tree_host_common_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_common.h"
 
 #include "cc/content_layer.h"
 #include "cc/content_layer_client.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_sorter.h"
 #include "cc/math_util.h"
 #include "cc/proxy.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/thread.h"
 #include "ui/gfx/size_conversions.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include <public/WebTransformationMatrix.h>
+#include "ui/gfx/transform.h"
 
 using namespace WebKitTests;
-using WebKit::WebTransformationMatrix;
+using gfx::Transform;
 
 namespace cc {
 namespace {
 
 template<typename LayerType>
-void setLayerPropertiesForTestingInternal(LayerType* layer, const WebTransformationMatrix& transform, const WebTransformationMatrix& sublayerTransform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool preserves3D)
+void setLayerPropertiesForTestingInternal(LayerType* layer, const Transform& transform, const Transform& sublayerTransform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool preserves3D)
 {
     layer->setTransform(transform);
     layer->setSublayerTransform(sublayerTransform);
     layer->setAnchorPoint(anchor);
     layer->setPosition(position);
     layer->setBounds(bounds);
     layer->setPreserves3D(preserves3D);
 }
 
-void setLayerPropertiesForTesting(Layer* layer, const WebTransformationMatrix& transform, const WebTransformationMatrix& sublayerTransform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool preserves3D)
+void setLayerPropertiesForTesting(Layer* layer, const Transform& transform, const Transform& sublayerTransform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool preserves3D)
 {
     setLayerPropertiesForTestingInternal<Layer>(layer, transform, sublayerTransform, anchor, position, bounds, preserves3D);
     layer->setAutomaticallyComputeRasterScale(true);
 }
 
-void setLayerPropertiesForTesting(LayerImpl* layer, const WebTransformationMatrix& transform, const WebTransformationMatrix& sublayerTransform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool preserves3D)
+void setLayerPropertiesForTesting(LayerImpl* layer, const Transform& transform, const Transform& sublayerTransform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool preserves3D)
 {
     setLayerPropertiesForTestingInternal<LayerImpl>(layer, transform, sublayerTransform, anchor, position, bounds, preserves3D);
     layer->setContentBounds(bounds);
 }
 
 void executeCalculateDrawTransformsAndVisibility(Layer* rootLayer, float deviceScaleFactor = 1, float pageScaleFactor = 1)
 {
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     std::vector<scoped_refptr<Layer> > dummyRenderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     gfx::Size deviceViewportSize = gfx::Size(rootLayer->bounds().width() * deviceScaleFactor, rootLayer->bounds().height() * deviceScaleFactor);
 
     // We are probably not testing what is intended if the rootLayer bounds are empty.
     DCHECK(!rootLayer->bounds().IsEmpty());
     LayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize, deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, dummyRenderSurfaceLayerList);
 }
 
 void executeCalculateDrawTransformsAndVisibility(LayerImpl* rootLayer, float deviceScaleFactor = 1, float pageScaleFactor = 1)
 {
     // Note: this version skips layer sorting.
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     std::vector<LayerImpl*> dummyRenderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     gfx::Size deviceViewportSize = gfx::Size(rootLayer->bounds().width() * deviceScaleFactor, rootLayer->bounds().height() * deviceScaleFactor);
 
     // We are probably not testing what is intended if the rootLayer bounds are empty.
     DCHECK(!rootLayer->bounds().IsEmpty());
     LayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize, deviceScaleFactor, pageScaleFactor, 0, dummyMaxTextureSize, dummyRenderSurfaceLayerList);
 }
 
-WebTransformationMatrix remove3DComponentOfMatrix(const WebTransformationMatrix& mat)
+Transform remove3DComponentOfMatrix(const Transform& mat)
 {
-    WebTransformationMatrix ret = mat;
-    ret.setM13(0);
-    ret.setM23(0);
-    ret.setM31(0);
-    ret.setM32(0);
-    ret.setM33(1);
-    ret.setM34(0);
-    ret.setM43(0);
+    Transform ret = mat;
+    ret.matrix().setDouble(2, 0, 0);
+    ret.matrix().setDouble(2, 1, 0);
+    ret.matrix().setDouble(0, 2, 0);
+    ret.matrix().setDouble(1, 2, 0);
+    ret.matrix().setDouble(2, 2, 1);
+    ret.matrix().setDouble(3, 2, 0);
+    ret.matrix().setDouble(2, 3, 0);
     return ret;
 }
 
 scoped_ptr<LayerImpl> createTreeForFixedPositionTests()
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     scoped_ptr<LayerImpl> child = LayerImpl::create(2);
     scoped_ptr<LayerImpl> grandChild = LayerImpl::create(3);
     scoped_ptr<LayerImpl> greatGrandChild = LayerImpl::create(4);
 
-    WebTransformationMatrix IdentityMatrix;
+    Transform IdentityMatrix;
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);
     setLayerPropertiesForTesting(child.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);
     setLayerPropertiesForTesting(grandChild.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);
     setLayerPropertiesForTesting(greatGrandChild.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);
 
     grandChild->addChild(greatGrandChild.Pass());
     child->addChild(grandChild.Pass());
@@ skipping 43 matching lines @@
     // and with identity transforms, then the drawTransform,
     // screenSpaceTransform, and the hierarchy passed on to children
     // layers should also be identity transforms.
 
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<Layer> grandChild = Layer::create();
     parent->addChild(child);
     child->addChild(grandChild);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(0, 0), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(0, 0), false);
 
     executeCalculateDrawTransformsAndVisibility(parent.get());
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->screenSpaceTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer)
 {
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     scoped_refptr<Layer> layer = Layer::create();
 
     scoped_refptr<Layer> root = Layer::create();
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(1, 2), false);
     root->addChild(layer);
 
     // Case 1: setting the sublayer transform should not affect this layer's draw transform or screen-space transform.
-    WebTransformationMatrix arbitraryTranslation;
-    arbitraryTranslation.translate(10, 20);
+    Transform arbitraryTranslation;
+    arbitraryTranslation.PreconcatTranslate(10, 20);
     setLayerPropertiesForTesting(layer.get(), identityMatrix, arbitraryTranslation, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
-    WebTransformationMatrix expectedDrawTransform = identityMatrix;
+    Transform expectedDrawTransform = identityMatrix;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedDrawTransform, layer->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->screenSpaceTransform());
 
     // Case 2: Setting the bounds of the layer should not affect either the draw transform or the screenspace transform.
-    WebTransformationMatrix translationToCenter;
-    translationToCenter.translate(5, 6);
+    Transform translationToCenter;
+    translationToCenter.PreconcatTranslate(5, 6);
     setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->screenSpaceTransform());
 
     // Case 3: The anchor point by itself (without a layer transform) should have no effect on the transforms.
     setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, gfx::PointF(0.25, 0.25), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->screenSpaceTransform());
 
     // Case 4: A change in actual position affects both the draw transform and screen space transform.
-    WebTransformationMatrix positionTransform;
-    positionTransform.translate(0, 1.2);
+    Transform positionTransform;
+    positionTransform.PreconcatTranslate(0, 1.2);
     setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, gfx::PointF(0.25, 0.25), gfx::PointF(0, 1.2f), gfx::Size(10, 12), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(positionTransform, layer->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(positionTransform, layer->screenSpaceTransform());
 
     // Case 5: In the correct sequence of transforms, the layer transform should pre-multiply the translationToCenter. This is easily tested by
     //         using a scale transform, because scale and translation are not commutative.
-    WebTransformationMatrix layerTransform;
-    layerTransform.scale3d(2, 2, 1);
+    Transform layerTransform;
+    layerTransform.PreconcatScale3d(2, 2, 1);
     setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(layerTransform, layer->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(layerTransform, layer->screenSpaceTransform());
 
     // Case 6: The layer transform should occur with respect to the anchor point.
-    WebTransformationMatrix translationToAnchor;
-    translationToAnchor.translate(5, 0);
-    WebTransformationMatrix expectedResult = translationToAnchor * layerTransform * translationToAnchor.inverse();
+    Transform translationToAnchor;
+    translationToAnchor.PreconcatTranslate(5, 0);
+    Transform expectedResult = translationToAnchor * layerTransform * MathUtil::inverse(translationToAnchor);
     setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, gfx::PointF(0.5, 0), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->screenSpaceTransform());
 
     // Case 7: Verify that position pre-multiplies the layer transform.
     //         The current implementation of calculateDrawTransforms does this implicitly, but it is
     //         still worth testing to detect accidental regressions.
-    expectedResult = positionTransform * translationToAnchor * layerTransform * translationToAnchor.inverse();
+    expectedResult = positionTransform * translationToAnchor * layerTransform * MathUtil::inverse(translationToAnchor);
     setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, gfx::PointF(0.5, 0), gfx::PointF(0, 1.2f), gfx::Size(10, 12), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->screenSpaceTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy)
 {
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<Layer> grandChild = Layer::create();
     root->addChild(parent);
     parent->addChild(child);
     child->addChild(grandChild);
 
     // One-time setup of root layer
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(1, 2), false);
 
     // Case 1: parent's anchorPoint should not affect child or grandChild.
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0.25, 0.25), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(16, 18), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(76, 78), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->screenSpaceTransform());
 
     // Case 2: parent's position affects child and grandChild.
-    WebTransformationMatrix parentPositionTransform;
-    parentPositionTransform.translate(0, 1.2);
+    Transform parentPositionTransform;
+    parentPositionTransform.PreconcatTranslate(0, 1.2);
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0.25, 0.25), gfx::PointF(0, 1.2f), gfx::Size(10, 12), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(16, 18), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(76, 78), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentPositionTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentPositionTransform, child->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentPositionTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentPositionTransform, grandChild->screenSpaceTransform());
 
     // Case 3: parent's local transform affects child and grandchild
-    WebTransformationMatrix parentLayerTransform;
-    parentLayerTransform.scale3d(2, 2, 1);
-    WebTransformationMatrix parentTranslationToAnchor;
-    parentTranslationToAnchor.translate(2.5, 3);
-    WebTransformationMatrix parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * parentTranslationToAnchor.inverse();
+    Transform parentLayerTransform;
+    parentLayerTransform.PreconcatScale3d(2, 2, 1);
+    Transform parentTranslationToAnchor;
+    parentTranslationToAnchor.PreconcatTranslate(2.5, 3);
+    Transform parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * MathUtil::inverse(parentTranslationToAnchor);
     setLayerPropertiesForTesting(parent.get(), parentLayerTransform, identityMatrix, gfx::PointF(0.25, 0.25), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(16, 18), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(76, 78), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, grandChild->screenSpaceTransform());
 
     // Case 4: parent's sublayerMatrix affects child and grandchild
     //         scaling is used here again so that the correct sequence of transforms is properly tested.
     //         Note that preserves3D is false, but the sublayer matrix should retain its 3D properties when given to child.
     //         But then, the child also does not preserve3D. When it gives its hierarchy to the grandChild, it should be flattened to 2D.
-    WebTransformationMatrix parentSublayerMatrix;
-    parentSublayerMatrix.scale3d(10, 10, 3.3);
-    WebTransformationMatrix parentTranslationToCenter;
-    parentTranslationToCenter.translate(5, 6);
+    Transform parentSublayerMatrix;
+    parentSublayerMatrix.PreconcatScale3d(10, 10, 3.3);
+    Transform parentTranslationToCenter;
+    parentTranslationToCenter.PreconcatTranslate(5, 6);
     // Sublayer matrix is applied to the center of the parent layer.
-    parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * parentTranslationToAnchor.inverse()
-            * parentTranslationToCenter * parentSublayerMatrix * parentTranslationToCenter.inverse();
-    WebTransformationMatrix flattenedCompositeTransform = remove3DComponentOfMatrix(parentCompositeTransform);
+    parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * MathUtil::inverse(parentTranslationToAnchor)
+            * parentTranslationToCenter * parentSublayerMatrix * MathUtil::inverse(parentTranslationToCenter);
+    Transform flattenedCompositeTransform = remove3DComponentOfMatrix(parentCompositeTransform);
     setLayerPropertiesForTesting(parent.get(), parentLayerTransform, parentSublayerMatrix, gfx::PointF(0.25, 0.25), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(16, 18), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(76, 78), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(flattenedCompositeTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(flattenedCompositeTransform, grandChild->screenSpaceTransform());
 
     // Case 5: same as Case 4, except that child does preserve 3D, so the grandChild should receive the non-flattened composite transform.
@@ skipping 12 matching lines @@
 {
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> grandChild = make_scoped_refptr(new LayerWithForcedDrawsContent());
     root->addChild(parent);
     parent->addChild(child);
     child->addChild(grandChild);
 
     // One-time setup of root layer
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(1, 2), false);
 
     // Child is set up so that a new render surface should be created.
     child->setOpacity(0.5);
 
-    WebTransformationMatrix parentLayerTransform;
-    parentLayerTransform.scale3d(1, 0.9, 1);
-    WebTransformationMatrix parentTranslationToAnchor;
-    parentTranslationToAnchor.translate(25, 30);
-    WebTransformationMatrix parentSublayerMatrix;
-    parentSublayerMatrix.scale3d(0.9, 1, 3.3);
-    WebTransformationMatrix parentTranslationToCenter;
-    parentTranslationToCenter.translate(50, 60);
-    WebTransformationMatrix parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * parentTranslationToAnchor.inverse()
-            * parentTranslationToCenter * parentSublayerMatrix * parentTranslationToCenter.inverse();
+    Transform parentLayerTransform;
+    parentLayerTransform.PreconcatScale3d(1, 0.9, 1);
+    Transform parentTranslationToAnchor;
+    parentTranslationToAnchor.PreconcatTranslate(25, 30);
+    Transform parentSublayerMatrix;
+    parentSublayerMatrix.PreconcatScale3d(0.9, 1, 3.3);
+    Transform parentTranslationToCenter;
+    parentTranslationToCenter.PreconcatTranslate(50, 60);
+    Transform parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * MathUtil::inverse(parentTranslationToAnchor)
+            * parentTranslationToCenter * parentSublayerMatrix * MathUtil::inverse(parentTranslationToCenter);
     gfx::Vector2dF parentCompositeScale = MathUtil::computeTransform2dScaleComponents(parentCompositeTransform);
-    WebTransformationMatrix surfaceSublayerTransform;
-    surfaceSublayerTransform.scaleNonUniform(parentCompositeScale.x(), parentCompositeScale.y());
-    WebTransformationMatrix surfaceSublayerCompositeTransform = parentCompositeTransform * surfaceSublayerTransform.inverse();
+    Transform surfaceSublayerTransform;
+    surfaceSublayerTransform.PreconcatScale(parentCompositeScale.x(), parentCompositeScale.y());
+    Transform surfaceSublayerCompositeTransform = parentCompositeTransform * MathUtil::inverse(surfaceSublayerTransform);
 
     // Child's render surface should not exist yet.
     ASSERT_FALSE(child->renderSurface());
 
     setLayerPropertiesForTesting(parent.get(), parentLayerTransform, parentSublayerMatrix, gfx::PointF(0.25, 0.25), gfx::PointF(0, 0), gfx::Size(100, 120), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(16, 18), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(8, 10), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Render surface should have been created now.
@@ skipping 19 matching lines @@
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<Layer> childReplica = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> grandChild = make_scoped_refptr(new LayerWithForcedDrawsContent());
     root->addChild(parent);
     parent->addChild(child);
     child->addChild(grandChild);
     child->setReplicaLayer(childReplica.get());
 
     // One-time setup of root layer
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(1, 2), false);
 
     // Child is set up so that a new render surface should be created.
     child->setOpacity(0.5);
 
-    WebTransformationMatrix parentLayerTransform;
-    parentLayerTransform.scale3d(2, 2, 1);
-    WebTransformationMatrix parentTranslationToAnchor;
-    parentTranslationToAnchor.translate(2.5, 3);
-    WebTransformationMatrix parentSublayerMatrix;
-    parentSublayerMatrix.scale3d(10, 10, 3.3);
-    WebTransformationMatrix parentTranslationToCenter;
-    parentTranslationToCenter.translate(5, 6);
-    WebTransformationMatrix parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * parentTranslationToAnchor.inverse()
-            * parentTranslationToCenter * parentSublayerMatrix * parentTranslationToCenter.inverse();
-    WebTransformationMatrix childTranslationToCenter;
-    childTranslationToCenter.translate(8, 9);
-    WebTransformationMatrix replicaLayerTransform;
-    replicaLayerTransform.scale3d(3, 3, 1);
+    Transform parentLayerTransform;
+    parentLayerTransform.PreconcatScale3d(2, 2, 1);
+    Transform parentTranslationToAnchor;
+    parentTranslationToAnchor.PreconcatTranslate(2.5, 3);
+    Transform parentSublayerMatrix;
+    parentSublayerMatrix.PreconcatScale3d(10, 10, 3.3);
+    Transform parentTranslationToCenter;
+    parentTranslationToCenter.PreconcatTranslate(5, 6);
+    Transform parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * MathUtil::inverse(parentTranslationToAnchor)
+            * parentTranslationToCenter * parentSublayerMatrix * MathUtil::inverse(parentTranslationToCenter);
+    Transform childTranslationToCenter;
+    childTranslationToCenter.PreconcatTranslate(8, 9);
+    Transform replicaLayerTransform;
+    replicaLayerTransform.PreconcatScale3d(3, 3, 1);
     gfx::Vector2dF parentCompositeScale = MathUtil::computeTransform2dScaleComponents(parentCompositeTransform);
-    WebTransformationMatrix surfaceSublayerTransform;
-    surfaceSublayerTransform.scaleNonUniform(parentCompositeScale.x(), parentCompositeScale.y());
-    WebTransformationMatrix replicaCompositeTransform = parentCompositeTransform * replicaLayerTransform * surfaceSublayerTransform.inverse();
+    Transform surfaceSublayerTransform;
+    surfaceSublayerTransform.PreconcatScale(parentCompositeScale.x(), parentCompositeScale.y());
+    Transform replicaCompositeTransform = parentCompositeTransform * replicaLayerTransform * MathUtil::inverse(surfaceSublayerTransform);
 
     // Child's render surface should not exist yet.
     ASSERT_FALSE(child->renderSurface());
 
     setLayerPropertiesForTesting(parent.get(), parentLayerTransform, parentSublayerMatrix, gfx::PointF(0.25, 0.25), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(16, 18), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(-0.5, -0.5), gfx::Size(1, 1), false);
     setLayerPropertiesForTesting(childReplica.get(), replicaLayerTransform, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(0, 0), false);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
@@ skipping 36 matching lines @@
     childOfRS1->addChild(grandChildOfRS1);
     childOfRS2->addChild(grandChildOfRS2);
     renderSurface1->setReplicaLayer(replicaOfRS1.get());
     renderSurface2->setReplicaLayer(replicaOfRS2.get());
 
     // In combination with descendantDrawsContent, opacity != 1 forces the layer to have a new renderSurface.
     renderSurface1->setOpacity(0.5);
     renderSurface2->setOpacity(0.33f);
 
     // One-time setup of root layer
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(1, 2), false);
 
     // All layers in the tree are initialized with an anchor at .25 and a size of (10,10).
     // matrix "A" is the composite layer transform used in all layers, centered about the anchor point
     // matrix "B" is the sublayer transform used in all layers, centered about the center position of the layer.
     // matrix "R" is the composite replica transform used in all replica layers.
     //
     // x component tests that layerTransform and sublayerTransform are done in the right order (translation and scale are noncommutative).
     // y component has a translation by 1 for every ancestor, which indicates the "depth" of the layer in the hierarchy.
-    WebTransformationMatrix translationToAnchor;
-    translationToAnchor.translate(2.5, 0);
-    WebTransformationMatrix translationToCenter;
-    translationToCenter.translate(5, 5);
-    WebTransformationMatrix layerTransform;
-    layerTransform.translate(1, 1);
-    WebTransformationMatrix sublayerTransform;
-    sublayerTransform.scale3d(10, 1, 1);
-    WebTransformationMatrix replicaLayerTransform;
-    replicaLayerTransform.scale3d(-2, 5, 1);
+    Transform translationToAnchor;
+    translationToAnchor.PreconcatTranslate(2.5, 0);
+    Transform translationToCenter;
+    translationToCenter.PreconcatTranslate(5, 5);
+    Transform layerTransform;
+    layerTransform.PreconcatTranslate(1, 1);
+    Transform sublayerTransform;
+    sublayerTransform.PreconcatScale3d(10, 1, 1);
+    Transform replicaLayerTransform;
+    replicaLayerTransform.PreconcatScale3d(-2, 5, 1);
 
-    WebTransformationMatrix A = translationToAnchor * layerTransform * translationToAnchor.inverse();
-    WebTransformationMatrix B = translationToCenter * sublayerTransform * translationToCenter.inverse();
-    WebTransformationMatrix R = A * translationToAnchor * replicaLayerTransform * translationToAnchor.inverse();
+    Transform A = translationToAnchor * layerTransform * MathUtil::inverse(translationToAnchor);
+    Transform B = translationToCenter * sublayerTransform * MathUtil::inverse(translationToCenter);
+    Transform R = A * translationToAnchor * replicaLayerTransform * MathUtil::inverse(translationToAnchor);
 
     gfx::Vector2dF surface1ParentTransformScale = MathUtil::computeTransform2dScaleComponents(A * B);
-    WebTransformationMatrix surface1SublayerTransform;
-    surface1SublayerTransform.scaleNonUniform(surface1ParentTransformScale.x(), surface1ParentTransformScale.y());
+    Transform surface1SublayerTransform;
+    surface1SublayerTransform.PreconcatScale(surface1ParentTransformScale.x(), surface1ParentTransformScale.y());
 
     // SS1 = transform given to the subtree of renderSurface1
-    WebTransformationMatrix SS1 = surface1SublayerTransform;
+    Transform SS1 = surface1SublayerTransform;
     // S1 = transform to move from renderSurface1 pixels to the layer space of the owning layer
-    WebTransformationMatrix S1 = surface1SublayerTransform.inverse();
+    Transform S1 = MathUtil::inverse(surface1SublayerTransform);
 
     gfx::Vector2dF surface2ParentTransformScale = MathUtil::computeTransform2dScaleComponents(SS1 * A * B);
-    WebTransformationMatrix surface2SublayerTransform;
-    surface2SublayerTransform.scaleNonUniform(surface2ParentTransformScale.x(), surface2ParentTransformScale.y());
+    Transform surface2SublayerTransform;
+    surface2SublayerTransform.PreconcatScale(surface2ParentTransformScale.x(), surface2ParentTransformScale.y());
 
     // SS2 = transform given to the subtree of renderSurface2
-    WebTransformationMatrix SS2 = surface2SublayerTransform;
+    Transform SS2 = surface2SublayerTransform;
     // S2 = transform to move from renderSurface2 pixels to the layer space of the owning layer
-    WebTransformationMatrix S2 = surface2SublayerTransform.inverse();
+    Transform S2 = MathUtil::inverse(surface2SublayerTransform);
 
     setLayerPropertiesForTesting(parent.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(renderSurface1.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(renderSurface2.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(childOfRoot.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(childOfRS1.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(childOfRS2.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(grandChildOfRoot.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(grandChildOfRS1.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(grandChildOfRS2.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
@@ skipping 69 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * R * S1, renderSurface1->renderSurface()->replicaScreenSpaceTransform());
     // Draw transform of render surface 2 is described with respect to render surface 1.
     EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * B * A * S2, renderSurface2->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * B * R * S2, renderSurface2->renderSurface()->replicaDrawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A * S2, renderSurface2->renderSurface()->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * R * S2, renderSurface2->renderSurface()->replicaScreenSpaceTransform());
 
     // Sanity check. If these fail there is probably a bug in the test itself.
     // It is expected that we correctly set up transforms so that the y-component of the screen-space transform
     // encodes the "depth" of the layer in the tree.
-    EXPECT_FLOAT_EQ(1, parent->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(2, childOfRoot->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(3, grandChildOfRoot->screenSpaceTransform().m42());
+    EXPECT_FLOAT_EQ(1, parent->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(2, childOfRoot->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(3, grandChildOfRoot->screenSpaceTransform().matrix().getDouble(1, 3));
 
-    EXPECT_FLOAT_EQ(2, renderSurface1->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(3, childOfRS1->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(4, grandChildOfRS1->screenSpaceTransform().m42());
+    EXPECT_FLOAT_EQ(2, renderSurface1->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(3, childOfRS1->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(4, grandChildOfRS1->screenSpaceTransform().matrix().getDouble(1, 3));
 
-    EXPECT_FLOAT_EQ(3, renderSurface2->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(4, childOfRS2->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(5, grandChildOfRS2->screenSpaceTransform().m42());
+    EXPECT_FLOAT_EQ(3, renderSurface2->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(4, childOfRS2->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(5, grandChildOfRS2->screenSpaceTransform().matrix().getDouble(1, 3));
 }
 
 TEST(LayerTreeHostCommonTest, verifyTransformsForFlatteningLayer)
 {
     // For layers that flatten their subtree, there should be an orthographic projection
     // (for x and y values) in the middle of the transform sequence. Note that the way the
     // code is currently implemented, it is not expected to use a canonical orthographic
     // projection.
 
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> grandChild = make_scoped_refptr(new LayerWithForcedDrawsContent());
 
-    WebTransformationMatrix rotationAboutYAxis;
-    rotationAboutYAxis.rotate3d(0, 30, 0);
+    Transform rotationAboutYAxis;
+    MathUtil::rotateEulerAngles(&rotationAboutYAxis, 0, 30, 0);
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child.get(), rotationAboutYAxis, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(grandChild.get(), rotationAboutYAxis, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
 
     root->addChild(child);
     child->addChild(grandChild);
     child->setForceRenderSurface(true);
 
     // No layers in this test should preserve 3d.
     ASSERT_FALSE(root->preserves3D());
     ASSERT_FALSE(child->preserves3D());
     ASSERT_FALSE(grandChild->preserves3D());
 
-    WebTransformationMatrix expectedChildDrawTransform = rotationAboutYAxis;
-    WebTransformationMatrix expectedChildScreenSpaceTransform = rotationAboutYAxis;
-    WebTransformationMatrix expectedGrandChildDrawTransform = rotationAboutYAxis; // draws onto child's renderSurface
-    WebTransformationMatrix expectedGrandChildScreenSpaceTransform = rotationAboutYAxis.to2dTransform() * rotationAboutYAxis;
+    Transform expectedChildDrawTransform = rotationAboutYAxis;
+    Transform expectedChildScreenSpaceTransform = rotationAboutYAxis;
+    Transform expectedGrandChildDrawTransform = rotationAboutYAxis; // draws onto child's renderSurface
+    Transform expectedGrandChildScreenSpaceTransform = MathUtil::to2dTransform(rotationAboutYAxis) * rotationAboutYAxis;
 
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // The child's drawTransform should have been taken by its surface.
     ASSERT_TRUE(child->renderSurface());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildDrawTransform, child->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildScreenSpaceTransform, child->renderSurface()->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildScreenSpaceTransform, child->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildDrawTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildScreenSpaceTransform, grandChild->screenSpaceTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyTransformsForDegenerateIntermediateLayer)
 {
     // A layer that is empty in one axis, but not the other, was accidentally skipping a necessary translation.
     // Without that translation, the coordinate space of the layer's drawTransform is incorrect.
     //
     // Normally this isn't a problem, because the layer wouldn't be drawn anyway, but if that layer becomes a renderSurface, then
     // its drawTransform is implicitly inherited by the rest of the subtree, which then is positioned incorrectly as a result.
 
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> grandChild = make_scoped_refptr(new LayerWithForcedDrawsContent());
 
     // The child height is zero, but has non-zero width that should be accounted for while computing drawTransforms.
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 0), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
 
     root->addChild(child);
     child->addChild(grandChild);
     child->setForceRenderSurface(true);
 
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     ASSERT_TRUE(child->renderSurface());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->renderSurface()->drawTransform()); // This is the real test, the rest are sanity checks.
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->drawTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyRenderSurfaceListForRenderSurfaceWithClippedLayer)
 {
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> renderSurface1 = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> child = make_scoped_refptr(new LayerWithForcedDrawsContent());
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(30, 30), gfx::Size(10, 10), false);
 
     parent->addChild(renderSurface1);
     parent->setMasksToBounds(true);
     renderSurface1->addChild(child);
     renderSurface1->setForceRenderSurface(true);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // The child layer's content is entirely outside the parent's clip rect, so the intermediate
     // render surface should not be listed here, even if it was forced to be created. Render surfaces without children or visible
     // content are unexpected at draw time (e.g. we might try to create a content texture of size 0).
     ASSERT_TRUE(parent->renderSurface());
     ASSERT_FALSE(renderSurface1->renderSurface());
     EXPECT_EQ(1U, renderSurfaceLayerList.size());
 }
 
 TEST(LayerTreeHostCommonTest, verifyRenderSurfaceListForTransparentChild)
 {
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> renderSurface1 = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> child = make_scoped_refptr(new LayerWithForcedDrawsContent());
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
 
     parent->addChild(renderSurface1);
     renderSurface1->addChild(child);
     renderSurface1->setForceRenderSurface(true);
     renderSurface1->setOpacity(0);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Since the layer is transparent, renderSurface1->renderSurface() should not have gotten added anywhere.
     // Also, the drawable content rect should not have been extended by the children.
     ASSERT_TRUE(parent->renderSurface());
     EXPECT_EQ(0U, parent->renderSurface()->layerList().size());
     EXPECT_EQ(1U, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
     EXPECT_EQ(gfx::Rect(), parent->drawableContentRect());
 }
 
 TEST(LayerTreeHostCommonTest, verifyForceRenderSurface)
 {
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> renderSurface1 = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> child = make_scoped_refptr(new LayerWithForcedDrawsContent());
     renderSurface1->setForceRenderSurface(true);
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
 
     parent->addChild(renderSurface1);
     renderSurface1->addChild(child);
 
     // Sanity check before the actual test
     EXPECT_FALSE(parent->renderSurface());
     EXPECT_FALSE(renderSurface1->renderSurface());
@@ skipping 23 matching lines @@
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
 
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setFixedToContainerLayer(true);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    WebTransformationMatrix expectedChildTransform;
-    WebTransformationMatrix expectedGrandChildTransform = expectedChildTransform;
+    Transform expectedChildTransform;
+    Transform expectedGrandChildTransform = expectedChildTransform;
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 10
     child->setScrollDelta(gfx::Vector2d(10, 10));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the child is affected by scrollDelta, but the fixed position grandChild should not be affected.
-    expectedChildTransform.makeIdentity();
-    expectedChildTransform.translate(-10, -10);
+    expectedChildTransform.matrix().setIdentity();

[danakj, 2012/11/24 02:34:54]

note: we should have API on gfx::Transform to never need to access matrix().

+    expectedChildTransform.PreconcatTranslate(-10, -10);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithTransformedDirectContainer)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // is the direct parent of the fixed-position layer, but that container is transformed.
     // In this case, the fixed position element inherits the container's transform,
     // but the scrollDelta that has to be undone should not be affected by that transform.
     //
     // Transforms are in general non-commutative; using something like a non-uniform scale
     // helps to verify that translations and non-uniform scales are applied in the correct
     // order.
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests();
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
 
     // This scale will cause child and grandChild to be effectively 200 x 800 with respect to the renderTarget.
-    WebTransformationMatrix nonUniformScale;
-    nonUniformScale.scaleNonUniform(2, 8);
+    Transform nonUniformScale;
+    nonUniformScale.PreconcatScale(2, 8);
     child->setTransform(nonUniformScale);
 
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setFixedToContainerLayer(true);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    WebTransformationMatrix expectedChildTransform;
-    expectedChildTransform.multiply(nonUniformScale);
+    Transform expectedChildTransform;
+    expectedChildTransform.PreconcatTransform(nonUniformScale);
 
-    WebTransformationMatrix expectedGrandChildTransform = expectedChildTransform;
+    Transform expectedGrandChildTransform = expectedChildTransform;
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 20
     child->setScrollDelta(gfx::Vector2d(10, 20));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // The child should be affected by scrollDelta, but the fixed position grandChild should not be affected.
-    expectedChildTransform.makeIdentity();
-    expectedChildTransform.translate(-10, -20); // scrollDelta
-    expectedChildTransform.multiply(nonUniformScale);
+    expectedChildTransform.matrix().setIdentity();
+    expectedChildTransform.PreconcatTranslate(-10, -20); // scrollDelta
+    expectedChildTransform.PreconcatTransform(nonUniformScale);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithDistantContainer)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // is NOT the direct parent of the fixed-position layer.
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests();
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
     LayerImpl* greatGrandChild = grandChild->children()[0];
 
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setPosition(gfx::PointF(8, 6));
     greatGrandChild->setFixedToContainerLayer(true);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    WebTransformationMatrix expectedChildTransform;
-    WebTransformationMatrix expectedGrandChildTransform;
-    expectedGrandChildTransform.translate(8, 6);
+    Transform expectedChildTransform;
+    Transform expectedGrandChildTransform;
+    expectedGrandChildTransform.PreconcatTranslate(8, 6);
 
-    WebTransformationMatrix expectedGreatGrandChildTransform = expectedGrandChildTransform;
+    Transform expectedGreatGrandChildTransform = expectedGrandChildTransform;
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 10
     child->setScrollDelta(gfx::Vector2d(10, 10));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the child and grandChild are affected by scrollDelta, but the fixed position greatGrandChild should not be affected.
-    expectedChildTransform.makeIdentity();
-    expectedChildTransform.translate(-10, -10);
-    expectedGrandChildTransform.makeIdentity();
-    expectedGrandChildTransform.translate(-2, -4);
+    expectedChildTransform.matrix().setIdentity();
+    expectedChildTransform.PreconcatTranslate(-10, -10);
+    expectedGrandChildTransform.matrix().setIdentity();
+    expectedGrandChildTransform.PreconcatTranslate(-2, -4);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithDistantContainerAndTransforms)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // is NOT the direct parent of the fixed-position layer, and the hierarchy has various
     // transforms that have to be processed in the correct order.
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests();
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
     LayerImpl* greatGrandChild = grandChild->children()[0];
 
-    WebTransformationMatrix rotationAboutZ;
-    rotationAboutZ.rotate3d(0, 0, 90);
+    Transform rotationAboutZ;
+    MathUtil::rotateEulerAngles(&rotationAboutZ, 0, 0, 90);
 
     child->setIsContainerForFixedPositionLayers(true);
     child->setTransform(rotationAboutZ);
     grandChild->setPosition(gfx::PointF(8, 6));
     grandChild->setTransform(rotationAboutZ);
     greatGrandChild->setFixedToContainerLayer(true); // greatGrandChild is positioned upside-down with respect to the renderTarget.
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    WebTransformationMatrix expectedChildTransform;
-    expectedChildTransform.multiply(rotationAboutZ);
+    Transform expectedChildTransform;
+    expectedChildTransform.PreconcatTransform(rotationAboutZ);
 
-    WebTransformationMatrix expectedGrandChildTransform;
-    expectedGrandChildTransform.multiply(rotationAboutZ); // child's local transform is inherited
-    expectedGrandChildTransform.translate(8, 6); // translation because of position occurs before layer's local transform.
-    expectedGrandChildTransform.multiply(rotationAboutZ); // grandChild's local transform
+    Transform expectedGrandChildTransform;
+    expectedGrandChildTransform.PreconcatTransform(rotationAboutZ); // child's local transform is inherited
+    expectedGrandChildTransform.PreconcatTranslate(8, 6); // translation because of position occurs before layer's local transform.
+    expectedGrandChildTransform.PreconcatTransform(rotationAboutZ); // grandChild's local transform
 
-    WebTransformationMatrix expectedGreatGrandChildTransform = expectedGrandChildTransform;
+    Transform expectedGreatGrandChildTransform = expectedGrandChildTransform;
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 20
     child->setScrollDelta(gfx::Vector2d(10, 20));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the child and grandChild are affected by scrollDelta, but the fixed position greatGrandChild should not be affected.
-    expectedChildTransform.makeIdentity();
-    expectedChildTransform.translate(-10, -20); // scrollDelta
-    expectedChildTransform.multiply(rotationAboutZ);
+    expectedChildTransform.matrix().setIdentity();
+    expectedChildTransform.PreconcatTranslate(-10, -20); // scrollDelta
+    expectedChildTransform.PreconcatTransform(rotationAboutZ);
 
-    expectedGrandChildTransform.makeIdentity();
-    expectedGrandChildTransform.translate(-10, -20); // child's scrollDelta is inherited
-    expectedGrandChildTransform.multiply(rotationAboutZ); // child's local transform is inherited
-    expectedGrandChildTransform.translate(8, 6); // translation because of position occurs before layer's local transform.
-    expectedGrandChildTransform.multiply(rotationAboutZ); // grandChild's local transform
+    expectedGrandChildTransform.matrix().setIdentity();
+    expectedGrandChildTransform.PreconcatTranslate(-10, -20); // child's scrollDelta is inherited
+    expectedGrandChildTransform.PreconcatTransform(rotationAboutZ); // child's local transform is inherited
+    expectedGrandChildTransform.PreconcatTranslate(8, 6); // translation because of position occurs before layer's local transform.
+    expectedGrandChildTransform.PreconcatTransform(rotationAboutZ); // grandChild's local transform
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithMultipleScrollDeltas)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // has multiple ancestors that have nonzero scrollDelta before reaching the space where the layer is fixed.
     // In this test, each scrollDelta occurs in a different space because of each layer's local transform.
     // This test checks for correct scroll compensation when the fixed-position container
     // is NOT the direct parent of the fixed-position layer, and the hierarchy has various
     // transforms that have to be processed in the correct order.
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests();
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
     LayerImpl* greatGrandChild = grandChild->children()[0];
 
-    WebTransformationMatrix rotationAboutZ;
-    rotationAboutZ.rotate3d(0, 0, 90);
+    Transform rotationAboutZ;
+    MathUtil::rotateEulerAngles(&rotationAboutZ, 0, 0, 90);
 
     child->setIsContainerForFixedPositionLayers(true);
     child->setTransform(rotationAboutZ);
     grandChild->setPosition(gfx::PointF(8, 6));
     grandChild->setTransform(rotationAboutZ);
     greatGrandChild->setFixedToContainerLayer(true); // greatGrandChild is positioned upside-down with respect to the renderTarget.
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    WebTransformationMatrix expectedChildTransform;
-    expectedChildTransform.multiply(rotationAboutZ);
+    Transform expectedChildTransform;
+    expectedChildTransform.PreconcatTransform(rotationAboutZ);
 
-    WebTransformationMatrix expectedGrandChildTransform;
-    expectedGrandChildTransform.multiply(rotationAboutZ); // child's local transform is inherited
-    expectedGrandChildTransform.translate(8, 6); // translation because of position occurs before layer's local transform.
-    expectedGrandChildTransform.multiply(rotationAboutZ); // grandChild's local transform
+    Transform expectedGrandChildTransform;
+    expectedGrandChildTransform.PreconcatTransform(rotationAboutZ); // child's local transform is inherited
+    expectedGrandChildTransform.PreconcatTranslate(8, 6); // translation because of position occurs before layer's local transform.
+    expectedGrandChildTransform.PreconcatTransform(rotationAboutZ); // grandChild's local transform
 
-    WebTransformationMatrix expectedGreatGrandChildTransform = expectedGrandChildTransform;
+    Transform expectedGreatGrandChildTransform = expectedGrandChildTransform;
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 20
     child->setScrollDelta(gfx::Vector2d(10, 0));
     grandChild->setScrollDelta(gfx::Vector2d(5, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the child and grandChild are affected by scrollDelta, but the fixed position greatGrandChild should not be affected.
-    expectedChildTransform.makeIdentity();
-    expectedChildTransform.translate(-10, 0); // scrollDelta
-    expectedChildTransform.multiply(rotationAboutZ);
+    expectedChildTransform.matrix().setIdentity();
+    expectedChildTransform.PreconcatTranslate(-10, 0); // scrollDelta
+    expectedChildTransform.PreconcatTransform(rotationAboutZ);
 
-    expectedGrandChildTransform.makeIdentity();
-    expectedGrandChildTransform.translate(-10, 0); // child's scrollDelta is inherited
-    expectedGrandChildTransform.multiply(rotationAboutZ); // child's local transform is inherited
-    expectedGrandChildTransform.translate(-5, 0); // grandChild's scrollDelta
-    expectedGrandChildTransform.translate(8, 6); // translation because of position occurs before layer's local transform.
-    expectedGrandChildTransform.multiply(rotationAboutZ); // grandChild's local transform
+    expectedGrandChildTransform.matrix().setIdentity();
+    expectedGrandChildTransform.PreconcatTranslate(-10, 0); // child's scrollDelta is inherited
+    expectedGrandChildTransform.PreconcatTransform(rotationAboutZ); // child's local transform is inherited
+    expectedGrandChildTransform.PreconcatTranslate(-5, 0); // grandChild's scrollDelta
+    expectedGrandChildTransform.PreconcatTranslate(8, 6); // translation because of position occurs before layer's local transform.
+    expectedGrandChildTransform.PreconcatTransform(rotationAboutZ); // grandChild's local transform
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithIntermediateSurfaceAndTransforms)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // contributes to a different renderSurface than the fixed-position layer. In this
     // case, the surface drawTransforms also have to be accounted for when checking the
     // scrollDelta.
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests();
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
     LayerImpl* greatGrandChild = grandChild->children()[0];
 
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setPosition(gfx::PointF(8, 6));
     grandChild->setForceRenderSurface(true);
     greatGrandChild->setFixedToContainerLayer(true);
     greatGrandChild->setDrawsContent(true);
 
-    WebTransformationMatrix rotationAboutZ;
-    rotationAboutZ.rotate3d(0, 0, 90);
+    Transform rotationAboutZ;
+    MathUtil::rotateEulerAngles(&rotationAboutZ, 0, 0, 90);
     grandChild->setTransform(rotationAboutZ);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    WebTransformationMatrix expectedChildTransform;
-    WebTransformationMatrix expectedSurfaceDrawTransform;
-    expectedSurfaceDrawTransform.translate(8, 6);
-    expectedSurfaceDrawTransform.multiply(rotationAboutZ);
-    WebTransformationMatrix expectedGrandChildTransform;
-    WebTransformationMatrix expectedGreatGrandChildTransform;
+    Transform expectedChildTransform;
+    Transform expectedSurfaceDrawTransform;
+    expectedSurfaceDrawTransform.PreconcatTranslate(8, 6);
+    expectedSurfaceDrawTransform.PreconcatTransform(rotationAboutZ);
+    Transform expectedGrandChildTransform;
+    Transform expectedGreatGrandChildTransform;
     ASSERT_TRUE(grandChild->renderSurface());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedSurfaceDrawTransform, grandChild->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 30
     child->setScrollDelta(gfx::Vector2d(10, 30));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the grandChild remains unchanged, because it scrolls along with the
     // renderSurface, and the translation is actually in the renderSurface. But, the fixed
     // position greatGrandChild is more awkward: its actually being drawn with respect to
     // the renderSurface, but it needs to remain fixed with resepct to a container beyond
     // that surface. So, the net result is that, unlike previous tests where the fixed
     // position layer's transform remains unchanged, here the fixed position layer's
     // transform explicitly contains the translation that cancels out the scroll.
-    expectedChildTransform.makeIdentity();
-    expectedChildTransform.translate(-10, -30); // scrollDelta
+    expectedChildTransform.matrix().setIdentity();
+    expectedChildTransform.PreconcatTranslate(-10, -30); // scrollDelta
 
-    expectedSurfaceDrawTransform.makeIdentity();
-    expectedSurfaceDrawTransform.translate(-10, -30); // scrollDelta
-    expectedSurfaceDrawTransform.translate(8, 6);
-    expectedSurfaceDrawTransform.multiply(rotationAboutZ);
+    expectedSurfaceDrawTransform.matrix().setIdentity();
+    expectedSurfaceDrawTransform.PreconcatTranslate(-10, -30); // scrollDelta
+    expectedSurfaceDrawTransform.PreconcatTranslate(8, 6);
+    expectedSurfaceDrawTransform.PreconcatTransform(rotationAboutZ);
 
     // The rotation and its inverse are needed to place the scrollDelta compensation in
     // the correct space. This test will fail if the rotation/inverse are backwards, too,
     // so it requires perfect order of operations.
-    expectedGreatGrandChildTransform.makeIdentity();
-    expectedGreatGrandChildTransform.multiply(rotationAboutZ.inverse());
-    expectedGreatGrandChildTransform.translate(10, 30); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface.
-    expectedGreatGrandChildTransform.multiply(rotationAboutZ);
+    expectedGreatGrandChildTransform.matrix().setIdentity();
+    expectedGreatGrandChildTransform.PreconcatTransform(MathUtil::inverse(rotationAboutZ));
+    expectedGreatGrandChildTransform.PreconcatTranslate(10, 30); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface.
+    expectedGreatGrandChildTransform.PreconcatTransform(rotationAboutZ);
 
     ASSERT_TRUE(grandChild->renderSurface());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedSurfaceDrawTransform, grandChild->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithMultipleIntermediateSurfaces)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // contributes to a different renderSurface than the fixed-position layer, with
     // additional renderSurfaces in-between. This checks that the conversion to ancestor
     // surfaces is accumulated properly in the final matrix transform.
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests();
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
     LayerImpl* greatGrandChild = grandChild->children()[0];
 
     // Add one more layer to the test tree for this scenario.
     {
-        WebTransformationMatrix identity;
+        Transform identity;
         scoped_ptr<LayerImpl> fixedPositionChild = LayerImpl::create(5);
         setLayerPropertiesForTesting(fixedPositionChild.get(), identity, identity, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
         greatGrandChild->addChild(fixedPositionChild.Pass());
     }
     LayerImpl* fixedPositionChild = greatGrandChild->children()[0];
 
     // Actually set up the scenario here.
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setPosition(gfx::PointF(8, 6));
     grandChild->setForceRenderSurface(true);
     greatGrandChild->setPosition(gfx::PointF(40, 60));
     greatGrandChild->setForceRenderSurface(true);
     fixedPositionChild->setFixedToContainerLayer(true);
     fixedPositionChild->setDrawsContent(true);
 
     // The additional rotations, which are non-commutative with translations, help to
     // verify that we have correct order-of-operations in the final scroll compensation.
     // Note that rotating about the center of the layer ensures we do not accidentally
     // clip away layers that we want to test.
-    WebTransformationMatrix rotationAboutZ;
-    rotationAboutZ.translate(50, 50);
-    rotationAboutZ.rotate3d(0, 0, 90);
-    rotationAboutZ.translate(-50, -50);
+    Transform rotationAboutZ;
+    rotationAboutZ.PreconcatTranslate(50, 50);
+    MathUtil::rotateEulerAngles(&rotationAboutZ, 0, 0, 90);
+    rotationAboutZ.PreconcatTranslate(-50, -50);
     grandChild->setTransform(rotationAboutZ);
     greatGrandChild->setTransform(rotationAboutZ);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    WebTransformationMatrix expectedChildTransform;
+    Transform expectedChildTransform;
 
-    WebTransformationMatrix expectedGrandChildSurfaceDrawTransform;
-    expectedGrandChildSurfaceDrawTransform.translate(8, 6);
-    expectedGrandChildSurfaceDrawTransform.multiply(rotationAboutZ);
+    Transform expectedGrandChildSurfaceDrawTransform;
+    expectedGrandChildSurfaceDrawTransform.PreconcatTranslate(8, 6);
+    expectedGrandChildSurfaceDrawTransform.PreconcatTransform(rotationAboutZ);
 
-    WebTransformationMatrix expectedGrandChildTransform;
+    Transform expectedGrandChildTransform;
 
-    WebTransformationMatrix expectedGreatGrandChildSurfaceDrawTransform;
-    expectedGreatGrandChildSurfaceDrawTransform.translate(40, 60);
-    expectedGreatGrandChildSurfaceDrawTransform.multiply(rotationAboutZ);
+    Transform expectedGreatGrandChildSurfaceDrawTransform;
+    expectedGreatGrandChildSurfaceDrawTransform.PreconcatTranslate(40, 60);
+    expectedGreatGrandChildSurfaceDrawTransform.PreconcatTransform(rotationAboutZ);
 
-    WebTransformationMatrix expectedGreatGrandChildTransform;
+    Transform expectedGreatGrandChildTransform;
 
-    WebTransformationMatrix expectedFixedPositionChildTransform;
+    Transform expectedFixedPositionChildTransform;
 
     ASSERT_TRUE(grandChild->renderSurface());
     ASSERT_TRUE(greatGrandChild->renderSurface());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildSurfaceDrawTransform, grandChild->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildSurfaceDrawTransform, greatGrandChild->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedFixedPositionChildTransform, fixedPositionChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 30
     child->setScrollDelta(gfx::Vector2d(10, 30));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    expectedChildTransform.makeIdentity();
-    expectedChildTransform.translate(-10, -30); // scrollDelta
+    expectedChildTransform.matrix().setIdentity();
+    expectedChildTransform.PreconcatTranslate(-10, -30); // scrollDelta
 
-    expectedGrandChildSurfaceDrawTransform.makeIdentity();
-    expectedGrandChildSurfaceDrawTransform.translate(-10, -30); // scrollDelta
-    expectedGrandChildSurfaceDrawTransform.translate(8, 6);
-    expectedGrandChildSurfaceDrawTransform.multiply(rotationAboutZ);
+    expectedGrandChildSurfaceDrawTransform.matrix().setIdentity();
+    expectedGrandChildSurfaceDrawTransform.PreconcatTranslate(-10, -30); // scrollDelta
+    expectedGrandChildSurfaceDrawTransform.PreconcatTranslate(8, 6);
+    expectedGrandChildSurfaceDrawTransform.PreconcatTransform(rotationAboutZ);
 
     // grandChild, greatGrandChild, and greatGrandChild's surface are not expected to
     // change, since they are all not fixed, and they are all drawn with respect to
     // grandChild's surface that already has the scrollDelta accounted for.
 
     // But the great-great grandchild, "fixedPositionChild", should have a transform that explicitly cancels out the scrollDelta.
     // The expected transform is:
     //   compoundDrawTransform.inverse() * translate(positive scrollDelta) * compoundOriginTransform
-    WebTransformationMatrix compoundDrawTransform; // transform from greatGrandChildSurface's origin to the root surface.
-    compoundDrawTransform.translate(8, 6); // origin translation of grandChild
-    compoundDrawTransform.multiply(rotationAboutZ); // rotation of grandChild
-    compoundDrawTransform.translate(40, 60); // origin translation of greatGrandChild
-    compoundDrawTransform.multiply(rotationAboutZ); // rotation of greatGrandChild
+    Transform compoundDrawTransform; // transform from greatGrandChildSurface's origin to the root surface.
+    compoundDrawTransform.PreconcatTranslate(8, 6); // origin translation of grandChild
+    compoundDrawTransform.PreconcatTransform(rotationAboutZ); // rotation of grandChild
+    compoundDrawTransform.PreconcatTranslate(40, 60); // origin translation of greatGrandChild
+    compoundDrawTransform.PreconcatTransform(rotationAboutZ); // rotation of greatGrandChild
 
-    expectedFixedPositionChildTransform.makeIdentity();
-    expectedFixedPositionChildTransform.multiply(compoundDrawTransform.inverse());
-    expectedFixedPositionChildTransform.translate(10, 30); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface.
-    expectedFixedPositionChildTransform.multiply(compoundDrawTransform);
+    expectedFixedPositionChildTransform.matrix().setIdentity();
+    expectedFixedPositionChildTransform.PreconcatTransform(MathUtil::inverse(compoundDrawTransform));
+    expectedFixedPositionChildTransform.PreconcatTranslate(10, 30); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface.
+    expectedFixedPositionChildTransform.PreconcatTransform(compoundDrawTransform);
 
     ASSERT_TRUE(grandChild->renderSurface());
     ASSERT_TRUE(greatGrandChild->renderSurface());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildSurfaceDrawTransform, grandChild->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildSurfaceDrawTransform, greatGrandChild->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedFixedPositionChildTransform, fixedPositionChild->drawTransform());
 }
@@ skipping 10 matching lines @@
 
     child->setIsContainerForFixedPositionLayers(true);
     child->setForceRenderSurface(true);
     grandChild->setFixedToContainerLayer(true);
     grandChild->setDrawsContent(true);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    WebTransformationMatrix expectedSurfaceDrawTransform;
-    expectedSurfaceDrawTransform.translate(0, 0);
-    WebTransformationMatrix expectedChildTransform;
-    WebTransformationMatrix expectedGrandChildTransform;
+    Transform expectedSurfaceDrawTransform;
+    expectedSurfaceDrawTransform.PreconcatTranslate(0, 0);
+    Transform expectedChildTransform;
+    Transform expectedGrandChildTransform;
     ASSERT_TRUE(child->renderSurface());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedSurfaceDrawTransform, child->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 10
     child->setScrollDelta(gfx::Vector2d(10, 10));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // The surface is translated by scrollDelta, the child transform doesn't change
     // because it scrolls along with the surface, but the fixed position grandChild
     // needs to compensate for the scroll translation.
-    expectedSurfaceDrawTransform.makeIdentity();
-    expectedSurfaceDrawTransform.translate(-10, -10);
-    expectedGrandChildTransform.makeIdentity();
-    expectedGrandChildTransform.translate(10, 10);
+    expectedSurfaceDrawTransform.matrix().setIdentity();
+    expectedSurfaceDrawTransform.PreconcatTranslate(-10, -10);
+    expectedGrandChildTransform.matrix().setIdentity();
+    expectedGrandChildTransform.PreconcatTranslate(10, 10);
 
     ASSERT_TRUE(child->renderSurface());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedSurfaceDrawTransform, child->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatIsAlsoFixedPositionContainer)
 {
     // This test checks the scenario where a fixed-position layer also happens to be a
     // container itself for a descendant fixed position layer. In particular, the layer
     // should not accidentally be fixed to itself.
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests();
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
 
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setFixedToContainerLayer(true);
 
     // This should not confuse the grandChild. If correct, the grandChild would still be considered fixed to its container (i.e. "child").
     grandChild->setIsContainerForFixedPositionLayers(true);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    WebTransformationMatrix expectedChildTransform;
-    WebTransformationMatrix expectedGrandChildTransform;
+    Transform expectedChildTransform;
+    Transform expectedGrandChildTransform;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 
     // Case 2: scrollDelta of 10, 10
     child->setScrollDelta(gfx::Vector2d(10, 10));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // Here the child is affected by scrollDelta, but the fixed position grandChild should not be affected.
-    expectedChildTransform.makeIdentity();
-    expectedChildTransform.translate(-10, -10);
+    expectedChildTransform.matrix().setIdentity();
+    expectedChildTransform.PreconcatTranslate(-10, -10);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatHasNoContainer)
 {
     // This test checks scroll compensation when a fixed-position layer does not find any
     // ancestor that is a "containerForFixedPositionLayers". In this situation, the layer should
     // be fixed to the viewport -- not the rootLayer, which may have transforms of its own.
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests();
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
 
-    WebTransformationMatrix rotationByZ;
-    rotationByZ.rotate3d(0, 0, 90);
+    Transform rotationByZ;
+    MathUtil::rotateEulerAngles(&rotationByZ, 0, 0, 90);
 
     root->setTransform(rotationByZ);
     grandChild->setFixedToContainerLayer(true);
 
     // Case 1: root scrollDelta of 0, 0
     root->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->drawTransform());
 
     // Case 2: root scrollDelta of 10, 10
     root->setScrollDelta(gfx::Vector2d(10, 20));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     // The child is affected by scrollDelta, but it is already implcitly accounted for by
     // the child's target surface (i.e. the root renderSurface). The grandChild is not
     // affected by the scrollDelta, so its drawTransform needs to explicitly
     // inverse-compensate for the scroll that's embedded in the target surface.
-    WebTransformationMatrix expectedGrandChildTransform;
-    expectedGrandChildTransform.multiply(rotationByZ.inverse());
-    expectedGrandChildTransform.translate(10, 20); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface.
-    expectedGrandChildTransform.multiply(rotationByZ);
+    Transform expectedGrandChildTransform;
+    expectedGrandChildTransform.PreconcatTransform(MathUtil::inverse(rotationByZ));
+    expectedGrandChildTransform.PreconcatTranslate(10, 20); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface.
+    expectedGrandChildTransform.PreconcatTransform(rotationByZ);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyClipRectCullsRenderSurfaces)
 {
     // The entire subtree of layers that are outside the clipRect should be culled away,
     // and should not affect the renderSurfaceLayerList.
     //
     // The test tree is set up as follows:
     //  - all layers except the leafNodes are forced to be a new renderSurface that have something to draw.
     //  - parent is a large container layer.
     //  - child has masksToBounds=true to cause clipping.
     //  - grandChild is positioned outside of the child's bounds
     //  - greatGrandChild is also kept outside child's bounds.
     //
     // In this configuration, grandChild and greatGrandChild are completely outside the
     // clipRect, and they should never get scheduled on the list of renderSurfaces.
     //
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<Layer> grandChild = Layer::create();
     scoped_refptr<Layer> greatGrandChild = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> leafNode1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> leafNode2 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     parent->addChild(child);
     child->addChild(grandChild);
     grandChild->addChild(greatGrandChild);
 
@@ skipping 34 matching lines @@
     //  - parent is a container layer that masksToBounds=true to cause clipping.
     //  - child is a renderSurface, which has a clipRect set to the bounds of the parent.
     //  - grandChild is a renderSurface, and the only visible content in child. It is positioned outside of the clipRect from parent.
 
     // In this configuration, grandChild should be outside the clipped
     // contentRect of the child, making grandChild not appear in the
     // renderSurfaceLayerList. However, when we place an animation on the child,
     // this clipping should be avoided and we should keep the grandChild
     // in the renderSurfaceLayerList.
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<Layer> grandChild = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> leafNode = make_scoped_refptr(new LayerWithForcedDrawsContent());
     parent->addChild(child);
     child->addChild(grandChild);
     grandChild->addChild(leafNode);
 
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(20, 20), false);
@@ skipping 37 matching lines @@
     //    renderTarget,
     //  - a surface is clipped by an ancestor that contributes to the same
     //    renderTarget.
     //
     // In particular, for a layer that owns a renderSurface:
     //  - the renderSurfarce inherits any clip from ancestors, and does NOT
     //    pass that clipped status to the layer itself.
     //  - but if the layer itself masks to bounds, it is considered clipped
     //    and propagates the clip to the subtree.
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child1 = Layer::create();
     scoped_refptr<Layer> child2 = Layer::create();
     scoped_refptr<Layer> grandChild = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> leafNode1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> leafNode2 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     root->addChild(parent);
     parent->addChild(child1);
     parent->addChild(child2);
@@ skipping 74 matching lines @@
 TEST(LayerTreeHostCommonTest, verifyDrawableContentRectForLayers)
 {
     // Verify that layers get the appropriate drawableContentRect when their parent masksToBounds is true.
     //
     //   grandChild1 - completely inside the region; drawableContentRect should be the layer rect expressed in target space.
     //   grandChild2 - partially clipped but NOT masksToBounds; the clipRect will be the intersection of layerBounds and the mask region.
     //   grandChild3 - partially clipped and masksToBounds; the drawableContentRect will still be the intersection of layerBounds and the mask region.
     //   grandChild4 - outside parent's clipRect; the drawableContentRect should be empty.
     //
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<Layer> grandChild1 = Layer::create();
     scoped_refptr<Layer> grandChild2 = Layer::create();
     scoped_refptr<Layer> grandChild3 = Layer::create();
     scoped_refptr<Layer> grandChild4 = Layer::create();
 
     parent->addChild(child);
     child->addChild(grandChild1);
     child->addChild(grandChild2);
@@ skipping 29 matching lines @@
 
 TEST(LayerTreeHostCommonTest, verifyClipRectIsPropagatedCorrectlyToSurfaces)
 {
     // Verify that renderSurfaces (and their layers) get the appropriate clipRects when their parent masksToBounds is true.
     //
     // Layers that own renderSurfaces (at least for now) do not inherit any clipping;
     // instead the surface will enforce the clip for the entire subtree. They may still
     // have a clipRect of their own layer bounds, however, if masksToBounds was true.
     //
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<Layer> grandChild1 = Layer::create();
     scoped_refptr<Layer> grandChild2 = Layer::create();
     scoped_refptr<Layer> grandChild3 = Layer::create();
     scoped_refptr<Layer> grandChild4 = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> leafNode1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> leafNode2 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> leafNode3 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> leafNode4 = make_scoped_refptr(new LayerWithForcedDrawsContent());
@@ skipping 70 matching lines @@
     // Make our render surfaces.
     renderSurface1->setForceRenderSurface(true);
     renderSurface2->setForceRenderSurface(true);
 
     // Put an animated opacity on the render surface.
     addOpacityTransitionToController(*renderSurface1->layerAnimationController(), 10, 1, 0, false);
 
     // Also put an animated opacity on a layer without descendants.
     addOpacityTransitionToController(*grandChildOfRoot->layerAnimationController(), 10, 1, 0, false);
 
-    WebTransformationMatrix layerTransform;
-    layerTransform.translate(1, 1);
-    WebTransformationMatrix sublayerTransform;
-    sublayerTransform.scale3d(10, 1, 1);
+    Transform layerTransform;
+    layerTransform.PreconcatTranslate(1, 1);
+    Transform sublayerTransform;
+    sublayerTransform.PreconcatScale3d(10, 1, 1);
 
     // Put a transform animation on the render surface.
     addAnimatedTransformToController(*renderSurface2->layerAnimationController(), 10, 30, 0);
 
     // Also put transform animations on grandChildOfRoot, and grandChildOfRS2
     addAnimatedTransformToController(*grandChildOfRoot->layerAnimationController(), 10, 30, 0);
     addAnimatedTransformToController(*grandChildOfRS2->layerAnimationController(), 10, 30, 0);
 
     setLayerPropertiesForTesting(parent.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(2.5, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(renderSurface1.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(2.5, 0), gfx::Size(10, 10), false);
@@ skipping 74 matching lines @@
     EXPECT_FALSE(grandChildOfRS1->screenSpaceTransformIsAnimating());
     EXPECT_TRUE(renderSurface2->screenSpaceTransformIsAnimating());
     EXPECT_TRUE(renderSurface2->renderSurface()->screenSpaceTransformsAreAnimating());
     EXPECT_TRUE(childOfRS2->screenSpaceTransformIsAnimating());
     EXPECT_TRUE(grandChildOfRS2->screenSpaceTransformIsAnimating());
 
 
     // Sanity check. If these fail there is probably a bug in the test itself.
     // It is expected that we correctly set up transforms so that the y-component of the screen-space transform
     // encodes the "depth" of the layer in the tree.
-    EXPECT_FLOAT_EQ(1, parent->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(2, childOfRoot->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(3, grandChildOfRoot->screenSpaceTransform().m42());
+    EXPECT_FLOAT_EQ(1, parent->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(2, childOfRoot->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(3, grandChildOfRoot->screenSpaceTransform().matrix().getDouble(1, 3));
 
-    EXPECT_FLOAT_EQ(2, renderSurface1->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(3, childOfRS1->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(4, grandChildOfRS1->screenSpaceTransform().m42());
+    EXPECT_FLOAT_EQ(2, renderSurface1->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(3, childOfRS1->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(4, grandChildOfRS1->screenSpaceTransform().matrix().getDouble(1, 3));
 
-    EXPECT_FLOAT_EQ(3, renderSurface2->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(4, childOfRS2->screenSpaceTransform().m42());
-    EXPECT_FLOAT_EQ(5, grandChildOfRS2->screenSpaceTransform().m42());
+    EXPECT_FLOAT_EQ(3, renderSurface2->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(4, childOfRS2->screenSpaceTransform().matrix().getDouble(1, 3));
+    EXPECT_FLOAT_EQ(5, grandChildOfRS2->screenSpaceTransform().matrix().getDouble(1, 3));
 }
 
 TEST(LayerTreeHostCommonTest, verifyVisibleRectForIdentityTransform)
 {
     // Test the calculateVisibleRect() function works correctly for identity transforms.
 
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
-    WebTransformationMatrix layerToSurfaceTransform;
+    Transform layerToSurfaceTransform;
 
     // Case 1: Layer is contained within the surface.
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(10, 10), gfx::Size(30, 30));
     gfx::Rect expected = gfx::Rect(gfx::Point(10, 10), gfx::Size(30, 30));
     gfx::Rect actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 
     // Case 2: Layer is outside the surface rect.
     layerContentRect = gfx::Rect(gfx::Point(120, 120), gfx::Size(30, 30));
     actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_TRUE(actual.IsEmpty());
 
     // Case 3: Layer is partially overlapping the surface rect.
     layerContentRect = gfx::Rect(gfx::Point(80, 80), gfx::Size(30, 30));
     expected = gfx::Rect(gfx::Point(80, 80), gfx::Size(20, 20));
     actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, verifyVisibleRectForTranslations)
 {
     // Test the calculateVisibleRect() function works correctly for scaling transforms.
 
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(30, 30));
-    WebTransformationMatrix layerToSurfaceTransform;
+    Transform layerToSurfaceTransform;
 
     // Case 1: Layer is contained within the surface.
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.translate(10, 10);
+    layerToSurfaceTransform.matrix().setIdentity();
+    layerToSurfaceTransform.PreconcatTranslate(10, 10);
     gfx::Rect expected = gfx::Rect(gfx::Point(0, 0), gfx::Size(30, 30));
     gfx::Rect actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 
     // Case 2: Layer is outside the surface rect.
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.translate(120, 120);
+    layerToSurfaceTransform.matrix().setIdentity();
+    layerToSurfaceTransform.PreconcatTranslate(120, 120);
     actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_TRUE(actual.IsEmpty());
 
     // Case 3: Layer is partially overlapping the surface rect.
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.translate(80, 80);
+    layerToSurfaceTransform.matrix().setIdentity();
+    layerToSurfaceTransform.PreconcatTranslate(80, 80);
     expected = gfx::Rect(gfx::Point(0, 0), gfx::Size(20, 20));
     actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, verifyVisibleRectFor2DRotations)
 {
     // Test the calculateVisibleRect() function works correctly for rotations about z-axis (i.e. 2D rotations).
     // Remember that calculateVisibleRect() should return the visible rect in the layer's space.
 
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(30, 30));
-    WebTransformationMatrix layerToSurfaceTransform;
+    Transform layerToSurfaceTransform;
 
     // Case 1: Layer is contained within the surface.
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.translate(50, 50);
-    layerToSurfaceTransform.rotate(45);
+    layerToSurfaceTransform.matrix().setIdentity();
+    layerToSurfaceTransform.PreconcatTranslate(50, 50);
+    layerToSurfaceTransform.PreconcatRotate(45);
     gfx::Rect expected = gfx::Rect(gfx::Point(0, 0), gfx::Size(30, 30));
     gfx::Rect actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 
     // Case 2: Layer is outside the surface rect.
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.translate(-50, 0);
-    layerToSurfaceTransform.rotate(45);
+    layerToSurfaceTransform.matrix().setIdentity();
+    layerToSurfaceTransform.PreconcatTranslate(-50, 0);
+    layerToSurfaceTransform.PreconcatRotate(45);
     actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_TRUE(actual.IsEmpty());
 
     // Case 3: The layer is rotated about its top-left corner. In surface space, the layer
     //         is oriented diagonally, with the left half outside of the renderSurface. In
     //         this case, the visible rect should still be the entire layer (remember the
     //         visible rect is computed in layer space); both the top-left and
     //         bottom-right corners of the layer are still visible.
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.rotate(45);
+    layerToSurfaceTransform.matrix().setIdentity();
+    layerToSurfaceTransform.PreconcatRotate(45);
     expected = gfx::Rect(gfx::Point(0, 0), gfx::Size(30, 30));
     actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 
     // Case 4: The layer is rotated about its top-left corner, and translated upwards. In
     //         surface space, the layer is oriented diagonally, with only the top corner
     //         of the surface overlapping the layer. In layer space, the render surface
     //         overlaps the right side of the layer. The visible rect should be the
     //         layer's right half.
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.translate(0, -sqrt(2.0) * 15);
-    layerToSurfaceTransform.rotate(45);
+    layerToSurfaceTransform.matrix().setIdentity();
+    layerToSurfaceTransform.PreconcatTranslate(0, -sqrt(2.0) * 15);
+    layerToSurfaceTransform.PreconcatRotate(45);
     expected = gfx::Rect(gfx::Point(15, 0), gfx::Size(15, 30)); // right half of layer bounds.
     actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, verifyVisibleRectFor3dOrthographicTransform)
 {
     // Test that the calculateVisibleRect() function works correctly for 3d transforms.
 
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
-    WebTransformationMatrix layerToSurfaceTransform;
+    Transform layerToSurfaceTransform;
 
     // Case 1: Orthographic projection of a layer rotated about y-axis by 45 degrees, should be fully contained in the renderSurface.
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.rotate3d(0, 45, 0);
+    layerToSurfaceTransform.matrix().setIdentity();
+    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 0, 45, 0);
     gfx::Rect expected = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Rect actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 
     // Case 2: Orthographic projection of a layer rotated about y-axis by 45 degrees, but
     //         shifted to the side so only the right-half the layer would be visible on
     //         the surface.
     double halfWidthOfRotatedLayer = (100 / sqrt(2.0)) * 0.5; // 100 is the un-rotated layer width; divided by sqrt(2) is the rotated width.
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.translate(-halfWidthOfRotatedLayer, 0);
-    layerToSurfaceTransform.rotate3d(0, 45, 0); // rotates about the left edge of the layer
+    layerToSurfaceTransform.matrix().setIdentity();
+    layerToSurfaceTransform.PreconcatTranslate(-halfWidthOfRotatedLayer, 0);
+    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 0, 45, 0); // rotates about the left edge of the layer
     expected = gfx::Rect(gfx::Point(50, 0), gfx::Size(50, 100)); // right half of the layer.
     actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, verifyVisibleRectFor3dPerspectiveTransform)
 {
     // Test the calculateVisibleRect() function works correctly when the layer has a
     // perspective projection onto the target surface.
 
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(-50, -50), gfx::Size(200, 200));
-    WebTransformationMatrix layerToSurfaceTransform;
+    Transform layerToSurfaceTransform;
 
     // Case 1: Even though the layer is twice as large as the surface, due to perspective
     //         foreshortening, the layer will fit fully in the surface when its translated
     //         more than the perspective amount.
-    layerToSurfaceTransform.makeIdentity();
+    layerToSurfaceTransform.matrix().setIdentity();
 
     // The following sequence of transforms applies the perspective about the center of the surface.
-    layerToSurfaceTransform.translate(50, 50);
-    layerToSurfaceTransform.applyPerspective(9);
-    layerToSurfaceTransform.translate(-50, -50);
+    layerToSurfaceTransform.PreconcatTranslate(50, 50);
+    layerToSurfaceTransform.PreconcatPerspectiveDepth(9);
+    layerToSurfaceTransform.PreconcatTranslate(-50, -50);
 
     // This translate places the layer in front of the surface's projection plane.
-    layerToSurfaceTransform.translate3d(0, 0, -27);
+    layerToSurfaceTransform.PreconcatTranslate3d(0, 0, -27);
 
     gfx::Rect expected = gfx::Rect(gfx::Point(-50, -50), gfx::Size(200, 200));
     gfx::Rect actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 
     // Case 2: same projection as before, except that the layer is also translated to the
     //         side, so that only the right half of the layer should be visible.
     //
     // Explanation of expected result:
     // The perspective ratio is (z distance between layer and camera origin) / (z distance between projection plane and camera origin) == ((-27 - 9) / 9)
     // Then, by similar triangles, if we want to move a layer by translating -50 units in projected surface units (so that only half of it is
     // visible), then we would need to translate by (-36 / 9) * -50 == -200 in the layer's units.
     //
-    layerToSurfaceTransform.translate3d(-200, 0, 0);
+    layerToSurfaceTransform.PreconcatTranslate3d(-200, 0, 0);
     expected = gfx::Rect(gfx::Point(50, -50), gfx::Size(100, 200)); // The right half of the layer's bounding rect.
     actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, verifyVisibleRectFor3dOrthographicIsNotClippedBehindSurface)
 {
     // There is currently no explicit concept of an orthographic projection plane in our
     // code (nor in the CSS spec to my knowledge). Therefore, layers that are technically
     // behind the surface in an orthographic world should not be clipped when they are
     // flattened to the surface.
 
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
-    WebTransformationMatrix layerToSurfaceTransform;
+    Transform layerToSurfaceTransform;
 
     // This sequence of transforms effectively rotates the layer about the y-axis at the
     // center of the layer.
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.translate(50, 0);
-    layerToSurfaceTransform.rotate3d(0, 45, 0);
-    layerToSurfaceTransform.translate(-50, 0);
+    layerToSurfaceTransform.matrix().setIdentity();
+    layerToSurfaceTransform.PreconcatTranslate(50, 0);
+    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 0, 45, 0);
+    layerToSurfaceTransform.PreconcatTranslate(-50, 0);
 
     gfx::Rect expected = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Rect actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, verifyVisibleRectFor3dPerspectiveWhenClippedByW)
 {
     // Test the calculateVisibleRect() function works correctly when projecting a surface
     // onto a layer, but the layer is partially behind the camera (not just behind the
     // projection plane). In this case, the cartesian coordinates may seem to be valid,
     // but actually they are not. The visibleRect needs to be properly clipped by the
     // w = 0 plane in homogeneous coordinates before converting to cartesian coordinates.
 
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(-50, -50), gfx::Size(100, 100));
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(-10, -1), gfx::Size(20, 2));
-    WebTransformationMatrix layerToSurfaceTransform;
+    Transform layerToSurfaceTransform;
 
     // The layer is positioned so that the right half of the layer should be in front of
     // the camera, while the other half is behind the surface's projection plane. The
     // following sequence of transforms applies the perspective and rotation about the
     // center of the layer.
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.applyPerspective(1);
-    layerToSurfaceTransform.translate3d(-2, 0, 1);
-    layerToSurfaceTransform.rotate3d(0, 45, 0);
+    layerToSurfaceTransform.matrix().setIdentity();
+    layerToSurfaceTransform.PreconcatPerspectiveDepth(1);
+    layerToSurfaceTransform.PreconcatTranslate3d(-2, 0, 1);
+    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 0, 45, 0);
 
     // Sanity check that this transform does indeed cause w < 0 when applying the
     // transform, otherwise this code is not testing the intended scenario.
     bool clipped = false;
     MathUtil::mapQuad(layerToSurfaceTransform, gfx::QuadF(gfx::RectF(layerContentRect)), clipped);
     ASSERT_TRUE(clipped);
 
     int expectedXPosition = 0;
     int expectedWidth = 10;
     gfx::Rect actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_EQ(expectedXPosition, actual.x());
     EXPECT_EQ(expectedWidth, actual.width());
 }
 
 TEST(LayerTreeHostCommonTest, verifyVisibleRectForPerspectiveUnprojection)
 {
     // To determine visibleRect in layer space, there needs to be an un-projection from
     // surface space to layer space. When the original transform was a perspective
     // projection that was clipped, it returns a rect that encloses the clipped bounds.
     // Un-projecting this new rect may require clipping again.
 
     // This sequence of transforms causes one corner of the layer to protrude across the w = 0 plane, and should be clipped.
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(-50, -50), gfx::Size(100, 100));
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(-10, -10), gfx::Size(20, 20));
-    WebTransformationMatrix layerToSurfaceTransform;
-    layerToSurfaceTransform.makeIdentity();
-    layerToSurfaceTransform.applyPerspective(1);
-    layerToSurfaceTransform.translate3d(0, 0, -5);
-    layerToSurfaceTransform.rotate3d(0, 45, 0);
-    layerToSurfaceTransform.rotate3d(80, 0, 0);
+    Transform layerToSurfaceTransform;
+    layerToSurfaceTransform.matrix().setIdentity();
+    layerToSurfaceTransform.PreconcatPerspectiveDepth(1);
+    layerToSurfaceTransform.PreconcatTranslate3d(0, 0, -5);
+    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 0, 45, 0);
+    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 80, 0, 0);
 
     // Sanity check that un-projection does indeed cause w < 0, otherwise this code is not
     // testing the intended scenario.
     bool clipped = false;
     gfx::RectF clippedRect = MathUtil::mapClippedRect(layerToSurfaceTransform, layerContentRect);
-    MathUtil::projectQuad(layerToSurfaceTransform.inverse(), gfx::QuadF(clippedRect), clipped);
+    MathUtil::projectQuad(MathUtil::inverse(layerToSurfaceTransform), gfx::QuadF(clippedRect), clipped);
     ASSERT_TRUE(clipped);
 
     // Only the corner of the layer is not visible on the surface because of being
     // clipped. But, the net result of rounding visible region to an axis-aligned rect is
     // that the entire layer should still be considered visible.
     gfx::Rect expected = gfx::Rect(gfx::Point(-10, -10), gfx::Size(20, 20));
     gfx::Rect actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, verifyDrawableAndVisibleContentRectsForSimpleLayers)
 {
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> child1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> child2 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> child3 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     root->addChild(child1);
     root->addChild(child2);
     root->addChild(child3);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(75, 75), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(child3.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(125, 125), gfx::Size(50, 50), false);
 
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawableContentRect());
 
@@ skipping 16 matching lines @@
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> grandChild1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> grandChild2 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> grandChild3 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     root->addChild(child);
     child->addChild(grandChild1);
     child->addChild(grandChild2);
     child->addChild(grandChild3);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(grandChild1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(5, 5), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(grandChild2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(75, 75), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(grandChild3.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(125, 125), gfx::Size(50, 50), false);
 
     child->setMasksToBounds(true);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     ASSERT_FALSE(child->renderSurface());
@@ skipping 21 matching lines @@
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> renderSurface1 = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> child1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> child2 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> child3 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     root->addChild(renderSurface1);
     renderSurface1->addChild(child1);
     renderSurface1->addChild(child2);
     renderSurface1->addChild(child3);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(3, 4), false);
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(5, 5), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(75, 75), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(child3.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(125, 125), gfx::Size(50, 50), false);
 
     renderSurface1->setForceRenderSurface(true);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     ASSERT_TRUE(renderSurface1->renderSurface());
@@ skipping 23 matching lines @@
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> renderSurface1 = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> child1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> child2 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> child3 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     root->addChild(renderSurface1);
     renderSurface1->addChild(child1);
     renderSurface1->addChild(child2);
     renderSurface1->addChild(child3);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(3, 4), false);
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(5, 5), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(75, 75), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(child3.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(125, 125), gfx::Size(50, 50), false);
 
     root->setMasksToBounds(true);
     renderSurface1->setForceRenderSurface(true);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
@@ skipping 29 matching lines @@
     scoped_refptr<Layer> renderSurface2 = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> child1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> child2 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> child3 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     root->addChild(renderSurface1);
     renderSurface1->addChild(renderSurface2);
     renderSurface2->addChild(child1);
     renderSurface2->addChild(child2);
     renderSurface2->addChild(child3);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(3, 4), false);
     setLayerPropertiesForTesting(renderSurface2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(7, 13), false);
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(5, 5), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(75, 75), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(child3.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(125, 125), gfx::Size(50, 50), false);
 
     root->setMasksToBounds(true);
     renderSurface1->setForceRenderSurface(true);
     renderSurface2->setForceRenderSurface(true);
@@ skipping 34 matching lines @@
 {
     // Layers that have non-axis aligned bounds (due to transforms) have an expanded,
     // axis-aligned drawableContentRect and visibleContentRect.
 
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> renderSurface1 = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> child1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     root->addChild(renderSurface1);
     renderSurface1->addChild(child1);
 
-    WebTransformationMatrix identityMatrix;
-    WebTransformationMatrix childRotation;
-    childRotation.rotate(45);
+    Transform identityMatrix;
+    Transform childRotation;
+    childRotation.PreconcatRotate(45);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(3, 4), false);
     setLayerPropertiesForTesting(child1.get(), childRotation, identityMatrix, gfx::PointF(0.5, 0.5), gfx::PointF(25, 25), gfx::Size(50, 50), false);
 
     renderSurface1->setForceRenderSurface(true);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     ASSERT_TRUE(renderSurface1->renderSurface());
 
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
@@ skipping 17 matching lines @@
 {
     // Layers that have non-axis aligned bounds (due to transforms) have an expanded,
     // axis-aligned drawableContentRect and visibleContentRect.
 
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> renderSurface1 = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> child1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     root->addChild(renderSurface1);
     renderSurface1->addChild(child1);
 
-    WebTransformationMatrix identityMatrix;
-    WebTransformationMatrix childRotation;
-    childRotation.rotate(45);
+    Transform identityMatrix;
+    Transform childRotation;
+    childRotation.PreconcatRotate(45);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(3, 4), false);
     setLayerPropertiesForTesting(child1.get(), childRotation, identityMatrix, gfx::PointF(0.5, 0.5), gfx::PointF(25, 25), gfx::Size(50, 50), false);
 
     root->setMasksToBounds(true);
     renderSurface1->setForceRenderSurface(true);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     ASSERT_TRUE(renderSurface1->renderSurface());
 
@@ skipping 21 matching lines @@
     scoped_refptr<ContentLayer> renderSurface2 = createDrawableContentLayer(&client);
     scoped_refptr<ContentLayer> child1 = createDrawableContentLayer(&client);
     scoped_refptr<ContentLayer> child2 = createDrawableContentLayer(&client);
     scoped_refptr<ContentLayer> child3 = createDrawableContentLayer(&client);
     root->addChild(renderSurface1);
     renderSurface1->addChild(renderSurface2);
     renderSurface2->addChild(child1);
     renderSurface2->addChild(child2);
     renderSurface2->addChild(child3);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(5, 5), gfx::Size(3, 4), false);
     setLayerPropertiesForTesting(renderSurface2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(5, 5), gfx::Size(7, 13), false);
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(5, 5), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(75, 75), gfx::Size(50, 50), false);
     setLayerPropertiesForTesting(child3.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(125, 125), gfx::Size(50, 50), false);
 
     const double deviceScaleFactor = 2;
     root->setContentsScale(deviceScaleFactor);
     renderSurface1->setContentsScale(deviceScaleFactor);
@@ skipping 34 matching lines @@
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), child2->visibleContentRect());
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), child3->visibleContentRect());
 }
 
 TEST(LayerTreeHostCommonTest, verifyBackFaceCullingWithoutPreserves3d)
 {
     // Verify the behavior of back-face culling when there are no preserve-3d layers. Note
     // that 3d transforms still apply in this case, but they are "flattened" to each
     // parent layer according to current W3C spec.
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> frontFacingChild = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> backFacingChild = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> frontFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> backFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> frontFacingChildOfFrontFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> backFacingChildOfFrontFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> frontFacingChildOfBackFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> backFacingChildOfBackFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
 
     parent->addChild(frontFacingChild);
     parent->addChild(backFacingChild);
     parent->addChild(frontFacingSurface);
     parent->addChild(backFacingSurface);
     frontFacingSurface->addChild(frontFacingChildOfFrontFacingSurface);
     frontFacingSurface->addChild(backFacingChildOfFrontFacingSurface);
     backFacingSurface->addChild(frontFacingChildOfBackFacingSurface);
     backFacingSurface->addChild(backFacingChildOfBackFacingSurface);
 
     // Nothing is double-sided
     frontFacingChild->setDoubleSided(false);
     backFacingChild->setDoubleSided(false);
     frontFacingSurface->setDoubleSided(false);
     backFacingSurface->setDoubleSided(false);
     frontFacingChildOfFrontFacingSurface->setDoubleSided(false);
     backFacingChildOfFrontFacingSurface->setDoubleSided(false);
     frontFacingChildOfBackFacingSurface->setDoubleSided(false);
     backFacingChildOfBackFacingSurface->setDoubleSided(false);
 
-    WebTransformationMatrix backfaceMatrix;
-    backfaceMatrix.translate(50, 50);
-    backfaceMatrix.rotate3d(0, 1, 0, 180);
-    backfaceMatrix.translate(-50, -50);
+    Transform backfaceMatrix;
+    backfaceMatrix.PreconcatTranslate(50, 50);
+    MathUtil::rotateAxisAngle(&backfaceMatrix, 0, 1, 0, 180);
+    backfaceMatrix.PreconcatTranslate(-50, -50);
 
     // Having a descendant and opacity will force these to have render surfaces.
     frontFacingSurface->setOpacity(0.5);
     backFacingSurface->setOpacity(0.5);
 
     // Nothing preserves 3d. According to current W3C CSS Transforms spec, these layers
     // should blindly use their own local transforms to determine back-face culling.
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(frontFacingChild.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(backFacingChild.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
@@ skipping 38 matching lines @@
 
     // Verify backFacingSurface's layerList; its own layer should be culled from the surface list.
     ASSERT_EQ(1u, renderSurfaceLayerList[2]->renderSurface()->layerList().size());
     EXPECT_EQ(frontFacingChildOfBackFacingSurface->id(), renderSurfaceLayerList[2]->renderSurface()->layerList()[0]->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyBackFaceCullingWithPreserves3d)
 {
     // Verify the behavior of back-face culling when preserves-3d transform style is used.
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> frontFacingChild = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> backFacingChild = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> frontFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> backFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> frontFacingChildOfFrontFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> backFacingChildOfFrontFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> frontFacingChildOfBackFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> backFacingChildOfBackFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> dummyReplicaLayer1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
@@ skipping 11 matching lines @@
     // Nothing is double-sided
     frontFacingChild->setDoubleSided(false);
     backFacingChild->setDoubleSided(false);
     frontFacingSurface->setDoubleSided(false);
     backFacingSurface->setDoubleSided(false);
     frontFacingChildOfFrontFacingSurface->setDoubleSided(false);
     backFacingChildOfFrontFacingSurface->setDoubleSided(false);
     frontFacingChildOfBackFacingSurface->setDoubleSided(false);
     backFacingChildOfBackFacingSurface->setDoubleSided(false);
 
-    WebTransformationMatrix backfaceMatrix;
-    backfaceMatrix.translate(50, 50);
-    backfaceMatrix.rotate3d(0, 1, 0, 180);
-    backfaceMatrix.translate(-50, -50);
+    Transform backfaceMatrix;
+    backfaceMatrix.PreconcatTranslate(50, 50);
+    MathUtil::rotateAxisAngle(&backfaceMatrix, 0, 1, 0, 180);
+    backfaceMatrix.PreconcatTranslate(-50, -50);
 
     // Opacity will not force creation of renderSurfaces in this case because of the
     // preserve-3d transform style. Instead, an example of when a surface would be
     // created with preserve-3d is when there is a replica layer.
     frontFacingSurface->setReplicaLayer(dummyReplicaLayer1.get());
     backFacingSurface->setReplicaLayer(dummyReplicaLayer2.get());
 
     // Each surface creates its own new 3d rendering context (as defined by W3C spec).
     // According to current W3C CSS Transforms spec, layers in a 3d rendering context
     // should use the transform with respect to that context. This 3d rendering context
@@ skipping 41 matching lines @@
 
 TEST(LayerTreeHostCommonTest, verifyBackFaceCullingWithAnimatingTransforms)
 {
     // Verify that layers are appropriately culled when their back face is showing and
     // they are not double sided, while animations are going on.
     //
     // Layers that are animating do not get culled on the main thread, as their transforms should be
     // treated as "unknown" so we can not be sure that their back face is really showing.
     //
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> child = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> animatingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> childOfAnimatingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> animatingChild = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> child2 = make_scoped_refptr(new LayerWithForcedDrawsContent());
 
     parent->addChild(child);
     parent->addChild(animatingSurface);
     animatingSurface->addChild(childOfAnimatingSurface);
     parent->addChild(animatingChild);
     parent->addChild(child2);
 
     // Nothing is double-sided
     child->setDoubleSided(false);
     child2->setDoubleSided(false);
     animatingSurface->setDoubleSided(false);
     childOfAnimatingSurface->setDoubleSided(false);
     animatingChild->setDoubleSided(false);
 
-    WebTransformationMatrix backfaceMatrix;
-    backfaceMatrix.translate(50, 50);
-    backfaceMatrix.rotate3d(0, 1, 0, 180);
-    backfaceMatrix.translate(-50, -50);
+    Transform backfaceMatrix;
+    backfaceMatrix.PreconcatTranslate(50, 50);
+    MathUtil::rotateAxisAngle(&backfaceMatrix, 0, 1, 0, 180);
+    backfaceMatrix.PreconcatTranslate(-50, -50);
 
     // Make our render surface.
     animatingSurface->setForceRenderSurface(true);
 
     // Animate the transform on the render surface.
     addAnimatedTransformToController(*animatingSurface->layerAnimationController(), 10, 30, 0);
     // This is just an animating layer, not a surface.
     addAnimatedTransformToController(*animatingChild->layerAnimationController(), 10, 30, 0);
 
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
@@ skipping 35 matching lines @@
     EXPECT_EQ(animatingSurface->visibleContentRect(), gfx::Rect(gfx::Point(), animatingSurface->contentBounds()));
     // And layers in the subtree of the animating layer should have valid visibleContentRects also.
     EXPECT_EQ(childOfAnimatingSurface->visibleContentRect(), gfx::Rect(gfx::Point(), childOfAnimatingSurface->contentBounds()));
 }
 
 TEST(LayerTreeHostCommonTest, verifyBackFaceCullingWithPreserves3dForFlatteningSurface)
 {
     // Verify the behavior of back-face culling for a renderSurface that is created
     // when it flattens its subtree, and its parent has preserves-3d.
 
-    const WebTransformationMatrix identityMatrix;
+    const Transform identityMatrix;
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> frontFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> backFacingSurface = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> child1 = make_scoped_refptr(new LayerWithForcedDrawsContent());
     scoped_refptr<LayerWithForcedDrawsContent> child2 = make_scoped_refptr(new LayerWithForcedDrawsContent());
 
     parent->addChild(frontFacingSurface);
     parent->addChild(backFacingSurface);
     frontFacingSurface->addChild(child1);
     backFacingSurface->addChild(child2);
 
     // RenderSurfaces are not double-sided
     frontFacingSurface->setDoubleSided(false);
     backFacingSurface->setDoubleSided(false);
 
-    WebTransformationMatrix backfaceMatrix;
-    backfaceMatrix.translate(50, 50);
-    backfaceMatrix.rotate3d(0, 1, 0, 180);
-    backfaceMatrix.translate(-50, -50);
+    Transform backfaceMatrix;
+    backfaceMatrix.PreconcatTranslate(50, 50);
+    MathUtil::rotateAxisAngle(&backfaceMatrix, 0, 1, 0, 180);
+    backfaceMatrix.PreconcatTranslate(-50, -50);
 
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), true); // parent transform style is preserve3d.
     setLayerPropertiesForTesting(frontFacingSurface.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false); // surface transform style is flat.
     setLayerPropertiesForTesting(backFacingSurface.get(),  backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false); // surface transform style is flat.
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
@@ skipping 30 matching lines @@
 
     testPoint = gfx::Point(10, 20);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSingleLayer)
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(12345);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
@@ skipping 19 matching lines @@
     testPoint = gfx::Point(99, 99);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForUninvertibleTransform)
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(12345);
 
-    WebTransformationMatrix uninvertibleTransform;
-    uninvertibleTransform.setM11(0);
-    uninvertibleTransform.setM22(0);
-    uninvertibleTransform.setM33(0);
-    uninvertibleTransform.setM44(0);
-    ASSERT_FALSE(uninvertibleTransform.isInvertible());
+    Transform uninvertibleTransform;
+    uninvertibleTransform.matrix().setDouble(0, 0, 0);
+    uninvertibleTransform.matrix().setDouble(1, 1, 0);
+    uninvertibleTransform.matrix().setDouble(2, 2, 0);
+    uninvertibleTransform.matrix().setDouble(3, 3, 0);
+    ASSERT_FALSE(uninvertibleTransform.IsInvertible());
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), uninvertibleTransform, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
-    ASSERT_FALSE(root->screenSpaceTransform().isInvertible());
+    ASSERT_FALSE(root->screenSpaceTransform().IsInvertible());
 
     // Hit testing any point should not hit the layer. If the invertible matrix is
     // accidentally ignored and treated like an identity, then the hit testing will
     // incorrectly hit the layer when it shouldn't.
     gfx::Point testPoint(1, 1);
     LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 
     testPoint = gfx::Point(10, 10);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
@@ skipping 17 matching lines @@
 
     testPoint = gfx::Point(-1, -1);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSinglePositionedLayer)
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(12345);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
     gfx::PointF position(50, 50); // this layer is positioned, and hit testing should correctly know where the layer is located.
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
@@ skipping 20 matching lines @@
     testPoint = gfx::Point(99, 99);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSingleRotatedLayer)
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(12345);
 
-    WebTransformationMatrix identityMatrix;
-    WebTransformationMatrix rotation45DegreesAboutCenter;
-    rotation45DegreesAboutCenter.translate(50, 50);
-    rotation45DegreesAboutCenter.rotate3d(0, 0, 45);
-    rotation45DegreesAboutCenter.translate(-50, -50);
+    Transform identityMatrix;
+    Transform rotation45DegreesAboutCenter;
+    rotation45DegreesAboutCenter.PreconcatTranslate(50, 50);
+    MathUtil::rotateEulerAngles(&rotation45DegreesAboutCenter, 0, 0, 45);
+    rotation45DegreesAboutCenter.PreconcatTranslate(-50, -50);
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), rotation45DegreesAboutCenter, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
@@ skipping 24 matching lines @@
 
     testPoint = gfx::Point(-1, 50);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_FALSE(resultLayer);
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSinglePerspectiveLayer)
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(12345);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
 
     // perspectiveProjectionAboutCenter * translationByZ is designed so that the 100 x 100 layer becomes 50 x 50, and remains centered at (50, 50).
-    WebTransformationMatrix perspectiveProjectionAboutCenter;
-    perspectiveProjectionAboutCenter.translate(50, 50);
-    perspectiveProjectionAboutCenter.applyPerspective(1);
-    perspectiveProjectionAboutCenter.translate(-50, -50);
-    WebTransformationMatrix translationByZ;
-    translationByZ.translate3d(0, 0, -1);
+    Transform perspectiveProjectionAboutCenter;
+    perspectiveProjectionAboutCenter.PreconcatTranslate(50, 50);
+    perspectiveProjectionAboutCenter.PreconcatPerspectiveDepth(1);
+    perspectiveProjectionAboutCenter.PreconcatTranslate(-50, -50);
+    Transform translationByZ;
+    translationByZ.PreconcatTranslate3d(0, 0, -1);
 
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), perspectiveProjectionAboutCenter * translationByZ, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
@@ skipping 31 matching lines @@
     // test makes sure that hit testing works correctly accounts for the contents scale.
     // A contentsScale that is not 1 effectively forces a non-identity transform between
     // layer's content space and layer's origin space. The hit testing code must take this into account.
     //
     // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
     // contentsScale is ignored, then hit testing will mis-interpret the visibleContentRect
     // as being larger than the actual bounds of the layer.
     //
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
 
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
         gfx::PointF position(25, 25);
         gfx::Size bounds(50, 50);
         scoped_ptr<LayerImpl> testLayer = LayerImpl::create(12345);
         setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
 
@@ skipping 38 matching lines @@
     testPoint = gfx::Point(74, 74);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSimpleClippedLayer)
 {
     // Test that hit-testing will only work for the visible portion of a layer, and not
     // the entire layer bounds. Here we just test the simple axis-aligned case.
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
         scoped_ptr<LayerImpl> clippingLayer = LayerImpl::create(123);
         gfx::PointF position(25, 25); // this layer is positioned, and hit testing should correctly know where the layer is located.
         gfx::Size bounds(50, 50);
         setLayerPropertiesForTesting(clippingLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
@@ skipping 47 matching lines @@
     // algorithm needs to recognize that multiple parent layers may clip the layer, and
     // should not actually hit those clipped areas.
     //
     // The child and grandChild layers are both initialized to clip the rotatedLeaf. The
     // child layer is rotated about the top-left corner, so that the root + child clips
     // combined create a triangle. The rotatedLeaf will only be visible where it overlaps
     // this triangle.
     //
     scoped_ptr<LayerImpl> root = LayerImpl::create(123);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setMasksToBounds(true);
 
     {
         scoped_ptr<LayerImpl> child = LayerImpl::create(456);
         scoped_ptr<LayerImpl> grandChild = LayerImpl::create(789);
         scoped_ptr<LayerImpl> rotatedLeaf = LayerImpl::create(2468);
 
         position = gfx::PointF(10, 10);
         bounds = gfx::Size(80, 80);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->setMasksToBounds(true);
 
-        WebTransformationMatrix rotation45DegreesAboutCorner;
-        rotation45DegreesAboutCorner.rotate3d(0, 0, 45);
+        Transform rotation45DegreesAboutCorner;
+        MathUtil::rotateEulerAngles(&rotation45DegreesAboutCorner, 0, 0, 45);
 
         position = gfx::PointF(0, 0); // remember, positioned with respect to its parent which is already at 10, 10
         bounds = gfx::Size(200, 200); // to ensure it covers at least sqrt(2) * 100.
         setLayerPropertiesForTesting(grandChild.get(), rotation45DegreesAboutCorner, identityMatrix, anchor, position, bounds, false);
         grandChild->setMasksToBounds(true);
 
         // Rotates about the center of the layer
-        WebTransformationMatrix rotatedLeafTransform;
-        rotatedLeafTransform.translate(-10, -10); // cancel out the grandParent's position
-        rotatedLeafTransform.rotate3d(0, 0, -45); // cancel out the corner 45-degree rotation of the parent.
-        rotatedLeafTransform.translate(50, 50);
-        rotatedLeafTransform.rotate3d(0, 0, 45);
-        rotatedLeafTransform.translate(-50, -50);
+        Transform rotatedLeafTransform;
+        rotatedLeafTransform.PreconcatTranslate(-10, -10); // cancel out the grandParent's position
+        MathUtil::rotateEulerAngles(&rotatedLeafTransform, 0, 0, -45); // cancel out the corner 45-degree rotation of the parent.
+        rotatedLeafTransform.PreconcatTranslate(50, 50);
+        MathUtil::rotateEulerAngles(&rotatedLeafTransform, 0, 0, 45);
+        rotatedLeafTransform.PreconcatTranslate(-50, -50);
         position = gfx::PointF(0, 0);
         bounds = gfx::Size(100, 100);
         setLayerPropertiesForTesting(rotatedLeaf.get(), rotatedLeafTransform, identityMatrix, anchor, position, bounds, false);
         rotatedLeaf->setDrawsContent(true);
 
         grandChild->addChild(rotatedLeaf.Pass());
         child->addChild(grandChild.Pass());
         root->addChild(child.Pass());
     }
 
@@ skipping 44 matching lines @@
     testPoint = gfx::Point(49, 51);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(2468, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForNonClippingIntermediateLayer)
 {
     // This test checks that hit testing code does not accidentally clip to layer
     // bounds for a layer that actually does not clip.
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
         scoped_ptr<LayerImpl> intermediateLayer = LayerImpl::create(123);
         gfx::PointF position(10, 10); // this layer is positioned, and hit testing should correctly know where the layer is located.
         gfx::Size bounds(50, 50);
         setLayerPropertiesForTesting(intermediateLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
@@ skipping 40 matching lines @@
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(456, resultLayer->id());
 }
 
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForMultipleLayers)
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     {
         // child 1 and child2 are initialized to overlap between x=50 and x=60.
         // grandChild is set to overlap both child1 and child2 between y=50 and y=60.
         // The expected stacking order is:
@@ skipping 82 matching lines @@
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForMultipleLayerLists)
 {
     //
     // The geometry is set up similarly to the previous case, but
     // all layers are forced to be renderSurfaces now.
     //
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     {
         // child 1 and child2 are initialized to overlap between x=50 and x=60.
         // grandChild is set to overlap both child1 and child2 between y=50 and y=60.
         // The expected stacking order is:
@@ skipping 101 matching lines @@
 
     testPoint = gfx::Point(10, 20);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSingleLayer)
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(12345);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
@@ skipping 35 matching lines @@
     testPoint = gfx::Point(59, 59);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForUninvertibleTransform)
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(12345);
 
-    WebTransformationMatrix uninvertibleTransform;
-    uninvertibleTransform.setM11(0);
-    uninvertibleTransform.setM22(0);
-    uninvertibleTransform.setM33(0);
-    uninvertibleTransform.setM44(0);
-    ASSERT_FALSE(uninvertibleTransform.isInvertible());
+    Transform uninvertibleTransform;
+    uninvertibleTransform.matrix().setDouble(0, 0, 0);
+    uninvertibleTransform.matrix().setDouble(1, 1, 0);
+    uninvertibleTransform.matrix().setDouble(2, 2, 0);
+    uninvertibleTransform.matrix().setDouble(3, 3, 0);
+    ASSERT_FALSE(uninvertibleTransform.IsInvertible());
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), uninvertibleTransform, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
     root->setTouchEventHandlerRegion(touchHandlerRegion);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
-    ASSERT_FALSE(root->screenSpaceTransform().isInvertible());
+    ASSERT_FALSE(root->screenSpaceTransform().IsInvertible());
 
     // Hit checking any point should not hit the touch handler region on the layer. If the invertible matrix is
     // accidentally ignored and treated like an identity, then the hit testing will
     // incorrectly hit the layer when it shouldn't.
     gfx::Point testPoint(1, 1);
     LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 
     testPoint = gfx::Point(10, 10);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
@@ skipping 17 matching lines @@
 
     testPoint = gfx::Point(-1, -1);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSinglePositionedLayer)
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(12345);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
     gfx::PointF anchor(0, 0);
     gfx::PointF position(50, 50); // this layer is positioned, and hit testing should correctly know where the layer is located.
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
     root->setTouchEventHandlerRegion(touchHandlerRegion);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
@@ skipping 37 matching lines @@
     // test makes sure that hit testing works correctly accounts for the contents scale.
     // A contentsScale that is not 1 effectively forces a non-identity transform between
     // layer's content space and layer's origin space. The hit testing code must take this into account.
     //
     // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
     // contentsScale is ignored, then hit checking will mis-interpret the visibleContentRect
     // as being larger than the actual bounds of the layer.
     //
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
 
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
         Region touchHandlerRegion(gfx::Rect(10, 10, 30, 30));
         gfx::PointF position(25, 25);
         gfx::Size bounds(50, 50);
         scoped_ptr<LayerImpl> testLayer = LayerImpl::create(12345);
         setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
@@ skipping 51 matching lines @@
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSingleLayerWithDeviceScale)
 {
     // The layer's deviceScalefactor and pageScaleFactor should scale the contentRect and we should
     // be able to hit the touch handler region by scaling the points accordingly.
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
 
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
     // Set the bounds of the root layer big enough to fit the child when scaled.
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
         Region touchHandlerRegion(gfx::Rect(10, 10, 30, 30));
         gfx::PointF position(25, 25);
         gfx::Size bounds(50, 50);
         scoped_ptr<LayerImpl> testLayer = LayerImpl::create(12345);
         setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
 
         testLayer->setDrawsContent(true);
         testLayer->setTouchEventHandlerRegion(touchHandlerRegion);
         root->addChild(testLayer.Pass());
     }
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     float deviceScaleFactor = 3.0f;
     float pageScaleFactor = 5.0f;
-    WebTransformationMatrix pageScaleTransform;
-    pageScaleTransform.scale(pageScaleFactor);
+    Transform pageScaleTransform;
+    pageScaleTransform.PreconcatScale(pageScaleFactor, pageScaleFactor);
     root->setImplTransform(pageScaleTransform); // Applying the pageScaleFactor through implTransform.
     gfx::Size scaledBoundsForRoot = gfx::ToCeiledSize(gfx::ScaleSize(root->bounds(), deviceScaleFactor * pageScaleFactor));
     LayerTreeHostCommon::calculateDrawTransforms(root.get(), scaledBoundsForRoot, deviceScaleFactor, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     // The visibleContentRect for testLayer is actually 100x100, even though its layout size is 50x50, positioned at 25x25.
     LayerImpl* testLayer = root->children()[0];
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
@@ skipping 38 matching lines @@
     testPoint = gfx::ScalePoint(testPoint, deviceScaleFactor * pageScaleFactor);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSimpleClippedLayer)
 {
     // Test that hit-checking will only work for the visible portion of a layer, and not
     // the entire layer bounds. Here we just test the simple axis-aligned case.
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
     gfx::PointF anchor(0, 0);
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
         scoped_ptr<LayerImpl> clippingLayer = LayerImpl::create(123);
         gfx::PointF position(25, 25); // this layer is positioned, and hit testing should correctly know where the layer is located.
         gfx::Size bounds(50, 50);
         setLayerPropertiesForTesting(clippingLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
@@ skipping 64 matching lines @@
 {
     scoped_refptr<NoScaleContentLayer> toReturn = NoScaleContentLayer::create(delegate);
     toReturn->setIsDrawable(true);
     return toReturn;
 }
 
 TEST(LayerTreeHostCommonTest, verifyLayerTransformsInHighDPI)
 {
     // Verify draw and screen space transforms of layers not in a surface.
     MockContentLayerClient delegate;
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
 
     scoped_refptr<ContentLayer> parent = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), true);
 
     scoped_refptr<ContentLayer> child = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(2, 2), gfx::Size(10, 10), true);
 
     scoped_refptr<ContentLayer> childEmpty = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(childEmpty.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(2, 2), gfx::Size(0, 0), true);
 
@@ skipping 13 matching lines @@
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor, child);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor, childEmpty);
     EXPECT_CONTENTS_SCALE_EQ(1, childNoScale);
 
     EXPECT_EQ(1u, renderSurfaceLayerList.size());
 
     // Verify parent transforms
-    WebTransformationMatrix expectedParentTransform;
+    Transform expectedParentTransform;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->drawTransform());
 
     // Verify results of transformed parent rects
     gfx::RectF parentContentBounds(gfx::PointF(), gfx::SizeF(parent->contentBounds()));
 
     gfx::RectF parentDrawRect = MathUtil::mapClippedRect(parent->drawTransform(), parentContentBounds);
     gfx::RectF parentScreenSpaceRect = MathUtil::mapClippedRect(parent->screenSpaceTransform(), parentContentBounds);
 
     gfx::RectF expectedParentDrawRect(gfx::PointF(), parent->bounds());
     expectedParentDrawRect.Scale(deviceScaleFactor);
     EXPECT_FLOAT_RECT_EQ(expectedParentDrawRect, parentDrawRect);
     EXPECT_FLOAT_RECT_EQ(expectedParentDrawRect, parentScreenSpaceRect);
 
     // Verify child and childEmpty transforms. They should match.
-    WebTransformationMatrix expectedChildTransform;
-    expectedChildTransform.translate(deviceScaleFactor * child->position().x(), deviceScaleFactor * child->position().y());
+    Transform expectedChildTransform;
+    expectedChildTransform.PreconcatTranslate(deviceScaleFactor * child->position().x(), deviceScaleFactor * child->position().y());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, childEmpty->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, childEmpty->screenSpaceTransform());
 
     // Verify results of transformed child and childEmpty rects. They should match.
     gfx::RectF childContentBounds(gfx::PointF(), gfx::SizeF(child->contentBounds()));
 
     gfx::RectF childDrawRect = MathUtil::mapClippedRect(child->drawTransform(), childContentBounds);
     gfx::RectF childScreenSpaceRect = MathUtil::mapClippedRect(child->screenSpaceTransform(), childContentBounds);
 
     gfx::RectF childEmptyDrawRect = MathUtil::mapClippedRect(childEmpty->drawTransform(), childContentBounds);
     gfx::RectF childEmptyScreenSpaceRect = MathUtil::mapClippedRect(childEmpty->screenSpaceTransform(), childContentBounds);
 
     gfx::RectF expectedChildDrawRect(child->position(), child->bounds());
     expectedChildDrawRect.Scale(deviceScaleFactor);
     EXPECT_FLOAT_RECT_EQ(expectedChildDrawRect, childDrawRect);
     EXPECT_FLOAT_RECT_EQ(expectedChildDrawRect, childScreenSpaceRect);
     EXPECT_FLOAT_RECT_EQ(expectedChildDrawRect, childEmptyDrawRect);
     EXPECT_FLOAT_RECT_EQ(expectedChildDrawRect, childEmptyScreenSpaceRect);
 
     // Verify childNoScale transforms
-    WebTransformationMatrix expectedChildNoScaleTransform = child->drawTransform();
+    Transform expectedChildNoScaleTransform = child->drawTransform();
     // All transforms operate on content rects. The child's content rect
     // incorporates device scale, but the childNoScale does not; add it here.
-    expectedChildNoScaleTransform.scale(deviceScaleFactor);
+    expectedChildNoScaleTransform.PreconcatScale(deviceScaleFactor, deviceScaleFactor);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildNoScaleTransform, childNoScale->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildNoScaleTransform, childNoScale->screenSpaceTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyLayerTransformsInHighDPIAccurateScaleZeroChildPosition)
 {
     // Verify draw and screen space transforms of layers not in a surface.
     MockContentLayerClient delegate;
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
 
     scoped_refptr<ContentLayer> parent = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(133, 133), true);
 
     scoped_refptr<ContentLayer> child = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(13, 13), true);
 
     scoped_refptr<NoScaleContentLayer> childNoScale = createNoScaleDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(childNoScale.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(13, 13), true);
 
     parent->addChild(child);
     parent->addChild(childNoScale);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     const float deviceScaleFactor = 1.7f;
     const float pageScaleFactor = 1;
 
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor, child);
     EXPECT_CONTENTS_SCALE_EQ(1, childNoScale);
 
     EXPECT_EQ(1u, renderSurfaceLayerList.size());
 
     // Verify parent transforms
-    WebTransformationMatrix expectedParentTransform;
+    Transform expectedParentTransform;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->drawTransform());
 
     // Verify results of transformed parent rects
     gfx::RectF parentContentBounds(gfx::PointF(), gfx::SizeF(parent->contentBounds()));
 
     gfx::RectF parentDrawRect = MathUtil::mapClippedRect(parent->drawTransform(), parentContentBounds);
     gfx::RectF parentScreenSpaceRect = MathUtil::mapClippedRect(parent->screenSpaceTransform(), parentContentBounds);
 
     gfx::RectF expectedParentDrawRect(gfx::PointF(), parent->bounds());
     expectedParentDrawRect.Scale(deviceScaleFactor);
     expectedParentDrawRect.set_width(ceil(expectedParentDrawRect.width()));
     expectedParentDrawRect.set_height(ceil(expectedParentDrawRect.height()));
     EXPECT_FLOAT_RECT_EQ(expectedParentDrawRect, parentDrawRect);
     EXPECT_FLOAT_RECT_EQ(expectedParentDrawRect, parentScreenSpaceRect);
 
     // Verify child transforms
-    WebTransformationMatrix expectedChildTransform;
+    Transform expectedChildTransform;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->screenSpaceTransform());
 
     // Verify results of transformed child rects
     gfx::RectF childContentBounds(gfx::PointF(), gfx::SizeF(child->contentBounds()));
 
     gfx::RectF childDrawRect = MathUtil::mapClippedRect(child->drawTransform(), childContentBounds);
     gfx::RectF childScreenSpaceRect = MathUtil::mapClippedRect(child->screenSpaceTransform(), childContentBounds);
 
     gfx::RectF expectedChildDrawRect(gfx::PointF(), child->bounds());
     expectedChildDrawRect.Scale(deviceScaleFactor);
     expectedChildDrawRect.set_width(ceil(expectedChildDrawRect.width()));
     expectedChildDrawRect.set_height(ceil(expectedChildDrawRect.height()));
     EXPECT_FLOAT_RECT_EQ(expectedChildDrawRect, childDrawRect);
     EXPECT_FLOAT_RECT_EQ(expectedChildDrawRect, childScreenSpaceRect);
 
     // Verify childNoScale transforms
-    WebTransformationMatrix expectedChildNoScaleTransform = child->drawTransform();
+    Transform expectedChildNoScaleTransform = child->drawTransform();
     // All transforms operate on content rects. The child's content rect
     // incorporates device scale, but the childNoScale does not; add it here.
-    expectedChildNoScaleTransform.scale(deviceScaleFactor);
+    expectedChildNoScaleTransform.PreconcatScale(deviceScaleFactor, deviceScaleFactor);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildNoScaleTransform, childNoScale->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildNoScaleTransform, childNoScale->screenSpaceTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyContentsScale)
 {
     MockContentLayerClient delegate;
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
 
-    WebTransformationMatrix parentScaleMatrix;
+    Transform parentScaleMatrix;
     const double initialParentScale = 1.75;
-    parentScaleMatrix.scale(initialParentScale);
+    parentScaleMatrix.PreconcatScale(initialParentScale, initialParentScale);
 
-    WebTransformationMatrix childScaleMatrix;
+    Transform childScaleMatrix;
     const double initialChildScale = 1.25;
-    childScaleMatrix.scale(initialChildScale);
+    childScaleMatrix.PreconcatScale(initialChildScale, initialChildScale);
 
     float fixedRasterScale = 2.5;
 
     scoped_refptr<ContentLayer> parent = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(parent.get(), parentScaleMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), true);
 
     scoped_refptr<ContentLayer> childScale = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(childScale.get(), childScaleMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(2, 2), gfx::Size(10, 10), true);
 
     scoped_refptr<ContentLayer> childEmpty = createDrawableContentLayer(&delegate);
@@ skipping 16 matching lines @@
     parent->addChild(childNoScale);
     parent->addChild(childNoAutoScale);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     double deviceScaleFactor = 2.5;
     double pageScaleFactor = 1.5;
 
     // FIXME: Remove this when pageScaleFactor is applied in the compositor.
-    WebTransformationMatrix pageScaleMatrix;
-    pageScaleMatrix.scale(pageScaleFactor);
+    Transform pageScaleMatrix;
+    pageScaleMatrix.PreconcatScale(pageScaleFactor, pageScaleFactor);
     parent->setSublayerTransform(pageScaleMatrix);
 
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childEmpty);
     EXPECT_CONTENTS_SCALE_EQ(1, childNoScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * fixedRasterScale, childNoAutoScale);
 
     // The parent is scaled up and shouldn't need to scale during draw. The child that can scale its contents should
     // also not need to scale during draw. This shouldn't change if the child has empty bounds. The other children should.
-    EXPECT_FLOAT_EQ(1, parent->drawTransform().m11());
-    EXPECT_FLOAT_EQ(1, parent->drawTransform().m22());
-    EXPECT_FLOAT_EQ(1, childScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(1, childScale->drawTransform().m22());
-    EXPECT_FLOAT_EQ(1, childEmpty->drawTransform().m11());
-    EXPECT_FLOAT_EQ(1, childEmpty->drawTransform().m22());
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childNoScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childNoScale->drawTransform().m22());
-    EXPECT_FLOAT_EQ(initialParentScale * initialChildScale / fixedRasterScale, childNoAutoScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(initialParentScale * initialChildScale / fixedRasterScale, childNoAutoScale->drawTransform().m22());
+    EXPECT_FLOAT_EQ(1, parent->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(1, parent->drawTransform().matrix().getDouble(1, 1));
+    EXPECT_FLOAT_EQ(1, childScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(1, childScale->drawTransform().matrix().getDouble(1, 1));
+    EXPECT_FLOAT_EQ(1, childEmpty->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(1, childEmpty->drawTransform().matrix().getDouble(1, 1));
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childNoScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childNoScale->drawTransform().matrix().getDouble(1, 1));
+    EXPECT_FLOAT_EQ(initialParentScale * initialChildScale / fixedRasterScale, childNoAutoScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(initialParentScale * initialChildScale / fixedRasterScale, childNoAutoScale->drawTransform().matrix().getDouble(1, 1));
 
     // If the transform changes, we expect the contentsScale to remain unchanged.
     childScale->setTransform(identityMatrix);
     childEmpty->setTransform(identityMatrix);
 
     renderSurfaceLayerList.clear();
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childEmpty);
     EXPECT_CONTENTS_SCALE_EQ(1, childNoScale);
 
     // But if the deviceScaleFactor or pageScaleFactor changes, then it should be updated, but using the initial transform.
     deviceScaleFactor = 2.25;
     pageScaleFactor = 1.25;
 
     // FIXME: Remove this when pageScaleFactor is applied in the compositor.
     pageScaleMatrix = identityMatrix;
-    pageScaleMatrix.scale(pageScaleFactor);
+    pageScaleMatrix.PreconcatScale(pageScaleFactor, pageScaleFactor);
     parent->setSublayerTransform(pageScaleMatrix);
 
     renderSurfaceLayerList.clear();
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childEmpty);
     EXPECT_CONTENTS_SCALE_EQ(1, childNoScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * fixedRasterScale, childNoAutoScale);
 }
 
 TEST(LayerTreeHostCommonTest, verifySmallContentsScale)
 {
     MockContentLayerClient delegate;
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
 
-    WebTransformationMatrix parentScaleMatrix;
+    Transform parentScaleMatrix;
     const double initialParentScale = 1.75;
-    parentScaleMatrix.scale(initialParentScale);
+    parentScaleMatrix.PreconcatScale(initialParentScale, initialParentScale);
 
-    WebTransformationMatrix childScaleMatrix;
+    Transform childScaleMatrix;
     const double initialChildScale = 0.25;
-    childScaleMatrix.scale(initialChildScale);
+    childScaleMatrix.PreconcatScale(initialChildScale, initialChildScale);
 
     scoped_refptr<ContentLayer> parent = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(parent.get(), parentScaleMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), true);
 
     scoped_refptr<ContentLayer> childScale = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(childScale.get(), childScaleMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(2, 2), gfx::Size(10, 10), true);
 
     // FIXME: Remove this when pageScaleFactor is applied in the compositor.
     // Page scale should not apply to the parent.
     parent->setBoundsContainPageScale(true);
 
     parent->addChild(childScale);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     double deviceScaleFactor = 2.5;
     double pageScaleFactor = 0.01;
 
     // FIXME: Remove this when pageScaleFactor is applied in the compositor.
-    WebTransformationMatrix pageScaleMatrix;
-    pageScaleMatrix.scale(pageScaleFactor);
+    Transform pageScaleMatrix;
+    pageScaleMatrix.PreconcatScale(pageScaleFactor, pageScaleFactor);
     parent->setSublayerTransform(pageScaleMatrix);
 
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     // The child's scale is < 1, so we should not save and use that scale factor.
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * 1, childScale);
 
     // When chilld's total scale becomes >= 1, we should save and use that scale factor.
-    childScaleMatrix.makeIdentity();
+    childScaleMatrix.matrix().setIdentity();
     const double finalChildScale = 0.75;
-    childScaleMatrix.scale(finalChildScale);
+    childScaleMatrix.PreconcatScale(finalChildScale, finalChildScale);
     childScale->setTransform(childScaleMatrix);
 
     renderSurfaceLayerList.clear();
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * finalChildScale, childScale);
 }
 
 TEST(LayerTreeHostCommonTest, verifyContentsScaleForSurfaces)
 {
     MockContentLayerClient delegate;
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
 
-    WebTransformationMatrix parentScaleMatrix;
+    Transform parentScaleMatrix;
     const double initialParentScale = 2;
-    parentScaleMatrix.scale(initialParentScale);
+    parentScaleMatrix.PreconcatScale(initialParentScale, initialParentScale);
 
-    WebTransformationMatrix childScaleMatrix;
+    Transform childScaleMatrix;
     const double initialChildScale = 3;
-    childScaleMatrix.scale(initialChildScale);
+    childScaleMatrix.PreconcatScale(initialChildScale, initialChildScale);
 
     float fixedRasterScale = 4;
 
     scoped_refptr<ContentLayer> parent = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(parent.get(), parentScaleMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), true);
 
     scoped_refptr<ContentLayer> surfaceScale = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(surfaceScale.get(), childScaleMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(2, 2), gfx::Size(10, 10), true);
 
     scoped_refptr<ContentLayer> surfaceScaleChildScale = createDrawableContentLayer(&delegate);
@@ skipping 42 matching lines @@
     surfaceNoAutoScale->addChild(surfaceNoAutoScaleChildScale);
     surfaceNoAutoScale->addChild(surfaceNoAutoScaleChildNoScale);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     double deviceScaleFactor = 5;
     double pageScaleFactor = 7;
 
     // FIXME: Remove this when pageScaleFactor is applied in the compositor.
-    WebTransformationMatrix pageScaleMatrix;
-    pageScaleMatrix.scale(pageScaleFactor);
+    Transform pageScaleMatrix;
+    pageScaleMatrix.PreconcatScale(pageScaleFactor, pageScaleFactor);
     parent->setSublayerTransform(pageScaleMatrix);
 
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, surfaceScale);
     EXPECT_CONTENTS_SCALE_EQ(1, surfaceNoScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * fixedRasterScale, surfaceNoAutoScale);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceScaleChildScale);
     EXPECT_CONTENTS_SCALE_EQ(1, surfaceScaleChildNoScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoScaleChildScale);
     EXPECT_CONTENTS_SCALE_EQ(1, surfaceNoScaleChildNoScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoAutoScaleChildScale);
     EXPECT_CONTENTS_SCALE_EQ(1, surfaceNoAutoScaleChildNoScale);
 
     // The parent is scaled up and shouldn't need to scale during draw.
-    EXPECT_FLOAT_EQ(1, parent->drawTransform().m11());
-    EXPECT_FLOAT_EQ(1, parent->drawTransform().m22());
+    EXPECT_FLOAT_EQ(1, parent->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(1, parent->drawTransform().matrix().getDouble(1, 1));
 
     // RenderSurfaces should always be 1:1 with their target.
-    EXPECT_FLOAT_EQ(1, surfaceScale->renderSurface()->drawTransform().m11());
-    EXPECT_FLOAT_EQ(1, surfaceScale->renderSurface()->drawTransform().m22());
+    EXPECT_FLOAT_EQ(1, surfaceScale->renderSurface()->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(1, surfaceScale->renderSurface()->drawTransform().matrix().getDouble(1, 1));
 
     // The surfaceScale can apply contents scale so the layer shouldn't need to scale during draw.
-    EXPECT_FLOAT_EQ(1, surfaceScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(1, surfaceScale->drawTransform().m22());
+    EXPECT_FLOAT_EQ(1, surfaceScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(1, surfaceScale->drawTransform().matrix().getDouble(1, 1));
 
     // The surfaceScaleChildScale can apply contents scale so it shouldn't need to scale during draw.
-    EXPECT_FLOAT_EQ(1, surfaceScaleChildScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(1, surfaceScaleChildScale->drawTransform().m22());
+    EXPECT_FLOAT_EQ(1, surfaceScaleChildScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(1, surfaceScaleChildScale->drawTransform().matrix().getDouble(1, 1));
 
     // The surfaceScaleChildNoScale can not apply contents scale, so it needs to be scaled during draw.
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceScaleChildNoScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceScaleChildNoScale->drawTransform().m22());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceScaleChildNoScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceScaleChildNoScale->drawTransform().matrix().getDouble(1, 1));
 
     // RenderSurfaces should always be 1:1 with their target.
-    EXPECT_FLOAT_EQ(1, surfaceNoScale->renderSurface()->drawTransform().m11());
-    EXPECT_FLOAT_EQ(1, surfaceNoScale->renderSurface()->drawTransform().m22());
+    EXPECT_FLOAT_EQ(1, surfaceNoScale->renderSurface()->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(1, surfaceNoScale->renderSurface()->drawTransform().matrix().getDouble(1, 1));
 
     // The surfaceNoScale layer can not apply contents scale, so it needs to be scaled during draw.
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, surfaceNoScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, surfaceNoScale->drawTransform().m22());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, surfaceNoScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, surfaceNoScale->drawTransform().matrix().getDouble(1, 1));
 
     // The surfaceScaleChildScale can apply contents scale so it shouldn't need to scale during draw.
-    EXPECT_FLOAT_EQ(1, surfaceNoScaleChildScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(1, surfaceNoScaleChildScale->drawTransform().m22());
+    EXPECT_FLOAT_EQ(1, surfaceNoScaleChildScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(1, surfaceNoScaleChildScale->drawTransform().matrix().getDouble(1, 1));
 
     // The surfaceScaleChildNoScale can not apply contents scale, so it needs to be scaled during draw.
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoScaleChildNoScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoScaleChildNoScale->drawTransform().m22());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoScaleChildNoScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoScaleChildNoScale->drawTransform().matrix().getDouble(1, 1));
 
     // RenderSurfaces should always be 1:1 with their target.
-    EXPECT_FLOAT_EQ(1, surfaceNoAutoScale->renderSurface()->drawTransform().m11());
-    EXPECT_FLOAT_EQ(1, surfaceNoAutoScale->renderSurface()->drawTransform().m22());
+    EXPECT_FLOAT_EQ(1, surfaceNoAutoScale->renderSurface()->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(1, surfaceNoAutoScale->renderSurface()->drawTransform().matrix().getDouble(1, 1));
 
     // The surfaceNoAutoScale layer has a fixed contents scale, so it needs to be scaled during draw.
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale / (deviceScaleFactor * pageScaleFactor * fixedRasterScale), surfaceNoAutoScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale / (deviceScaleFactor * pageScaleFactor * fixedRasterScale), surfaceNoAutoScale->drawTransform().m22());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale / (deviceScaleFactor * pageScaleFactor * fixedRasterScale), surfaceNoAutoScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale / (deviceScaleFactor * pageScaleFactor * fixedRasterScale), surfaceNoAutoScale->drawTransform().matrix().getDouble(1, 1));
 
     // The surfaceScaleChildScale can apply contents scale so it shouldn't need to scale during draw.
-    EXPECT_FLOAT_EQ(1, surfaceNoAutoScaleChildScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(1, surfaceNoAutoScaleChildScale->drawTransform().m22());
+    EXPECT_FLOAT_EQ(1, surfaceNoAutoScaleChildScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(1, surfaceNoAutoScaleChildScale->drawTransform().matrix().getDouble(1, 1));
 
     // The surfaceScaleChildNoScale can not apply contents scale, so it needs to be scaled during draw.
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoAutoScaleChildNoScale->drawTransform().m11());
-    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoAutoScaleChildNoScale->drawTransform().m22());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoAutoScaleChildNoScale->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoAutoScaleChildNoScale->drawTransform().matrix().getDouble(1, 1));
 }
 
 TEST(LayerTreeHostCommonTest, verifyContentsScaleForAnimatingLayer)
 {
     MockContentLayerClient delegate;
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
 
-    WebTransformationMatrix parentScaleMatrix;
+    Transform parentScaleMatrix;
     const double initialParentScale = 1.75;
-    parentScaleMatrix.scale(initialParentScale);
+    parentScaleMatrix.PreconcatScale(initialParentScale, initialParentScale);
 
-    WebTransformationMatrix childScaleMatrix;
+    Transform childScaleMatrix;
     const double initialChildScale = 1.25;
-    childScaleMatrix.scale(initialChildScale);
+    childScaleMatrix.PreconcatScale(initialChildScale, initialChildScale);
 
     scoped_refptr<ContentLayer> parent = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(parent.get(), parentScaleMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), true);
 
     scoped_refptr<ContentLayer> childScale = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(childScale.get(), childScaleMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(2, 2), gfx::Size(10, 10), true);
 
     parent->addChild(childScale);
 
     // Now put an animating transform on child.
@@ skipping 15 matching lines @@
 
     EXPECT_CONTENTS_SCALE_EQ(initialParentScale, parent);
     // The layers with animating transforms should not compute a contentsScale other than 1 until they finish animating.
     EXPECT_CONTENTS_SCALE_EQ(initialParentScale * initialChildScale, childScale);
 }
 
 
 TEST(LayerTreeHostCommonTest, verifyRenderSurfaceTransformsInHighDPI)
 {
     MockContentLayerClient delegate;
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
 
     scoped_refptr<ContentLayer> parent = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(30, 30), true);
 
     scoped_refptr<ContentLayer> child = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(2, 2), gfx::Size(10, 10), true);
 
-    WebTransformationMatrix replicaTransform;
-    replicaTransform.scaleNonUniform(1, -1);
+    Transform replicaTransform;
+    replicaTransform.PreconcatScale(1, -1);
     scoped_refptr<ContentLayer> replica = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(replica.get(), replicaTransform, identityMatrix, gfx::PointF(0, 0), gfx::PointF(2, 2), gfx::Size(10, 10), true);
 
     // This layer should end up in the same surface as child, with the same draw
     // and screen space transforms.
     scoped_refptr<ContentLayer> duplicateChildNonOwner = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(duplicateChildNonOwner.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(10, 10), true);
 
     parent->addChild(child);
     child->addChild(duplicateChildNonOwner);
     child->setReplicaLayer(replica.get());
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     const double deviceScaleFactor = 1.5;
     parent->setContentsScale(deviceScaleFactor);
     child->setContentsScale(deviceScaleFactor);
     duplicateChildNonOwner->setContentsScale(deviceScaleFactor);
     replica->setContentsScale(deviceScaleFactor);
 
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // We should have two render surfaces. The root's render surface and child's
     // render surface (it needs one because it has a replica layer).
     EXPECT_EQ(2u, renderSurfaceLayerList.size());
 
-    WebTransformationMatrix expectedParentTransform;
+    Transform expectedParentTransform;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->drawTransform());
 
-    WebTransformationMatrix expectedDrawTransform;
+    Transform expectedDrawTransform;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedDrawTransform, child->drawTransform());
 
-    WebTransformationMatrix expectedScreenSpaceTransform;
-    expectedScreenSpaceTransform.translate(deviceScaleFactor * child->position().x(), deviceScaleFactor * child->position().y());
+    Transform expectedScreenSpaceTransform;
+    expectedScreenSpaceTransform.PreconcatTranslate(deviceScaleFactor * child->position().x(), deviceScaleFactor * child->position().y());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedScreenSpaceTransform, child->screenSpaceTransform());
 
-    WebTransformationMatrix expectedDuplicateChildDrawTransform = child->drawTransform();
+    Transform expectedDuplicateChildDrawTransform = child->drawTransform();
     EXPECT_TRANSFORMATION_MATRIX_EQ(child->drawTransform(), duplicateChildNonOwner->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(child->screenSpaceTransform(), duplicateChildNonOwner->screenSpaceTransform());
     EXPECT_RECT_EQ(child->drawableContentRect(), duplicateChildNonOwner->drawableContentRect());
     EXPECT_EQ(child->contentBounds(), duplicateChildNonOwner->contentBounds());
 
-    WebTransformationMatrix expectedRenderSurfaceDrawTransform;
-    expectedRenderSurfaceDrawTransform.translate(deviceScaleFactor * child->position().x(), deviceScaleFactor * child->position().y());
+    Transform expectedRenderSurfaceDrawTransform;
+    expectedRenderSurfaceDrawTransform.PreconcatTranslate(deviceScaleFactor * child->position().x(), deviceScaleFactor * child->position().y());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedRenderSurfaceDrawTransform, child->renderSurface()->drawTransform());
 
-    WebTransformationMatrix expectedSurfaceDrawTransform;
-    expectedSurfaceDrawTransform.translate(deviceScaleFactor * 2, deviceScaleFactor * 2);
+    Transform expectedSurfaceDrawTransform;
+    expectedSurfaceDrawTransform.PreconcatTranslate(deviceScaleFactor * 2, deviceScaleFactor * 2);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedSurfaceDrawTransform, child->renderSurface()->drawTransform());
 
-    WebTransformationMatrix expectedSurfaceScreenSpaceTransform;
-    expectedSurfaceScreenSpaceTransform.translate(deviceScaleFactor * 2, deviceScaleFactor * 2);
+    Transform expectedSurfaceScreenSpaceTransform;
+    expectedSurfaceScreenSpaceTransform.PreconcatTranslate(deviceScaleFactor * 2, deviceScaleFactor * 2);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedSurfaceScreenSpaceTransform, child->renderSurface()->screenSpaceTransform());
 
-    WebTransformationMatrix expectedReplicaDrawTransform;
-    expectedReplicaDrawTransform.setM22(-1);
-    expectedReplicaDrawTransform.setM41(6);
-    expectedReplicaDrawTransform.setM42(6);
+    Transform expectedReplicaDrawTransform;
+    expectedReplicaDrawTransform.matrix().setDouble(1, 1, -1);
+    expectedReplicaDrawTransform.matrix().setDouble(0, 3, 6);
+    expectedReplicaDrawTransform.matrix().setDouble(1, 3, 6);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedReplicaDrawTransform, child->renderSurface()->replicaDrawTransform());
 
-    WebTransformationMatrix expectedReplicaScreenSpaceTransform;
-    expectedReplicaScreenSpaceTransform.setM22(-1);
-    expectedReplicaScreenSpaceTransform.setM41(6);
-    expectedReplicaScreenSpaceTransform.setM42(6);
+    Transform expectedReplicaScreenSpaceTransform;
+    expectedReplicaScreenSpaceTransform.matrix().setDouble(1, 1, -1);
+    expectedReplicaScreenSpaceTransform.matrix().setDouble(0, 3, 6);
+    expectedReplicaScreenSpaceTransform.matrix().setDouble(1, 3, 6);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedReplicaScreenSpaceTransform, child->renderSurface()->replicaScreenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedReplicaScreenSpaceTransform, child->renderSurface()->replicaScreenSpaceTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifyRenderSurfaceTransformsInHighDPIAccurateScaleZeroPosition)
 {
     MockContentLayerClient delegate;
-    WebTransformationMatrix identityMatrix;
+    Transform identityMatrix;
 
     scoped_refptr<ContentLayer> parent = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(33, 31), true);
 
     scoped_refptr<ContentLayer> child = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(13, 11), true);
 
-    WebTransformationMatrix replicaTransform;
-    replicaTransform.scaleNonUniform(1, -1);
+    Transform replicaTransform;
+    replicaTransform.PreconcatScale(1, -1);
     scoped_refptr<ContentLayer> replica = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(replica.get(), replicaTransform, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(13, 11), true);
 
     // This layer should end up in the same surface as child, with the same draw
     // and screen space transforms.
     scoped_refptr<ContentLayer> duplicateChildNonOwner = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(duplicateChildNonOwner.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(13, 11), true);
 
     parent->addChild(child);
     child->addChild(duplicateChildNonOwner);
     child->setReplicaLayer(replica.get());
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     const float deviceScaleFactor = 1.7f;
     parent->setContentsScale(deviceScaleFactor);
     child->setContentsScale(deviceScaleFactor);
     duplicateChildNonOwner->setContentsScale(deviceScaleFactor);
     replica->setContentsScale(deviceScaleFactor);
 
     LayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // We should have two render surfaces. The root's render surface and child's
     // render surface (it needs one because it has a replica layer).
     EXPECT_EQ(2u, renderSurfaceLayerList.size());
 
-    WebTransformationMatrix identityTransform;
+    Transform identityTransform;
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, parent->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, parent->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, child->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, duplicateChildNonOwner->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, duplicateChildNonOwner->screenSpaceTransform());
     EXPECT_RECT_EQ(child->drawableContentRect(), duplicateChildNonOwner->drawableContentRect());
     EXPECT_EQ(child->contentBounds(), duplicateChildNonOwner->contentBounds());
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, child->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, child->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, child->renderSurface()->screenSpaceTransform());
 
-    WebTransformationMatrix expectedReplicaDrawTransform;
-    expectedReplicaDrawTransform.setM22(-1);
+    Transform expectedReplicaDrawTransform;
+    expectedReplicaDrawTransform.matrix().setDouble(1, 1, -1);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedReplicaDrawTransform, child->renderSurface()->replicaDrawTransform());
 
-    WebTransformationMatrix expectedReplicaScreenSpaceTransform;
-    expectedReplicaScreenSpaceTransform.setM22(-1);
+    Transform expectedReplicaScreenSpaceTransform;
+    expectedReplicaScreenSpaceTransform.matrix().setDouble(1, 1, -1);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedReplicaScreenSpaceTransform, child->renderSurface()->replicaScreenSpaceTransform());
 }
 
 TEST(LayerTreeHostCommonTest, verifySubtreeSearch)
 {
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<Layer> grandChild = Layer::create();
     scoped_refptr<Layer> maskLayer = Layer::create();
     scoped_refptr<Layer> replicaLayer = Layer::create();
 
     grandChild->setReplicaLayer(replicaLayer.get());
     child->addChild(grandChild.get());
     child->setMaskLayer(maskLayer.get());
     root->addChild(child.get());
 
     int nonexistentId = -1;
     EXPECT_EQ(root, LayerTreeHostCommon::findLayerInSubtree(root.get(), root->id()));
     EXPECT_EQ(child, LayerTreeHostCommon::findLayerInSubtree(root.get(), child->id()));
     EXPECT_EQ(grandChild, LayerTreeHostCommon::findLayerInSubtree(root.get(), grandChild->id()));
     EXPECT_EQ(maskLayer, LayerTreeHostCommon::findLayerInSubtree(root.get(), maskLayer->id()));
     EXPECT_EQ(replicaLayer, LayerTreeHostCommon::findLayerInSubtree(root.get(), replicaLayer->id()));
     EXPECT_EQ(0, LayerTreeHostCommon::findLayerInSubtree(root.get(), nonexistentId));
 }
 
 }  // namespace
 }  // namespace cc