Deprecate step timing with position 'middle'

third_party/WebKit/Source/core/animation/TimingInputTest.cpp

 // Copyright 2014 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 "core/animation/TimingInput.h"
 
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "bindings/core/v8/V8KeyframeAnimationOptions.h"
 #include "bindings/core/v8/V8KeyframeEffectOptions.h"
 #include "core/animation/AnimationEffectTiming.h"
 #include "core/animation/AnimationTestHelper.h"
 #include "core/testing/DummyPageHolder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"
 
 namespace blink {
 
-Timing ApplyTimingInputNumber(v8::Isolate* isolate,
-                              String timing_property,
-                              double timing_property_value,
-                              bool& timing_conversion_success,
-                              bool is_keyframeeffectoptions = true) {
+class AnimationTimingInputTest : public testing::Test {
+ public:
+  Timing ApplyTimingInputNumber(v8::Isolate*,
+                                String timing_property,
+                                double timing_property_value,
+                                bool& timing_conversion_success,
+                                bool is_keyframeeffectoptions = true);
+  Timing ApplyTimingInputString(v8::Isolate*,
+                                String timing_property,
+                                String timing_property_value,
+                                bool& timing_conversion_success,
+                                bool is_keyframeeffectoptions = true);
+
+ private:
+  void SetUp() override { page_holder_ = DummyPageHolder::Create(); }
+
+  Document* GetDocument() const { return &page_holder_->GetDocument(); }
+
+  std::unique_ptr<DummyPageHolder> page_holder_;
+};
+
+Timing AnimationTimingInputTest::ApplyTimingInputNumber(
+    v8::Isolate* isolate,
+    String timing_property,
+    double timing_property_value,
+    bool& timing_conversion_success,
+    bool is_keyframeeffectoptions) {
   v8::Local<v8::Object> timing_input = v8::Object::New(isolate);
   SetV8ObjectPropertyAsNumber(isolate, timing_input, timing_property,
                               timing_property_value);
   DummyExceptionStateForTesting exception_state;
   Timing result;
   if (is_keyframeeffectoptions) {
     KeyframeEffectOptions timing_input_dictionary;
     V8KeyframeEffectOptions::toImpl(isolate, timing_input,
                                     timing_input_dictionary, exception_state);
     timing_conversion_success =
-        TimingInput::Convert(timing_input_dictionary, result, nullptr,
+        TimingInput::Convert(timing_input_dictionary, result, GetDocument(),
                              exception_state) &&
         !exception_state.HadException();
   } else {
     KeyframeAnimationOptions timing_input_dictionary;
     V8KeyframeAnimationOptions::toImpl(
         isolate, timing_input, timing_input_dictionary, exception_state);
     timing_conversion_success =
-        TimingInput::Convert(timing_input_dictionary, result, nullptr,
+        TimingInput::Convert(timing_input_dictionary, result, GetDocument(),
                              exception_state) &&
         !exception_state.HadException();
   }
   return result;
 }
 
-Timing ApplyTimingInputString(v8::Isolate* isolate,
-                              String timing_property,
-                              String timing_property_value,
-                              bool& timing_conversion_success,
-                              bool is_keyframeeffectoptions = true) {
+Timing AnimationTimingInputTest::ApplyTimingInputString(
+    v8::Isolate* isolate,
+    String timing_property,
+    String timing_property_value,
+    bool& timing_conversion_success,
+    bool is_keyframeeffectoptions) {
   v8::Local<v8::Object> timing_input = v8::Object::New(isolate);
   SetV8ObjectPropertyAsString(isolate, timing_input, timing_property,
                               timing_property_value);
 
   DummyExceptionStateForTesting exception_state;
   Timing result;
   if (is_keyframeeffectoptions) {
     KeyframeEffectOptions timing_input_dictionary;
     V8KeyframeEffectOptions::toImpl(isolate, timing_input,
                                     timing_input_dictionary, exception_state);
     timing_conversion_success =
-        TimingInput::Convert(timing_input_dictionary, result, nullptr,
+        TimingInput::Convert(timing_input_dictionary, result, GetDocument(),
                              exception_state) &&
         !exception_state.HadException();
   } else {
     KeyframeAnimationOptions timing_input_dictionary;
     V8KeyframeAnimationOptions::toImpl(
         isolate, timing_input, timing_input_dictionary, exception_state);
     timing_conversion_success =
-        TimingInput::Convert(timing_input_dictionary, result, nullptr,
+        TimingInput::Convert(timing_input_dictionary, result, GetDocument(),
                              exception_state) &&
         !exception_state.HadException();
   }
   return result;
 }
 
-TEST(AnimationTimingInputTest, TimingInputStartDelay) {
+TEST_F(AnimationTimingInputTest, TimingInputStartDelay) {
   V8TestingScope scope;
   bool ignored_success;
   EXPECT_EQ(1.1, ApplyTimingInputNumber(scope.GetIsolate(), "delay", 1100,
                                         ignored_success)
                      .start_delay);
   EXPECT_EQ(-1, ApplyTimingInputNumber(scope.GetIsolate(), "delay", -1000,
                                        ignored_success)
                     .start_delay);
   EXPECT_EQ(1, ApplyTimingInputString(scope.GetIsolate(), "delay", "1000",
                                       ignored_success)
                    .start_delay);
   EXPECT_EQ(0, ApplyTimingInputString(scope.GetIsolate(), "delay", "1s",
                                       ignored_success)
                    .start_delay);
   EXPECT_EQ(0, ApplyTimingInputString(scope.GetIsolate(), "delay", "Infinity",
                                       ignored_success)
                    .start_delay);
   EXPECT_EQ(0, ApplyTimingInputString(scope.GetIsolate(), "delay", "-Infinity",
                                       ignored_success)
                    .start_delay);
   EXPECT_EQ(0, ApplyTimingInputString(scope.GetIsolate(), "delay", "NaN",
                                       ignored_success)
                    .start_delay);
   EXPECT_EQ(0, ApplyTimingInputString(scope.GetIsolate(), "delay", "rubbish",
                                       ignored_success)
                    .start_delay);
 }
 
-TEST(AnimationTimingInputTest, TimingInputStartDelayKeyframeAnimationOptions) {
+TEST_F(AnimationTimingInputTest,
+       TimingInputStartDelayKeyframeAnimationOptions) {
   V8TestingScope scope;
   bool ignored_success;
   EXPECT_EQ(1.1, ApplyTimingInputNumber(scope.GetIsolate(), "delay", 1100,
                                         ignored_success, false)
                      .start_delay);
   EXPECT_EQ(-1, ApplyTimingInputNumber(scope.GetIsolate(), "delay", -1000,
                                        ignored_success, false)
                     .start_delay);
   EXPECT_EQ(1, ApplyTimingInputString(scope.GetIsolate(), "delay", "1000",
                                       ignored_success, false)
                    .start_delay);
   EXPECT_EQ(0, ApplyTimingInputString(scope.GetIsolate(), "delay", "1s",
                                       ignored_success, false)
                    .start_delay);
   EXPECT_EQ(0, ApplyTimingInputString(scope.GetIsolate(), "delay", "Infinity",
                                       ignored_success, false)
                    .start_delay);
   EXPECT_EQ(0, ApplyTimingInputString(scope.GetIsolate(), "delay", "-Infinity",
                                       ignored_success, false)
                    .start_delay);
   EXPECT_EQ(0, ApplyTimingInputString(scope.GetIsolate(), "delay", "NaN",
                                       ignored_success, false)
                    .start_delay);
   EXPECT_EQ(0, ApplyTimingInputString(scope.GetIsolate(), "delay", "rubbish",
                                       ignored_success, false)
                    .start_delay);
 }
 
-TEST(AnimationTimingInputTest, TimingInputEndDelay) {
+TEST_F(AnimationTimingInputTest, TimingInputEndDelay) {
   V8TestingScope scope;
   bool ignored_success;
   EXPECT_EQ(10, ApplyTimingInputNumber(scope.GetIsolate(), "endDelay", 10000,
                                        ignored_success)
                     .end_delay);
   EXPECT_EQ(-2.5, ApplyTimingInputNumber(scope.GetIsolate(), "endDelay", -2500,
                                          ignored_success)
                       .end_delay);
 }
 
-TEST(AnimationTimingInputTest, TimingInputFillMode) {
+TEST_F(AnimationTimingInputTest, TimingInputFillMode) {
   V8TestingScope scope;
   Timing::FillMode default_fill_mode = Timing::FillMode::AUTO;
   bool ignored_success;
 
   EXPECT_EQ(Timing::FillMode::AUTO,
             ApplyTimingInputString(scope.GetIsolate(), "fill", "auto",
                                    ignored_success)
                 .fill_mode);
   EXPECT_EQ(Timing::FillMode::FORWARDS,
             ApplyTimingInputString(scope.GetIsolate(), "fill", "forwards",
@@ skipping 18 matching lines @@
   EXPECT_EQ(default_fill_mode,
             ApplyTimingInputString(scope.GetIsolate(), "fill",
                                    "backwardsandforwards", ignored_success)
                 .fill_mode);
   EXPECT_EQ(
       default_fill_mode,
       ApplyTimingInputNumber(scope.GetIsolate(), "fill", 2, ignored_success)
           .fill_mode);
 }
 
-TEST(AnimationTimingInputTest, TimingInputIterationStart) {
+TEST_F(AnimationTimingInputTest, TimingInputIterationStart) {
   V8TestingScope scope;
   bool success;
   EXPECT_EQ(1.1, ApplyTimingInputNumber(scope.GetIsolate(), "iterationStart",
                                         1.1, success)
                      .iteration_start);
   EXPECT_TRUE(success);
 
   ApplyTimingInputNumber(scope.GetIsolate(), "iterationStart", -1, success);
   EXPECT_FALSE(success);
 
   ApplyTimingInputString(scope.GetIsolate(), "iterationStart", "Infinity",
                          success);
   EXPECT_FALSE(success);
 
   ApplyTimingInputString(scope.GetIsolate(), "iterationStart", "-Infinity",
                          success);
   EXPECT_FALSE(success);
 
   ApplyTimingInputString(scope.GetIsolate(), "iterationStart", "NaN", success);
   EXPECT_FALSE(success);
 
   ApplyTimingInputString(scope.GetIsolate(), "iterationStart", "rubbish",
                          success);
   EXPECT_FALSE(success);
 }
 
-TEST(AnimationTimingInputTest, TimingInputIterationCount) {
+TEST_F(AnimationTimingInputTest, TimingInputIterationCount) {
   V8TestingScope scope;
   bool success;
   EXPECT_EQ(2.1, ApplyTimingInputNumber(scope.GetIsolate(), "iterations", 2.1,
                                         success)
                      .iteration_count);
   EXPECT_TRUE(success);
 
   Timing timing = ApplyTimingInputString(scope.GetIsolate(), "iterations",
                                          "Infinity", success);
   EXPECT_TRUE(success);
   EXPECT_TRUE(std::isinf(timing.iteration_count));
   EXPECT_GT(timing.iteration_count, 0);
 
   ApplyTimingInputNumber(scope.GetIsolate(), "iterations", -1, success);
   EXPECT_FALSE(success);
 
   ApplyTimingInputString(scope.GetIsolate(), "iterations", "-Infinity",
                          success);
   EXPECT_FALSE(success);
 
   ApplyTimingInputString(scope.GetIsolate(), "iterations", "NaN", success);
   EXPECT_FALSE(success);
 
   ApplyTimingInputString(scope.GetIsolate(), "iterations", "rubbish", success);
   EXPECT_FALSE(success);
 }
 
-TEST(AnimationTimingInputTest, TimingInputIterationDuration) {
+TEST_F(AnimationTimingInputTest, TimingInputIterationDuration) {
   V8TestingScope scope;
   bool success;
   EXPECT_EQ(
       1.1, ApplyTimingInputNumber(scope.GetIsolate(), "duration", 1100, success)
                .iteration_duration);
   EXPECT_TRUE(success);
 
   Timing timing =
       ApplyTimingInputNumber(scope.GetIsolate(), "duration",
                              std::numeric_limits<double>::infinity(), success);
@@ skipping 15 matching lines @@
   ApplyTimingInputString(scope.GetIsolate(), "duration", "-Infinity", success);
   EXPECT_FALSE(success);
 
   ApplyTimingInputString(scope.GetIsolate(), "duration", "NaN", success);
   EXPECT_FALSE(success);
 
   ApplyTimingInputString(scope.GetIsolate(), "duration", "rubbish", success);
   EXPECT_FALSE(success);
 }
 
-TEST(AnimationTimingInputTest, TimingInputDirection) {
+TEST_F(AnimationTimingInputTest, TimingInputDirection) {
   V8TestingScope scope;
   Timing::PlaybackDirection default_playback_direction =
       Timing::PlaybackDirection::NORMAL;
   bool ignored_success;
 
   EXPECT_EQ(Timing::PlaybackDirection::NORMAL,
             ApplyTimingInputString(scope.GetIsolate(), "direction", "normal",
                                    ignored_success)
                 .direction);
   EXPECT_EQ(Timing::PlaybackDirection::REVERSE,
@@ skipping 11 matching lines @@
   EXPECT_EQ(default_playback_direction,
             ApplyTimingInputString(scope.GetIsolate(), "direction", "rubbish",
                                    ignored_success)
                 .direction);
   EXPECT_EQ(default_playback_direction,
             ApplyTimingInputNumber(scope.GetIsolate(), "direction", 2,
                                    ignored_success)
                 .direction);
 }
 
-TEST(AnimationTimingInputTest, TimingInputTimingFunction) {
+TEST_F(AnimationTimingInputTest, TimingInputTimingFunction) {
   V8TestingScope scope;
   const RefPtr<TimingFunction> default_timing_function =
       LinearTimingFunction::Shared();
   bool success;
 
   EXPECT_EQ(
       *CubicBezierTimingFunction::Preset(
           CubicBezierTimingFunction::EaseType::EASE),
       *ApplyTimingInputString(scope.GetIsolate(), "easing", "ease", success)
            .timing_function);
@@ skipping 81 matching lines @@
                          success);
   EXPECT_FALSE(success);
   ApplyTimingInputString(scope.GetIsolate(), "easing", "rubbish", success);
   EXPECT_FALSE(success);
   ApplyTimingInputNumber(scope.GetIsolate(), "easing", 2, success);
   EXPECT_FALSE(success);
   ApplyTimingInputString(scope.GetIsolate(), "easing", "initial", success);
   EXPECT_FALSE(success);
 }
 
-TEST(AnimationTimingInputTest, TimingInputEmpty) {
+TEST_F(AnimationTimingInputTest, TimingInputEmpty) {
   DummyExceptionStateForTesting exception_state;
   Timing control_timing;
   Timing updated_timing;
   bool success = TimingInput::Convert(KeyframeEffectOptions(), updated_timing,
                                       nullptr, exception_state);
   EXPECT_TRUE(success);
   EXPECT_FALSE(exception_state.HadException());
 
   EXPECT_EQ(control_timing.start_delay, updated_timing.start_delay);
   EXPECT_EQ(control_timing.fill_mode, updated_timing.fill_mode);
   EXPECT_EQ(control_timing.iteration_start, updated_timing.iteration_start);
   EXPECT_EQ(control_timing.iteration_count, updated_timing.iteration_count);
   EXPECT_TRUE(std::isnan(updated_timing.iteration_duration));
   EXPECT_EQ(control_timing.playback_rate, updated_timing.playback_rate);
   EXPECT_EQ(control_timing.direction, updated_timing.direction);
   EXPECT_EQ(*control_timing.timing_function, *updated_timing.timing_function);
 }
 
-TEST(AnimationTimingInputTest, TimingInputEmptyKeyframeAnimationOptions) {
+TEST_F(AnimationTimingInputTest, TimingInputEmptyKeyframeAnimationOptions) {
   DummyExceptionStateForTesting exception_state;
   Timing control_timing;
   Timing updated_timing;
   bool success = TimingInput::Convert(KeyframeAnimationOptions(),
                                       updated_timing, nullptr, exception_state);
   EXPECT_TRUE(success);
   EXPECT_FALSE(exception_state.HadException());
 
   EXPECT_EQ(control_timing.start_delay, updated_timing.start_delay);
   EXPECT_EQ(control_timing.fill_mode, updated_timing.fill_mode);
   EXPECT_EQ(control_timing.iteration_start, updated_timing.iteration_start);
   EXPECT_EQ(control_timing.iteration_count, updated_timing.iteration_count);
   EXPECT_TRUE(std::isnan(updated_timing.iteration_duration));
   EXPECT_EQ(control_timing.playback_rate, updated_timing.playback_rate);
   EXPECT_EQ(control_timing.direction, updated_timing.direction);
   EXPECT_EQ(*control_timing.timing_function, *updated_timing.timing_function);
 }
 
 }  // namespace blink