CC Animation: Erase EaseTimingFunction helpers.

cc/animation/keyframed_animation_curve_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 "cc/animation/keyframed_animation_curve.h"
 
 #include "cc/animation/transform_operations.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/animation/tween.h"
@@ skipping 530 matching lines @@
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations1;
   curve->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   operations1.AppendTranslate(2.0, 3.0, -1.0);
   curve->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(0.5f), operations1, nullptr));
   TransformOperations operations2;
   operations2.AppendTranslate(4.0, 1.0, 2.0);
-  curve->AddKeyframe(
-      TransformKeyframe::Create(base::TimeDelta::FromSecondsD(1.f), operations2,
-                                EaseTimingFunction::Create()));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta::FromSecondsD(1.f), operations2,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
 
   gfx::BoxF box(2.f, 3.f, 4.f, 1.f, 3.f, 2.f);
   gfx::BoxF bounds;
 
   EXPECT_TRUE(curve->AnimatedBoundsForBox(box, &bounds));
   EXPECT_EQ(gfx::BoxF(2.f, 3.f, 3.f, 5.f, 6.f, 5.f).ToString(),
             bounds.ToString());
 }
 
 // Tests that animations that affect scale are correctly identified.
@@ skipping 60 matching lines @@
 
 // Tests that maximum target scale is computed as expected.
 TEST(KeyframedAnimationCurveTest, MaximumTargetScale) {
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations1;
   curve->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   operations1.AppendScale(2.f, -3.f, 1.f);
-  curve->AddKeyframe(
-      TransformKeyframe::Create(base::TimeDelta::FromSecondsD(1.f), operations1,
-                                EaseTimingFunction::Create()));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta::FromSecondsD(1.f), operations1,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
 
   float maximum_scale = 0.f;
   EXPECT_TRUE(curve->MaximumTargetScale(true, &maximum_scale));
   EXPECT_EQ(3.f, maximum_scale);
 
   TransformOperations operations2;
   operations2.AppendScale(6.f, 3.f, 2.f);
-  curve->AddKeyframe(
-      TransformKeyframe::Create(base::TimeDelta::FromSecondsD(2.f), operations2,
-                                EaseTimingFunction::Create()));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta::FromSecondsD(2.f), operations2,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
 
   EXPECT_TRUE(curve->MaximumTargetScale(true, &maximum_scale));
   EXPECT_EQ(6.f, maximum_scale);
 
   TransformOperations operations3;
   operations3.AppendRotate(1.f, 0.f, 0.f, 90.f);
-  curve->AddKeyframe(
-      TransformKeyframe::Create(base::TimeDelta::FromSecondsD(3.f), operations3,
-                                EaseTimingFunction::Create()));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta::FromSecondsD(3.f), operations3,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
 
   EXPECT_FALSE(curve->MaximumTargetScale(true, &maximum_scale));
 
   // The original scale is not used in computing the max.
   std::unique_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations4;
   operations4.AppendScale(0.4f, 0.2f, 0.6f);
-  curve2->AddKeyframe(TransformKeyframe::Create(base::TimeDelta(), operations4,
-                                                EaseTimingFunction::Create()));
+  curve2->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta(), operations4,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
   TransformOperations operations5;
   operations5.AppendScale(0.5f, 0.3f, -0.8f);
-  curve2->AddKeyframe(
-      TransformKeyframe::Create(base::TimeDelta::FromSecondsD(1.f), operations5,
-                                EaseTimingFunction::Create()));
+  curve2->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta::FromSecondsD(1.f), operations5,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
 
   EXPECT_TRUE(curve2->MaximumTargetScale(true, &maximum_scale));
   EXPECT_EQ(0.8f, maximum_scale);
 
   EXPECT_TRUE(curve2->MaximumTargetScale(false, &maximum_scale));
   EXPECT_EQ(0.6f, maximum_scale);
 }
 
 // Tests that starting animation scale is computed as expected.
 TEST(KeyframedAnimationCurveTest, AnimationStartScale) {
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations1;
   curve->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   operations1.AppendScale(2.f, -3.f, 1.f);
-  curve->AddKeyframe(
-      TransformKeyframe::Create(base::TimeDelta::FromSecondsD(1.f), operations1,
-                                EaseTimingFunction::Create()));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta::FromSecondsD(1.f), operations1,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
 
   float start_scale = 0.f;
 
   // Forward direction
   EXPECT_TRUE(curve->AnimationStartScale(true, &start_scale));
   EXPECT_EQ(1.f, start_scale);
 
   // Backward direction
   EXPECT_TRUE(curve->AnimationStartScale(false, &start_scale));
   EXPECT_EQ(3.f, start_scale);
 
   TransformOperations operations2;
   operations2.AppendScale(6.f, 3.f, 2.f);
-  curve->AddKeyframe(
-      TransformKeyframe::Create(base::TimeDelta::FromSecondsD(2.f), operations2,
-                                EaseTimingFunction::Create()));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta::FromSecondsD(2.f), operations2,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
 
   // Backward direction
   EXPECT_TRUE(curve->AnimationStartScale(true, &start_scale));
   EXPECT_EQ(1.f, start_scale);
 
   // Backward direction
   EXPECT_TRUE(curve->AnimationStartScale(false, &start_scale));
   EXPECT_EQ(6.f, start_scale);
 
   TransformOperations operations3;
   operations3.AppendRotate(1.f, 0.f, 0.f, 90.f);
-  curve->AddKeyframe(
-      TransformKeyframe::Create(base::TimeDelta::FromSecondsD(3.f), operations3,
-                                EaseTimingFunction::Create()));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta::FromSecondsD(3.f), operations3,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
 
   EXPECT_FALSE(curve->AnimationStartScale(false, &start_scale));
   EXPECT_EQ(0.f, start_scale);
 }
 
 // Tests that an animation with a curve timing function works as expected.
 TEST(KeyframedAnimationCurveTest, CurveTiming) {
   std::unique_ptr<KeyframedFloatAnimationCurve> curve(
       KeyframedFloatAnimationCurve::Create());
   curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 0.f, nullptr));
@@ skipping 151 matching lines @@
   curve->SetTimingFunction(
       CubicBezierTimingFunction::Create(0.5f, -0.5f, 0.5f, 1.5f));
   EXPECT_LE(curve->GetValue(base::TimeDelta::FromSecondsD(1.f)),
             0.f);  // c(.25) < 0
   EXPECT_GE(curve->GetValue(base::TimeDelta::FromSecondsD(3.f)),
             9.f);  // c(.75) > 1
 }
 
 }  // namespace
 }  // namespace cc