Make CalculateIterationTime() return AnimationTimeDelta

It's currently returning a double. As part of the process of rewriting the
animation engine we're replacing doubles by base::Time* alternatives.

Bug: 737867
Change-Id: I71aa8eb08210f8809ce5d6727c813c238ec1d08c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1813305Reviewed-by: Stephen McGruer <smcgruer@chromium.org>
Commit-Queue: Sergio Villar <svillar@igalia.com>
Cr-Commit-Position: refs/heads/master@{#698606}

third_party/blink/renderer/core/animation/timing.cc

@@ -195,13 +195,15 @@ Timing::CalculatedTiming Timing::CalculateTimings(
     DCHECK_GE(start_offset, 0);
     const base::Optional<double> offset_active_time =
         CalculateOffsetActiveTime(active_duration, active_time, start_offset);
-    const base::Optional<double> iteration_time = CalculateIterationTime(
-        iteration_duration, active_duration, offset_active_time, start_offset,
-        current_phase, *this);
+    const base::Optional<AnimationTimeDelta> iteration_time =
+        CalculateIterationTime(iteration_duration, active_duration,
+                               offset_active_time, start_offset, current_phase,
+                               *this);
     if (iteration_time) {
       // active_time cannot be null if iteration_time is not null.
       DCHECK(active_time);
-      time_to_next_iteration = iteration_duration - iteration_time.value();
+      time_to_next_iteration =
+          iteration_duration - iteration_time->InSecondsF();
       if (active_duration - active_time.value() < time_to_next_iteration)
         time_to_next_iteration = std::numeric_limits<double>::infinity();
     }

third_party/blink/renderer/core/animation/timing_calculations.h

@@ -339,7 +339,7 @@ static inline base::Optional<double> CalculateOffsetActiveTime(
 // the time until the next iteration to optimize scheduling.
 //
 // [0] https://drafts.csswg.org/web-animations-1/#iteration-time-space
-static inline base::Optional<double> CalculateIterationTime(
+static inline base::Optional<AnimationTimeDelta> CalculateIterationTime(
     double iteration_duration,
     double active_duration,
     base::Optional<double> offset_active_time,
@@ -363,7 +363,7 @@ static inline base::Optional<double> CalculateIterationTime(
        specified.iteration_count &&
        EndsOnIterationBoundary(specified.iteration_count,
                                specified.iteration_start)))
-    return iteration_duration;
+    return AnimationTimeDelta::FromSecondsD(iteration_duration);
 
   DCHECK(std::isfinite(offset_active_time.value()));
   double iteration_time = fmod(offset_active_time.value(), iteration_duration);
@@ -372,9 +372,9 @@ static inline base::Optional<double> CalculateIterationTime(
   // https://drafts.csswg.org/web-animations/#calculating-the-simple-iteration-progress
   if (iteration_time == 0 && phase == Timing::kPhaseAfter &&
       active_duration != 0 && offset_active_time != 0)
-    return iteration_duration;
+    return AnimationTimeDelta::FromSecondsD(iteration_duration);
 
-  return iteration_time;
+  return AnimationTimeDelta::FromSecondsD(iteration_time);
 }
 
 }  // namespace blink

third_party/blink/renderer/core/animation/timing_calculations_test.cc

@@ -110,17 +110,21 @@ TEST(AnimationTimingCalculationsTest, IterationTime) {
 
   // if (complex-conditions)...
   EXPECT_EQ(
-      12, CalculateIterationTime(12, 12, 12, 0, Timing::kPhaseActive, timing));
+      AnimationTimeDelta::FromSecondsD(12),
+      CalculateIterationTime(12, 12, 12, 0, Timing::kPhaseActive, timing));
 
   // otherwise
   timing.iteration_count = 10;
   EXPECT_EQ(
-      5, CalculateIterationTime(10, 100, 25, 4, Timing::kPhaseActive, timing));
+      AnimationTimeDelta::FromSecondsD(5),
+      CalculateIterationTime(10, 100, 25, 4, Timing::kPhaseActive, timing));
   EXPECT_EQ(
-      7, CalculateIterationTime(11, 110, 29, 1, Timing::kPhaseActive, timing));
+      AnimationTimeDelta::FromSecondsD(7),
+      CalculateIterationTime(11, 110, 29, 1, Timing::kPhaseActive, timing));
   timing.iteration_start = 1.1;
   EXPECT_EQ(
-      8, CalculateIterationTime(12, 120, 20, 7, Timing::kPhaseActive, timing));
+      AnimationTimeDelta::FromSecondsD(8),
+      CalculateIterationTime(12, 120, 20, 7, Timing::kPhaseActive, timing));
 
   // Edge case for offset_active_time being within epsilon of (active_duration
   // + start_offset). https://crbug.com/962138
@@ -132,7 +136,7 @@ TEST(AnimationTimingCalculationsTest, IterationTime) {
               CalculateIterationTime(iteration_duration, active_duration,
                                      offset_active_time, 0,
                                      Timing::kPhaseActive, timing)
-                  .value(),
+                  ->InSecondsF(),
               std::numeric_limits<float>::epsilon());
 }