gfx: Add FrameTime and DisplayTime classes

ui/compositor/layer_animator.h

 // 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.
 
 #ifndef UI_COMPOSITOR_LAYER_ANIMATOR_H_
 #define UI_COMPOSITOR_LAYER_ANIMATOR_H_
 
 #include <deque>
 #include <vector>
 
@@ skipping 162 matching lines @@
   // effect on animations that are explicitly started or scheduled. The default
   // is Tween::LINEAR.
   void set_tween_type(gfx::Tween::Type tween_type) { tween_type_ = tween_type; }
   gfx::Tween::Type tween_type() const { return tween_type_; }
 
   // For testing purposes only.
   void set_disable_timer_for_test(bool disable_timer) {
     disable_timer_for_test_ = disable_timer;
   }
 
-  void set_last_step_time(base::TimeTicks time) {
+  void set_last_step_time(gfx::FrameTime time) {
     last_step_time_ = time;
   }
-  base::TimeTicks last_step_time() const { return last_step_time_; }
+  gfx::FrameTime last_step_time() const { return last_step_time_; }
 
  protected:
   virtual ~LayerAnimator();
 
   LayerAnimationDelegate* delegate() { return delegate_; }
   const LayerAnimationDelegate* delegate() const { return delegate_; }
 
   // Virtual for testing.
   virtual void ProgressAnimation(LayerAnimationSequence* sequence,
-                                 base::TimeTicks now);
+                                 gfx::FrameTime now);
 
   void ProgressAnimationToEnd(LayerAnimationSequence* sequence);
 
   // Returns true if the sequence is owned by this animator.
   bool HasAnimation(LayerAnimationSequence* sequence) const;
 
  private:
   friend class base::RefCounted<LayerAnimator>;
   friend class ScopedLayerAnimationSettings;
   friend class LayerAnimatorTestController;
 
   class RunningAnimation {
    public:
     RunningAnimation(const base::WeakPtr<LayerAnimationSequence>& sequence);
     ~RunningAnimation();
 
     bool is_sequence_alive() const { return !!sequence_.get(); }
     LayerAnimationSequence* sequence() const { return sequence_.get(); }
 
    private:
     base::WeakPtr<LayerAnimationSequence> sequence_;
 
     // Copy and assign are allowed.
   };
 
   typedef std::vector<RunningAnimation> RunningAnimations;
   typedef std::deque<linked_ptr<LayerAnimationSequence> > AnimationQueue;
 
   // Implementation of AnimationContainerElement
-  virtual void SetStartTime(base::TimeTicks start_time) OVERRIDE;
-  virtual void Step(base::TimeTicks time_now) OVERRIDE;
+  virtual void SetStartTime(gfx::FrameTime start_time) OVERRIDE;
+  virtual void Step(gfx::FrameTime time_now) OVERRIDE;
   virtual base::TimeDelta GetTimerInterval() const OVERRIDE;
 
   // Finishes all animations by either advancing them to their final state or by
   // aborting them.
   void StopAnimatingInternal(bool abort);
 
   // Starts or stops stepping depending on whether thare are running animations.
   void UpdateAnimationState();
 
   // Removes the sequences from both the running animations and the queue.
@@ skipping 79 matching lines @@
   // Determines how animations are replaced.
   PreemptionStrategy preemption_strategy_;
 
   // The default length of animations.
   base::TimeDelta transition_duration_;
 
   // The default tween type for implicit transitions
   gfx::Tween::Type tween_type_;
 
   // Used for coordinating the starting of animations.
-  base::TimeTicks last_step_time_;
+  gfx::FrameTime last_step_time_;
 
   // True if we are being stepped by our container.
   bool is_started_;
 
   // This prevents the animator from automatically stepping through animations
   // and allows for manual stepping.
   bool disable_timer_for_test_;
 
   // Prevents timer adjustments in case when we start multiple animations
   // with preemption strategies that discard previous animations.
   bool adding_animations_;
 
   // Observers are notified when layer animations end, are scheduled or are
   // aborted.
   ObserverList<LayerAnimationObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimator);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATOR_H_