gfx: Add FrameTime and DisplayTime classes

ui/compositor/layer_animation_element.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_animation_element.h"
 
 #include "base/compiler_specific.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_id_provider.h"
 #include "ui/compositor/float_animation_curve_adapter.h"
@@ skipping 396 matching lines @@
     }
   }
 
   virtual void RequestEffectiveStart(
       LayerAnimationDelegate* delegate) OVERRIDE {
     DCHECK(animation_group_id());
     if (duration() == base::TimeDelta()) {
       set_effective_start_time(requested_start_time());
       return;
     }
-    set_effective_start_time(base::TimeTicks());
+    set_effective_start_time(gfx::FrameTime());
     scoped_ptr<cc::Animation> animation = CreateCCAnimation();
     animation->set_needs_synchronized_start_time(true);
     delegate->AddThreadedAnimation(animation.Pass());
   }
 
   virtual void OnEnd(LayerAnimationDelegate* delegate) = 0;
 
   virtual scoped_ptr<cc::Animation> CreateCCAnimation() = 0;
 
  private:
@@ skipping 299 matching lines @@
       animation_group_id_(element.animation_group_id_),
       last_progressed_fraction_(element.last_progressed_fraction_),
       weak_ptr_factory_(this) {
 }
 
 LayerAnimationElement::~LayerAnimationElement() {
 }
 
 void LayerAnimationElement::Start(LayerAnimationDelegate* delegate,
                                   int animation_group_id) {
-  DCHECK(requested_start_time_ != base::TimeTicks());
+  DCHECK(requested_start_time_ != gfx::FrameTime());
   DCHECK(first_frame_);
   animation_group_id_ = animation_group_id;
   last_progressed_fraction_ = 0.0;
   OnStart(delegate);
   RequestEffectiveStart(delegate);
   first_frame_ = false;
 }
 
-bool LayerAnimationElement::Progress(base::TimeTicks now,
+bool LayerAnimationElement::Progress(gfx::FrameTime now,
                                      LayerAnimationDelegate* delegate) {
-  DCHECK(requested_start_time_ != base::TimeTicks());
+  DCHECK(requested_start_time_ != gfx::FrameTime());
   DCHECK(!first_frame_);
 
   bool need_draw;
   double t = 1.0;
 
-  if ((effective_start_time_ == base::TimeTicks()) ||
+  if ((effective_start_time_ == gfx::FrameTime()) ||
       (now < effective_start_time_))  {
     // This hasn't actually started yet.
     need_draw = false;
     last_progressed_fraction_ = 0.0;
     return need_draw;
   }
 
   base::TimeDelta elapsed = now - effective_start_time_;
   if ((duration_ > base::TimeDelta()) && (elapsed < duration_))
     t = elapsed.InMillisecondsF() / duration_.InMillisecondsF();
   base::WeakPtr<LayerAnimationElement> alive(weak_ptr_factory_.GetWeakPtr());
   need_draw = OnProgress(gfx::Tween::CalculateValue(tween_type_, t), delegate);
   if (!alive)
     return need_draw;
   first_frame_ = t == 1.0;
   last_progressed_fraction_ = t;
   return need_draw;
 }
 
-bool LayerAnimationElement::IsFinished(base::TimeTicks time,
+bool LayerAnimationElement::IsFinished(gfx::FrameTime time,
                                        base::TimeDelta* total_duration) {
   // If an effective start has been requested but the effective start time
   // hasn't yet been set, the animation is not finished, regardless of the
   // value of |time|.
-  if (!first_frame_ && (effective_start_time_ == base::TimeTicks()))
+  if (!first_frame_ && (effective_start_time_ == gfx::FrameTime()))
     return false;
 
   base::TimeDelta queueing_delay;
   if (!first_frame_)
     queueing_delay = effective_start_time_ - requested_start_time_;
 
   base::TimeDelta elapsed = time - requested_start_time_;
   if (elapsed >= duration_ + queueing_delay) {
     *total_duration = duration_ + queueing_delay;
     return true;
@@ skipping 21 matching lines @@
   return false;
 }
 
 void LayerAnimationElement::Abort(LayerAnimationDelegate* delegate) {
   OnAbort(delegate);
   first_frame_ = true;
 }
 
 void LayerAnimationElement::RequestEffectiveStart(
     LayerAnimationDelegate* delegate) {
-  DCHECK(requested_start_time_ != base::TimeTicks());
+  DCHECK(requested_start_time_ != gfx::FrameTime());
   effective_start_time_ = requested_start_time_;
 }
 
 // static
 LayerAnimationElement::AnimatableProperty
 LayerAnimationElement::ToAnimatableProperty(
     cc::Animation::TargetProperty property) {
   switch (property) {
     case cc::Animation::Transform:
       return TRANSFORM;
@@ skipping 94 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui