cc: Send all begin frames using a PostTask.

cc/scheduler/delay_based_time_source.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/delay_based_time_source.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/begin_frame_args.h"
 
 namespace cc {
 
 // The following methods correspond to the DelayBasedTimeSource that uses
 // the base::TimeTicks::Now as the timebase.
 DelayBasedTimeSource::DelayBasedTimeSource(
-    base::SingleThreadTaskRunner* task_runner)
-    : client_(nullptr),
+    base::SingleThreadTaskRunner* task_runner,
+    base::TickClock* clock)
+    : task_runner_(task_runner),
+      clock_(clock),
+      client_(nullptr),
       active_(false),
       timebase_(base::TimeTicks()),
       interval_(BeginFrameArgs::DefaultInterval()),
       last_tick_time_(base::TimeTicks() - interval_),
       next_tick_time_(base::TimeTicks()),
-      task_runner_(task_runner),
       weak_factory_(this) {}
 
 DelayBasedTimeSource::~DelayBasedTimeSource() {}
 
 void DelayBasedTimeSource::SetActive(bool active) {
   TRACE_EVENT1("cc", "DelayBasedTimeSource::SetActive", "active", active);
 
   if (active == active_)
     return;
 
   active_ = active;
 
   if (active_) {
     PostNextTickTask(Now());
   } else {
     last_tick_time_ = base::TimeTicks();
     next_tick_time_ = base::TimeTicks();
     tick_closure_.Cancel();
   }
 }
 
 base::TimeDelta DelayBasedTimeSource::Interval() const {
   return interval_;
 }
 
-bool DelayBasedTimeSource::Active() const { return active_; }
+base::TimeTicks DelayBasedTimeSource::Now() {
+  return clock_ ? clock_->NowTicks() : base::TimeTicks::Now();

[brianderson, 2016/07/13 21:14:49]

DefaultTickClock?

+}
+
+bool DelayBasedTimeSource::Active() const {
+  return active_;
+}
 
 base::TimeTicks DelayBasedTimeSource::LastTickTime() const {
   return last_tick_time_;
 }
 
 base::TimeTicks DelayBasedTimeSource::NextTickTime() const {
   return next_tick_time_;
 }
 
 void DelayBasedTimeSource::OnTimerTick() {
@@ skipping 11 matching lines @@
 void DelayBasedTimeSource::SetClient(DelayBasedTimeSourceClient* client) {
   client_ = client;
 }
 
 void DelayBasedTimeSource::SetTimebaseAndInterval(base::TimeTicks timebase,
                                                   base::TimeDelta interval) {
   interval_ = interval;
   timebase_ = timebase;
 }
 
-base::TimeTicks DelayBasedTimeSource::Now() const {
-  return base::TimeTicks::Now();
-}
-
 // This code tries to achieve an average tick rate as close to interval_ as
 // possible.  To do this, it has to deal with a few basic issues:
 //   1. PostDelayedTask can delay only at a millisecond granularity. So, 16.666
 //   has to posted as 16 or 17.
 //   2. A delayed task may come back a bit late (a few ms), or really late
 //   (frames later)
 //
 // The basic idea with this scheduler here is to keep track of where we *want*
 // to run in tick_target_. We update this with the exact interval.
 //
@@ skipping 49 matching lines @@
     if (next_tick_time_ == now)
       next_tick_time_ += interval_;
     DCHECK_GT(next_tick_time_, now);
   }
   tick_closure_.Reset(base::Bind(&DelayBasedTimeSource::OnTimerTick,
                                  weak_factory_.GetWeakPtr()));
   task_runner_->PostDelayedTask(FROM_HERE, tick_closure_.callback(),
                                 next_tick_time_ - now);
 }
 
-std::string DelayBasedTimeSource::TypeString() const {
-  return "DelayBasedTimeSource";
-}
-
 void DelayBasedTimeSource::AsValueInto(
     base::trace_event::TracedValue* state) const {
-  state->SetString("type", TypeString());
   state->SetDouble("last_tick_time_us", LastTickTime().ToInternalValue());
   state->SetDouble("next_tick_time_us", NextTickTime().ToInternalValue());
   state->SetDouble("interval_us", interval_.InMicroseconds());
   state->SetDouble("timebase_us", timebase_.ToInternalValue());
   state->SetBoolean("active", active_);
 }
 
 }  // namespace cc