Fixing and enhancing OrderedSimpleTaskRunner to allow 100% deterministic tests.

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"
 #include "base/single_thread_task_runner.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/scheduler/delay_based_time_source.h"
-#include "ui/gfx/frame_time.h"
 
 namespace cc {
 
 Scheduler::SyntheticBeginFrameSource::SyntheticBeginFrameSource(
     Scheduler* scheduler,
     base::SingleThreadTaskRunner* task_runner)
     : scheduler_(scheduler) {
   if (gfx::FrameTime::TimestampsAreHighRes()) {
     time_source_ = DelayBasedTimeSourceHighRes::Create(
         scheduler_->VSyncInterval(), task_runner);
@@ skipping 96 matching lines @@
                                                       &begin_retro_frame_args_);
   }
 }
 
 void Scheduler::SetupSyntheticBeginFrames() {
   DCHECK(!synthetic_begin_frame_source_);
   synthetic_begin_frame_source_.reset(
       new SyntheticBeginFrameSource(this, impl_task_runner_.get()));
 }
 
+base::TimeTicks Scheduler::Now() const {
+  return gfx::FrameTime::Now();
+}
+
 void Scheduler::CommitVSyncParameters(base::TimeTicks timebase,
                                       base::TimeDelta interval) {
   // TODO(brianderson): We should not be receiving 0 intervals.
   if (interval == base::TimeDelta())
     interval = BeginFrameArgs::DefaultInterval();
   vsync_interval_ = interval;
   if (!settings_.begin_frame_scheduling_enabled)
     synthetic_begin_frame_source_->CommitVSyncParameters(timebase, interval);
 }
 
@@ skipping 111 matching lines @@
 void Scheduler::NotifyBeginMainFrameStarted() {
   TRACE_EVENT0("cc", "Scheduler::NotifyBeginMainFrameStarted");
   state_machine_.NotifyBeginMainFrameStarted();
 }
 
 base::TimeTicks Scheduler::AnticipatedDrawTime() const {
   if (!last_set_needs_begin_frame_ ||
       begin_impl_frame_args_.interval <= base::TimeDelta())
     return base::TimeTicks();
 
-  base::TimeTicks now = gfx::FrameTime::Now();
+  base::TimeTicks now = Now();
   base::TimeTicks timebase = std::max(begin_impl_frame_args_.frame_time,
                                       begin_impl_frame_args_.deadline);
   int64 intervals = 1 + ((now - timebase) / begin_impl_frame_args_.interval);
   return timebase + (begin_impl_frame_args_.interval * intervals);
 }
 
 base::TimeTicks Scheduler::LastBeginImplFrameTime() {
   return begin_impl_frame_args_.frame_time;
 }
 
@@ skipping 54 matching lines @@
   begin_unthrottled_frame_posted_ = true;
   impl_task_runner_->PostTask(FROM_HERE, begin_unthrottled_frame_closure_);
 }
 
 // BeginUnthrottledFrame is used when we aren't throttling frame production.
 // This will usually be because VSync is disabled.
 void Scheduler::BeginUnthrottledFrame() {
   DCHECK(!settings_.throttle_frame_production);
   DCHECK(begin_retro_frame_args_.empty());
 
-  base::TimeTicks now = gfx::FrameTime::Now();
+  base::TimeTicks now = Now();
   base::TimeTicks deadline = now + vsync_interval_;
 
   BeginFrameArgs begin_frame_args =
       BeginFrameArgs::Create(now, deadline, vsync_interval_);
   BeginImplFrame(begin_frame_args);
 
   begin_unthrottled_frame_posted_ = false;
 }
 
 // We may need to poll when we can't rely on BeginFrame to advance certain
@@ skipping 90 matching lines @@
   if (begin_retro_frame_args_.empty())
     return;
 
   // Discard expired BeginRetroFrames
   // Today, we should always end up with at most one un-expired BeginRetroFrame
   // because deadlines will not be greater than the next frame time. We don't
   // DCHECK though because some systems don't always have monotonic timestamps.
   // TODO(brianderson): In the future, long deadlines could result in us not
   // draining the queue if we don't catch up. If we consistently can't catch
   // up, our fallback should be to lower our frame rate.
-  base::TimeTicks now = gfx::FrameTime::Now();
+  base::TimeTicks now = Now();
   base::TimeDelta draw_duration_estimate = client_->DrawDurationEstimate();
   while (!begin_retro_frame_args_.empty() &&
          now > AdjustedBeginImplFrameDeadline(begin_retro_frame_args_.front(),
                                               draw_duration_estimate)) {
     TRACE_EVENT1("cc",
                  "Scheduler::BeginRetroFrame discarding",
                  "frame_time",
                  begin_retro_frame_args_.front().frame_time);
     begin_retro_frame_args_.pop_front();
   }
@@ skipping 95 matching lines @@
     // within this call.
     // 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();
     return;
   }
   begin_impl_frame_deadline_task_.Cancel();
   begin_impl_frame_deadline_task_.Reset(begin_impl_frame_deadline_closure_);
 
-  base::TimeDelta delta = deadline - gfx::FrameTime::Now();
+  base::TimeDelta delta = deadline - Now();
   if (delta <= base::TimeDelta())
     delta = base::TimeDelta();
   impl_task_runner_->PostDelayedTask(
       FROM_HERE, begin_impl_frame_deadline_task_.callback(), delta);
 }
 
 void Scheduler::OnBeginImplFrameDeadline() {
   TRACE_EVENT0("cc", "Scheduler::OnBeginImplFrameDeadline");
   begin_impl_frame_deadline_task_.Cancel();
 
@@ skipping 171 matching lines @@
 }
 
 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
   return (state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT ||
           state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED);
 }
 
 }  // namespace cc