Implement frames() timing function

third_party/WebKit/Source/platform/animation/TimingFunctionTest.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 97 matching lines @@
 
   RefPtr<TimingFunction> stepTimingCustomMiddle =
       StepsTimingFunction::create(4, StepsTimingFunction::StepPosition::MIDDLE);
   EXPECT_EQ("steps(4, middle)", stepTimingCustomMiddle->toString());
 
   RefPtr<TimingFunction> stepTimingCustomEnd =
       StepsTimingFunction::create(5, StepsTimingFunction::StepPosition::END);
   EXPECT_EQ("steps(5)", stepTimingCustomEnd->toString());
 }
 
+TEST_F(TimingFunctionTest, FrameToString) {
+  RefPtr<TimingFunction> frameTiming = FramesTimingFunction::create(3);
+  EXPECT_EQ("frames(3)", frameTiming->toString());
+}
+
 TEST_F(TimingFunctionTest, BaseOperatorEq) {
   RefPtr<TimingFunction> linearTiming = LinearTimingFunction::shared();
   RefPtr<TimingFunction> cubicTiming1 = CubicBezierTimingFunction::preset(
       CubicBezierTimingFunction::EaseType::EASE_IN);
   RefPtr<TimingFunction> cubicTiming2 =
       CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73);
   RefPtr<TimingFunction> stepsTiming1 =
       StepsTimingFunction::preset(StepsTimingFunction::StepPosition::END);
   RefPtr<TimingFunction> stepsTiming2 =
       StepsTimingFunction::create(5, StepsTimingFunction::StepPosition::START);
+  RefPtr<TimingFunction> framesTiming = FramesTimingFunction::create(5);
 
   Vector<std::pair<std::string, RefPtr<TimingFunction>>> v;
   v.push_back(std::make_pair("linearTiming", linearTiming));
   v.push_back(std::make_pair("cubicTiming1", cubicTiming1));
   v.push_back(std::make_pair("cubicTiming2", cubicTiming2));
   v.push_back(std::make_pair("stepsTiming1", stepsTiming1));
   v.push_back(std::make_pair("stepsTiming2", stepsTiming2));
+  v.push_back(std::make_pair("framesTiming", framesTiming));
   notEqualHelperLoop(v);
 }
 
 TEST_F(TimingFunctionTest, LinearOperatorEq) {
   RefPtr<TimingFunction> linearTiming1 = LinearTimingFunction::shared();
   RefPtr<TimingFunction> linearTiming2 = LinearTimingFunction::shared();
   EXPECT_EQ(*linearTiming1, *linearTiming1);
   EXPECT_EQ(*linearTiming1, *linearTiming2);
 }
 
@@ skipping 96 matching lines @@
 
 TEST_F(TimingFunctionTest, StepsOperatorEqPreset) {
   RefPtr<TimingFunction> stepsA =
       StepsTimingFunction::preset(StepsTimingFunction::StepPosition::START);
   RefPtr<TimingFunction> stepsB =
       StepsTimingFunction::create(1, StepsTimingFunction::StepPosition::START);
   EXPECT_EQ(*stepsA, *stepsB);
   EXPECT_EQ(*stepsB, *stepsA);
 }
 
+TEST_F(TimingFunctionTest, FramesOperatorEq) {
+  RefPtr<TimingFunction> framesTiming1 = FramesTimingFunction::create(5);
+  RefPtr<TimingFunction> framesTiming2 = FramesTimingFunction::create(7);
+
+  EXPECT_EQ(*FramesTimingFunction::create(5), *framesTiming1);
+  EXPECT_EQ(*FramesTimingFunction::create(7), *framesTiming2);
+
+  Vector<std::pair<std::string, RefPtr<TimingFunction>>> v;
+  v.push_back(std::make_pair("framesTiming1", framesTiming1));
+  v.push_back(std::make_pair("framesTiming2", framesTiming2));
+  notEqualHelperLoop(v);
+}
+
 TEST_F(TimingFunctionTest, LinearEvaluate) {
   RefPtr<TimingFunction> linearTiming = LinearTimingFunction::shared();
   EXPECT_EQ(0.2, linearTiming->evaluate(0.2, 0));
   EXPECT_EQ(0.6, linearTiming->evaluate(0.6, 0));
   EXPECT_EQ(-0.2, linearTiming->evaluate(-0.2, 0));
   EXPECT_EQ(1.6, linearTiming->evaluate(1.6, 0));
 }
 
 TEST_F(TimingFunctionTest, LinearRange) {
   double start = 0;
@@ skipping 18 matching lines @@
   EXPECT_NEAR(0, start, 0.01);
   EXPECT_NEAR(1, end, 0.01);
 
   start = -1;
   end = 10;
   steps->range(&start, &end);
   EXPECT_NEAR(0, start, 0.01);
   EXPECT_NEAR(1, end, 0.01);
 }
 
+TEST_F(TimingFunctionTest, FrameRange) {
+  double start = 0;
+  double end = 1;
+  RefPtr<TimingFunction> frames = FramesTimingFunction::create(4);
+  frames->range(&start, &end);
+  EXPECT_NEAR(0, start, 0.01);
+  EXPECT_NEAR(1, end, 0.01);
+
+  start = -1;
+  end = 10;
+  frames->range(&start, &end);
+  EXPECT_NEAR(0, start, 0.01);
+  EXPECT_NEAR(1, end, 0.01);
+}
+
 TEST_F(TimingFunctionTest, CubicRange) {
   double start = 0;
   double end = 1;
 
   RefPtr<TimingFunction> cubicEaseTiming = CubicBezierTimingFunction::preset(
       CubicBezierTimingFunction::EaseType::EASE);
   start = 0;
   end = 1;
   cubicEaseTiming->range(&start, &end);
   EXPECT_NEAR(0, start, 0.01);
@@ skipping 161 matching lines @@
   EXPECT_EQ(0.25, stepsTimingCustomEnd->evaluate(0.25, 0));
   EXPECT_EQ(0.25, stepsTimingCustomEnd->evaluate(0.49, 0));
   EXPECT_EQ(0.50, stepsTimingCustomEnd->evaluate(0.50, 0));
   EXPECT_EQ(0.50, stepsTimingCustomEnd->evaluate(0.74, 0));
   EXPECT_EQ(0.75, stepsTimingCustomEnd->evaluate(0.75, 0));
   EXPECT_EQ(0.75, stepsTimingCustomEnd->evaluate(0.99, 0));
   EXPECT_EQ(1.00, stepsTimingCustomEnd->evaluate(1.00, 0));
   EXPECT_EQ(1.00, stepsTimingCustomEnd->evaluate(2.00, 0));
 }
 
+TEST_F(TimingFunctionTest, FramesEvaluate) {
+  RefPtr<TimingFunction> framesTiming = FramesTimingFunction::create(5);
+  EXPECT_EQ(0.00, framesTiming->evaluate(-2.00, 0));
+  EXPECT_EQ(0.00, framesTiming->evaluate(0.00, 0));
+  EXPECT_EQ(0.00, framesTiming->evaluate(0.19, 0));
+  EXPECT_EQ(0.25, framesTiming->evaluate(0.20, 0));
+  EXPECT_EQ(0.25, framesTiming->evaluate(0.39, 0));
+  EXPECT_EQ(0.50, framesTiming->evaluate(0.40, 0));
+  EXPECT_EQ(0.50, framesTiming->evaluate(0.59, 0));
+  EXPECT_EQ(0.75, framesTiming->evaluate(0.60, 0));
+  EXPECT_EQ(0.75, framesTiming->evaluate(0.79, 0));
+  EXPECT_EQ(1.00, framesTiming->evaluate(0.80, 0));
+  EXPECT_EQ(1.00, framesTiming->evaluate(1.00, 0));
+  EXPECT_EQ(1.00, framesTiming->evaluate(3.00, 0));
+}
+
 }  // namespace
 
 }  // namespace blink