Make cc::animation::TrimTimeToCurrentIteration,cc::AnimationCurve::Duration use TimeTicks/TimeDelta

cc/animation/animation.cc

 // Copyright 2012 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 "cc/animation/animation.h"
 
 #include <cmath>
 
 #include "base/debug/trace_event.h"
 #include "base/strings/string_util.h"
 #include "cc/animation/animation_curve.h"
+#include "cc/base/time_util.h"
 
 namespace {
 
 // This should match the RunState enum.
 static const char* const s_runStateNames[] = {
   "WaitingForTargetAvailability",
   "WaitingForDeletion",
   "Starting",
   "Running",
   "Paused",
@@ skipping 125 matching lines @@
   if (is_finished())
     return true;
 
   if (needs_synchronized_start_time_)
     return false;
 
   if (playback_rate_ == 0)
     return false;
 
   return run_state_ == Running && iterations_ >= 0 &&
-         iterations_ * curve_->Duration() / std::abs(playback_rate_) <=
-             (monotonic_time + time_offset_ - start_time_ - total_paused_time_)
-                 .InSecondsF();
+         TimeUtil::Scale(curve_->Duration(),
+                         iterations_ / std::abs(playback_rate_)) <=
+             (monotonic_time + time_offset_ - start_time_ - total_paused_time_);
 }
 
 bool Animation::InEffect(base::TimeTicks monotonic_time) const {
-  return ConvertToActiveTime(monotonic_time) >= 0 ||
+  return ConvertToActiveTime(monotonic_time) >= base::TimeDelta() ||
          (fill_mode_ == FillModeBoth || fill_mode_ == FillModeBackwards);
 }
 
-double Animation::ConvertToActiveTime(base::TimeTicks monotonic_time) const {
+base::TimeDelta Animation::ConvertToActiveTime(
+    base::TimeTicks monotonic_time) const {
   base::TimeTicks trimmed = monotonic_time + time_offset_;
 
   // If we're paused, time is 'stuck' at the pause time.
   if (run_state_ == Paused)
     trimmed = pause_time_;
 
   // Returned time should always be relative to the start time and should
   // subtract all time spent paused.
   trimmed -= (start_time_ - base::TimeTicks()) + total_paused_time_;
 
   // If we're just starting or we're waiting on receiving a start time,
   // time is 'stuck' at the initial state.
   if ((run_state_ == Starting && !has_set_start_time()) ||
       needs_synchronized_start_time())
     trimmed = base::TimeTicks() + time_offset_;
 
-  return (trimmed - base::TimeTicks()).InSecondsF();
+  return (trimmed - base::TimeTicks());
 }
 
-double Animation::TrimTimeToCurrentIteration(
+base::TimeDelta Animation::TrimTimeToCurrentIteration(
     base::TimeTicks monotonic_time) const {
   // Check for valid parameters
   DCHECK(playback_rate_);
   DCHECK_GE(iteration_start_, 0);
 
-  double active_time = ConvertToActiveTime(monotonic_time);
-  double start_offset = iteration_start_ * curve_->Duration();
+  base::TimeDelta active_time = ConvertToActiveTime(monotonic_time);
+  base::TimeDelta start_offset =
+      TimeUtil::Scale(curve_->Duration(), iteration_start_);
 
   // Return start offset if we are before the start of the animation
-  if (active_time < 0)
+  if (active_time < base::TimeDelta())
     return start_offset;
-
   // Always return zero if we have no iterations.
   if (!iterations_)
-    return 0;
+    return base::TimeDelta();
 
   // Don't attempt to trim if we have no duration.
-  if (curve_->Duration() <= 0)
-    return 0;
+  if (curve_->Duration() <= base::TimeDelta())
+    return base::TimeDelta();
 
-  double repeated_duration = iterations_ * curve_->Duration();
-  double active_duration = repeated_duration / std::abs(playback_rate_);
+  base::TimeDelta repeated_duration =
+      TimeUtil::Scale(curve_->Duration(), iterations_);
+  base::TimeDelta active_duration =
+      TimeUtil::Scale(repeated_duration, 1.0 / std::abs(playback_rate_));
 
   // Check if we are past active duration
   if (iterations_ > 0 && active_time >= active_duration)
     active_time = active_duration;
 
   // Calculate the scaled active time
-  double scaled_active_time;
+  base::TimeDelta scaled_active_time;
   if (playback_rate_ < 0)
     scaled_active_time =
-        (active_time - active_duration) * playback_rate_ + start_offset;
+        TimeUtil::Scale((active_time - active_duration), playback_rate_) +
+        start_offset;
   else
-    scaled_active_time = active_time * playback_rate_ + start_offset;
+    scaled_active_time =
+        TimeUtil::Scale(active_time, playback_rate_) + start_offset;
 
   // Calculate the iteration time
-  double iteration_time;
+  base::TimeDelta iteration_time;
   if (scaled_active_time - start_offset == repeated_duration &&
       fmod(iterations_ + iteration_start_, 1) == 0)
     iteration_time = curve_->Duration();
   else
-    iteration_time = fmod(scaled_active_time, curve_->Duration());
+    iteration_time = TimeUtil::Mod(scaled_active_time, curve_->Duration());
 
   // Calculate the current iteration
   int iteration;
-  if (scaled_active_time <= 0)
+  if (scaled_active_time <= base::TimeDelta())
     iteration = 0;
   else if (iteration_time == curve_->Duration())
     iteration = ceil(iteration_start_ + iterations_ - 1);
   else
     iteration = static_cast<int>(scaled_active_time / curve_->Duration());
 
   // Check if we are running the animation in reverse direction for the current
   // iteration
   bool reverse = (direction_ == Reverse) ||
                  (direction_ == Alternate && iteration % 2 == 1) ||
@@ skipping 30 matching lines @@
   // the main thread.
   if (run_state_ == Animation::Paused ||
       other->run_state_ == Animation::Paused) {
     other->run_state_ = run_state_;
     other->pause_time_ = pause_time_;
     other->total_paused_time_ = total_paused_time_;
   }
 }
 
 }  // namespace cc