Make CalculateOffsetActiveTime() 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: Ibfaf523e3879ed2b8a34bf0ca710d46b3ac1f8c7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1814820Reviewed-by: Stephen McGruer <smcgruer@chromium.org>
Commit-Queue: Sergio Villar <svillar@igalia.com>
Cr-Commit-Position: refs/heads/master@{#698648}

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

@@ -193,7 +193,7 @@ Timing::CalculatedTiming Timing::CalculateTimings(
     const double start_offset =
         MultiplyZeroAlwaysGivesZero(iteration_start, iteration_duration);
     DCHECK_GE(start_offset, 0);
-    const base::Optional<double> offset_active_time =
+    const base::Optional<AnimationTimeDelta> offset_active_time =
         CalculateOffsetActiveTime(active_duration, active_time, start_offset);
     const base::Optional<AnimationTimeDelta> iteration_time =
         CalculateIterationTime(iteration_duration, active_duration,

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

@@ -314,7 +314,7 @@ static inline base::Optional<double> CalculateTransformedProgress(
 // product of the iteration start and iteration duration). This is not part of
 // the Web Animations spec; it is used for calculating the time until the next
 // iteration to optimize scheduling.
-static inline base::Optional<double> CalculateOffsetActiveTime(
+static inline base::Optional<AnimationTimeDelta> CalculateOffsetActiveTime(
     double active_duration,
     base::Optional<double> active_time,
     double start_offset) {
@@ -328,9 +328,9 @@ static inline base::Optional<double> CalculateOffsetActiveTime(
          LessThanOrEqualToWithinEpsilon(active_time.value(), active_duration));
 
   if (!std::isfinite(active_time.value()))
-    return std::numeric_limits<double>::infinity();
+    return AnimationTimeDelta::Max();
 
-  return active_time.value() + start_offset;
+  return AnimationTimeDelta::FromSecondsD(active_time.value() + start_offset);
 }
 
 // Maps the offset active time into 'iteration time space'[0], aka the offset
@@ -342,7 +342,7 @@ static inline base::Optional<double> CalculateOffsetActiveTime(
 static inline base::Optional<AnimationTimeDelta> CalculateIterationTime(
     double iteration_duration,
     double active_duration,
-    base::Optional<double> offset_active_time,
+    base::Optional<AnimationTimeDelta> offset_active_time,
     double start_offset,
     Timing::Phase phase,
     const Timing& specified) {
@@ -354,24 +354,26 @@ static inline base::Optional<AnimationTimeDelta> CalculateIterationTime(
   if (!offset_active_time)
     return base::nullopt;
 
-  DCHECK_GE(offset_active_time.value(), 0);
-  DCHECK(LessThanOrEqualToWithinEpsilon(offset_active_time.value(),
+  DCHECK_GE(offset_active_time.value(), AnimationTimeDelta());
+  DCHECK(LessThanOrEqualToWithinEpsilon(offset_active_time->InSecondsF(),
                                         active_duration + start_offset));
 
-  if (!std::isfinite(offset_active_time.value()) ||
-      (offset_active_time.value() - start_offset == active_duration &&
+  if (offset_active_time->is_max() ||
+      (offset_active_time->InSecondsF() - start_offset == active_duration &&
        specified.iteration_count &&
        EndsOnIterationBoundary(specified.iteration_count,
                                specified.iteration_start)))
     return AnimationTimeDelta::FromSecondsD(iteration_duration);
 
-  DCHECK(std::isfinite(offset_active_time.value()));
-  double iteration_time = fmod(offset_active_time.value(), iteration_duration);
+  DCHECK(!offset_active_time->is_max());
+  double iteration_time =
+      fmod(offset_active_time->InSecondsF(), iteration_duration);
 
   // This implements step 3 of
   // 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)
+      active_duration != 0 &&
+      offset_active_time.value() != AnimationTimeDelta())
     return AnimationTimeDelta::FromSecondsD(iteration_duration);
 
   return AnimationTimeDelta::FromSecondsD(iteration_time);

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

@@ -81,19 +81,20 @@ TEST(AnimationTimingCalculationsTest, OffsetActiveTime) {
   EXPECT_FALSE(CalculateOffsetActiveTime(4, base::nullopt, 5));
 
   // normal case
-  EXPECT_EQ(15, CalculateOffsetActiveTime(40, 10, 5));
+  EXPECT_EQ(AnimationTimeDelta::FromSecondsD(15),
+            CalculateOffsetActiveTime(40, 10, 5));
 
   // infinte activeTime
-  EXPECT_EQ(
-      std::numeric_limits<double>::infinity(),
-      CalculateOffsetActiveTime(std::numeric_limits<double>::infinity(),
-                                std::numeric_limits<double>::infinity(), 0));
+  EXPECT_TRUE(CalculateOffsetActiveTime(std::numeric_limits<double>::infinity(),
+                                        std::numeric_limits<double>::infinity(),
+                                        0)
+                  ->is_max());
 
   // Edge case for active_time being within epsilon of active_duration.
   // https://crbug.com/962138
   const double active_time = 1.3435713716800004;
   const double active_duration = 1.3435713716800002;
-  EXPECT_EQ(active_time,
+  EXPECT_EQ(AnimationTimeDelta::FromSecondsD(active_time),
             CalculateOffsetActiveTime(active_duration, active_time, 0));
 }
 
@@ -109,22 +110,25 @@ TEST(AnimationTimingCalculationsTest, IterationTime) {
                                       Timing::kPhaseActive, timing));
 
   // if (complex-conditions)...
-  EXPECT_EQ(
-      AnimationTimeDelta::FromSecondsD(12),
-      CalculateIterationTime(12, 12, 12, 0, Timing::kPhaseActive, timing));
+  EXPECT_EQ(AnimationTimeDelta::FromSecondsD(12),
+            CalculateIterationTime(12, 12, AnimationTimeDelta::FromSecondsD(12),
+                                   0, Timing::kPhaseActive, timing));
 
   // otherwise
   timing.iteration_count = 10;
   EXPECT_EQ(
       AnimationTimeDelta::FromSecondsD(5),
-      CalculateIterationTime(10, 100, 25, 4, Timing::kPhaseActive, timing));
+      CalculateIterationTime(10, 100, AnimationTimeDelta::FromSecondsD(25), 4,
+                             Timing::kPhaseActive, timing));
   EXPECT_EQ(
       AnimationTimeDelta::FromSecondsD(7),
-      CalculateIterationTime(11, 110, 29, 1, Timing::kPhaseActive, timing));
+      CalculateIterationTime(11, 110, AnimationTimeDelta::FromSecondsD(29), 1,
+                             Timing::kPhaseActive, timing));
   timing.iteration_start = 1.1;
   EXPECT_EQ(
       AnimationTimeDelta::FromSecondsD(8),
-      CalculateIterationTime(12, 120, 20, 7, Timing::kPhaseActive, timing));
+      CalculateIterationTime(12, 120, AnimationTimeDelta::FromSecondsD(20), 7,
+                             Timing::kPhaseActive, timing));
 
   // Edge case for offset_active_time being within epsilon of (active_duration
   // + start_offset). https://crbug.com/962138
@@ -133,9 +137,10 @@ TEST(AnimationTimingCalculationsTest, IterationTime) {
   const double iteration_duration = 1.3435713716800002;
   const double active_duration = 1.3435713716800002;
   EXPECT_NEAR(2.22045e-16,
-              CalculateIterationTime(iteration_duration, active_duration,
-                                     offset_active_time, 0,
-                                     Timing::kPhaseActive, timing)
+              CalculateIterationTime(
+                  iteration_duration, active_duration,
+                  AnimationTimeDelta::FromSecondsD(offset_active_time), 0,
+                  Timing::kPhaseActive, timing)
                   ->InSecondsF(),
               std::numeric_limits<float>::epsilon());
 }