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>
@@ skipping 247 matching lines @@
   expected_scale_matrix.Scale3d(sx, sy, sz);
 
   gfx::Transform expected_translate_matrix;
   expected_translate_matrix.Translate3d(dx, dy, dz);
 
   gfx::Transform expected_combined_matrix = expected_scale_matrix;
   expected_combined_matrix.PreconcatTransform(expected_translate_matrix);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_combined_matrix, operations.Apply());
 }
 

[ajuma, 2017/07/04 14:50:56]

Please add a couple tests to verify
the unbaked TransformOperatoins produced by Blend (one case with matching
types and one case with non-matching type where we fallback to matrix blending).

[Ian Vollick, 2017/07/04 16:15:17]

Done.

 TEST(TransformOperationTest, BlendOrder) {
   SkMScalar sx1 = 2;
   SkMScalar sy1 = 4;
   SkMScalar sz1 = 8;
 
   SkMScalar dx1 = 1;
   SkMScalar dy1 = 2;
   SkMScalar dz1 = 3;
 
   SkMScalar sx2 = 4;
@@ skipping 27 matching lines @@
   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));
+      expected, operations_to.Blend(operations_from, progress).Apply());
 }
 
 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