Define step timing function for the cc animation framework.

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 422 matching lines @@
   EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::TimeDelta::FromSecondsD(0.f)));
   EXPECT_LT(0.f, curve->GetValue(base::TimeDelta::FromSecondsD(0.25f)));
   EXPECT_GT(0.25f, curve->GetValue(base::TimeDelta::FromSecondsD(0.25f)));
   EXPECT_NEAR(curve->GetValue(base::TimeDelta::FromSecondsD(0.5f)), 0.5f,
               0.00015f);
   EXPECT_LT(0.75f, curve->GetValue(base::TimeDelta::FromSecondsD(0.75f)));
   EXPECT_GT(1.f, curve->GetValue(base::TimeDelta::FromSecondsD(0.75f)));
   EXPECT_FLOAT_EQ(1.f, curve->GetValue(base::TimeDelta::FromSecondsD(1.f)));
 }
 
+// Tests that a steps timing function works as expected.

[ajuma, 2014/12/17 16:32:55]

Please add a few words so that it explains how this test is different from the
two other tests below (and do the same for the comments for the other tests).

+TEST(KeyframedAnimationCurveTest, StepsTimingFunction_StepAtStart) {

[ajuma, 2014/12/17 16:32:55]

Style nit: no underscore in the test name. (Same for the other tests.)

+  scoped_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  const int num_steps = 36;
+  const float steps_start_offset = 1.0f;
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta(), 0.f,
+      StepsTimingFunction::Create(num_steps, steps_start_offset)));
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta::FromSecondsD(1.0),
+                                           num_steps, nullptr));
+
+  const float time_threshold = 0.0001f;
+
+  for (float i = 0; i < num_steps; i += 1.0f) {

[ajuma, 2014/12/17 16:32:56]

0.f

[loyso (OOO), 2014/12/18 01:53:05]

Do we have a rationale behind it (any references to style guides)? The type of a
literal and the source type are meaningless (this is not a narrowing
conversion). It bloats the code and introduces extra noise otherwise. Thanks in
advance for any comments :)

[ajuma, 2014/12/18 02:15:41]

Not sure if it's documented anywhere, but this is the usual practice at least in
cc. It's true that it doesn't change the value of something like 0, but it would
make a difference if the value wasn't exactly representable as a float. Using
float literals everywhere seems more consistent.

[loyso (OOO), 2014/12/18 03:17:30]

Ok, I'll make it consistent to cc/ folder. Overall: the usage of integer
literals with no narrowing conversion would reduce our code base significantly.

+    const base::TimeDelta time1 =
+        base::TimeDelta::FromSecondsD(i / num_steps - time_threshold);
+    const base::TimeDelta time2 =
+        base::TimeDelta::FromSecondsD(i / num_steps + time_threshold);
+    EXPECT_FLOAT_EQ(ceil(i), curve->GetValue(time1));
+    EXPECT_FLOAT_EQ(ceil(i) + 1, curve->GetValue(time2));

[ajuma, 2014/12/17 16:32:56]

1.f

+  }
+  EXPECT_FLOAT_EQ(num_steps,
+                  curve->GetValue(base::TimeDelta::FromSecondsD(1.0f)));
+
+  for (float i = 0.5f; i <= num_steps; i += 1.0f) {
+    const base::TimeDelta time = base::TimeDelta::FromSecondsD(i / num_steps);
+    EXPECT_FLOAT_EQ(ceil(i), curve->GetValue(time));
+  }
+}
+
+// Tests that a steps timing function works as expected.
+TEST(KeyframedAnimationCurveTest, StepsTimingFunction_StepAtMiddle) {
+  scoped_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  const int num_steps = 36;
+  const float steps_start_offset = 0.5f;
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta(), 0.f,
+      StepsTimingFunction::Create(num_steps, steps_start_offset)));
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta::FromSecondsD(1.0),
+                                           num_steps, nullptr));
+
+  const float time_threshold = 0.0001f;
+
+  EXPECT_FLOAT_EQ(0, curve->GetValue(base::TimeDelta()));

[ajuma, 2014/12/17 16:32:55]

0.f

+  for (float i = 0.5f; i < num_steps; i += 1.0f) {
+    const base::TimeDelta time1 =
+        base::TimeDelta::FromSecondsD(i / num_steps - time_threshold);
+    const base::TimeDelta time2 =
+        base::TimeDelta::FromSecondsD(i / num_steps + time_threshold);
+    EXPECT_FLOAT_EQ(floor(i), curve->GetValue(time1));
+    EXPECT_FLOAT_EQ(floor(i) + 1.0f, curve->GetValue(time2));
+  }
+  EXPECT_FLOAT_EQ(num_steps,
+                  curve->GetValue(base::TimeDelta::FromSecondsD(1.0f)));
+
+  for (float i = 0.25f; i <= num_steps; i += 1.0f) {
+    const base::TimeDelta time = base::TimeDelta::FromSecondsD(i / num_steps);
+    EXPECT_FLOAT_EQ(floor(i), curve->GetValue(time));
+  }
+}
+
+// Tests that a steps timing function works as expected.
+TEST(KeyframedAnimationCurveTest, StepsTimingFunction_StepAtEnd) {
+  scoped_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  const int num_steps = 36;
+  const float steps_start_offset = 0.0f;
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta(), 0.f,
+      StepsTimingFunction::Create(num_steps, steps_start_offset)));
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta::FromSecondsD(1.0),
+                                           num_steps, nullptr));
+
+  const float time_threshold = 0.0001f;
+
+  EXPECT_FLOAT_EQ(0, curve->GetValue(base::TimeDelta()));

[ajuma, 2014/12/17 16:32:55]

0.f

+  for (float i = 1; i <= num_steps; i += 1.0f) {

[ajuma, 2014/12/17 16:32:56]

1.f

+    const base::TimeDelta time1 =
+        base::TimeDelta::FromSecondsD(i / num_steps - time_threshold);
+    const base::TimeDelta time2 =
+        base::TimeDelta::FromSecondsD(i / num_steps + time_threshold);
+    EXPECT_FLOAT_EQ(floor(i) - 1, curve->GetValue(time1));

[ajuma, 2014/12/17 16:32:55]

1.f

+    EXPECT_FLOAT_EQ(floor(i), curve->GetValue(time2));
+  }
+  EXPECT_FLOAT_EQ(num_steps,
+                  curve->GetValue(base::TimeDelta::FromSecondsD(1.0f)));
+
+  for (float i = 0.5f; i <= num_steps; i += 1.0f) {
+    const base::TimeDelta time = base::TimeDelta::FromSecondsD(i / num_steps);
+    EXPECT_FLOAT_EQ(floor(i), curve->GetValue(time));
+  }
+}
+
 // Tests that animated bounds are computed as expected.
 TEST(KeyframedAnimationCurveTest, AnimatedBounds) {
   scoped_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations1;
   curve->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   operations1.AppendTranslate(2.0, 3.0, -1.0);
   curve->AddKeyframe(TransformKeyframe::Create(
@@ skipping 224 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