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 99 matching lines @@
 
   RefPtr<TimingFunction> step_timing_custom_middle =
       StepsTimingFunction::Create(4, StepsTimingFunction::StepPosition::MIDDLE);
   EXPECT_EQ("steps(4, middle)", step_timing_custom_middle->ToString());
 
   RefPtr<TimingFunction> step_timing_custom_end =
       StepsTimingFunction::Create(5, StepsTimingFunction::StepPosition::END);
   EXPECT_EQ("steps(5)", step_timing_custom_end->ToString());
 }
 
+TEST_F(TimingFunctionTest, FrameToString) {
+  RefPtr<TimingFunction> frame_timing = FramesTimingFunction::Create(3);
+  EXPECT_EQ("frames(3)", frame_timing->ToString());
+}
+
 TEST_F(TimingFunctionTest, BaseOperatorEq) {
   RefPtr<TimingFunction> linear_timing = LinearTimingFunction::Shared();
   RefPtr<TimingFunction> cubic_timing1 = CubicBezierTimingFunction::Preset(
       CubicBezierTimingFunction::EaseType::EASE_IN);
   RefPtr<TimingFunction> cubic_timing2 =
       CubicBezierTimingFunction::Create(0.17, 0.67, 1, -1.73);
   RefPtr<TimingFunction> steps_timing1 =
       StepsTimingFunction::Preset(StepsTimingFunction::StepPosition::END);
   RefPtr<TimingFunction> steps_timing2 =
       StepsTimingFunction::Create(5, StepsTimingFunction::StepPosition::START);
+  RefPtr<TimingFunction> frames_timing = FramesTimingFunction::Create(5);
 
   Vector<std::pair<std::string, RefPtr<TimingFunction>>> v;
   v.push_back(std::make_pair("linearTiming", linear_timing));
   v.push_back(std::make_pair("cubicTiming1", cubic_timing1));
   v.push_back(std::make_pair("cubicTiming2", cubic_timing2));
   v.push_back(std::make_pair("stepsTiming1", steps_timing1));
   v.push_back(std::make_pair("stepsTiming2", steps_timing2));
+  v.push_back(std::make_pair("framesTiming", frames_timing));
   NotEqualHelperLoop(v);
 }
 
 TEST_F(TimingFunctionTest, LinearOperatorEq) {
   RefPtr<TimingFunction> linear_timing1 = LinearTimingFunction::Shared();
   RefPtr<TimingFunction> linear_timing2 = LinearTimingFunction::Shared();
   EXPECT_EQ(*linear_timing1, *linear_timing1);
   EXPECT_EQ(*linear_timing1, *linear_timing2);
 }
 
@@ skipping 99 matching lines @@
 
 TEST_F(TimingFunctionTest, StepsOperatorEqPreset) {
   RefPtr<TimingFunction> steps_a =
       StepsTimingFunction::Preset(StepsTimingFunction::StepPosition::START);
   RefPtr<TimingFunction> steps_b =
       StepsTimingFunction::Create(1, StepsTimingFunction::StepPosition::START);
   EXPECT_EQ(*steps_a, *steps_b);
   EXPECT_EQ(*steps_b, *steps_a);
 }
 
+TEST_F(TimingFunctionTest, FramesOperatorEq) {
+  RefPtr<TimingFunction> frames_timing1 = FramesTimingFunction::Create(5);
+  RefPtr<TimingFunction> frames_timing2 = FramesTimingFunction::Create(7);
+
+  EXPECT_EQ(*FramesTimingFunction::Create(5), *frames_timing1);
+  EXPECT_EQ(*FramesTimingFunction::Create(7), *frames_timing2);
+
+  Vector<std::pair<std::string, RefPtr<TimingFunction>>> v;
+  v.push_back(std::make_pair("framesTiming1", frames_timing1));
+  v.push_back(std::make_pair("framesTiming2", frames_timing2));
+  NotEqualHelperLoop(v);
+}
+
 TEST_F(TimingFunctionTest, LinearEvaluate) {
   RefPtr<TimingFunction> linear_timing = LinearTimingFunction::Shared();
   EXPECT_EQ(0.2, linear_timing->Evaluate(0.2, 0));
   EXPECT_EQ(0.6, linear_timing->Evaluate(0.6, 0));
   EXPECT_EQ(-0.2, linear_timing->Evaluate(-0.2, 0));
   EXPECT_EQ(1.6, linear_timing->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> cubic_ease_timing = CubicBezierTimingFunction::Preset(
       CubicBezierTimingFunction::EaseType::EASE);
   start = 0;
   end = 1;
   cubic_ease_timing->Range(&start, &end);
   EXPECT_NEAR(0, start, 0.01);
@@ skipping 173 matching lines @@
   EXPECT_EQ(0.25, steps_timing_custom_end->Evaluate(0.25, 0));
   EXPECT_EQ(0.25, steps_timing_custom_end->Evaluate(0.49, 0));
   EXPECT_EQ(0.50, steps_timing_custom_end->Evaluate(0.50, 0));
   EXPECT_EQ(0.50, steps_timing_custom_end->Evaluate(0.74, 0));
   EXPECT_EQ(0.75, steps_timing_custom_end->Evaluate(0.75, 0));
   EXPECT_EQ(0.75, steps_timing_custom_end->Evaluate(0.99, 0));
   EXPECT_EQ(1.00, steps_timing_custom_end->Evaluate(1.00, 0));
   EXPECT_EQ(2.00, steps_timing_custom_end->Evaluate(2.00, 0));
 }
 
+TEST_F(TimingFunctionTest, FramesEvaluate) {
+  RefPtr<TimingFunction> frames_timing = FramesTimingFunction::Create(5);
+  EXPECT_EQ(-2.50, frames_timing->Evaluate(-2.00, 0));
+  EXPECT_EQ(0.00, frames_timing->Evaluate(0.00, 0));
+  EXPECT_EQ(0.00, frames_timing->Evaluate(0.19, 0));
+  EXPECT_EQ(0.25, frames_timing->Evaluate(0.20, 0));
+  EXPECT_EQ(0.25, frames_timing->Evaluate(0.39, 0));
+  EXPECT_EQ(0.50, frames_timing->Evaluate(0.40, 0));
+  EXPECT_EQ(0.50, frames_timing->Evaluate(0.59, 0));
+  EXPECT_EQ(0.75, frames_timing->Evaluate(0.60, 0));
+  EXPECT_EQ(0.75, frames_timing->Evaluate(0.79, 0));
+  EXPECT_EQ(1.00, frames_timing->Evaluate(0.80, 0));
+  EXPECT_EQ(1.00, frames_timing->Evaluate(1.00, 0));
+  EXPECT_EQ(3.75, frames_timing->Evaluate(3.00, 0));
+}
+
 }  // namespace
 
 }  // namespace blink