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 <memory>
 
 namespace blink {
 
 class AnimationCompositorAnimationsTest : public ::testing::Test {
  protected:
   RefPtr<TimingFunction> m_linearTimingFunction;
   RefPtr<TimingFunction> m_cubicEaseTimingFunction;
   RefPtr<TimingFunction> m_cubicCustomTimingFunction;
   RefPtr<TimingFunction> m_stepTimingFunction;
+  RefPtr<TimingFunction> m_framesTimingFunction;
 
   Timing m_timing;
   CompositorAnimations::CompositorTiming m_compositorTiming;
   std::unique_ptr<AnimatableValueKeyframeVector> m_keyframeVector2;
   Persistent<AnimatableValueKeyframeEffectModel> m_keyframeAnimationEffect2;
   std::unique_ptr<AnimatableValueKeyframeVector> m_keyframeVector5;
   Persistent<AnimatableValueKeyframeEffectModel> m_keyframeAnimationEffect5;
 
   Persistent<Document> m_document;
   Persistent<Element> m_element;
   Persistent<AnimationTimeline> m_timeline;
   std::unique_ptr<DummyPageHolder> m_pageHolder;
 
   void SetUp() override {
     m_linearTimingFunction = LinearTimingFunction::shared();
     m_cubicEaseTimingFunction = CubicBezierTimingFunction::preset(
         CubicBezierTimingFunction::EaseType::EASE);
     m_cubicCustomTimingFunction = CubicBezierTimingFunction::create(1, 2, 3, 4);
     m_stepTimingFunction =
         StepsTimingFunction::create(1, StepsTimingFunction::StepPosition::END);
+    m_framesTimingFunction = FramesTimingFunction::create(2);
 
     m_timing = createCompositableTiming();
     m_compositorTiming = CompositorAnimations::CompositorTiming();
     // Make sure the CompositableTiming is really compositable, otherwise
     // most other tests will fail.
     ASSERT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 
     m_keyframeVector2 = createCompositableFloatKeyframeVector(2);
     m_keyframeAnimationEffect2 =
         AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2);
@@ skipping 499 matching lines @@
 TEST_F(AnimationCompositorAnimationsTest,
        isCandidateForAnimationOnCompositorTimingFunctionSteps) {
   m_timing.timingFunction = m_stepTimingFunction;
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
                                                   *m_keyframeAnimationEffect2));
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
                                                   *m_keyframeAnimationEffect5));
 }
 
 TEST_F(AnimationCompositorAnimationsTest,
+       isCandidateForAnimationOnCompositorTimingFunctionFrames) {
+  m_timing.timingFunction = m_framesTimingFunction;
+  EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
+                                                  *m_keyframeAnimationEffect2));
+  EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
+                                                  *m_keyframeAnimationEffect5));
+}
+
+TEST_F(AnimationCompositorAnimationsTest,
        isCandidateForAnimationOnCompositorTimingFunctionChainedLinear) {
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
                                                   *m_keyframeAnimationEffect2));
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
                                                   *m_keyframeAnimationEffect5));
 }
 
 TEST_F(
     AnimationCompositorAnimationsTest,
     isCandidateForAnimationOnCompositorNonLinearTimingFunctionOnFirstOrLastFrame) {
@@ skipping 49 matching lines @@
   (*m_keyframeVector5)[1]->setEasing(m_cubicEaseTimingFunction.get());
   (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get());
   (*m_keyframeVector5)[3]->setEasing(m_linearTimingFunction.get());
   m_keyframeAnimationEffect5 =
       AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
                                                   *m_keyframeAnimationEffect5));
 }
 
 TEST_F(AnimationCompositorAnimationsTest,
-       isCandidateForAnimationOnCompositorTimingFunctionWithStepOkay) {
+       isCandidateForAnimationOnCompositorTimingFunctionWithStepOrFrameOkay) {
   (*m_keyframeVector2)[0]->setEasing(m_stepTimingFunction.get());
   m_keyframeAnimationEffect2 =
       AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2);
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
                                                   *m_keyframeAnimationEffect2));
 
+  (*m_keyframeVector2)[0]->setEasing(m_framesTimingFunction.get());
+  m_keyframeAnimationEffect2 =
+      AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2);
+  EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
+                                                  *m_keyframeAnimationEffect2));
+
   (*m_keyframeVector5)[0]->setEasing(m_stepTimingFunction.get());
   (*m_keyframeVector5)[1]->setEasing(m_linearTimingFunction.get());
   (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get());
-  (*m_keyframeVector5)[3]->setEasing(m_linearTimingFunction.get());
+  (*m_keyframeVector5)[3]->setEasing(m_framesTimingFunction.get());
   m_keyframeAnimationEffect5 =
       AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
                                                   *m_keyframeAnimationEffect5));
 
-  (*m_keyframeVector5)[0]->setEasing(m_linearTimingFunction.get());
+  (*m_keyframeVector5)[0]->setEasing(m_framesTimingFunction.get());
   (*m_keyframeVector5)[1]->setEasing(m_stepTimingFunction.get());
   (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get());
   (*m_keyframeVector5)[3]->setEasing(m_linearTimingFunction.get());
   m_keyframeAnimationEffect5 =
       AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
                                                   *m_keyframeAnimationEffect5));
 
   (*m_keyframeVector5)[0]->setEasing(m_linearTimingFunction.get());
-  (*m_keyframeVector5)[1]->setEasing(m_cubicEaseTimingFunction.get());
+  (*m_keyframeVector5)[1]->setEasing(m_framesTimingFunction.get());
   (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get());
   (*m_keyframeVector5)[3]->setEasing(m_stepTimingFunction.get());
   m_keyframeAnimationEffect5 =
       AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
                                                   *m_keyframeAnimationEffect5));
 }
 
 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositor) {
   AnimatableValueKeyframeVector basicFramesVector;
@@ skipping 582 matching lines @@
 
   // Clearing the effect node entirely should also produce false.
   properties.clearEffect();
   EXPECT_FALSE(CompositorAnimations::canStartAnimationOnCompositor(*element));
 
   element->setLayoutObject(nullptr);
   LayoutObjectProxy::dispose(layoutObject);
 }
 
 }  // namespace blink