cc:: Change plumbing for external_begin_frame_source to the Scheduler.

cc/trees/layer_tree_host.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/trees/layer_tree_host.h"
 
 #include <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 126 matching lines @@
       debug_state_.RecordRenderingStats());
 }
 
 void LayerTreeHost::InitializeThreaded(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
   task_runner_provider_ =
       TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
   scoped_ptr<ProxyMain> proxy_main =
-      ProxyMain::CreateThreaded(this, task_runner_provider_.get(),
-                                std::move(external_begin_frame_source));
-  InitializeProxy(std::move(proxy_main));
+      ProxyMain::CreateThreaded(this, task_runner_provider_.get());
+  InitializeProxy(std::move(proxy_main),
+                  std::move(external_begin_frame_source));
 }
 
 void LayerTreeHost::InitializeSingleThreaded(
     LayerTreeHostSingleThreadClient* single_thread_client,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
   task_runner_provider_ = TaskRunnerProvider::Create(main_task_runner, nullptr);
-  InitializeProxy(SingleThreadProxy::Create(
-      this, single_thread_client, task_runner_provider_.get(),
-      std::move(external_begin_frame_source)));
+  InitializeProxy(SingleThreadProxy::Create(this, single_thread_client,
+                                            task_runner_provider_.get()),
+                  std::move(external_begin_frame_source));
 }
 
 void LayerTreeHost::InitializeForTesting(
     scoped_ptr<TaskRunnerProvider> task_runner_provider,
-    scoped_ptr<Proxy> proxy_for_testing) {
+    scoped_ptr<Proxy> proxy_for_testing,
+    scoped_ptr<BeginFrameSource> external_begin_frame_source) {
   task_runner_provider_ = std::move(task_runner_provider);
-  InitializeProxy(std::move(proxy_for_testing));
+  InitializeProxy(std::move(proxy_for_testing),
+                  std::move(external_begin_frame_source));
 }
 
 void LayerTreeHost::SetTaskRunnerProviderForTesting(
     scoped_ptr<TaskRunnerProvider> task_runner_provider) {
   DCHECK(!task_runner_provider_);
   task_runner_provider_ = std::move(task_runner_provider);
 }
 
-void LayerTreeHost::InitializeProxy(scoped_ptr<Proxy> proxy) {
+void LayerTreeHost::InitializeProxy(
+    scoped_ptr<Proxy> proxy,
+    scoped_ptr<BeginFrameSource> external_begin_frame_source) {
   TRACE_EVENT0("cc", "LayerTreeHost::InitializeForReal");
 
   proxy_ = std::move(proxy);
-  proxy_->Start();
+  proxy_->Start(std::move(external_begin_frame_source));
   if (settings_.accelerated_animation_enabled) {
     if (animation_host_)
       animation_host_->SetSupportsScrollAnimations(
           proxy_->SupportsImplScrolling());
     else
       animation_registrar_->set_supports_scroll_animations(
           proxy_->SupportsImplScrolling());
   }
 }
 
@@ skipping 1073 matching lines @@
   return compositor_mode_ == CompositorMode::SingleThreaded;
 }
 
 bool LayerTreeHost::IsThreaded() const {
   DCHECK(compositor_mode_ != CompositorMode::Threaded ||
          task_runner_provider_->HasImplThread());
   return compositor_mode_ == CompositorMode::Threaded;
 }
 
 }  // namespace cc