gfx: Add FrameTime and DisplayTime classes

ui/compositor/layer_animator.cc

 // Copyright (c) 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 "ui/compositor/layer_animator.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/animation/animation_id_provider.h"
@@ skipping 310 matching lines @@
     return;
   DCHECK(running->is_sequence_alive());
 
   if (running->sequence()->animation_group_id() != event.group_id)
     return;
 
   running->sequence()->OnThreadedAnimationStarted(event);
   if (!running->sequence()->waiting_for_group_start())
     return;
 
-  base::TimeTicks start_time = base::TimeTicks::FromInternalValue(
-      event.monotonic_time * base::Time::kMicrosecondsPerSecond);
+  gfx::FrameTime start_time =
+      gfx::FrameTime::Unsafe_FromSecondsF(event.monotonic_time);
 
   running->sequence()->set_waiting_for_group_start(false);
 
   // The call to GetRunningAnimation made above already purged deleted
   // animations, so we are guaranteed that all the animations we iterate
   // over now are alive.
   for (RunningAnimations::iterator iter = running_animations_.begin();
        iter != running_animations_.end(); ++iter) {
     // Ensure that each sequence is only Started once, regardless of the
     // number of sequences in the group that have threaded first elements.
     if (((*iter).sequence()->animation_group_id() == event.group_id) &&
         !(*iter).sequence()->IsFirstElementThreaded() &&
         (*iter).sequence()->waiting_for_group_start()) {
       (*iter).sequence()->set_start_time(start_time);
       (*iter).sequence()->set_waiting_for_group_start(false);
       (*iter).sequence()->Start(delegate());
     }
   }
 }
 
 // LayerAnimator protected -----------------------------------------------------
 
 void LayerAnimator::ProgressAnimation(LayerAnimationSequence* sequence,
-                                      base::TimeTicks now) {
+                                      gfx::FrameTime now) {
   if (!delegate() || sequence->waiting_for_group_start())
     return;
 
   sequence->Progress(now, delegate());
 }
 
 void LayerAnimator::ProgressAnimationToEnd(LayerAnimationSequence* sequence) {
   if (!delegate())
     return;
 
   sequence->ProgressToEnd(delegate());
 }
 
 bool LayerAnimator::HasAnimation(LayerAnimationSequence* sequence) const {
   for (AnimationQueue::const_iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter) {
     if ((*queue_iter).get() == sequence)
       return true;
   }
   return false;
 }
 
 // LayerAnimator private -------------------------------------------------------
 
-void LayerAnimator::Step(base::TimeTicks now) {
+void LayerAnimator::Step(gfx::FrameTime now) {
   TRACE_EVENT0("ui", "LayerAnimator::Step");
   scoped_refptr<LayerAnimator> retain(this);
 
   last_step_time_ = now;
 
   PurgeDeletedAnimations();
 
   // We need to make a copy of the running animations because progressing them
   // and finishing them may indirectly affect the collection of running
   // animations.
   RunningAnimations running_animations_copy = running_animations_;
   for (size_t i = 0; i < running_animations_copy.size(); ++i) {
     if (!SAFE_INVOKE_BOOL(HasAnimation, running_animations_copy[i]))
       continue;
 
     if (running_animations_copy[i].sequence()->IsFinished(now)) {
       SAFE_INVOKE_VOID(FinishAnimation, running_animations_copy[i], false);
     } else {
       SAFE_INVOKE_VOID(ProgressAnimation, running_animations_copy[i], now);
     }
   }
 }
 
-void LayerAnimator::SetStartTime(base::TimeTicks start_time) {
+void LayerAnimator::SetStartTime(gfx::FrameTime start_time) {
   // Do nothing.
 }
 
 base::TimeDelta LayerAnimator::GetTimerInterval() const {
   return base::TimeDelta::FromMilliseconds(kTimerIntervalMs);
 }
 
 void LayerAnimator::StopAnimatingInternal(bool abort) {
   scoped_refptr<LayerAnimator> retain(this);
   while (is_animating()) {
@@ skipping 341 matching lines @@
       return false;
   }
 
   // All clear, actually start the sequence. Note: base::TimeTicks::Now has
   // a resolution that can be as bad as 15ms. If this causes glitches in the
   // animations, this can be switched to HighResNow() (animation uses Now()
   // internally).
   // All LayerAnimators share the same AnimationContainer. Use the
   // last_tick_time() from there to ensure animations started during the same
   // event complete at the same time.
-  base::TimeTicks start_time;
+  gfx::FrameTime start_time;
   if (is_animating() || adding_animations_)
     start_time = last_step_time_;
   else if (GetAnimationContainer()->is_running())
     start_time = GetAnimationContainer()->last_tick_time();
   else
     start_time = gfx::FrameTime::Now();
 
   if (!sequence->animation_group_id())
     sequence->set_animation_group_id(cc::AnimationIdProvider::NextGroupId());
   if (!sequence->waiting_for_group_start() ||
@@ skipping 68 matching lines @@
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui