Implement frames() timing function

third_party/WebKit/Source/platform/animation/TimingFunction.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 "platform/animation/TimingFunction.h"
 
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
@@ skipping 90 matching lines @@
 }
 
 double StepsTimingFunction::evaluate(double fraction, double) const {
   return m_steps->GetPreciseValue(fraction);
 }
 
 std::unique_ptr<cc::TimingFunction> StepsTimingFunction::cloneToCC() const {
   return m_steps->Clone();
 }
 
+String FramesTimingFunction::toString() const {
+  StringBuilder builder;
+  builder.append("frames(");
+  builder.append(String::numberToStringECMAScript(this->numberOfFrames()));
+  builder.append(")");
+  return builder.toString();
+}
+
+void FramesTimingFunction::range(double* minValue, double* maxValue) const {
+  *minValue = 0;
+  *maxValue = 1;
+}
+
+double FramesTimingFunction::evaluate(double fraction, double) const {
+  return m_frames->GetPreciseValue(fraction);
+}
+
+std::unique_ptr<cc::TimingFunction> FramesTimingFunction::cloneToCC() const {
+  return m_frames->Clone();
+}
+
 PassRefPtr<TimingFunction> createCompositorTimingFunctionFromCC(
     const cc::TimingFunction* timingFunction) {
   if (!timingFunction)
     return LinearTimingFunction::shared();
 
   switch (timingFunction->GetType()) {
     case cc::TimingFunction::Type::CUBIC_BEZIER: {
       auto cubicTimingFunction =
           static_cast<const cc::CubicBezierTimingFunction*>(timingFunction);
       if (cubicTimingFunction->ease_type() !=
@@ skipping 40 matching lines @@
 
 bool operator==(const StepsTimingFunction& lhs, const TimingFunction& rhs) {
   if (rhs.getType() != TimingFunction::Type::STEPS)
     return false;
 
   const StepsTimingFunction& stf = toStepsTimingFunction(rhs);
   return (lhs.numberOfSteps() == stf.numberOfSteps()) &&
          (lhs.getStepPosition() == stf.getStepPosition());
 }
 
+bool operator==(const FramesTimingFunction& lhs, const TimingFunction& rhs) {
+  if (rhs.getType() != TimingFunction::Type::FRAMES)
+    return false;
+
+  const FramesTimingFunction& stf = toFramesTimingFunction(rhs);
+  return lhs.numberOfFrames() == stf.numberOfFrames();
+}
+
 // The generic operator== *must* come after the
 // non-generic operator== otherwise it will end up calling itself.
 bool operator==(const TimingFunction& lhs, const TimingFunction& rhs) {
   switch (lhs.getType()) {
     case TimingFunction::Type::LINEAR: {
       const LinearTimingFunction& linear = toLinearTimingFunction(lhs);
       return (linear == rhs);
     }
     case TimingFunction::Type::CUBIC_BEZIER: {
       const CubicBezierTimingFunction& cubic = toCubicBezierTimingFunction(lhs);
       return (cubic == rhs);
     }
     case TimingFunction::Type::STEPS: {
       const StepsTimingFunction& step = toStepsTimingFunction(lhs);
       return (step == rhs);
     }
+    case TimingFunction::Type::FRAMES: {
+      const FramesTimingFunction& frame = toFramesTimingFunction(lhs);
+      return (frame == rhs);
+    }
     default:
       ASSERT_NOT_REACHED();
   }
   return false;
 }
 
 // No need to define specific operator!= as they can all come via this function.
 bool operator!=(const TimingFunction& lhs, const TimingFunction& rhs) {
   return !(lhs == rhs);
 }
 
 }  // namespace blink