Only create instances of WebTransformOperations using cc::TransformOperations::Create

webkit/compositor_bindings/web_transform_operations_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "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"
 
 using namespace WebKit;
 
 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);
 
     for (size_t i = 0; i < transforms.size(); ++i) {
         for (size_t j = 0; j < transforms.size(); ++j) {
             bool matchesType = transforms[i]->matchesTypes(*transforms[j]);
             EXPECT_TRUE((i == j && matchesType) || !matchesType);
         }
     }
 }
 
 TEST(WebTransformOperationTest, matchTypesSameLength)
 {
-    WebTransformOperations translates;
-    translates.appendTranslate(1, 0, 0);
-    translates.appendTranslate(1, 0, 0);
-    translates.appendTranslate(1, 0, 0);
+    scoped_ptr<WebTransformOperations> translates(
+        cc::TransformOperations::Create());
+    translates->appendTranslate(1, 0, 0);
+    translates->appendTranslate(1, 0, 0);
+    translates->appendTranslate(1, 0, 0);
 
-    WebTransformOperations skews;
-    skews.appendSkew(0, 2);
-    skews.appendSkew(0, 2);
-    skews.appendSkew(0, 2);
+    scoped_ptr<WebTransformOperations> skews(
+        cc::TransformOperations::Create());
+    skews->appendSkew(0, 2);
+    skews->appendSkew(0, 2);
+    skews->appendSkew(0, 2);
 
-    WebTransformOperations translates2;
-    translates2.appendTranslate(0, 2, 0);
-    translates2.appendTranslate(0, 2, 0);
-    translates2.appendTranslate(0, 2, 0);
+    scoped_ptr<WebTransformOperations> translates2(
+        cc::TransformOperations::Create());
+    translates2->appendTranslate(0, 2, 0);
+    translates2->appendTranslate(0, 2, 0);
+    translates2->appendTranslate(0, 2, 0);
 
-    WebTransformOperations translates3 = translates2;
+    scoped_ptr<WebTransformOperations> translates3(
+        cc::TransformOperations::Create(*translates2));
 
-    EXPECT_FALSE(translates.matchesTypes(skews));
-    EXPECT_TRUE(translates.matchesTypes(translates2));
-    EXPECT_TRUE(translates.matchesTypes(translates3));
+    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);
-    translates.appendTranslate(1, 0, 0);
-    translates.appendTranslate(1, 0, 0);
+    scoped_ptr<WebTransformOperations> translates(
+        cc::TransformOperations::Create());
+    translates->appendTranslate(1, 0, 0);
+    translates->appendTranslate(1, 0, 0);
+    translates->appendTranslate(1, 0, 0);
 
-    WebTransformOperations skews;
-    skews.appendSkew(2, 0);
-    skews.appendSkew(2, 0);
+    scoped_ptr<WebTransformOperations> skews(
+        cc::TransformOperations::Create());
+    skews->appendSkew(2, 0);
+    skews->appendSkew(2, 0);
 
-    WebTransformOperations translates2;
-    translates2.appendTranslate(0, 2, 0);
-    translates2.appendTranslate(0, 2, 0);
+    scoped_ptr<WebTransformOperations> translates2(
+        cc::TransformOperations::Create());
+    translates2->appendTranslate(0, 2, 0);
+    translates2->appendTranslate(0, 2, 0);
 
-    EXPECT_FALSE(translates.matchesTypes(skews));
-    EXPECT_FALSE(translates.matchesTypes(translates2));
+    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);
     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);
     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);
     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);
     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());
     toAdd->appendMatrix(WebTransformationMatrix());
     operations->push_back(toAdd);
 }
 
 TEST(WebTransformOperationTest, identityAlwaysMatches)
 {
     ScopedVector<WebTransformOperations> operations;
     getIdentityOperations(&operations);
 
     for (size_t i = 0; i < operations.size(); ++i) {
         for (size_t j = 0; j < operations.size(); ++j)
             EXPECT_TRUE(operations[i]->matchesTypes(*operations[j]));
     }
 }
 
 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)
 {
     double x = 1;
     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)
 {
     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)
 {
     double dx = 1;
     double dy = 2;
     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)
 {
     double sx = 2;
     double sy = 4;
     double sz = 8;
 
     double dx = 1;
     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);
 
     WebTransformationMatrix expectedTranslateMatrix;
     expectedTranslateMatrix.translate3d(dx, dy, dz);
 
     WebTransformationMatrix expectedCombinedMatrix = expectedScaleMatrix;
     expectedCombinedMatrix.multiply(expectedTranslateMatrix);
 
-    EXPECT_TRANSFORMATION_MATRIX_EQ(expectedCombinedMatrix, operations.apply());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(expectedCombinedMatrix, operations->apply());
 }
 
 TEST(WebTransformOperationTest, blendOrder)
 {
     double sx1 = 2;
     double sy1 = 4;
     double sz1 = 8;
 
     double dx1 = 1;
     double dy1 = 2;
     double dz1 = 3;
 
     double sx2 = 4;
     double sy2 = 8;
     double sz2 = 16;
 
     double dx2 = 10;
     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);
     WebTransformationMatrix translateFrom;
     translateFrom.translate3d(dx1, dy1, dz1);
 
     WebTransformationMatrix scaleTo;
     scaleTo.scale3d(sx2, sy2, sz2);
     WebTransformationMatrix translateTo;
     translateTo.translate3d(dx2, dy2, dz2);
 
     double progress = 0.25;
 
     WebTransformationMatrix blendedScale = scaleTo;
     blendedScale.blend(scaleFrom, progress);
 
     WebTransformationMatrix blendedTranslate = translateTo;
     blendedTranslate.blend(translateFrom, progress);
 
     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,
                           const WebTransformationMatrix& fromMatrix,
                           const WebTransformationMatrix& toMatrix,
                           const WebTransformOperations& fromTransform,
                           const WebTransformOperations& toTransform)
 {
     WebTransformationMatrix expectedMatrix = toMatrix;
     expectedMatrix.blend(fromMatrix, progress);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedMatrix, toTransform.blend(fromTransform, progress));
 }
 
 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);
 
     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)
 {
     double sx1 = 2;
     double sy1 = 4;
     double sz1 = 8;
 
     double dx1 = 1;
     double dy1 = 2;
     double dz1 = 3;
 
     double sx2 = 4;
     double sy2 = 8;
     double sz2 = 16;
 
     double dx2 = 10;
     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);
     from.translate3d(dx1, dy1, dz1);
 
     WebTransformationMatrix to;
     to.translate3d(dx2, dy2, dz2);
     to.scale3d(sx2, sy2, sz2);
 
     double progress = 0.25;
 
     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;
     matrixFrom.rotate3d(0, 0, 1, 180);
 
     WebTransformationMatrix matrixTo;
     matrixTo.rotate3d(0, 1, 0, 180);
 
     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)
 {
     ScopedVector<WebTransformOperations> identityOperations;
     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));
     }
 }
 
 TEST(WebTransformOperationTest, blendTranslationFromIdentity)
 {
     ScopedVector<WebTransformOperations> identityOperations;
     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));
     }
 }
 
 TEST(WebTransformOperationTest, blendScaleFromIdentity)
 {
     ScopedVector<WebTransformOperations> identityOperations;
     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));
     }
 }
 
 TEST(WebTransformOperationTest, blendSkewFromIdentity)
 {
     ScopedVector<WebTransformOperations> identityOperations;
     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;
 
         WebTransformationMatrix expected;
         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));
     }
 }
 
 TEST(WebTransformOperationTest, blendPerspectiveFromIdentity)
 {
     ScopedVector<WebTransformOperations> identityOperations;
     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));
     }
 }
 
 TEST(WebTransformOperationTest, blendRotationToIdentity)
 {
     ScopedVector<WebTransformOperations> identityOperations;
     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));
     }
 }
 
 TEST(WebTransformOperationTest, blendTranslationToIdentity)
 {
     ScopedVector<WebTransformOperations> identityOperations;
     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));
     }
 }
 
 TEST(WebTransformOperationTest, blendScaleToIdentity)
 {
     ScopedVector<WebTransformOperations> identityOperations;
     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));
     }
 }
 
 TEST(WebTransformOperationTest, blendSkewToIdentity)
 {
     ScopedVector<WebTransformOperations> identityOperations;
     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;
 
         WebTransformationMatrix expected;
         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));
     }
 }
 
 TEST(WebTransformOperationTest, blendPerspectiveToIdentity)
 {
     ScopedVector<WebTransformOperations> identityOperations;
     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));
     }
 }