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 "platform/wtf/text/StringBuilder.h"
 
 namespace blink {
 
@@ skipping 90 matching lines @@
 }
 
 double StepsTimingFunction::Evaluate(double fraction, double) const {
   return steps_->GetPreciseValue(fraction);
 }
 
 std::unique_ptr<cc::TimingFunction> StepsTimingFunction::CloneToCC() const {
   return 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* min_value, double* max_value) const {
+  *min_value = 0;
+  *max_value = 1;
+}
+
+double FramesTimingFunction::Evaluate(double fraction, double) const {
+  return frames_->GetPreciseValue(fraction);
+}
+
+std::unique_ptr<cc::TimingFunction> FramesTimingFunction::CloneToCC() const {
+  return frames_->Clone();
+}
+
 PassRefPtr<TimingFunction> CreateCompositorTimingFunctionFromCC(
     const cc::TimingFunction* timing_function) {
   if (!timing_function)
     return LinearTimingFunction::Shared();
 
   switch (timing_function->GetType()) {
     case cc::TimingFunction::Type::CUBIC_BEZIER: {
       auto cubic_timing_function =
           static_cast<const cc::CubicBezierTimingFunction*>(timing_function);
       if (cubic_timing_function->ease_type() !=
@@ skipping 41 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& ftf = ToFramesTimingFunction(rhs);
+  return lhs.NumberOfFrames() == ftf.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