Hoist begin frame sources out of scheduler

cc/trees/single_thread_proxy.cc

Index: cc/trees/single_thread_proxy.cc
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index 27350291ec21f220d2c07b2b2c546c932817ce4e..7cc96e500836bbc5620a8569adeb8a592917c488 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -57,7 +57,7 @@ SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layer_tree_host,
 void SingleThreadProxy::Start(
     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
   DebugScopedSetImplThread impl(task_runner_provider_);
-  external_begin_frame_source_ = std::move(external_begin_frame_source);
+  begin_frame_source_ = std::move(external_begin_frame_source);
 
   if (layer_tree_host_->settings().single_thread_proxy_scheduler &&
       !scheduler_on_impl_thread_) {
@@ -71,11 +71,23 @@ void SingleThreadProxy::Start(
             CompositorTimingHistory::BROWSER_UMA,
             layer_tree_host_->rendering_stats_instrumentation()));
 
+    if (!scheduler_settings.throttle_frame_production) {
+      // Unthrottled source takes precedence over external sources.
+      begin_frame_source_ = BackToBackBeginFrameSource::Create(
+          task_runner_provider_->MainThreadTaskRunner());
+    }
+    BeginFrameSource* frame_source = begin_frame_source_.get();
+    if (!frame_source) {
+      synthetic_frame_source_ = SyntheticBeginFrameSource::Create(
+          task_runner_provider_->MainThreadTaskRunner(),
+          BeginFrameArgs::DefaultInterval());
+      frame_source = synthetic_frame_source_.get();
+    }
+
     scheduler_on_impl_thread_ =
         Scheduler::Create(this, scheduler_settings, layer_tree_host_->id(),
                           task_runner_provider_->MainThreadTaskRunner(),
-                          external_begin_frame_source_.get(),
-                          std::move(compositor_timing_history));
+                          frame_source, std::move(compositor_timing_history));
   }
 
   layer_tree_host_impl_ = layer_tree_host_->CreateLayerTreeHostImpl(this);
@@ -463,8 +475,17 @@ void SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() {
 
 void SingleThreadProxy::CommitVSyncParameters(base::TimeTicks timebase,
                                               base::TimeDelta interval) {
-  if (scheduler_on_impl_thread_)
-    scheduler_on_impl_thread_->CommitVSyncParameters(timebase, interval);
+  if (authoritative_vsync_interval_ != base::TimeDelta()) {
+    interval = authoritative_vsync_interval_;
+  } else if (interval == base::TimeDelta()) {
+    // TODO(brianderson): We should not be receiving 0 intervals.
+    interval = BeginFrameArgs::DefaultInterval();
+  }
+
+  last_vsync_timebase_ = timebase;
+
+  if (synthetic_frame_source_)
+    synthetic_frame_source_->OnUpdateVSyncParameters(timebase, interval);
 }
 
 void SingleThreadProxy::SetEstimatedParentDrawTime(base::TimeDelta draw_time) {
@@ -699,7 +720,11 @@ void SingleThreadProxy::SetChildrenNeedBeginFrames(
 
 void SingleThreadProxy::SetAuthoritativeVSyncInterval(
     const base::TimeDelta& interval) {
-  scheduler_on_impl_thread_->SetAuthoritativeVSyncInterval(interval);
+  authoritative_vsync_interval_ = interval;
+  if (synthetic_frame_source_) {
+    synthetic_frame_source_->OnUpdateVSyncParameters(last_vsync_timebase_,
+                                                     interval);
+  }
 }
 
 void SingleThreadProxy::WillBeginImplFrame(const BeginFrameArgs& args) {