gfx: Add FrameTime and DisplayTime classes

cc/trees/thread_proxy.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/thread_proxy.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 671 matching lines @@
   DCHECK(IsImplThread());
   layer_tree_host_impl_->FinishAllRendering();
   completion->Signal();
 }
 
 void ThreadProxy::ScheduledActionSendBeginMainFrame() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionSendBeginMainFrame");
   scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state(
       new BeginMainFrameAndCommitState);
   begin_main_frame_state->monotonic_frame_begin_time =
-      layer_tree_host_impl_->CurrentPhysicalTimeTicks();
+      layer_tree_host_impl_->CurrentFrameTimeTicks();
   begin_main_frame_state->scroll_info =
       layer_tree_host_impl_->ProcessScrollDeltas();
 
   if (!layer_tree_host_impl_->settings().impl_side_painting) {
     DCHECK_GT(layer_tree_host_impl_->memory_allocation_limit_bytes(), 0u);
   }
   begin_main_frame_state->memory_allocation_limit_bytes =
       layer_tree_host_impl_->memory_allocation_limit_bytes();
   begin_main_frame_state->memory_allocation_priority_cutoff =
       layer_tree_host_impl_->memory_allocation_priority_cutoff();
@@ skipping 334 matching lines @@
 
   DCHECK(layer_tree_host_impl_->renderer());
   if (!layer_tree_host_impl_->renderer())
     return result;
 
   base::TimeTicks start_time = base::TimeTicks::HighResNow();
   base::TimeDelta draw_duration_estimate = DrawDurationEstimate();
   base::AutoReset<bool> mark_inside(&inside_draw_, true);
 
   // Advance our animations.
-  base::TimeTicks monotonic_time =
+  gfx::FrameTime monotonic_time =
       layer_tree_host_impl_->CurrentFrameTimeTicks();
   base::Time wall_clock_time = layer_tree_host_impl_->CurrentFrameTime();
 
   // TODO(enne): This should probably happen post-animate.
   if (layer_tree_host_impl_->pending_tree())
     layer_tree_host_impl_->pending_tree()->UpdateDrawProperties();
   layer_tree_host_impl_->Animate(monotonic_time, wall_clock_time);
 
   // This method is called on a forced draw, regardless of whether we are able
   // to produce a frame, as the calling site on main thread is blocked until its
@@ skipping 165 matching lines @@
 
 DrawSwapReadbackResult ThreadProxy::ScheduledActionDrawAndReadback() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionDrawAndReadback");
   bool forced_draw = true;
   bool swap_requested = false;
   bool readback_requested = true;
   return DrawSwapReadbackInternal(
       forced_draw, swap_requested, readback_requested);
 }
 
-void ThreadProxy::DidAnticipatedDrawTimeChange(base::TimeTicks time) {
+void ThreadProxy::DidAnticipatedDrawTimeChange(gfx::FrameTime time) {
   if (current_resource_update_controller_on_impl_thread_)
     current_resource_update_controller_on_impl_thread_->PerformMoreUpdates(
         time);
 }
 
 base::TimeDelta ThreadProxy::DrawDurationEstimate() {
   base::TimeDelta historical_estimate =
       draw_duration_history_.Percentile(kDrawDurationEstimationPercentile);
   base::TimeDelta padding = base::TimeDelta::FromMicroseconds(
       kDrawDurationEstimatePaddingInMicroseconds);
   return historical_estimate + padding;
 }
 
 base::TimeDelta ThreadProxy::BeginMainFrameToCommitDurationEstimate() {
   return begin_main_frame_to_commit_duration_history_.Percentile(
       kCommitAndActivationDurationEstimationPercentile);
 }
 
 base::TimeDelta ThreadProxy::CommitToActivateDurationEstimate() {
   return commit_to_activate_duration_history_.Percentile(
       kCommitAndActivationDurationEstimationPercentile);
 }
 
-void ThreadProxy::PostBeginImplFrameDeadline(const base::Closure& closure,
-                                             base::TimeTicks deadline) {
+void ThreadProxy::PostBeginImplFrameDeadline(
+    const base::Closure& closure,
+    gfx::FrameTime deadline) {
   base::TimeDelta delta = deadline - gfx::FrameTime::Now();
   if (delta <= base::TimeDelta())
     delta = base::TimeDelta();
   Proxy::ImplThreadTaskRunner()->PostDelayedTask(FROM_HERE, closure, delta);
 }
 
 void ThreadProxy::DidBeginImplFrameDeadline() {
   layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
 }
 
@@ skipping 223 matching lines @@
   request->completion.Signal();
 }
 
 void ThreadProxy::RenewTreePriority() {
   DCHECK(IsImplThread());
   bool smoothness_takes_priority =
       layer_tree_host_impl_->pinch_gesture_active() ||
       layer_tree_host_impl_->IsCurrentlyScrolling() ||
       layer_tree_host_impl_->page_scale_animation_active();
 
-  base::TimeTicks now = layer_tree_host_impl_->CurrentPhysicalTimeTicks();
+  base::TimeTicks now = base::TimeTicks::Now();
 
   // Update expiration time if smoothness currently takes priority.
   if (smoothness_takes_priority) {
     smoothness_takes_priority_expiration_time_ =
         now + base::TimeDelta::FromMilliseconds(
                   kSmoothnessTakesPriorityExpirationDelay * 1000);
   }
 
   // We use the same priority for both trees by default.
   TreePriority priority = SAME_PRIORITY_FOR_BOTH_TREES;
@@ skipping 72 matching lines @@
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 
   UpdateBackgroundAnimateTicking();
 
   commit_to_activate_duration_history_.InsertSample(
       base::TimeTicks::HighResNow() - commit_complete_time_);
 }
 
 }  // namespace cc