CC::Animations should use TimeTicks & TimeDelta to represent time

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 35 matching lines @@
 Animation::Animation(scoped_ptr<AnimationCurve> curve,
                      int animation_id,
                      int group_id,
                      TargetProperty target_property)
     : curve_(curve.Pass()),
       id_(animation_id),
       group_(group_id),
       target_property_(target_property),
       run_state_(WaitingForTargetAvailability),
       iterations_(1),
-      start_time_(0),
+      start_time_(),
       direction_(Normal),
-      time_offset_(0),
+      time_offset_(),
       needs_synchronized_start_time_(false),
       received_finished_event_(false),
       suspended_(false),
-      pause_time_(0),
-      total_paused_time_(0),
+      pause_time_(),
+      total_paused_time_(),
       is_controlling_instance_(false),
       is_impl_only_(false),
       affects_active_observers_(true),
       affects_pending_observers_(true) {
 }
 
 Animation::~Animation() {
   if (run_state_ == Running || run_state_ == Paused)
-    SetRunState(Aborted, 0);
+    SetRunState(Aborted, base::TimeTicks());
 }
 
-void Animation::SetRunState(RunState run_state, double monotonic_time) {
+void Animation::SetRunState(RunState run_state,
+                            base::TimeTicks monotonic_time) {
   if (suspended_)
     return;
 
   char name_buffer[256];
   base::snprintf(name_buffer,
                  sizeof(name_buffer),
                  "%s-%d%s",
                  s_targetPropertyNames[target_property_],
                  group_,
                  is_controlling_instance_ ? "(impl)" : "");
 
   bool is_waiting_to_start = run_state_ == WaitingForTargetAvailability ||
                              run_state_ == Starting;
 
   if (is_waiting_to_start && run_state == Running) {
     TRACE_EVENT_ASYNC_BEGIN1(
         "cc", "Animation", this, "Name", TRACE_STR_COPY(name_buffer));
   }
 
   bool was_finished = is_finished();
 
   const char* old_run_state_name = s_runStateNames[run_state_];
 
   if (run_state == Running && run_state_ == Paused)
-    total_paused_time_ += monotonic_time - pause_time_;
+    total_paused_time_ += (monotonic_time - pause_time_);
   else if (run_state == Paused)
     pause_time_ = monotonic_time;
   run_state_ = run_state;
 
   const char* new_run_state_name = s_runStateNames[run_state];
 
   if (!was_finished && is_finished())
     TRACE_EVENT_ASYNC_END0("cc", "Animation", this);
 
   char state_buffer[256];
   base::snprintf(state_buffer,
                  sizeof(state_buffer),
                  "%s->%s",
                  old_run_state_name,
                  new_run_state_name);
 
   TRACE_EVENT_INSTANT2("cc",
                        "LayerAnimationController::SetRunState",
                        TRACE_EVENT_SCOPE_THREAD,
                        "Name",
                        TRACE_STR_COPY(name_buffer),
                        "State",
                        TRACE_STR_COPY(state_buffer));
 }
 
-void Animation::Suspend(double monotonic_time) {
+void Animation::Suspend(base::TimeTicks monotonic_time) {
   SetRunState(Paused, monotonic_time);
   suspended_ = true;
 }
 
-void Animation::Resume(double monotonic_time) {
+void Animation::Resume(base::TimeTicks monotonic_time) {
   suspended_ = false;
   SetRunState(Running, monotonic_time);
 }
 
-bool Animation::IsFinishedAt(double monotonic_time) const {
+bool Animation::IsFinishedAt(base::TimeTicks monotonic_time) const {
   if (is_finished())
     return true;
 
   if (needs_synchronized_start_time_)
     return false;
 
-  return run_state_ == Running &&
-         iterations_ >= 0 &&
-         iterations_ * curve_->Duration() <= (monotonic_time -
-                                              start_time() -
-                                              total_paused_time_ +
-                                              time_offset_);
+  return run_state_ == Running && iterations_ >= 0 &&
+         iterations_ * curve_->Duration() <=
+             (TimeUtil::TicksInSecondsF(monotonic_time) +
+              time_offset_.InSecondsF() -
+              TimeUtil::TicksInSecondsF(start_time_) -
+              total_paused_time_.InSecondsF());
 }
 
-double Animation::TrimTimeToCurrentIteration(double monotonic_time) const {
-  double trimmed = monotonic_time + time_offset_;
+double Animation::TrimTimeToCurrentIteration(
+    base::TimeTicks monotonic_time) const {
+  double trimmed =
+      TimeUtil::TicksInSecondsF(monotonic_time) + time_offset_.InSecondsF();
 
   // If we're paused, time is 'stuck' at the pause time.
   if (run_state_ == Paused)
-    trimmed = pause_time_;
+    trimmed = TimeUtil::TicksInSecondsF(pause_time_);
 
   // Returned time should always be relative to the start time and should
   // subtract all time spent paused.
-  trimmed -= start_time_ + total_paused_time_;
+  trimmed -=
+      TimeUtil::TicksInSecondsF(start_time_) + total_paused_time_.InSecondsF();
 
   // 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 = time_offset_;
+    trimmed = time_offset_.InSecondsF();
 
   // Return 0 if we are before the start of the animation
   if (trimmed < 0)
     return 0;
 
   // Always return zero if we have no iterations.
   if (!iterations_)
     return 0;
 
   // Don't attempt to trim if we have no duration.
@@ skipping 52 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