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_(),

[ajuma, 2014/05/07 17:04:42]

Not needed.

[Sikugu_, 2014/05/12 16:01:53]

Done.

       value_provider_(NULL),
-      layer_animation_delegate_(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 < animations_.size(); ++i) {
     if (animations_[i]->id() == animation_id) {
       animations_[i]->SetRunState(Animation::Paused,
                                   time_offset + animations_[i]->start_time());
     }
   }
 }
 
 struct HasAnimationId {
   explicit HasAnimationId(int id) : 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 < animations_.size(); ++i) {
     Animation* animation = animations_[i];
     if (!animation->is_impl_only())
       continue;
 
     double trimmed = animation->TrimTimeToCurrentIteration(monotonic_time);
@@ skipping 50 matching lines @@
         NOTREACHED();
     }
   }
 }
 
 void LayerAnimationController::UpdateState(bool start_ready_animations,
                                            AnimationEventsVector* events) {
   if (!HasActiveValueObserver())
     return;
 
-  DCHECK(last_tick_time_);
+  DCHECK(last_tick_time_ != base::TimeTicks());
   if (start_ready_animations)
     PromoteStartedAnimations(last_tick_time_, events);
 
   MarkFinishedAnimations(last_tick_time_);
   MarkAnimationsForDeletion(last_tick_time_, events);
 
   if (start_ready_animations) {
     StartAnimations(last_tick_time_);
     PromoteStartedAnimations(last_tick_time_, events);
   }
@@ skipping 76 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 < animations_.size(); ++i) {
     if (animations_[i]->group() == event.group_id &&
         animations_[i]->target_property() == event.target_property &&
         animations_[i]->needs_synchronized_start_time()) {
       animations_[i]->set_needs_synchronized_start_time(false);
       if (!animations_[i]->has_set_start_time())
         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 < animations_.size(); ++i) {
     if (animations_[i]->group() == event.group_id &&
         animations_[i]->target_property() == event.target_property) {
       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 < animations_.size(); ++i) {
     if (animations_[i]->group() == event.group_id &&
@@ skipping 229 matching lines @@
 void LayerAnimationController::PushPropertiesToImplThread(
     LayerAnimationController* controller_impl) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     Animation* current_impl = controller_impl->GetAnimation(
         animations_[i]->group(), animations_[i]->target_property());
     if (current_impl)
       animations_[i]->PushPropertiesTo(current_impl);
   }
 }
 
-void LayerAnimationController::StartAnimations(double monotonic_time) {
+void LayerAnimationController::StartAnimations(base::TimeTicks monotonic_time) {
   // First collect running properties affecting each type of observer.
   TargetProperties blocked_properties_for_active_observers;
   TargetProperties blocked_properties_for_pending_observers;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::Starting ||
         animations_[i]->run_state() == Animation::Running) {
       if (animations_[i]->affects_active_observers()) {
         blocked_properties_for_active_observers.insert(
             animations_[i]->target_property());
       }
@@ skipping 50 matching lines @@
           if (animations_[i]->group() == animations_[j]->group()) {
             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 < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::Starting &&
         animations_[i]->affects_active_observers()) {
       animations_[i]->SetRunState(Animation::Running, monotonic_time);
       if (!animations_[i]->has_set_start_time() &&
           !animations_[i]->needs_synchronized_start_time())
         animations_[i]->set_start_time(monotonic_time);
       if (events) {
         AnimationEvent started_event(AnimationEvent::Started,
                                      id_,
                                      animations_[i]->group(),
                                      animations_[i]->target_property(),
                                      monotonic_time);
         started_event.is_impl_only = 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 < animations_.size(); ++i) {
     if (animations_[i]->IsFinishedAt(monotonic_time) &&
         animations_[i]->run_state() != Animation::Aborted &&
         animations_[i]->run_state() != Animation::WaitingForDeletion)
       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 < animations_.size(); i++) {
     int group_id = animations_[i]->group();
     if (animations_[i]->run_state() == Animation::Aborted) {
       if (events && !animations_[i]->is_impl_only()) {
@@ skipping 66 matching lines @@
 }
 
 void LayerAnimationController::PurgeAnimationsMarkedForDeletion() {
   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 < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::Starting ||
         animations_[i]->run_state() == Animation::Running ||
         animations_[i]->run_state() == Animation::Paused) {
       double trimmed =
           animations_[i]->TrimTimeToCurrentIteration(monotonic_time);
 
       switch (animations_[i]->target_property()) {
         case Animation::Transform: {
           const TransformAnimationCurve* transform_animation_curve =
@@ skipping 159 matching lines @@
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc