gfx: Add FrameTime and DisplayTime classes

cc/trees/layer_tree_host.cc

 // Copyright 2011 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/trees/layer_tree_host.h"
 
 #include <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 247 matching lines @@
 
 void LayerTreeHost::AcquireLayerTextures() {
   DCHECK(proxy_->IsMainThread());
   proxy_->AcquireLayerTextures();
 }
 
 void LayerTreeHost::DidBeginMainFrame() {
   client_->DidBeginMainFrame();
 }
 
-void LayerTreeHost::UpdateClientAnimations(base::TimeTicks frame_begin_time) {
+void LayerTreeHost::UpdateClientAnimations(gfx::FrameTime frame_begin_time) {
   animating_ = true;
-  client_->Animate((frame_begin_time - base::TimeTicks()).InSecondsF());
+  client_->Animate(frame_begin_time.Unsafe_InSecondsF());
   animating_ = false;
 }
 
 void LayerTreeHost::DidStopFlinging() {
   proxy_->MainThreadHasStoppedFlinging();
 }
 
 void LayerTreeHost::Layout() {
   client_->Layout();
 }
@@ skipping 440 matching lines @@
   pending_page_scale_animation_->scale = scale;
   pending_page_scale_animation_->duration = duration;
 
   SetNeedsCommit();
 }
 
 void LayerTreeHost::NotifyInputThrottledUntilCommit() {
   proxy_->NotifyInputThrottledUntilCommit();
 }
 
-void LayerTreeHost::Composite(base::TimeTicks frame_begin_time) {
+void LayerTreeHost::Composite(gfx::FrameTime frame_begin_time) {
   if (!proxy_->HasImplThread())
     static_cast<SingleThreadProxy*>(proxy_.get())->CompositeImmediately(
         frame_begin_time);
   else
     SetNeedsCommit();
 }
 
 void LayerTreeHost::ScheduleComposite() {
   client_->ScheduleComposite();
 }
@@ skipping 442 matching lines @@
                  current,
                  animate));
 }
 
 scoped_ptr<base::Value> LayerTreeHost::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->Set("proxy", proxy_->AsValue().release());
   return state.PassAs<base::Value>();
 }
 
-void LayerTreeHost::AnimateLayers(base::TimeTicks time) {
+void LayerTreeHost::AnimateLayers(gfx::FrameTime time) {
   if (!settings_.accelerated_animation_enabled ||
       animation_registrar_->active_animation_controllers().empty())
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHost::AnimateLayers");
 
-  double monotonic_time = (time - base::TimeTicks()).InSecondsF();
+  double monotonic_time = time.Unsafe_InSecondsF();
 
   AnimationRegistrar::AnimationControllerMap copy =
       animation_registrar_->active_animation_controllers();
   for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
        iter != copy.end();
        ++iter) {
     (*iter).second->Animate(monotonic_time);
     bool start_ready_animations = true;
     (*iter).second->UpdateState(start_ready_animations, NULL);
   }
@@ skipping 66 matching lines @@
 
 bool LayerTreeHost::ScheduleMicroBenchmark(
     const std::string& benchmark_name,
     scoped_ptr<base::Value> value,
     const MicroBenchmark::DoneCallback& callback) {
   return micro_benchmark_controller_.ScheduleRun(
       benchmark_name, value.Pass(), callback);
 }
 
 }  // namespace cc