CC: Allow cubic-bezier timing inputs outside the range [0, 1]

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 707 matching lines @@
               0.005f);  // c(.42)=.27, k(.27)=.17
   EXPECT_FLOAT_EQ(0.5f, curve->GetValue(base::TimeDelta::FromSecondsD(0.5f)));
   EXPECT_NEAR(0.83f, curve->GetValue(base::TimeDelta::FromSecondsD(0.58f)),
               0.005f);  // c(.58)=.73, k(.73)=.83
   EXPECT_FLOAT_EQ(1.f, curve->GetValue(base::TimeDelta::FromSecondsD(
                            0.75f)));  // Clamped. c(.75) > 1
   EXPECT_FLOAT_EQ(1.f, curve->GetValue(base::TimeDelta::FromSecondsD(1.f)));
   EXPECT_FLOAT_EQ(1.f, curve->GetValue(base::TimeDelta::FromSecondsD(2.f)));
 }
 
+// Tests that a linear timing function works as expected for inputs outside of

[Ian Vollick, 2015/01/05 15:36:04]

A couple of dumb questions.

I'm a bit confused by the term inputs here. Are you referring to the outputs of
the timing function which will be the inputs to the keyframe
interpolation/extrapolation?

Also, this test looks like it's using a cubic timing function; is linear in
reference to the keyframe timing function?

[loyso (OOO), 2015/01/06 02:24:53]

Yes. The outputs of per-curve timing function will be an input for per-keyframe
timing functions.
See the changelist here:
https://codereview.chromium.org/598853003/patch/80001/90001
TransformedAnimationTime function transforms time.
Yes, it tests per-keyframe linear timing function. Cubic per-curve timing
function is the only way to get input outside of range [0,1].

Overall, what's important. It's mentioned in original bug and I had to copy it
here:

We need to support this blink change:
https://codereview.chromium.org/238573002
for compositor-side animations.

So the main idea is to be consistent with the blink side. And we have a plan to
remove cc/blink redundant code in the future.

+// range [0,1]
+TEST(KeyframedAnimationCurveTest, LinearTimingInputsOutsideZeroOneRange) {
+  scoped_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 0.f, nullptr));
+  curve->AddKeyframe(
+      FloatKeyframe::Create(base::TimeDelta::FromSecondsD(1.0), 2.f, nullptr));
+  // Curve timing function producing timing outputs outside of range [0,1].
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.5f, -0.5f, 0.5f, 1.5f).Pass());
+
+  EXPECT_NEAR(-0.076f, curve->GetValue(base::TimeDelta::FromSecondsD(0.25f)),
+              0.001f);
+  EXPECT_NEAR(2.076f, curve->GetValue(base::TimeDelta::FromSecondsD(0.75f)),
+              0.001f);
+}
+
+// If a curve cubic-bezier timing function produces timing outputs outside
+// the range [0, 1] then a keyframe cubic-bezier timing function
+// should consume that input properly (using end-point gradients).
+TEST(KeyframedAnimationCurveTest, CurveTimingInputsOutsideZeroOneRange) {
+  scoped_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  // Keyframe timing function with 0.5 gradients at each end.
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta(), 0.f,
+      CubicBezierTimingFunction::Create(0.5f, 0.25f, 0.5f, 0.75f).Pass()));
+  curve->AddKeyframe(
+      FloatKeyframe::Create(base::TimeDelta::FromSecondsD(1.f), 1.f, nullptr));
+  // Curve timing function producing timing outputs outside of range [0,1].
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.5f, -0.5f, 0.5f, 1.5f).Pass());
+
+  EXPECT_NEAR(-0.02f, curve->GetValue(base::TimeDelta::FromSecondsD(0.25f)),
+              0.002f);  // c(.25)=-.04, -.04*0.5=-0.02
+  EXPECT_NEAR(0.33f, curve->GetValue(base::TimeDelta::FromSecondsD(0.46f)),
+              0.002f);  // c(.46)=.38, k(.38)=.33
+
+  EXPECT_NEAR(0.67f, curve->GetValue(base::TimeDelta::FromSecondsD(0.54f)),
+              0.002f);  // c(.54)=.62, k(.62)=.67
+  EXPECT_NEAR(1.02f, curve->GetValue(base::TimeDelta::FromSecondsD(0.75f)),
+              0.002f);  // c(.75)=1.04 1+.04*0.5=1.02
+}
+
+// Tests that a step timing function works as expected for inputs outside of
+// range [0,1]
+TEST(KeyframedAnimationCurveTest, StepsTimingInputsOutsideZeroOneRange) {
+  scoped_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta(), 0.f, StepsTimingFunction::Create(4, 0.5f)));
+  curve->AddKeyframe(
+      FloatKeyframe::Create(base::TimeDelta::FromSecondsD(1.0), 2.f, nullptr));
+  // Curve timing function producing timing outputs outside of range [0,1].
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.5f, -0.5f, 0.5f, 1.5f).Pass());
+
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::TimeDelta::FromSecondsD(0.25f)));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::TimeDelta::FromSecondsD(0.75f)));
+}
+
 // Tests that an animation with a curve timing function and multiple keyframes
 // works as expected.
 TEST(KeyframedAnimationCurveTest, CurveTimingMultipleKeyframes) {
   scoped_ptr<KeyframedFloatAnimationCurve> curve(
       KeyframedFloatAnimationCurve::Create());
   curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 0.f, nullptr));
   curve->AddKeyframe(
       FloatKeyframe::Create(base::TimeDelta::FromSecondsD(1.f), 1.f, nullptr));
   curve->AddKeyframe(
       FloatKeyframe::Create(base::TimeDelta::FromSecondsD(2.f), 3.f, nullptr));
@@ skipping 34 matching lines @@
   curve->SetTimingFunction(
       CubicBezierTimingFunction::Create(0.5f, -0.5f, 0.5f, 1.5f).Pass());
   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