cc: Make BackToBackBeginFrameSource a SyntheticBeginFrameSource.

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::TimeDelta interval,
     base::SingleThreadTaskRunner* task_runner)
     : client_(nullptr),
       active_(false),
       timebase_(base::TimeTicks()),
-      interval_(interval),
-      last_tick_time_(base::TimeTicks() - interval),
+      interval_(BeginFrameArgs::DefaultInterval()),
+      last_tick_time_(base::TimeTicks() - interval_),
       next_tick_time_(base::TimeTicks()),
       task_runner_(task_runner),
-      weak_factory_(this) {
-  DCHECK_GT(interval, base::TimeDelta());
-}
+      weak_factory_(this) {}
 
 DelayBasedTimeSource::~DelayBasedTimeSource() {}
 
 void DelayBasedTimeSource::SetActive(bool active) {
   TRACE_EVENT1("cc", "DelayBasedTimeSource::SetActive", "active", active);
 
   if (active == active_)
     return;
 
   active_ = active;
@@ skipping 32 matching lines @@
   if (client_)
     client_->OnTimerTick();
 }
 
 void DelayBasedTimeSource::SetClient(DelayBasedTimeSourceClient* client) {
   client_ = client;
 }
 
 void DelayBasedTimeSource::SetTimebaseAndInterval(base::TimeTicks timebase,
                                                   base::TimeDelta interval) {
-  DCHECK_GT(interval, base::TimeDelta());
+  // DCHECK_GT(interval, base::TimeDelta());
   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:
@@ skipping 43 matching lines @@
 //      now=18   tick_target=16.667  new_target=33.333   -->
 //          tick(), PostDelayedTask(floor(33.333-18)) --> PostDelayedTask(15)
 // This brings us back to 18+15 = 33, which was where we would have been if the
 // task hadn't been late.
 //
 // For the really late delay, we we move to the next logical tick. The timebase
 // is not reset.
 //      now=37   tick_target=16.667  new_target=50.000  -->
 //          tick(), PostDelayedTask(floor(50.000-37)) --> PostDelayedTask(13)
 void DelayBasedTimeSource::PostNextTickTask(base::TimeTicks now) {
-  next_tick_time_ = now.SnappedToNextTick(timebase_, interval_);
-  if (next_tick_time_ == now)
-    next_tick_time_ += interval_;
-  DCHECK_GT(next_tick_time_, now);
+  if (interval_.is_zero()) {
+    next_tick_time_ = now;
+  } else {
+    next_tick_time_ = now.SnappedToNextTick(timebase_, interval_);
+    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