webkit/compositor_bindings/web_transform_operations_unittest.cc - Issue 11644004: Only create instances of WebTransformOperations using cc::TransformOperations::Create

Unified Diff: webkit/compositor_bindings/web_transform_operations_unittest.cc

Issue 11644004: Only create instances of WebTransformOperations using cc::TransformOperations::Create (Closed) Base URL: http://git.chromium.org/chromium/src.git@master

Patch Set: Rebase, and fix WebTransformAnimationCurveImpl Created 8 years 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

« webkit/compositor_bindings/web_transform_animation_curve_impl.cc ('K') | « webkit/compositor_bindings/web_transform_animation_curve_unittest.cc ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: webkit/compositor_bindings/web_transform_operations_unittest.cc

diff --git a/webkit/compositor_bindings/web_transform_operations_unittest.cc b/webkit/compositor_bindings/web_transform_operations_unittest.cc

index 2c17082b8494345732a711bfc76d8e6877999997..14094a87baeabcd5638bc119a642a6120d9e6a37 100644

--- a/webkit/compositor_bindings/web_transform_operations_unittest.cc

+++ b/webkit/compositor_bindings/web_transform_operations_unittest.cc

@@ -2,8 +2,10 @@

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

+#include "base/memory/scoped_ptr.h"

#include "base/memory/scoped_vector.h"

#include "cc/test/geometry_test_utils.h"

+#include "cc/transform_operations.h"

#include "testing/gtest/include/gtest/gtest.h"

#include "third_party/WebKit/Source/Platform/chromium/public/WebTransformOperations.h"

#include "third_party/WebKit/Source/Platform/chromium/public/WebTransformationMatrix.h"

@@ -14,23 +16,23 @@ TEST(WebTransformOperationTest, transformTypesAreUnique)

{

ScopedVector<WebTransformOperations> transforms;

- WebTransformOperations* toAdd = new WebTransformOperations();

+ WebTransformOperations* toAdd = cc::TransformOperations::Create();

toAdd->appendTranslate(1, 0, 0);

transforms.push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendRotate(0, 0, 1, 2);

transforms.push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendScale(2, 2, 2);

transforms.push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendSkew(1, 0);

transforms.push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendPerspective(800);

transforms.push_back(toAdd);

@@ -44,93 +46,100 @@ TEST(WebTransformOperationTest, transformTypesAreUnique)

TEST(WebTransformOperationTest, matchTypesSameLength)

{

- WebTransformOperations translates;

- translates.appendTranslate(1, 0, 0);

- WebTransformOperations skews;

- skews.appendSkew(0, 2);

- WebTransformOperations translates2;

- translates2.appendTranslate(0, 2, 0);

- WebTransformOperations translates3 = translates2;

- EXPECT_FALSE(translates.matchesTypes(skews));

- EXPECT_TRUE(translates.matchesTypes(translates2));

- EXPECT_TRUE(translates.matchesTypes(translates3));

+ scoped_ptr<WebTransformOperations> translates(

+ cc::TransformOperations::Create());

+ translates->appendTranslate(1, 0, 0);

+ scoped_ptr<WebTransformOperations> skews(

+ cc::TransformOperations::Create());

+ skews->appendSkew(0, 2);

+ scoped_ptr<WebTransformOperations> translates2(

+ cc::TransformOperations::Create());

+ translates2->appendTranslate(0, 2, 0);

+ scoped_ptr<WebTransformOperations> translates3(

+ cc::TransformOperations::Create(*translates2));

+ EXPECT_FALSE(translates->matchesTypes(*skews));

+ EXPECT_TRUE(translates->matchesTypes(*translates2));

+ EXPECT_TRUE(translates->matchesTypes(*translates3));

}

TEST(WebTransformOperationTest, matchTypesDifferentLength)

{

- WebTransformOperations translates;

- translates.appendTranslate(1, 0, 0);

- WebTransformOperations skews;

- skews.appendSkew(2, 0);

- WebTransformOperations translates2;

- translates2.appendTranslate(0, 2, 0);

- EXPECT_FALSE(translates.matchesTypes(skews));

- EXPECT_FALSE(translates.matchesTypes(translates2));

+ scoped_ptr<WebTransformOperations> translates(

+ cc::TransformOperations::Create());

+ translates->appendTranslate(1, 0, 0);

+ scoped_ptr<WebTransformOperations> skews(

+ cc::TransformOperations::Create());

+ skews->appendSkew(2, 0);

+ scoped_ptr<WebTransformOperations> translates2(

+ cc::TransformOperations::Create());

+ translates2->appendTranslate(0, 2, 0);

+ EXPECT_FALSE(translates->matchesTypes(*skews));

+ EXPECT_FALSE(translates->matchesTypes(*translates2));

}

void getIdentityOperations(ScopedVector<WebTransformOperations>* operations)

{

- WebTransformOperations* toAdd = new WebTransformOperations();

+ WebTransformOperations* toAdd = cc::TransformOperations::Create();

operations->push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendTranslate(0, 0, 0);

operations->push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendTranslate(0, 0, 0);

operations->push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendScale(1, 1, 1);

operations->push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendScale(1, 1, 1);

operations->push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendSkew(0, 0);

operations->push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendSkew(0, 0);

operations->push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendRotate(0, 0, 1, 0);

operations->push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendRotate(0, 0, 1, 0);

operations->push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendMatrix(WebTransformationMatrix());

operations->push_back(toAdd);

- toAdd = new WebTransformOperations();

+ toAdd = cc::TransformOperations::Create();

toAdd->appendMatrix(WebTransformationMatrix());

operations->push_back(toAdd);

@@ -152,11 +161,12 @@ TEST(WebTransformOperationTest, applyTranslate)

double x = 1;

double y = 2;

double z = 3;

- WebTransformOperations operations;

- operations.appendTranslate(x, y, z);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendTranslate(x, y, z);

WebTransformationMatrix expected;

expected.translate3d(x, y, z);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply());

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations->apply());

}

TEST(WebTransformOperationTest, applyRotate)

@@ -165,11 +175,12 @@ TEST(WebTransformOperationTest, applyRotate)

double y = 2;

double z = 3;

double degrees = 80;

- WebTransformOperations operations;

- operations.appendRotate(x, y, z, degrees);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendRotate(x, y, z, degrees);

WebTransformationMatrix expected;

expected.rotate3d(x, y, z, degrees);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply());

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations->apply());

}

TEST(WebTransformOperationTest, applyScale)

@@ -177,33 +188,36 @@ TEST(WebTransformOperationTest, applyScale)

double x = 1;

double y = 2;

double z = 3;

- WebTransformOperations operations;

- operations.appendScale(x, y, z);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendScale(x, y, z);

WebTransformationMatrix expected;

expected.scale3d(x, y, z);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply());

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations->apply());

}

TEST(WebTransformOperationTest, applySkew)

{

double x = 1;

double y = 2;

- WebTransformOperations operations;

- operations.appendSkew(x, y);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendSkew(x, y);

WebTransformationMatrix expected;

expected.skewX(x);

expected.skewY(y);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply());

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations->apply());

}

TEST(WebTransformOperationTest, applyPerspective)

{

double depth = 800;

- WebTransformOperations operations;

- operations.appendPerspective(depth);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendPerspective(depth);

WebTransformationMatrix expected;

expected.applyPerspective(depth);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply());

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations->apply());

}

TEST(WebTransformOperationTest, applyMatrix)

@@ -213,9 +227,10 @@ TEST(WebTransformOperationTest, applyMatrix)

double dz = 3;

WebTransformationMatrix expectedMatrix;

expectedMatrix.translate3d(dx, dy, dz);

- WebTransformOperations matrixTransform;

- matrixTransform.appendMatrix(expectedMatrix);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedMatrix, matrixTransform.apply());

+ scoped_ptr<WebTransformOperations> matrixTransform(

+ cc::TransformOperations::Create());

+ matrixTransform->appendMatrix(expectedMatrix);

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expectedMatrix, matrixTransform->apply());

}

TEST(WebTransformOperationTest, applyOrder)

@@ -228,9 +243,10 @@ TEST(WebTransformOperationTest, applyOrder)

double dy = 2;

double dz = 3;

- WebTransformOperations operations;

- operations.appendScale(sx, sy, sz);

- operations.appendTranslate(dx, dy, dz);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendScale(sx, sy, sz);

+ operations->appendTranslate(dx, dy, dz);

WebTransformationMatrix expectedScaleMatrix;

expectedScaleMatrix.scale3d(sx, sy, sz);

@@ -241,7 +257,7 @@ TEST(WebTransformOperationTest, applyOrder)

WebTransformationMatrix expectedCombinedMatrix = expectedScaleMatrix;

expectedCombinedMatrix.multiply(expectedTranslateMatrix);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedCombinedMatrix, operations.apply());

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expectedCombinedMatrix, operations->apply());

}

TEST(WebTransformOperationTest, blendOrder)

@@ -262,13 +278,15 @@ TEST(WebTransformOperationTest, blendOrder)

double dy2 = 20;

double dz2 = 30;

- WebTransformOperations operationsFrom;

- operationsFrom.appendScale(sx1, sy1, sz1);

- operationsFrom.appendTranslate(dx1, dy1, dz1);

+ scoped_ptr<WebTransformOperations> operationsFrom(

+ cc::TransformOperations::Create());

+ operationsFrom->appendScale(sx1, sy1, sz1);

+ operationsFrom->appendTranslate(dx1, dy1, dz1);

- WebTransformOperations operationsTo;

- operationsTo.appendScale(sx2, sy2, sz2);

- operationsTo.appendTranslate(dx2, dy2, dz2);

+ scoped_ptr<WebTransformOperations> operationsTo(

+ cc::TransformOperations::Create());

+ operationsTo->appendScale(sx2, sy2, sz2);

+ operationsTo->appendTranslate(dx2, dy2, dz2);

WebTransformationMatrix scaleFrom;

scaleFrom.scale3d(sx1, sy1, sz1);

@@ -291,7 +309,7 @@ TEST(WebTransformOperationTest, blendOrder)

WebTransformationMatrix expected = blendedScale;

expected.multiply(blendedTranslate);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo->blend(*operationsFrom, progress));

}

static void checkProgress(double progress,

@@ -310,8 +328,9 @@ TEST(WebTransformOperationTest, blendProgress)

double sx = 2;

double sy = 4;

double sz = 8;

- WebTransformOperations operationsFrom;

- operationsFrom.appendScale(sx, sy, sz);

+ scoped_ptr<WebTransformOperations> operationsFrom(

+ cc::TransformOperations::Create());

+ operationsFrom->appendScale(sx, sy, sz);

WebTransformationMatrix matrixFrom;

matrixFrom.scale3d(sx, sy, sz);

@@ -319,18 +338,19 @@ TEST(WebTransformOperationTest, blendProgress)

sx = 4;

sy = 8;

sz = 16;

- WebTransformOperations operationsTo;

- operationsTo.appendScale(sx, sy, sz);

+ scoped_ptr<WebTransformOperations> operationsTo(

+ cc::TransformOperations::Create());

+ operationsTo->appendScale(sx, sy, sz);

WebTransformationMatrix matrixTo;

matrixTo.scale3d(sx, sy, sz);

- checkProgress(-1, matrixFrom, matrixTo, operationsFrom, operationsTo);

- checkProgress(0, matrixFrom, matrixTo, operationsFrom, operationsTo);

- checkProgress(0.25, matrixFrom, matrixTo, operationsFrom, operationsTo);

- checkProgress(0.5, matrixFrom, matrixTo, operationsFrom, operationsTo);

- checkProgress(1, matrixFrom, matrixTo, operationsFrom, operationsTo);

- checkProgress(2, matrixFrom, matrixTo, operationsFrom, operationsTo);

+ checkProgress(-1, matrixFrom, matrixTo, *operationsFrom, *operationsTo);

+ checkProgress(0, matrixFrom, matrixTo, *operationsFrom, *operationsTo);

+ checkProgress(0.25, matrixFrom, matrixTo, *operationsFrom, *operationsTo);

+ checkProgress(0.5, matrixFrom, matrixTo, *operationsFrom, *operationsTo);

+ checkProgress(1, matrixFrom, matrixTo, *operationsFrom, *operationsTo);

+ checkProgress(2, matrixFrom, matrixTo, *operationsFrom, *operationsTo);

}

TEST(WebTransformOperationTest, blendWhenTypesDoNotMatch)

@@ -351,13 +371,15 @@ TEST(WebTransformOperationTest, blendWhenTypesDoNotMatch)

double dy2 = 20;

double dz2 = 30;

- WebTransformOperations operationsFrom;

- operationsFrom.appendScale(sx1, sy1, sz1);

- operationsFrom.appendTranslate(dx1, dy1, dz1);

+ scoped_ptr<WebTransformOperations> operationsFrom(

+ cc::TransformOperations::Create());

+ operationsFrom->appendScale(sx1, sy1, sz1);

+ operationsFrom->appendTranslate(dx1, dy1, dz1);

- WebTransformOperations operationsTo;

- operationsTo.appendTranslate(dx2, dy2, dz2);

- operationsTo.appendScale(sx2, sy2, sz2);

+ scoped_ptr<WebTransformOperations> operationsTo(

+ cc::TransformOperations::Create());

+ operationsTo->appendTranslate(dx2, dy2, dz2);

+ operationsTo->appendScale(sx2, sy2, sz2);

WebTransformationMatrix from;

from.scale3d(sx1, sy1, sz1);

@@ -372,47 +394,53 @@ TEST(WebTransformOperationTest, blendWhenTypesDoNotMatch)

WebTransformationMatrix expected = to;

expected.blend(from, progress);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo->blend(*operationsFrom, progress));

}

TEST(WebTransformOperationTest, largeRotationsWithSameAxis)

{

- WebTransformOperations operationsFrom;

- operationsFrom.appendRotate(0, 0, 1, 0);

+ scoped_ptr<WebTransformOperations> operationsFrom(

+ cc::TransformOperations::Create());

+ operationsFrom->appendRotate(0, 0, 1, 0);

- WebTransformOperations operationsTo;

- operationsTo.appendRotate(0, 0, 2, 360);

+ scoped_ptr<WebTransformOperations> operationsTo(

+ cc::TransformOperations::Create());

+ operationsTo->appendRotate(0, 0, 2, 360);

double progress = 0.5;

WebTransformationMatrix expected;

expected.rotate3d(0, 0, 1, 180);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo->blend(*operationsFrom, progress));

}

TEST(WebTransformOperationTest, largeRotationsWithSameAxisInDifferentDirection)

{

- WebTransformOperations operationsFrom;

- operationsFrom.appendRotate(0, 0, 1, 180);

+ scoped_ptr<WebTransformOperations> operationsFrom(

+ cc::TransformOperations::Create());

+ operationsFrom->appendRotate(0, 0, 1, 180);

- WebTransformOperations operationsTo;

- operationsTo.appendRotate(0, 0, -1, 180);

+ scoped_ptr<WebTransformOperations> operationsTo(

+ cc::TransformOperations::Create());

+ operationsTo->appendRotate(0, 0, -1, 180);

double progress = 0.5;

WebTransformationMatrix expected;

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo->blend(*operationsFrom, progress));

}

TEST(WebTransformOperationTest, largeRotationsWithDifferentAxes)

{

- WebTransformOperations operationsFrom;

- operationsFrom.appendRotate(0, 0, 1, 180);

+ scoped_ptr<WebTransformOperations> operationsFrom(

+ cc::TransformOperations::Create());

+ operationsFrom->appendRotate(0, 0, 1, 180);

- WebTransformOperations operationsTo;

- operationsTo.appendRotate(0, 1, 0, 180);

+ scoped_ptr<WebTransformOperations> operationsTo(

+ cc::TransformOperations::Create());

+ operationsTo->appendRotate(0, 1, 0, 180);

double progress = 0.5;

WebTransformationMatrix matrixFrom;

@@ -424,7 +452,7 @@ TEST(WebTransformOperationTest, largeRotationsWithDifferentAxes)

WebTransformationMatrix expected = matrixTo;

expected.blend(matrixFrom, progress);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo->blend(*operationsFrom, progress));

}

TEST(WebTransformOperationTest, blendRotationFromIdentity)

@@ -433,15 +461,16 @@ TEST(WebTransformOperationTest, blendRotationFromIdentity)

getIdentityOperations(&identityOperations);

for (size_t i = 0; i < identityOperations.size(); ++i) {

- WebTransformOperations operations;

- operations.appendRotate(0, 0, 1, 360);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendRotate(0, 0, 1, 360);

double progress = 0.5;

WebTransformationMatrix expected;

expected.rotate3d(0, 0, 1, 180);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOperations[i], progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations->blend(*identityOperations[i], progress));

}

@@ -451,15 +480,16 @@ TEST(WebTransformOperationTest, blendTranslationFromIdentity)

getIdentityOperations(&identityOperations);

for (size_t i = 0; i < identityOperations.size(); ++i) {

- WebTransformOperations operations;

- operations.appendTranslate(2, 2, 2);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendTranslate(2, 2, 2);

double progress = 0.5;

WebTransformationMatrix expected;

expected.translate3d(1, 1, 1);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOperations[i], progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations->blend(*identityOperations[i], progress));

}

@@ -469,15 +499,16 @@ TEST(WebTransformOperationTest, blendScaleFromIdentity)

getIdentityOperations(&identityOperations);

for (size_t i = 0; i < identityOperations.size(); ++i) {

- WebTransformOperations operations;

- operations.appendScale(3, 3, 3);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendScale(3, 3, 3);

double progress = 0.5;

WebTransformationMatrix expected;

expected.scale3d(2, 2, 2);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOperations[i], progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations->blend(*identityOperations[i], progress));

}

@@ -487,8 +518,9 @@ TEST(WebTransformOperationTest, blendSkewFromIdentity)

getIdentityOperations(&identityOperations);

for (size_t i = 0; i < identityOperations.size(); ++i) {

- WebTransformOperations operations;

- operations.appendSkew(2, 2);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendSkew(2, 2);

double progress = 0.5;

@@ -496,7 +528,7 @@ TEST(WebTransformOperationTest, blendSkewFromIdentity)

expected.skewX(1);

expected.skewY(1);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOperations[i], progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations->blend(*identityOperations[i], progress));

}

@@ -506,15 +538,16 @@ TEST(WebTransformOperationTest, blendPerspectiveFromIdentity)

getIdentityOperations(&identityOperations);

for (size_t i = 0; i < identityOperations.size(); ++i) {

- WebTransformOperations operations;

- operations.appendPerspective(1000);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendPerspective(1000);

double progress = 0.5;

WebTransformationMatrix expected;

expected.applyPerspective(500 + 0.5 * std::numeric_limits<double>::max());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOperations[i], progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations->blend(*identityOperations[i], progress));

}

@@ -524,15 +557,16 @@ TEST(WebTransformOperationTest, blendRotationToIdentity)

getIdentityOperations(&identityOperations);

for (size_t i = 0; i < identityOperations.size(); ++i) {

- WebTransformOperations operations;

- operations.appendRotate(0, 0, 1, 360);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendRotate(0, 0, 1, 360);

double progress = 0.5;

WebTransformationMatrix expected;

expected.rotate3d(0, 0, 1, 180);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(operations, progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(*operations, progress));

}

@@ -542,15 +576,16 @@ TEST(WebTransformOperationTest, blendTranslationToIdentity)

getIdentityOperations(&identityOperations);

for (size_t i = 0; i < identityOperations.size(); ++i) {

- WebTransformOperations operations;

- operations.appendTranslate(2, 2, 2);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendTranslate(2, 2, 2);

double progress = 0.5;

WebTransformationMatrix expected;

expected.translate3d(1, 1, 1);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(operations, progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(*operations, progress));

}

@@ -560,15 +595,16 @@ TEST(WebTransformOperationTest, blendScaleToIdentity)

getIdentityOperations(&identityOperations);

for (size_t i = 0; i < identityOperations.size(); ++i) {

- WebTransformOperations operations;

- operations.appendScale(3, 3, 3);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendScale(3, 3, 3);

double progress = 0.5;

WebTransformationMatrix expected;

expected.scale3d(2, 2, 2);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(operations, progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(*operations, progress));

}

@@ -578,8 +614,9 @@ TEST(WebTransformOperationTest, blendSkewToIdentity)

getIdentityOperations(&identityOperations);

for (size_t i = 0; i < identityOperations.size(); ++i) {

- WebTransformOperations operations;

- operations.appendSkew(2, 2);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendSkew(2, 2);

double progress = 0.5;

@@ -587,7 +624,7 @@ TEST(WebTransformOperationTest, blendSkewToIdentity)

expected.skewX(1);

expected.skewY(1);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(operations, progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(*operations, progress));

}

@@ -597,14 +634,15 @@ TEST(WebTransformOperationTest, blendPerspectiveToIdentity)

getIdentityOperations(&identityOperations);

for (size_t i = 0; i < identityOperations.size(); ++i) {

- WebTransformOperations operations;

- operations.appendPerspective(1000);

+ scoped_ptr<WebTransformOperations> operations(

+ cc::TransformOperations::Create());

+ operations->appendPerspective(1000);

double progress = 0.5;

WebTransformationMatrix expected;

expected.applyPerspective(500 + 0.5 * std::numeric_limits<double>::max());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(operations, progress));

+ EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(*operations, progress));

}