Matrix decomposition for mismatched functions in keyframes

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/basictypes.h"
 #include "base/memory/scoped_vector.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/test/geometry_test_utils.h"
@@ skipping 121 matching lines @@
   to_add = new TransformOperations();
   to_add->AppendMatrix(gfx::Transform());
   operations->push_back(to_add);
 
   to_add = new TransformOperations();
   to_add->AppendMatrix(gfx::Transform());
   to_add->AppendMatrix(gfx::Transform());
   operations->push_back(to_add);
 }
 
-TEST(TransformOperationTest, IdentityAlwaysMatches) {
+TEST(TransformOperationTest, MatchTypesOrder) {
+  TransformOperations mix_order_identity;
+  mix_order_identity.AppendTranslate(0, 0, 0);
+  mix_order_identity.AppendScale(1, 1, 1);
+  mix_order_identity.AppendTranslate(0, 0, 0);
+
+  TransformOperations mix_order_one;
+  mix_order_one.AppendTranslate(0, 1, 0);
+  mix_order_one.AppendScale(2, 1, 3);
+  mix_order_one.AppendTranslate(1, 0, 0);
+
+  TransformOperations mix_order_two;
+  mix_order_two.AppendTranslate(0, 1, 0);
+  mix_order_two.AppendTranslate(1, 0, 0);
+  mix_order_two.AppendScale(2, 1, 3);
+
+  EXPECT_TRUE(mix_order_identity.MatchesTypes(mix_order_one));
+  EXPECT_FALSE(mix_order_identity.MatchesTypes(mix_order_two));
+  EXPECT_FALSE(mix_order_one.MatchesTypes(mix_order_two));
+}
+
+TEST(TransformOperationTest, NoneAlwaysMatches) {
   ScopedVector<TransformOperations> 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]));
-  }
+  TransformOperations none_operation;
+  for (size_t i = 0; i < operations.size(); ++i)
+    EXPECT_TRUE(operations[i]->MatchesTypes(none_operation));
 }
 
 TEST(TransformOperationTest, ApplyTranslate) {
   SkMScalar x = 1;
   SkMScalar y = 2;
   SkMScalar z = 3;
   TransformOperations operations;
   operations.AppendTranslate(x, y, z);
   gfx::Transform expected;
   expected.Translate3d(x, y, z);
@@ skipping 260 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected, operations_to.Blend(operations_from, progress));
 }
 
 TEST(TransformOperationTest, BlendRotationFromIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
-    operations.AppendRotate(0, 0, 1, 360);
+    operations.AppendRotate(0, 0, 1, 90);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
-    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
+    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 45);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
 
     progress = -0.5f;
 
     expected.MakeIdentity();
-    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), -180);
+    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), -45);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
 
     progress = 1.5f;
 
     expected.MakeIdentity();
-    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 540);
+    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 135);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
   }
 }
 
 TEST(TransformOperationTest, BlendTranslationFromIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
@@ skipping 54 matching lines @@
     progress = 1.5f;
 
     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);
+TEST(TransformOperationTest, BlendSkewFromEmpty) {
+  TransformOperations empty_operation;
 
-  for (size_t i = 0; i < identity_operations.size(); ++i) {
-    TransformOperations operations;
-    operations.AppendSkew(2, 2);
+  TransformOperations operations;
+  operations.AppendSkew(2, 2);
 
-    SkMScalar progress = 0.5f;
+  SkMScalar progress = 0.5f;
 
-    gfx::Transform expected;
-    expected.SkewX(1);
-    expected.SkewY(1);
+  gfx::Transform expected;
+  expected.SkewX(1);
+  expected.SkewY(1);
 
-    EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
+                                  operations.Blend(empty_operation, progress));
 
-    progress = -0.5f;
+  progress = -0.5f;
 
-    expected.MakeIdentity();
-    expected.SkewX(-1);
-    expected.SkewY(-1);
+  expected.MakeIdentity();
+  expected.SkewX(-1);
+  expected.SkewY(-1);
 
-    EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
+                                  operations.Blend(empty_operation, progress));
 
-    progress = 1.5f;
+  progress = 1.5f;
 
-    expected.MakeIdentity();
-    expected.SkewX(3);
-    expected.SkewY(3);
+  expected.MakeIdentity();
+  expected.SkewX(3);
+  expected.SkewY(3);
 
-    EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, operations.Blend(*identity_operations[i], progress));
-  }
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
+                                  operations.Blend(empty_operation, 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);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.ApplyPerspectiveDepth(2000);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
   }
 }
 
 TEST(TransformOperationTest, BlendRotationToIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
-    operations.AppendRotate(0, 0, 1, 360);
+    operations.AppendRotate(0, 0, 1, 90);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
-    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
+    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 45);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, identity_operations[i]->Blend(operations, progress));
   }
 }
 
 TEST(TransformOperationTest, BlendTranslationToIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
@@ skipping 22 matching lines @@
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.Scale3d(2, 2, 2);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, identity_operations[i]->Blend(operations, progress));
   }
 }
 
-TEST(TransformOperationTest, BlendSkewToIdentity) {
-  ScopedVector<TransformOperations> identity_operations;
-  GetIdentityOperations(&identity_operations);
+TEST(TransformOperationTest, BlendSkewToEmpty) {
+  TransformOperations empty_operation;
 
-  for (size_t i = 0; i < identity_operations.size(); ++i) {
-    TransformOperations operations;
-    operations.AppendSkew(2, 2);
+  TransformOperations operations;
+  operations.AppendSkew(2, 2);
 
-    SkMScalar progress = 0.5f;
+  SkMScalar progress = 0.5f;
 
-    gfx::Transform expected;
-    expected.SkewX(1);
-    expected.SkewY(1);
+  gfx::Transform expected;
+  expected.SkewX(1);
+  expected.SkewY(1);
 
-    EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected, identity_operations[i]->Blend(operations, progress));
-  }
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
+                                  empty_operation.Blend(operations, progress));
 }
 
 TEST(TransformOperationTest, BlendPerspectiveToIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendPerspective(1000);
 
@@ skipping 792 matching lines @@
 
   // Scale + Perspective can't.
   TransformOperations operations11;
   operations11.AppendScale(2.f, 2.f, 2.f);
   operations11.AppendPerspective(1.f);
   EXPECT_FALSE(operations11.ScaleComponent(&scale));
 }
 
 }  // namespace
 }  // namespace cc