gfx: Add FrameTime and DisplayTime classes

cc/animation/scrollbar_animation_controller_thinning.cc

 // Copyright 2013 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/scrollbar_animation_controller_thinning.h"
 
 #include <algorithm>
 
 #include "base/time/time.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 29 matching lines @@
       mouse_move_distance_to_trigger_animation_(100.f) {}
 
 ScrollbarAnimationControllerThinning::~ScrollbarAnimationControllerThinning() {
 }
 
 bool ScrollbarAnimationControllerThinning::IsAnimating() const {
   return !last_awaken_time_.is_null();
 }
 
 base::TimeDelta ScrollbarAnimationControllerThinning::DelayBeforeStart(
-    base::TimeTicks now) const {
+    gfx::FrameTime now) const {
   if (now > last_awaken_time_ + animation_delay_)
     return base::TimeDelta();
   return animation_delay_ - (now - last_awaken_time_);
 }
 
-bool ScrollbarAnimationControllerThinning::Animate(base::TimeTicks now) {
+bool ScrollbarAnimationControllerThinning::Animate(gfx::FrameTime now) {
   if (mouse_is_over_scrollbar_) {
     ApplyOpacityAndThumbThicknessScale(1, 1);
     return false;
   }
   float progress = AnimationProgressAtTime(now);
   float opacity = OpacityAtAnimationProgress(progress);
   float thumb_thickness_scale = ThumbThicknessScaleAtAnimationProgress(
       progress);
   ApplyOpacityAndThumbThicknessScale(opacity, thumb_thickness_scale);
   if (progress == 1.f)
-    last_awaken_time_ = base::TimeTicks();
+    last_awaken_time_ = gfx::FrameTime();
   return IsAnimating() && DelayBeforeStart(now) == base::TimeDelta();
 }
 
 void ScrollbarAnimationControllerThinning::DidScrollGestureBegin() {
   ApplyOpacityAndThumbThicknessScale(1, 1);
-  last_awaken_time_ = base::TimeTicks();
+  last_awaken_time_ = gfx::FrameTime();
   scroll_gesture_in_progress_ = true;
 }
 
 void ScrollbarAnimationControllerThinning::DidScrollGestureEnd(
-    base::TimeTicks now) {
+    gfx::FrameTime now) {
   last_awaken_time_ = now;
   scroll_gesture_in_progress_ = false;
 }
 
 void ScrollbarAnimationControllerThinning::DidMouseMoveOffScrollbar(
-    base::TimeTicks now) {
+    gfx::FrameTime now) {
   mouse_is_over_scrollbar_ = false;
   DidScrollUpdate(now);
 }
 
 bool ScrollbarAnimationControllerThinning::DidScrollUpdate(
-    base::TimeTicks now) {
+    gfx::FrameTime now) {
   ApplyOpacityAndThumbThicknessScale(1, 1);
 
   last_awaken_time_ = now;
   return true;
 }
 
 bool ScrollbarAnimationControllerThinning::DidMouseMoveNear(
-    base::TimeTicks now, float distance) {
+    gfx::FrameTime now, float distance) {
   if (distance == 0.0) {
     mouse_is_over_scrollbar_ = true;
     return false;
   }
 
   if (distance < mouse_move_distance_to_trigger_animation_)
     return DidScrollUpdate(now);
 
   return false;
 }
 
 float ScrollbarAnimationControllerThinning::AnimationProgressAtTime(
-    base::TimeTicks now) {
+    gfx::FrameTime now) {
   if (scroll_gesture_in_progress_)
     return 0;
 
   if (last_awaken_time_.is_null())
     return 1;
 
   base::TimeDelta delta = now - last_awaken_time_;
   float progress = (delta - animation_delay_).InSecondsF() /
       animation_duration_.InSecondsF();
   return std::max(std::min(progress, 1.f), 0.f);
@@ skipping 26 matching lines @@
 
   ScrollbarLayerImplBase* vertical_scrollbar =
       scroll_layer_->vertical_scrollbar_layer();
   if (vertical_scrollbar) {
     vertical_scrollbar->SetOpacity(opacity);
     vertical_scrollbar->set_thumb_thickness_scale_factor(thumb_thickness_scale);
   }
 }
 
 }  // namespace cc