gfx: Add FrameTime and DisplayTime classes

cc/scheduler/scheduler.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/scheduler/scheduler.h"
 
 #include <algorithm>
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 99 matching lines @@
 }
 
 void Scheduler::DidCreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeOutputSurface");
   DCHECK(!last_set_needs_begin_impl_frame_);
   DCHECK(begin_impl_frame_deadline_closure_.IsCancelled());
   state_machine_.DidCreateAndInitializeOutputSurface();
   ProcessScheduledActions();
 }
 
-base::TimeTicks Scheduler::AnticipatedDrawTime() {
+gfx::FrameTime Scheduler::AnticipatedDrawTime() {
   TRACE_EVENT0("cc", "Scheduler::AnticipatedDrawTime");
 
   if (!last_set_needs_begin_impl_frame_ ||
       last_begin_impl_frame_args_.interval <= base::TimeDelta())
-    return base::TimeTicks();
+    return gfx::FrameTime();
 
-  base::TimeTicks now = gfx::FrameTime::Now();
-  base::TimeTicks timebase = std::max(last_begin_impl_frame_args_.frame_time,
-                                      last_begin_impl_frame_args_.deadline);
+  gfx::FrameTime now = gfx::FrameTime::Now();
+  gfx::FrameTime timebase =
+      std::max<gfx::FrameTime>(
+          last_begin_impl_frame_args_.frame_time,
+          last_begin_impl_frame_args_.deadline);
   int64 intervals =
       1 + ((now - timebase) / last_begin_impl_frame_args_.interval);
   return timebase + (last_begin_impl_frame_args_.interval * intervals);
 }
 
-base::TimeTicks Scheduler::LastBeginImplFrameTime() {
+gfx::FrameTime Scheduler::LastBeginImplFrameTime() {
   return last_begin_impl_frame_args_.frame_time;
 }
 
 void Scheduler::SetupNextBeginImplFrameIfNeeded() {
   bool needs_begin_impl_frame =
       state_machine_.BeginImplFrameNeeded();
 
   bool at_end_of_deadline =
       state_machine_.begin_impl_frame_state() ==
           SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE;
@@ skipping 29 matching lines @@
     poll_for_draw_triggers_closure_.Cancel();
   }
 }
 
 void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
   TRACE_EVENT0("cc", "Scheduler::BeginImplFrame");
   DCHECK(state_machine_.begin_impl_frame_state() ==
          SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
   DCHECK(state_machine_.HasInitializedOutputSurface());
   last_begin_impl_frame_args_ = args;
-  last_begin_impl_frame_args_.deadline -= client_->DrawDurationEstimate();
+  last_begin_impl_frame_args_.deadline =
+      last_begin_impl_frame_args_.deadline - client_->DrawDurationEstimate();
   state_machine_.OnBeginImplFrame(last_begin_impl_frame_args_);
   ProcessScheduledActions();
 
   if (!state_machine_.HasInitializedOutputSurface())
     return;
 
   state_machine_.OnBeginImplFrameDeadlinePending();
 
   if (settings_.using_synchronous_renderer_compositor) {
     // The synchronous renderer compositor has to make its GL calls
     // within this call to BeginImplFrame.
     // TODO(brianderson): Have the OutputSurface initiate the deadline tasks
     // so the sychronous renderer compositor can take advantage of splitting
     // up the BeginImplFrame and deadline as well.
     OnBeginImplFrameDeadline();
   } else if (!settings_.deadline_scheduling_enabled) {
     // We emulate the old non-deadline scheduler here by posting the
     // deadline task without any delay.
-    PostBeginImplFrameDeadline(base::TimeTicks());
+    PostBeginImplFrameDeadline(gfx::FrameTime());
   } else if (state_machine_.ShouldTriggerBeginImplFrameDeadlineEarly()) {
     // We are ready to draw a new active tree immediately.
-    PostBeginImplFrameDeadline(base::TimeTicks());
+    PostBeginImplFrameDeadline(gfx::FrameTime());
   } else if (state_machine_.needs_redraw()) {
     // We have an animation or fast input path on the impl thread that wants
     // to draw, so don't wait too long for a new active tree.
     PostBeginImplFrameDeadline(last_begin_impl_frame_args_.deadline);
   } else {
     // The impl thread doesn't have anything it wants to draw and we are just
     // waiting for a new active tree, so post the deadline for the next
     // expected BeginImplFrame start. This allows us to draw immediately when
     // there is a new active tree, instead of waiting for the next
     // BeginImplFrame.
     // TODO(brianderson): Handle long deadlines (that are past the next frame's
     // frame time) properly instead of using this hack.
     PostBeginImplFrameDeadline(last_begin_impl_frame_args_.frame_time +
                                last_begin_impl_frame_args_.interval);
   }
 }
 
-void Scheduler::PostBeginImplFrameDeadline(base::TimeTicks deadline) {
+void Scheduler::PostBeginImplFrameDeadline(gfx::FrameTime deadline) {
   begin_impl_frame_deadline_closure_.Cancel();
   begin_impl_frame_deadline_closure_.Reset(
       base::Bind(&Scheduler::OnBeginImplFrameDeadline,
                  weak_factory_.GetWeakPtr()));
   client_->PostBeginImplFrameDeadline(
       begin_impl_frame_deadline_closure_.callback(), deadline);
 }
 
 void Scheduler::OnBeginImplFrameDeadline() {
   TRACE_EVENT0("cc", "Scheduler::OnBeginImplFrameDeadline");
@@ skipping 94 matching lines @@
       case SchedulerStateMachine::ACTION_MANAGE_TILES:
         client_->ScheduledActionManageTiles();
         break;
     }
   } while (action != SchedulerStateMachine::ACTION_NONE);
 
   SetupNextBeginImplFrameIfNeeded();
   client_->DidAnticipatedDrawTimeChange(AnticipatedDrawTime());
 
   if (state_machine_.ShouldTriggerBeginImplFrameDeadlineEarly())
-    PostBeginImplFrameDeadline(base::TimeTicks());
+    PostBeginImplFrameDeadline(gfx::FrameTime());
 }
 
 bool Scheduler::WillDrawIfNeeded() const {
   return !state_machine_.PendingDrawsShouldBeAborted();
 }
 
 }  // namespace cc