cc/layer_tree_host_common_unittest.cc - Issue 11308153: Migrate most of cc/ from WebKit::WebTransformationMatrix to gfx::Transform

Unified Diff: cc/layer_tree_host_common_unittest.cc

Issue 11308153: Migrate most of cc/ from WebKit::WebTransformationMatrix to gfx::Transform (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Rebased to tip of tree and addressed feedback Created 8 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: cc/layer_tree_host_common_unittest.cc

diff --git a/cc/layer_tree_host_common_unittest.cc b/cc/layer_tree_host_common_unittest.cc

index 456ea52f1fafac554620061135916567e46636b6..19e39874739cad00f3aa0c4cbcae42485abd36ce 100644

--- a/cc/layer_tree_host_common_unittest.cc

+++ b/cc/layer_tree_host_common_unittest.cc

@@ -19,16 +19,16 @@

#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);

@@ -38,13 +38,13 @@ void setLayerPropertiesForTestingInternal(LayerType* layer, const WebTransformat

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);

@@ -52,7 +52,7 @@ void setLayerPropertiesForTesting(LayerImpl* layer, const WebTransformationMatri

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);

@@ -66,7 +66,7 @@ void executeCalculateDrawTransformsAndVisibility(LayerImpl* rootLayer, float dev

{

// 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);

@@ -76,16 +76,16 @@ void executeCalculateDrawTransformsAndVisibility(LayerImpl* rootLayer, float dev

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;

}

@@ -96,7 +96,7 @@ scoped_ptr<LayerImpl> createTreeForFixedPositionTests()

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);

@@ -160,7 +160,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForNoOpLayer)

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);

@@ -175,7 +175,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForNoOpLayer)

TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer)

{

- WebTransformationMatrix identityMatrix;

+ Transform identityMatrix;

scoped_refptr<Layer> layer = Layer::create();

scoped_refptr<Layer> root = Layer::create();

@@ -183,17 +183,17 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer)

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());

@@ -206,8 +206,8 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer)

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());

@@ -215,17 +215,17 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer)

// 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());

@@ -234,7 +234,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer)

// 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());

@@ -243,7 +243,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer)

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();

@@ -266,8 +266,8 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy)

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);

@@ -278,11 +278,11 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy)

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);

@@ -296,14 +296,14 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy)

// 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);

@@ -336,26 +336,26 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleRenderSurface)

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());

@@ -395,30 +395,30 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForReplica)

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());

@@ -475,7 +475,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy)

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).

@@ -485,38 +485,38 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy)

// 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);

- WebTransformationMatrix A = translationToAnchor * layerTransform * translationToAnchor.inverse();

- WebTransformationMatrix B = translationToCenter * sublayerTransform * translationToCenter.inverse();

- WebTransformationMatrix R = A * translationToAnchor * replicaLayerTransform * translationToAnchor.inverse();

+ 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);

+ 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);

@@ -606,17 +606,17 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy)

// 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)

@@ -630,10 +630,10 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForFlatteningLayer)

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);

@@ -647,10 +647,10 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForFlatteningLayer)

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());

@@ -677,7 +677,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForDegenerateIntermediateLayer)

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);

@@ -700,7 +700,7 @@ TEST(LayerTreeHostCommonTest, verifyRenderSurfaceListForRenderSurfaceWithClipped

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);

@@ -728,7 +728,7 @@ TEST(LayerTreeHostCommonTest, verifyRenderSurfaceListForTransparentChild)

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);

@@ -757,7 +757,7 @@ TEST(LayerTreeHostCommonTest, verifyForceRenderSurface)

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);

@@ -801,8 +801,8 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD

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());

@@ -812,8 +812,8 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD

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 neve

+ expectedChildTransform.PreconcatTranslate(-10, -10);

EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

@@ -834,8 +834,8 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithT

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);

@@ -845,10 +845,10 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithT

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());

@@ -858,9 +858,9 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithT

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());

@@ -883,11 +883,11 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD

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());

@@ -898,10 +898,10 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD

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());

@@ -917,8 +917,8 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD

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);

@@ -930,15 +930,15 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD

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());

@@ -949,15 +949,15 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithD

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());

@@ -977,8 +977,8 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM

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);

@@ -990,15 +990,15 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM

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());

@@ -1010,16 +1010,16 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM

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());

@@ -1043,20 +1043,20 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithI

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());

@@ -1074,21 +1074,21 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithI

// 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());

@@ -1110,7 +1110,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM

// 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());

@@ -1130,10 +1130,10 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM

// 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);

@@ -1141,21 +1141,21 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM

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());

@@ -1170,13 +1170,13 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM

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

@@ -1185,16 +1185,16 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM

// 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());

@@ -1225,10 +1225,10 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithC

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());

@@ -1241,10 +1241,10 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithC

// 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());

@@ -1271,8 +1271,8 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatI

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());

@@ -1281,8 +1281,8 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatI

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());

}

@@ -1296,8 +1296,8 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatH

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);

@@ -1306,7 +1306,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatH

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());

@@ -1319,10 +1319,10 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatH

// 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());

@@ -1344,7 +1344,7 @@ TEST(LayerTreeHostCommonTest, verifyClipRectCullsRenderSurfaces)

// 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();

@@ -1399,7 +1399,7 @@ TEST(LayerTreeHostCommonTest, verifyClipRectCullsSurfaceWithoutVisibleContent)

// 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();

@@ -1457,7 +1457,7 @@ TEST(LayerTreeHostCommonTest, verifyIsClippedIsSetCorrectly)

// - 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();

@@ -1552,7 +1552,7 @@ TEST(LayerTreeHostCommonTest, verifyDrawableContentRectForLayers)

// 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();

@@ -1602,7 +1602,7 @@ TEST(LayerTreeHostCommonTest, verifyClipRectIsPropagatedCorrectlyToSurfaces)

// 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();

@@ -1693,10 +1693,10 @@ TEST(LayerTreeHostCommonTest, verifyAnimationsForRenderSurfaceHierarchy)

// 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);

@@ -1791,17 +1791,17 @@ TEST(LayerTreeHostCommonTest, verifyAnimationsForRenderSurfaceHierarchy)