Transform animations should not collapse by default when interpolating

cc/animation/transform_operations_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/animation/transform_operations.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/geometry/box_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/vector3d_f.h"
 
 namespace cc {
 namespace {
 
+void ExpectTransformOperationEqual(const TransformOperation& lhs,
+                                   const TransformOperation& rhs) {
+  EXPECT_EQ(lhs.type, rhs.type);
+  EXPECT_TRANSFORMATION_MATRIX_EQ(lhs.matrix, rhs.matrix);
+  switch (lhs.type) {
+    case TransformOperation::TRANSFORM_OPERATION_TRANSLATE:
+      EXPECT_FLOAT_EQ(lhs.translate.x, rhs.translate.x);
+      EXPECT_FLOAT_EQ(lhs.translate.y, rhs.translate.y);
+      EXPECT_FLOAT_EQ(lhs.translate.z, rhs.translate.z);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_ROTATE:
+      EXPECT_FLOAT_EQ(lhs.rotate.axis.x, rhs.rotate.axis.x);
+      EXPECT_FLOAT_EQ(lhs.rotate.axis.y, rhs.rotate.axis.y);
+      EXPECT_FLOAT_EQ(lhs.rotate.axis.z, rhs.rotate.axis.z);
+      EXPECT_FLOAT_EQ(lhs.rotate.angle, rhs.rotate.angle);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_SCALE:
+      EXPECT_FLOAT_EQ(lhs.scale.x, rhs.scale.x);
+      EXPECT_FLOAT_EQ(lhs.scale.y, rhs.scale.y);
+      EXPECT_FLOAT_EQ(lhs.scale.z, rhs.scale.z);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_SKEW:
+      EXPECT_FLOAT_EQ(lhs.skew.x, rhs.skew.x);
+      EXPECT_FLOAT_EQ(lhs.skew.y, rhs.skew.y);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE:
+      EXPECT_FLOAT_EQ(lhs.perspective_depth, rhs.perspective_depth);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_MATRIX:
+    case TransformOperation::TRANSFORM_OPERATION_IDENTITY:
+      break;
+  }
+}
+
 TEST(TransformOperationTest, TransformTypesAreUnique) {
   std::vector<std::unique_ptr<TransformOperations>> transforms;
 
   std::unique_ptr<TransformOperations> to_add(
       base::MakeUnique<TransformOperations>());
   to_add->AppendTranslate(1, 0, 0);
   transforms.push_back(std::move(to_add));
 
   to_add = base::MakeUnique<TransformOperations>();
   to_add->AppendRotate(0, 0, 1, 2);
@@ skipping 263 matching lines @@
   gfx::Transform translate_from;
   translate_from.Translate3d(dx1, dy1, dz1);
 
   gfx::Transform scale_to;
   scale_to.Scale3d(sx2, sy2, sz2);
   gfx::Transform translate_to;
   translate_to.Translate3d(dx2, dy2, dz2);
 
   SkMScalar progress = 0.25f;
 
+  TransformOperations operations_expected;
+  operations_expected.AppendScale(
+      gfx::Tween::FloatValueBetween(progress, sx1, sx2),
+      gfx::Tween::FloatValueBetween(progress, sy1, sy2),
+      gfx::Tween::FloatValueBetween(progress, sz1, sz2));
+
+  operations_expected.AppendTranslate(
+      gfx::Tween::FloatValueBetween(progress, dx1, dx2),
+      gfx::Tween::FloatValueBetween(progress, dy1, dy2),
+      gfx::Tween::FloatValueBetween(progress, dz1, dz2));
+
   gfx::Transform blended_scale = scale_to;
   blended_scale.Blend(scale_from, progress);
 
   gfx::Transform blended_translate = translate_to;
   blended_translate.Blend(translate_from, progress);
 
   gfx::Transform expected = blended_scale;
   expected.PreconcatTransform(blended_translate);
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations_to.Blend(operations_from, progress));
+  TransformOperations blended = operations_to.Blend(operations_from, progress);
+
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected, blended.Apply());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(operations_expected.Apply(), blended.Apply());
+  EXPECT_EQ(operations_expected.size(), blended.size());
+  for (size_t i = 0; i < operations_expected.size(); ++i) {
+    TransformOperation expected_op = operations_expected.at(i);
+    TransformOperation blended_op = blended.at(i);
+    SCOPED_TRACE(i);
+    ExpectTransformOperationEqual(expected_op, blended_op);
+  }
+
+  // Create a mismatch, forcing matrix interpolation.
+  operations_to.AppendMatrix(gfx::Transform());
+
+  blended = operations_to.Blend(operations_from, progress);
+
+  expected = operations_to.Apply();
+  expected.Blend(operations_from.Apply(), progress);
+
+  operations_expected = TransformOperations();
+  operations_expected.AppendMatrix(expected);
+
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected, blended.Apply());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(operations_expected.Apply(), blended.Apply());
+  EXPECT_EQ(operations_expected.size(), blended.size());
+  for (size_t i = 0; i < operations_expected.size(); ++i) {
+    TransformOperation expected_op = operations_expected.at(i);
+    TransformOperation blended_op = blended.at(i);
+    SCOPED_TRACE(i);
+    ExpectTransformOperationEqual(expected_op, blended_op);
+  }
 }
 
 static void CheckProgress(SkMScalar progress,
                           const gfx::Transform& from_matrix,
                           const gfx::Transform& to_matrix,
                           const TransformOperations& from_transform,
                           const TransformOperations& to_transform) {
   gfx::Transform expected_matrix = to_matrix;
   expected_matrix.Blend(from_matrix, progress);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected_matrix, to_transform.Blend(from_transform, progress));
+      expected_matrix, to_transform.Blend(from_transform, progress).Apply());
 }
 
 TEST(TransformOperationTest, BlendProgress) {
   SkMScalar sx = 2;
   SkMScalar sy = 4;
   SkMScalar sz = 8;
   TransformOperations operations_from;
   operations_from.AppendScale(sx, sy, sz);
 
   gfx::Transform matrix_from;
@@ skipping 48 matching lines @@
   gfx::Transform to;
   to.Translate3d(dx2, dy2, dz2);
   to.Scale3d(sx2, sy2, sz2);
 
   SkMScalar progress = 0.25f;
 
   gfx::Transform expected = to;
   expected.Blend(from, progress);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations_to.Blend(operations_from, progress));
+      expected, operations_to.Blend(operations_from, progress).Apply());
 }
 
 TEST(TransformOperationTest, LargeRotationsWithSameAxis) {
   TransformOperations operations_from;
   operations_from.AppendRotate(0, 0, 1, 0);
 
   TransformOperations operations_to;
   operations_to.AppendRotate(0, 0, 2, 360);
 
   SkMScalar progress = 0.5f;
 
   gfx::Transform expected;
   expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations_to.Blend(operations_from, progress));
+      expected, operations_to.Blend(operations_from, progress).Apply());
 }
 
 TEST(TransformOperationTest, LargeRotationsWithSameAxisInDifferentDirection) {
   TransformOperations operations_from;
   operations_from.AppendRotate(0, 0, 1, 180);
 
   TransformOperations operations_to;
   operations_to.AppendRotate(0, 0, -1, 180);
 
   SkMScalar progress = 0.5f;
 
   gfx::Transform expected;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations_to.Blend(operations_from, progress));
+      expected, operations_to.Blend(operations_from, progress).Apply());
 }
 
 TEST(TransformOperationTest, LargeRotationsWithDifferentAxes) {
   TransformOperations operations_from;
   operations_from.AppendRotate(0, 0, 1, 175);
 
   TransformOperations operations_to;
   operations_to.AppendRotate(0, 1, 0, 175);
 
   SkMScalar progress = 0.5f;
   gfx::Transform matrix_from;
   matrix_from.RotateAbout(gfx::Vector3dF(0, 0, 1), 175);
 
   gfx::Transform matrix_to;
   matrix_to.RotateAbout(gfx::Vector3dF(0, 1, 0), 175);
 
   gfx::Transform expected = matrix_to;
   expected.Blend(matrix_from, progress);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations_to.Blend(operations_from, progress));
+      expected, operations_to.Blend(operations_from, progress).Apply());
 }
 
 TEST(TransformOperationTest, RotationFromZeroDegDifferentAxes) {
   TransformOperations operations_from;
   operations_from.AppendRotate(0, 0, 1, 0);
 
   TransformOperations operations_to;
   operations_to.AppendRotate(0, 1, 0, 450);
 
   SkMScalar progress = 0.5f;
   gfx::Transform expected;
   expected.RotateAbout(gfx::Vector3dF(0, 1, 0), 225);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations_to.Blend(operations_from, progress));
+      expected, operations_to.Blend(operations_from, progress).Apply());
 }
 
 TEST(TransformOperationTest, RotationFromZeroDegSameAxes) {
   TransformOperations operations_from;
   operations_from.AppendRotate(0, 0, 1, 0);
 
   TransformOperations operations_to;
   operations_to.AppendRotate(0, 0, 1, 450);
 
   SkMScalar progress = 0.5f;
   gfx::Transform expected;
   expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 225);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations_to.Blend(operations_from, progress));
+      expected, operations_to.Blend(operations_from, progress).Apply());
 }
 
 TEST(TransformOperationTest, RotationToZeroDegDifferentAxes) {
   TransformOperations operations_from;
   operations_from.AppendRotate(0, 1, 0, 450);
 
   TransformOperations operations_to;
   operations_to.AppendRotate(0, 0, 1, 0);
 
   SkMScalar progress = 0.5f;
   gfx::Transform expected;
   expected.RotateAbout(gfx::Vector3dF(0, 1, 0), 225);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations_to.Blend(operations_from, progress));
+      expected, operations_to.Blend(operations_from, progress).Apply());
 }
 
 TEST(TransformOperationTest, RotationToZeroDegSameAxes) {
   TransformOperations operations_from;
   operations_from.AppendRotate(0, 0, 1, 450);
 
   TransformOperations operations_to;
   operations_to.AppendRotate(0, 0, 1, 0);
 
   SkMScalar progress = 0.5f;
   gfx::Transform expected;
   expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 225);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations_to.Blend(operations_from, progress));
+      expected, operations_to.Blend(operations_from, progress).Apply());
 }
 
 TEST(TransformOperationTest, BlendRotationFromIdentity) {
   std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendRotate(0, 0, 1, 90);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 45);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+        expected, operations.Blend(*identity_operations[i], progress).Apply());
 
     progress = -0.5f;
 
     expected.MakeIdentity();
     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), -45);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+        expected, operations.Blend(*identity_operations[i], progress).Apply());
 
     progress = 1.5f;
 
     expected.MakeIdentity();
     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 135);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+        expected, operations.Blend(*identity_operations[i], progress).Apply());
   }
 }
 
 TEST(TransformOperationTest, BlendTranslationFromIdentity) {
   std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendTranslate(2, 2, 2);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.Translate3d(1, 1, 1);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+        expected, operations.Blend(*identity_operations[i], progress).Apply());
 
     progress = -0.5f;
 
     expected.MakeIdentity();
     expected.Translate3d(-1, -1, -1);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+        expected, operations.Blend(*identity_operations[i], progress).Apply());
 
     progress = 1.5f;
 
     expected.MakeIdentity();
     expected.Translate3d(3, 3, 3);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+        expected, operations.Blend(*identity_operations[i], progress).Apply());
   }
 }
 
 TEST(TransformOperationTest, BlendScaleFromIdentity) {
   std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendScale(3, 3, 3);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.Scale3d(2, 2, 2);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+        expected, operations.Blend(*identity_operations[i], progress).Apply());
 
     progress = -0.5f;
 
     expected.MakeIdentity();
     expected.Scale3d(0, 0, 0);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+        expected, operations.Blend(*identity_operations[i], progress).Apply());
 
     progress = 1.5f;
 
     expected.MakeIdentity();
     expected.Scale3d(4, 4, 4);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+        expected, operations.Blend(*identity_operations[i], progress).Apply());
   }
 }
 
 TEST(TransformOperationTest, BlendSkewFromEmpty) {
   TransformOperations empty_operation;
 
   TransformOperations operations;
   operations.AppendSkew(2, 2);
 
   SkMScalar progress = 0.5f;
 
   gfx::Transform expected;
   expected.Skew(1, 1);
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
-                                  operations.Blend(empty_operation, progress));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      expected, operations.Blend(empty_operation, progress).Apply());
 
   progress = -0.5f;
 
   expected.MakeIdentity();
   expected.Skew(-1, -1);
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
-                                  operations.Blend(empty_operation, progress));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      expected, operations.Blend(empty_operation, progress).Apply());
 
   progress = 1.5f;
 
   expected.MakeIdentity();
   expected.Skew(3, 3);
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
-                                  operations.Blend(empty_operation, progress));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      expected, operations.Blend(empty_operation, progress).Apply());
 }
 
 TEST(TransformOperationTest, BlendPerspectiveFromIdentity) {
   std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendPerspective(1000);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.ApplyPerspectiveDepth(2000);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+        expected, operations.Blend(*identity_operations[i], progress).Apply());
   }
 }
 
 TEST(TransformOperationTest, BlendRotationToIdentity) {
   std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendRotate(0, 0, 1, 90);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 45);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, identity_operations[i]->Blend(operations, progress));
+        expected, identity_operations[i]->Blend(operations, progress).Apply());
   }
 }
 
 TEST(TransformOperationTest, BlendTranslationToIdentity) {
   std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendTranslate(2, 2, 2);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.Translate3d(1, 1, 1);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, identity_operations[i]->Blend(operations, progress));
+        expected, identity_operations[i]->Blend(operations, progress).Apply());
   }
 }
 
 TEST(TransformOperationTest, BlendScaleToIdentity) {
   std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendScale(3, 3, 3);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.Scale3d(2, 2, 2);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, identity_operations[i]->Blend(operations, progress));
+        expected, identity_operations[i]->Blend(operations, progress).Apply());
   }
 }
 
 TEST(TransformOperationTest, BlendSkewToEmpty) {
   TransformOperations empty_operation;
 
   TransformOperations operations;
   operations.AppendSkew(2, 2);
 
   SkMScalar progress = 0.5f;
 
   gfx::Transform expected;
   expected.Skew(1, 1);
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
-                                  empty_operation.Blend(operations, progress));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      expected, empty_operation.Blend(operations, progress).Apply());
 }
 
 TEST(TransformOperationTest, BlendPerspectiveToIdentity) {
   std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendPerspective(1000);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.ApplyPerspectiveDepth(2000);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, identity_operations[i]->Blend(operations, progress));
+        expected, identity_operations[i]->Blend(operations, progress).Apply());
   }
 }
 
 TEST(TransformOperationTest, ExtrapolatePerspectiveBlending) {
   TransformOperations operations1;
   operations1.AppendPerspective(1000);
 
   TransformOperations operations2;
   operations2.AppendPerspective(500);
 
   gfx::Transform expected;
   expected.ApplyPerspectiveDepth(400);
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations1.Blend(operations2, -0.5));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
+                                  operations1.Blend(operations2, -0.5).Apply());
 
   expected.MakeIdentity();
   expected.ApplyPerspectiveDepth(2000);
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations1.Blend(operations2, 1.5));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
+                                  operations1.Blend(operations2, 1.5).Apply());
 }
 
 TEST(TransformOperationTest, ExtrapolateMatrixBlending) {
   gfx::Transform transform1;
   transform1.Translate3d(1, 1, 1);
   TransformOperations operations1;
   operations1.AppendMatrix(transform1);
 
   gfx::Transform transform2;
   transform2.Translate3d(3, 3, 3);
   TransformOperations operations2;
   operations2.AppendMatrix(transform2);
 
   gfx::Transform expected;
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations1.Blend(operations2, 1.5));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
+                                  operations1.Blend(operations2, 1.5).Apply());
 
   expected.Translate3d(4, 4, 4);
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected, operations1.Blend(operations2, -0.5));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
+                                  operations1.Blend(operations2, -0.5).Apply());
 }
 
 TEST(TransformOperationTest, BlendedBoundsWhenTypesDoNotMatch) {
   TransformOperations operations_from;
   operations_from.AppendScale(2.0, 4.0, 8.0);
   operations_from.AppendTranslate(1.0, 2.0, 3.0);
 
   TransformOperations operations_to;
   operations_to.AppendTranslate(10.0, 20.0, 30.0);
   operations_to.AppendScale(4.0, 8.0, 16.0);
@@ skipping 267 matching lines @@
   gfx::BoxF bounds;
   EXPECT_TRUE(
       to.BlendedBoundsForBox(box, from, min_progress, max_progress, &bounds));
 
   bool first_time = true;
   gfx::BoxF empirical_bounds;
   static const size_t kNumSteps = 10;
   for (size_t step = 0; step < kNumSteps; ++step) {
     float t = step / (kNumSteps - 1.f);
     t = gfx::Tween::FloatValueBetween(t, min_progress, max_progress);
-    gfx::Transform partial_transform = to.Blend(from, t);
+    gfx::Transform partial_transform = to.Blend(from, t).Apply();
     gfx::BoxF transformed = box;
     partial_transform.TransformBox(&transformed);
 
     if (first_time) {
       empirical_bounds = transformed;
       first_time = false;
     } else {
       empirical_bounds.Union(transformed);
     }
   }
@@ skipping 114 matching lines @@
     to_transform.ApplyPerspectiveDepth(1000);
 
     static const int steps = 20;
     for (int i = 0; i < steps; ++i) {
       double progress = static_cast<double>(i) / (steps - 1);
 
       gfx::Transform blended_matrix = to_transform;
       EXPECT_TRUE(blended_matrix.Blend(from_transform, progress));
 
       gfx::Transform blended_transform =
-          to_operations.Blend(from_operations, progress);
+          to_operations.Blend(from_operations, progress).Apply();
 
       EXPECT_TRANSFORMATION_MATRIX_EQ(blended_matrix, blended_transform);
     }
 }
 
 TEST(TransformOperationTest, BlendedBoundsForPerspective) {
   struct {
     float from_depth;
     float to_depth;
   } perspective_depths[] = {
@@ skipping 63 matching lines @@
   operations_to.AppendRotate(0.0, 1.0, 0.0, 135.0);
 
   gfx::BoxF box(0, 0, 0, 1, 1, 1);
   gfx::BoxF bounds;
 
   SkMScalar min_progress = 0.0f;
   SkMScalar max_progress = 1.0f;
   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
       box, operations_from, min_progress, max_progress, &bounds));
   gfx::Transform blended_transform =
-      operations_to.Blend(operations_from, max_progress);
+      operations_to.Blend(operations_from, max_progress).Apply();
   gfx::Point3F blended_point(0.9f, 0.9f, 0.0f);
   blended_transform.TransformPoint(&blended_point);
   gfx::BoxF expanded_bounds = bounds;
   expanded_bounds.ExpandTo(blended_point);
   EXPECT_EQ(bounds.ToString(), expanded_bounds.ToString());
 }
 
 TEST(TransformOperationTest, BlendedBoundsForSequence) {
   TransformOperations operations_from;
   operations_from.AppendTranslate(1.0, -5.0, 1.0);
@@ skipping 209 matching lines @@
   TransformOperations operations16;
   gfx::Transform skew_transform;
   skew_transform.Skew(50.f, 60.f);
   operations16.AppendMatrix(skew_transform);
   EXPECT_TRUE(operations16.ScaleComponent(&scale));
   EXPECT_EQ(2.f, scale);
 }
 
 }  // namespace
 }  // namespace cc