Implement frames() timing function

third_party/WebKit/Source/core/animation/CompositorAnimationsTest.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 48 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
 class AnimationCompositorAnimationsTest : public ::testing::Test {
  protected:
   RefPtr<TimingFunction> linear_timing_function_;
   RefPtr<TimingFunction> cubic_ease_timing_function_;
   RefPtr<TimingFunction> cubic_custom_timing_function_;
   RefPtr<TimingFunction> step_timing_function_;
+  RefPtr<TimingFunction> frames_timing_function_;
 
   Timing timing_;
   CompositorAnimations::CompositorTiming compositor_timing_;
   std::unique_ptr<AnimatableValueKeyframeVector> keyframe_vector2_;
   Persistent<AnimatableValueKeyframeEffectModel> keyframe_animation_effect2_;
   std::unique_ptr<AnimatableValueKeyframeVector> keyframe_vector5_;
   Persistent<AnimatableValueKeyframeEffectModel> keyframe_animation_effect5_;
 
   Persistent<Document> document_;
   Persistent<Element> element_;
   Persistent<AnimationTimeline> timeline_;
   std::unique_ptr<DummyPageHolder> page_holder_;
 
   void SetUp() override {
     linear_timing_function_ = LinearTimingFunction::Shared();
     cubic_ease_timing_function_ = CubicBezierTimingFunction::Preset(
         CubicBezierTimingFunction::EaseType::EASE);
     cubic_custom_timing_function_ =
         CubicBezierTimingFunction::Create(1, 2, 3, 4);
     step_timing_function_ =
         StepsTimingFunction::Create(1, StepsTimingFunction::StepPosition::END);
+    frames_timing_function_ = FramesTimingFunction::Create(2);
 
     timing_ = CreateCompositableTiming();
     compositor_timing_ = CompositorAnimations::CompositorTiming();
     // Make sure the CompositableTiming is really compositable, otherwise
     // most other tests will fail.
     ASSERT_TRUE(ConvertTimingForCompositor(timing_, compositor_timing_));
 
     keyframe_vector2_ = CreateCompositableFloatKeyframeVector(2);
     keyframe_animation_effect2_ =
         AnimatableValueKeyframeEffectModel::Create(*keyframe_vector2_);
@@ skipping 503 matching lines @@
 TEST_F(AnimationCompositorAnimationsTest,
        isCandidateForAnimationOnCompositorTimingFunctionSteps) {
   timing_.timing_function = step_timing_function_;
   EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
       timing_, *keyframe_animation_effect2_));
   EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
       timing_, *keyframe_animation_effect5_));
 }
 
 TEST_F(AnimationCompositorAnimationsTest,
+       isCandidateForAnimationOnCompositorTimingFunctionFrames) {
+  timing_.timing_function = frames_timing_function_;
+  EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
+      timing_, *keyframe_animation_effect2_));
+  EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
+      timing_, *keyframe_animation_effect5_));
+}
+
+TEST_F(AnimationCompositorAnimationsTest,
        isCandidateForAnimationOnCompositorTimingFunctionChainedLinear) {
   EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
       timing_, *keyframe_animation_effect2_));
   EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
       timing_, *keyframe_animation_effect5_));
 }
 
 TEST_F(
     AnimationCompositorAnimationsTest,
     isCandidateForAnimationOnCompositorNonLinearTimingFunctionOnFirstOrLastFrame) {
@@ skipping 49 matching lines @@
   (*keyframe_vector5_)[1]->SetEasing(cubic_ease_timing_function_.Get());
   (*keyframe_vector5_)[2]->SetEasing(cubic_ease_timing_function_.Get());
   (*keyframe_vector5_)[3]->SetEasing(linear_timing_function_.Get());
   keyframe_animation_effect5_ =
       AnimatableValueKeyframeEffectModel::Create(*keyframe_vector5_);
   EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
       timing_, *keyframe_animation_effect5_));
 }
 
 TEST_F(AnimationCompositorAnimationsTest,
-       isCandidateForAnimationOnCompositorTimingFunctionWithStepOkay) {
+       isCandidateForAnimationOnCompositorTimingFunctionWithStepOrFrameOkay) {
   (*keyframe_vector2_)[0]->SetEasing(step_timing_function_.Get());
   keyframe_animation_effect2_ =
       AnimatableValueKeyframeEffectModel::Create(*keyframe_vector2_);
   EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
       timing_, *keyframe_animation_effect2_));
 
+  (*keyframe_vector2_)[0]->SetEasing(frames_timing_function_.Get());
+  keyframe_animation_effect2_ =
+      AnimatableValueKeyframeEffectModel::Create(*keyframe_vector2_);
+  EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
+      timing_, *keyframe_animation_effect2_));
+
   (*keyframe_vector5_)[0]->SetEasing(step_timing_function_.Get());
   (*keyframe_vector5_)[1]->SetEasing(linear_timing_function_.Get());
   (*keyframe_vector5_)[2]->SetEasing(cubic_ease_timing_function_.Get());
-  (*keyframe_vector5_)[3]->SetEasing(linear_timing_function_.Get());
+  (*keyframe_vector5_)[3]->SetEasing(frames_timing_function_.Get());
   keyframe_animation_effect5_ =
       AnimatableValueKeyframeEffectModel::Create(*keyframe_vector5_);
   EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
       timing_, *keyframe_animation_effect5_));
 
-  (*keyframe_vector5_)[0]->SetEasing(linear_timing_function_.Get());
+  (*keyframe_vector5_)[0]->SetEasing(frames_timing_function_.Get());
   (*keyframe_vector5_)[1]->SetEasing(step_timing_function_.Get());
   (*keyframe_vector5_)[2]->SetEasing(cubic_ease_timing_function_.Get());
   (*keyframe_vector5_)[3]->SetEasing(linear_timing_function_.Get());
   keyframe_animation_effect5_ =
       AnimatableValueKeyframeEffectModel::Create(*keyframe_vector5_);
   EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
       timing_, *keyframe_animation_effect5_));
 
   (*keyframe_vector5_)[0]->SetEasing(linear_timing_function_.Get());
-  (*keyframe_vector5_)[1]->SetEasing(cubic_ease_timing_function_.Get());
+  (*keyframe_vector5_)[1]->SetEasing(frames_timing_function_.Get());
   (*keyframe_vector5_)[2]->SetEasing(cubic_ease_timing_function_.Get());
   (*keyframe_vector5_)[3]->SetEasing(step_timing_function_.Get());
   keyframe_animation_effect5_ =
       AnimatableValueKeyframeEffectModel::Create(*keyframe_vector5_);
   EXPECT_TRUE(IsCandidateForAnimationOnCompositor(
       timing_, *keyframe_animation_effect5_));
 }
 
 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositor) {
   AnimatableValueKeyframeVector basic_frames_vector;
@@ skipping 588 matching lines @@
 
   // Clearing the effect node entirely should also produce false.
   properties.ClearEffect();
   EXPECT_FALSE(CompositorAnimations::CanStartAnimationOnCompositor(*element));
 
   element->SetLayoutObject(nullptr);
   LayoutObjectProxy::Dispose(layout_object);
 }
 
 }  // namespace blink