Web Animations API: Implement step-middle and steps(x, middle) timing functions.

Source/platform/animation/TimingFunctionTestHelperTest.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 100 matching lines @@
         ::testing::MatchesRegex("cubic-bezier\\(0.17, 0.67, 1, -1.73\\)"));
 }
 
 TEST_F(TimingFunctionTestHelperTest, StepPrintTo)
 {
     RefPtr<TimingFunction> stepTimingStart = StepsTimingFunction::preset(StepsTimingFunction::Start);
     EXPECT_THAT(
         PrintToString(stepTimingStart),
         ::testing::MatchesRegex("step-start"));
 
-    RefPtr<TimingFunction> stepTimingCustom = StepsTimingFunction::create(5, false);
+    RefPtr<TimingFunction> stepTimingMiddle = StepsTimingFunction::preset(StepsTimingFunction::Middle);
+    EXPECT_THAT(
+        PrintToString(stepTimingMiddle),
+        ::testing::MatchesRegex("step-middle"));
+
+    RefPtr<TimingFunction> stepTimingCustom = StepsTimingFunction::create(5, StepsTimingFunction::StepAtEnd);
     EXPECT_THAT(
         PrintToString(stepTimingCustom),
         ::testing::MatchesRegex("steps\\(5, end\\)"));
 }
 
 TEST_F(TimingFunctionTestHelperTest, ChainedPrintTo)
 {
     RefPtr<TimingFunction> linearTiming = LinearTimingFunction::create();
     RefPtr<ChainedTimingFunction> chainedLinearSingle = ChainedTimingFunction::create();
     chainedLinearSingle->appendSegment(1.0, linearTiming.get());
@@ skipping 19 matching lines @@
                 "cubic-bezier\\(1, 0, 1, -1\\)\\[0.75 -> 1\\]"
             "\\)"));
 }
 
 TEST_F(TimingFunctionTestHelperTest, BaseOperatorEq)
 {
     RefPtr<TimingFunction> linearTiming = LinearTimingFunction::create();
     RefPtr<TimingFunction> cubicTiming1 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
     RefPtr<TimingFunction> cubicTiming2 = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73);
     RefPtr<TimingFunction> stepsTiming1 = StepsTimingFunction::preset(StepsTimingFunction::End);
-    RefPtr<TimingFunction> stepsTiming2 = StepsTimingFunction::create(5, true);
+    RefPtr<TimingFunction> stepsTiming2 = StepsTimingFunction::create(5, StepsTimingFunction::StepAtStart);
 
     RefPtr<ChainedTimingFunction> chainedTiming1 = ChainedTimingFunction::create();
     chainedTiming1->appendSegment(1.0, linearTiming.get());
 
     RefPtr<ChainedTimingFunction> chainedTiming2 = ChainedTimingFunction::create();
     chainedTiming2->appendSegment(0.5, cubicTiming1.get());
     chainedTiming2->appendSegment(1.0, cubicTiming2.get());
 
     NE_HELPER(v);
     NE_HELPER_APPEND(v, linearTiming);
@@ skipping 53 matching lines @@
 {
     RefPtr<TimingFunction> stepsTimingStart1 = StepsTimingFunction::preset(StepsTimingFunction::Start);
     RefPtr<TimingFunction> stepsTimingStart2 = StepsTimingFunction::preset(StepsTimingFunction::Start);
     EXPECT_REFV_EQ(stepsTimingStart1, stepsTimingStart1);
     EXPECT_REFV_EQ(stepsTimingStart1, stepsTimingStart2);
 
     RefPtr<TimingFunction> stepsTimingEnd1 = StepsTimingFunction::preset(StepsTimingFunction::End);
     RefPtr<TimingFunction> stepsTimingEnd2 = StepsTimingFunction::preset(StepsTimingFunction::End);
     EXPECT_REFV_EQ(stepsTimingEnd1, stepsTimingEnd2);
 
-    RefPtr<TimingFunction> stepsTimingCustom1 = StepsTimingFunction::create(5, true);
-    RefPtr<TimingFunction> stepsTimingCustom2 = StepsTimingFunction::create(5, false);
-    RefPtr<TimingFunction> stepsTimingCustom3 = StepsTimingFunction::create(7, true);
-    RefPtr<TimingFunction> stepsTimingCustom4 = StepsTimingFunction::create(7, false);
+    RefPtr<TimingFunction> stepsTimingCustom1 = StepsTimingFunction::create(5, StepsTimingFunction::StepAtStart);
+    RefPtr<TimingFunction> stepsTimingCustom2 = StepsTimingFunction::create(5, StepsTimingFunction::StepAtEnd);
+    RefPtr<TimingFunction> stepsTimingCustom3 = StepsTimingFunction::create(7, StepsTimingFunction::StepAtStart);
+    RefPtr<TimingFunction> stepsTimingCustom4 = StepsTimingFunction::create(7, StepsTimingFunction::StepAtEnd);
 
-    EXPECT_REFV_EQ(stepsTimingCustom1, StepsTimingFunction::create(5, true));
-    EXPECT_REFV_EQ(stepsTimingCustom2, StepsTimingFunction::create(5, false));
-    EXPECT_REFV_EQ(stepsTimingCustom3, StepsTimingFunction::create(7, true));
-    EXPECT_REFV_EQ(stepsTimingCustom4, StepsTimingFunction::create(7, false));
+    EXPECT_REFV_EQ(stepsTimingCustom1, StepsTimingFunction::create(5, StepsTimingFunction::StepAtStart));
+    EXPECT_REFV_EQ(stepsTimingCustom2, StepsTimingFunction::create(5, StepsTimingFunction::StepAtEnd));
+    EXPECT_REFV_EQ(stepsTimingCustom3, StepsTimingFunction::create(7, StepsTimingFunction::StepAtStart));
+    EXPECT_REFV_EQ(stepsTimingCustom4, StepsTimingFunction::create(7, StepsTimingFunction::StepAtEnd));
 
     NE_HELPER(v);
     NE_HELPER_APPEND(v, stepsTimingStart1);
     NE_HELPER_APPEND(v, stepsTimingEnd1);
     NE_HELPER_APPEND(v, stepsTimingCustom1);
     NE_HELPER_APPEND(v, stepsTimingCustom2);
     NE_HELPER_APPEND(v, stepsTimingCustom3);
     NE_HELPER_APPEND(v, stepsTimingCustom4);
     NE_HELPER_LOOP(v);
 }
 
 TEST_F(TimingFunctionTestHelperTest, StepsOperatorEqReflectivity)
 {
     RefPtr<TimingFunction> stepsA = StepsTimingFunction::preset(StepsTimingFunction::Start);
-    RefPtr<TimingFunction> stepsB = StepsTimingFunction::create(1, true);
+    RefPtr<TimingFunction> stepsB = StepsTimingFunction::create(1, StepsTimingFunction::StepAtStart);
     EXPECT_REFV_NE(stepsA, stepsB);
     EXPECT_REFV_NE(stepsB, stepsA);
 }
 
 TEST_F(TimingFunctionTestHelperTest, ChainedEq)
 {
     // Single item in chain
     RefPtr<TimingFunction> cubicTiming1 = CubicBezierTimingFunction::create(0.25, 0.1, 0.25, 1.0);
     RefPtr<TimingFunction> cubicTiming2 = CubicBezierTimingFunction::create(0.25, 0.1, 0.25, 1.0);
     RefPtr<TimingFunction> cubicTiming3 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut);
@@ skipping 48 matching lines @@
     EXPECT_REFV_NE(chainedMixed1, chainedSingleCubic1);
     EXPECT_REFV_NE(chainedMixed1, chainedSingleLinear1);
 
     RefPtr<ChainedTimingFunction> chainedMixed4 = ChainedTimingFunction::create();
     chainedMixed4->appendSegment(0.20, chainedSingleLinear1.get()); // Different offset
     chainedMixed4->appendSegment(1.0, cubicTiming1.get());
     EXPECT_REFV_NE(chainedMixed1, chainedMixed4);
 }
 
 } // namespace