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

cc/animation/layer_animation_controller.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/layer_animation_controller.h"
 
 #include <algorithm>
 
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/layer_animation_value_observer.h"
 #include "cc/animation/layer_animation_value_provider.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/base/scoped_ptr_algorithm.h"
 #include "cc/output/filter_operations.h"
 #include "ui/gfx/box_f.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 LayerAnimationController::LayerAnimationController(int id)
     : registrar_(0),
       id_(id),
       is_active_(false),
-      last_tick_time_(0),
+      last_tick_time_(base::TimeTicks()),
       value_provider_(NULL),
       layer_animation_delegate_(NULL) {}
 
 LayerAnimationController::~LayerAnimationController() {
   if (registrar_)
     registrar_->UnregisterAnimationController(this);
 }
 
 scoped_refptr<LayerAnimationController> LayerAnimationController::Create(
     int id) {
   return make_scoped_refptr(new LayerAnimationController(id));
 }
 
 void LayerAnimationController::PauseAnimation(int animation_id,
-                                              double time_offset) {
+                                              base::TimeDelta time_offset) {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->id() == animation_id) {
+      // TODO(sikugu): http://crbug.com/178171 - Remove double
+      // and use base::TimeTicks/TimeDelta instead all over the file.
+      // Remove usage of TimeTicksToDoubleTime.
       active_animations_[i]->SetRunState(
           Animation::Paused, time_offset + active_animations_[i]->start_time());
     }
   }
 }
 
 struct HasAnimationId {
   explicit HasAnimationId(int id) : id_(id) {}
   bool operator()(Animation* animation) const {
     return animation->id() == id_;
@@ skipping 61 matching lines @@
   // Remove finished impl side animations only after pushing,
   // and only after the animations are deleted on the main thread
   // this insures we will never push an animation twice.
   RemoveAnimationsCompletedOnMainThread(controller_impl);
 
   PushPropertiesToImplThread(controller_impl);
   controller_impl->UpdateActivation(NormalActivation);
   UpdateActivation(NormalActivation);
 }
 
-void LayerAnimationController::Animate(double monotonic_time) {
-  DCHECK(monotonic_time);
+void LayerAnimationController::Animate(base::TimeTicks monotonic_time) {
+  DCHECK(monotonic_time != base::TimeTicks());
   if (!HasValueObserver())
     return;
 
   StartAnimations(monotonic_time);
   TickAnimations(monotonic_time);
   last_tick_time_ = monotonic_time;
 }
 
 void LayerAnimationController::AccumulatePropertyUpdates(
-    double monotonic_time,
+    base::TimeTicks monotonic_time,
     AnimationEventsVector* events) {
   if (!events)
     return;
 
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     Animation* animation = active_animations_[i];
     if (!animation->is_impl_only())
       continue;
 
     double trimmed = animation->TrimTimeToCurrentIteration(monotonic_time);
@@ skipping 126 matching lines @@
 
   registrar_ = registrar;
   if (registrar_)
     registrar_->RegisterAnimationController(this);
 
   UpdateActivation(ForceActivation);
 }
 
 void LayerAnimationController::NotifyAnimationStarted(
     const AnimationEvent& event) {
-  base::TimeTicks monotonic_time = base::TimeTicks::FromInternalValue(
-      event.monotonic_time * base::Time::kMicrosecondsPerSecond);
   if (event.is_impl_only) {
     FOR_EACH_OBSERVER(LayerAnimationEventObserver, event_observers_,
                       OnAnimationStarted(event));
     if (layer_animation_delegate_)
-      layer_animation_delegate_->NotifyAnimationStarted(monotonic_time,
+      layer_animation_delegate_->NotifyAnimationStarted(event.monotonic_time,
                                                         event.target_property);
-
     return;
   }
 
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->group() == event.group_id &&
         active_animations_[i]->target_property() == event.target_property &&
         active_animations_[i]->needs_synchronized_start_time()) {
       active_animations_[i]->set_needs_synchronized_start_time(false);
       if (!active_animations_[i]->has_set_start_time())
         active_animations_[i]->set_start_time(event.monotonic_time);
 
       FOR_EACH_OBSERVER(LayerAnimationEventObserver, event_observers_,
                         OnAnimationStarted(event));
       if (layer_animation_delegate_)
         layer_animation_delegate_->NotifyAnimationStarted(
-            monotonic_time, event.target_property);
+            event.monotonic_time, event.target_property);
 
       return;
     }
   }
 }
 
 void LayerAnimationController::NotifyAnimationFinished(
     const AnimationEvent& event) {
-  base::TimeTicks monotonic_time = base::TimeTicks::FromInternalValue(
-      event.monotonic_time * base::Time::kMicrosecondsPerSecond);
   if (event.is_impl_only) {
     if (layer_animation_delegate_)
-      layer_animation_delegate_->NotifyAnimationFinished(monotonic_time,
+      layer_animation_delegate_->NotifyAnimationFinished(event.monotonic_time,
                                                          event.target_property);
     return;
   }
 
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->group() == event.group_id &&
         active_animations_[i]->target_property() == event.target_property) {
       active_animations_[i]->set_received_finished_event(true);
       if (layer_animation_delegate_)
         layer_animation_delegate_->NotifyAnimationFinished(
-            monotonic_time, event.target_property);
+            event.monotonic_time, event.target_property);
 
       return;
     }
   }
 }
 
 void LayerAnimationController::NotifyAnimationAborted(
     const AnimationEvent& event) {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->group() == event.group_id &&
@@ skipping 225 matching lines @@
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     Animation* current_impl =
         controller_impl->GetAnimation(
             active_animations_[i]->group(),
             active_animations_[i]->target_property());
     if (current_impl)
       active_animations_[i]->PushPropertiesTo(current_impl);
   }
 }
 
-void LayerAnimationController::StartAnimations(double monotonic_time) {
+void LayerAnimationController::StartAnimations(base::TimeTicks monotonic_time) {
   // First collect running properties.
   TargetProperties blocked_properties;
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->run_state() == Animation::Starting ||
         active_animations_[i]->run_state() == Animation::Running)
       blocked_properties.insert(active_animations_[i]->target_property());
   }
 
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->run_state() ==
@@ skipping 30 matching lines @@
             active_animations_[j]->SetRunState(
                 Animation::Starting, monotonic_time);
           }
         }
       }
     }
   }
 }
 
 void LayerAnimationController::PromoteStartedAnimations(
-    double monotonic_time,
+    base::TimeTicks monotonic_time,
     AnimationEventsVector* events) {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->run_state() == Animation::Starting) {
       active_animations_[i]->SetRunState(Animation::Running, monotonic_time);
       if (!active_animations_[i]->has_set_start_time() &&
           !active_animations_[i]->needs_synchronized_start_time())
         active_animations_[i]->set_start_time(monotonic_time);
       if (events) {
         AnimationEvent started_event(
             AnimationEvent::Started,
             id_,
             active_animations_[i]->group(),
             active_animations_[i]->target_property(),
             monotonic_time);
         started_event.is_impl_only = active_animations_[i]->is_impl_only();
         events->push_back(started_event);
       }
     }
   }
 }
 
-void LayerAnimationController::MarkFinishedAnimations(double monotonic_time) {
+void LayerAnimationController::MarkFinishedAnimations(
+    base::TimeTicks monotonic_time) {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->IsFinishedAt(monotonic_time) &&
         active_animations_[i]->run_state() != Animation::Aborted &&
         active_animations_[i]->run_state() != Animation::WaitingForDeletion)
       active_animations_[i]->SetRunState(Animation::Finished, monotonic_time);
   }
 }
 
 void LayerAnimationController::MarkAnimationsForDeletion(
-    double monotonic_time, AnimationEventsVector* events) {
+    base::TimeTicks monotonic_time,
+    AnimationEventsVector* events) {
   bool marked_animations_for_deletions = false;
 
   // Non-aborted animations are marked for deletion after a corresponding
   // AnimationEvent::Finished event is sent or received. This means that if
   // we don't have an events vector, we must ensure that non-aborted animations
   // have received a finished event before marking them for deletion.
   for (size_t i = 0; i < active_animations_.size(); i++) {
     int group_id = active_animations_[i]->group();
     if (active_animations_[i]->run_state() == Animation::Aborted) {
       if (events && !active_animations_[i]->is_impl_only()) {
@@ skipping 69 matching lines @@
 
 void LayerAnimationController::PurgeAnimationsMarkedForDeletion() {
   ScopedPtrVector<Animation>& animations = active_animations_;
   animations.erase(cc::remove_if(&animations,
                                  animations.begin(),
                                  animations.end(),
                                  IsWaitingForDeletion),
                    animations.end());
 }
 
-void LayerAnimationController::TickAnimations(double monotonic_time) {
+void LayerAnimationController::TickAnimations(base::TimeTicks monotonic_time) {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->run_state() == Animation::Starting ||
         active_animations_[i]->run_state() == Animation::Running ||
         active_animations_[i]->run_state() == Animation::Paused) {
       double trimmed =
           active_animations_[i]->TrimTimeToCurrentIteration(monotonic_time);
 
       switch (active_animations_[i]->target_property()) {
         case Animation::Transform: {
           const TransformAnimationCurve* transform_animation_curve =
@@ skipping 110 matching lines @@
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc