gfx: Add FrameTime and DisplayTime classes

ui/compositor/layer_animation_element.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_ANIMATION_ELEMENT_H_
 #define UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_
 
 #include <set>
 
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_events.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/compositor/compositor_export.h"
 #include "ui/gfx/animation/tween.h"
+#include "ui/gfx/frame_time.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 
 namespace ui {
 
 class InterpolatedTransform;
 class LayerAnimationDelegate;
 
 // LayerAnimationElements represent one segment of an animation between two
 // keyframes. They know how to update a LayerAnimationDelegate given a value
@@ skipping 102 matching lines @@
 
   // Creates an element that transitions to the given color. The caller owns the
   // return value.
   static LayerAnimationElement* CreateColorElement(
       SkColor color,
       base::TimeDelta duration);
 
   // Sets the start time for the animation. This must be called before the first
   // call to {Start, IsFinished}. Once the animation is finished, this must
   // be called again in order to restart the animation.
-  void set_requested_start_time(base::TimeTicks start_time) {
+  void set_requested_start_time(gfx::FrameTime start_time) {
     requested_start_time_ = start_time;
   }
-  base::TimeTicks requested_start_time() const { return requested_start_time_; }
+  gfx::FrameTime requested_start_time() const { return requested_start_time_; }
 
   // Sets the actual start time for the animation, taking into account any
   // queueing delays.
-  void set_effective_start_time(base::TimeTicks start_time) {
+  void set_effective_start_time(gfx::FrameTime start_time) {
     effective_start_time_ = start_time;
   }
-  base::TimeTicks effective_start_time() const { return effective_start_time_; }
+  gfx::FrameTime effective_start_time() const { return effective_start_time_; }
 
   // This must be called before the first call to Progress. If starting the
   // animation involves dispatching to another thread, then this will proceed
   // with that dispatch, ultimately resulting in the animation getting an
   // effective start time (the time the animation starts on the other thread).
   void Start(LayerAnimationDelegate* delegate, int animation_group_id);
 
   // Returns true if the animation has started but hasn't finished.
   bool Started() { return !first_frame_; }
 
   // Updates the delegate to the appropriate value for |now|. Returns true
   // if a redraw is required.
-  bool Progress(base::TimeTicks now, LayerAnimationDelegate* delegate);
+  bool Progress(gfx::FrameTime now, LayerAnimationDelegate* delegate);
 
   // If calling Progress now, with the given time, will finish the animation,
   // returns true and sets |end_duration| to the actual duration for this
   // animation, incuding any queueing delays.
-  bool IsFinished(base::TimeTicks time, base::TimeDelta* total_duration);
+  bool IsFinished(gfx::FrameTime time, base::TimeDelta* total_duration);
 
   // Updates the delegate to the end of the animation. Returns true if a
   // redraw is required.
   bool ProgressToEnd(LayerAnimationDelegate* delegate);
 
   // Called if the animation is not allowed to complete. This may be called
   // before OnStarted or Progress.
   void Abort(LayerAnimationDelegate* delegate);
 
   // Assigns the target value to |target|.
@@ skipping 35 matching lines @@
   LayerAnimationElement(const LayerAnimationElement& element);
 
  private:
   // For debugging purposes, we sometimes alter the duration we actually use.
   // For example, during tests we often set duration = 0, and it is sometimes
   // useful to slow animations down to see them more clearly.
   base::TimeDelta GetEffectiveDuration(const base::TimeDelta& delta);
 
   bool first_frame_;
   const AnimatableProperties properties_;
-  base::TimeTicks requested_start_time_;
+  gfx::FrameTime requested_start_time_;
 
   // When the animation actually started, taking into account queueing delays.
-  base::TimeTicks effective_start_time_;
+  gfx::FrameTime effective_start_time_;
   const base::TimeDelta duration_;
   gfx::Tween::Type tween_type_;
 
   const int animation_id_;
   int animation_group_id_;
 
   double last_progressed_fraction_;
 
   base::WeakPtrFactory<LayerAnimationElement> weak_ptr_factory_;
 
   DISALLOW_ASSIGN(LayerAnimationElement);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_