TransformOperations should be able to blend outside the range [0, 1]

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 <limits>
 
 #include "base/memory/scoped_vector.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 414 matching lines @@
     TransformOperations operations;
     operations.AppendRotate(0, 0, 1, 360);
 
     double progress = 0.5;
 
     gfx::Transform expected;
     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
+
+    progress = -0.5;
+
+    expected.MakeIdentity();
+    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), -180);
+
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected, operations.Blend(*identity_operations[i], progress));
+
+    progress = 1.5;
+
+    expected.MakeIdentity();
+    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 540);
+
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected, operations.Blend(*identity_operations[i], progress));
   }
 }
 
 TEST(TransformOperationTest, BlendTranslationFromIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendTranslate(2, 2, 2);
 
     double progress = 0.5;
 
     gfx::Transform expected;
     expected.Translate3d(1, 1, 1);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
+
+    progress = -0.5;
+
+    expected.MakeIdentity();
+    expected.Translate3d(-1, -1, -1);
+
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected, operations.Blend(*identity_operations[i], progress));
+
+    progress = 1.5;
+
+    expected.MakeIdentity();
+    expected.Translate3d(3, 3, 3);
+
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected, operations.Blend(*identity_operations[i], progress));
   }
 }
 
 TEST(TransformOperationTest, BlendScaleFromIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendScale(3, 3, 3);
 
     double progress = 0.5;
 
     gfx::Transform expected;
     expected.Scale3d(2, 2, 2);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
+
+    progress = -0.5;
+
+    expected.MakeIdentity();
+    expected.Scale3d(0, 0, 0);
+
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected, operations.Blend(*identity_operations[i], progress));
+
+    progress = 1.5;
+
+    expected.MakeIdentity();
+    expected.Scale3d(4, 4, 4);
+
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected, operations.Blend(*identity_operations[i], progress));
   }
 }
 
 TEST(TransformOperationTest, BlendSkewFromIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendSkew(2, 2);
 
     double progress = 0.5;
 
     gfx::Transform expected;
     expected.SkewX(1);
     expected.SkewY(1);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
+
+    progress = -0.5;
+
+    expected.MakeIdentity();
+    expected.SkewX(-1);
+    expected.SkewY(-1);
+
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected, operations.Blend(*identity_operations[i], progress));
+
+    progress = 1.5;
+
+    expected.MakeIdentity();
+    expected.SkewX(3);
+    expected.SkewY(3);
+
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected, operations.Blend(*identity_operations[i], progress));
   }
 }
 
 TEST(TransformOperationTest, BlendPerspectiveFromIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendPerspective(1000);
@@ skipping 94 matching lines @@
 
     gfx::Transform expected;
     expected.ApplyPerspectiveDepth(
         500 + 0.5 * std::numeric_limits<double>::max());
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, identity_operations[i]->Blend(operations, progress));
   }
 }
 
+TEST(TransformOperationTest, ExtrapolatePerspectiveBlending) {
+  TransformOperations operations1;
+  operations1.AppendPerspective(1000);
+
+  TransformOperations operations2;
+  operations2.AppendPerspective(500);
+
+  gfx::Transform expected;
+  expected.ApplyPerspectiveDepth(250);
+
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      expected, operations1.Blend(operations2, -0.5));
+
+  expected.MakeIdentity();
+  expected.ApplyPerspectiveDepth(1250);
+
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      expected, operations1.Blend(operations2, 1.5));
+}
+
+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));
+
+  expected.Translate3d(4, 4, 4);
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      expected, operations1.Blend(operations2, -0.5));
+}
+
 }  // namespace
 }  // namespace cc