Use Clamped math in CubicBezierTimingFunction

The CubicBezierTimingFunction::GetValue and Velocity uses static_cast
that cast a double to float. This is not safe when the double is a
very big number and could result in float-cast-overflow.

This CL fixes it by using clamped math, which would clamp the value to
float range.

Bug: 925513
Change-Id: If29fe00c4d3ea4c7ca93c96878ab898d7ec8d6f3
Reviewed-on: https://chromium-review.googlesource.com/c/1438649Reviewed-by: Stephen McGruer <smcgruer@chromium.org>
Commit-Queue: Xida Chen <xidachen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#626633}

cc/animation/timing_function.cc

@@ -57,12 +57,12 @@ TimingFunction::Type CubicBezierTimingFunction::GetType() const {
   return Type::CUBIC_BEZIER;
 }
 
-float CubicBezierTimingFunction::GetValue(double x) const {
-  return static_cast<float>(bezier_.Solve(x));
+double CubicBezierTimingFunction::GetValue(double x) const {
+  return bezier_.Solve(x);
 }
 
-float CubicBezierTimingFunction::Velocity(double x) const {
-  return static_cast<float>(bezier_.Slope(x));
+double CubicBezierTimingFunction::Velocity(double x) const {
+  return bezier_.Slope(x);
 }
 
 std::unique_ptr<TimingFunction> CubicBezierTimingFunction::Clone() const {
@@ -84,16 +84,16 @@ TimingFunction::Type StepsTimingFunction::GetType() const {
   return Type::STEPS;
 }
 
-float StepsTimingFunction::GetValue(double t) const {
-  return static_cast<float>(GetPreciseValue(t));
+double StepsTimingFunction::GetValue(double t) const {
+  return GetPreciseValue(t);
 }
 
 std::unique_ptr<TimingFunction> StepsTimingFunction::Clone() const {
   return base::WrapUnique(new StepsTimingFunction(*this));
 }
 
-float StepsTimingFunction::Velocity(double x) const {
-  return 0.0f;
+double StepsTimingFunction::Velocity(double x) const {
+  return 0;
 }
 
 double StepsTimingFunction::GetPreciseValue(double t) const {
@@ -132,16 +132,16 @@ TimingFunction::Type FramesTimingFunction::GetType() const {
   return Type::FRAMES;
 }
 
-float FramesTimingFunction::GetValue(double t) const {
-  return static_cast<float>(GetPreciseValue(t));
+double FramesTimingFunction::GetValue(double t) const {
+  return GetPreciseValue(t);
 }
 
 std::unique_ptr<TimingFunction> FramesTimingFunction::Clone() const {
   return base::WrapUnique(new FramesTimingFunction(*this));
 }
 
-float FramesTimingFunction::Velocity(double x) const {
-  return 0.0f;
+double FramesTimingFunction::Velocity(double x) const {
+  return 0;
 }
 
 double FramesTimingFunction::GetPreciseValue(double t) const {

cc/animation/timing_function.h

@@ -22,8 +22,8 @@ class CC_ANIMATION_EXPORT TimingFunction {
   enum class Type { LINEAR, CUBIC_BEZIER, STEPS, FRAMES };
 
   virtual Type GetType() const = 0;
-  virtual float GetValue(double t) const = 0;
-  virtual float Velocity(double time) const = 0;
+  virtual double GetValue(double t) const = 0;
+  virtual double Velocity(double time) const = 0;
   virtual std::unique_ptr<TimingFunction> Clone() const = 0;
 
  protected:
@@ -46,8 +46,8 @@ class CC_ANIMATION_EXPORT CubicBezierTimingFunction : public TimingFunction {
 
   // TimingFunction implementation.
   Type GetType() const override;
-  float GetValue(double time) const override;
-  float Velocity(double time) const override;
+  double GetValue(double time) const override;
+  double Velocity(double time) const override;
   std::unique_ptr<TimingFunction> Clone() const override;
 
   EaseType ease_type() const { return ease_type_; }
@@ -78,9 +78,9 @@ class CC_ANIMATION_EXPORT StepsTimingFunction : public TimingFunction {
 
   // TimingFunction implementation.
   Type GetType() const override;
-  float GetValue(double t) const override;
+  double GetValue(double t) const override;
   std::unique_ptr<TimingFunction> Clone() const override;
-  float Velocity(double time) const override;
+  double Velocity(double time) const override;
 
   int steps() const { return steps_; }
   StepPosition step_position() const { return step_position_; }
@@ -104,9 +104,9 @@ class CC_ANIMATION_EXPORT FramesTimingFunction : public TimingFunction {
 
   // TimingFunction implementation.
   Type GetType() const override;
-  float GetValue(double t) const override;
+  double GetValue(double t) const override;
   std::unique_ptr<TimingFunction> Clone() const override;
-  float Velocity(double time) const override;
+  double Velocity(double time) const override;
 
   int frames() const { return frames_; }
   double GetPreciseValue(double t) const;

third_party/blink/renderer/platform/animation/compositor_float_animation_curve_test.cc

@@ -143,7 +143,7 @@ TEST(WebFloatAnimationCurveTest, EaseTimingFunction) {
           CubicBezierTimingFunction::EaseType::EASE));
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
-    EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->GetValue(time));
+    EXPECT_NEAR(timing_function->GetValue(time), curve->GetValue(time), 1e-7);
   }
 }
 
@@ -178,7 +178,7 @@ TEST(WebFloatAnimationCurveTest, EaseInTimingFunction) {
           CubicBezierTimingFunction::EaseType::EASE_IN));
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
-    EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->GetValue(time));
+    EXPECT_NEAR(timing_function->GetValue(time), curve->GetValue(time), 1e-7);
   }
 }
 
@@ -198,7 +198,7 @@ TEST(WebFloatAnimationCurveTest, EaseOutTimingFunction) {
           CubicBezierTimingFunction::EaseType::EASE_OUT));
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
-    EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->GetValue(time));
+    EXPECT_NEAR(timing_function->GetValue(time), curve->GetValue(time), 1e-7);
   }
 }
 
@@ -218,7 +218,7 @@ TEST(WebFloatAnimationCurveTest, EaseInOutTimingFunction) {
           CubicBezierTimingFunction::EaseType::EASE_IN_OUT));
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
-    EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->GetValue(time));
+    EXPECT_NEAR(timing_function->GetValue(time), curve->GetValue(time), 1e-7);
   }
 }
 
@@ -240,7 +240,7 @@ TEST(WebFloatAnimationCurveTest, CustomBezierTimingFunction) {
       cc::CubicBezierTimingFunction::Create(x1, y1, x2, y2));
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
-    EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->GetValue(time));
+    EXPECT_NEAR(timing_function->GetValue(time), curve->GetValue(time), 1e-7);
   }
 }
 
@@ -260,7 +260,7 @@ TEST(WebFloatAnimationCurveTest, DefaultTimingFunction) {
           CubicBezierTimingFunction::EaseType::EASE));
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
-    EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->GetValue(time));
+    EXPECT_NEAR(timing_function->GetValue(time), curve->GetValue(time), 1e-7);
   }
 }