cc:: Change plumbing for external_begin_frame_source to the Scheduler.

cc/test/layer_tree_test.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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 81 matching lines @@
                                 inner_bounds,
                                 outer_bounds,
                                 host,
                                 layer_settings);
 }
 
 // Creates a SingleThreadProxy that notifies the supplied |test_hooks| of
 // various actions.
 class SingleThreadProxyForTest : public SingleThreadProxy {
  public:
-  static scoped_ptr<Proxy> Create(
-      TestHooks* test_hooks,
-      LayerTreeHost* host,
-      LayerTreeHostSingleThreadClient* client,
-      TaskRunnerProvider* task_runner_provider,
-      scoped_ptr<BeginFrameSource> external_begin_frame_source) {
+  static scoped_ptr<Proxy> Create(TestHooks* test_hooks,
+                                  LayerTreeHost* host,
+                                  LayerTreeHostSingleThreadClient* client,
+                                  TaskRunnerProvider* task_runner_provider) {
     return make_scoped_ptr(new SingleThreadProxyForTest(
-        test_hooks, host, client, task_runner_provider,
-        std::move(external_begin_frame_source)));
+        test_hooks, host, client, task_runner_provider));
   }
 
   ~SingleThreadProxyForTest() override {}
 
  private:
-  SingleThreadProxyForTest(
-      TestHooks* test_hooks,
-      LayerTreeHost* host,
-      LayerTreeHostSingleThreadClient* client,
-      TaskRunnerProvider* task_runner_provider,
-      scoped_ptr<BeginFrameSource> external_begin_frame_source)
-      : SingleThreadProxy(host,
-                          client,
-                          task_runner_provider,
-                          std::move(external_begin_frame_source)),
+  SingleThreadProxyForTest(TestHooks* test_hooks,
+                           LayerTreeHost* host,
+                           LayerTreeHostSingleThreadClient* client,
+                           TaskRunnerProvider* task_runner_provider)
+      : SingleThreadProxy(host, client, task_runner_provider),
         test_hooks_(test_hooks) {}
 
   void ScheduledActionSendBeginMainFrame(const BeginFrameArgs& args) override {
     test_hooks_->ScheduledActionWillSendBeginMainFrame();
     SingleThreadProxy::ScheduledActionSendBeginMainFrame(args);
     test_hooks_->ScheduledActionSendBeginMainFrame();
   }
 
   DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     DrawResult result =
@@ skipping 314 matching lines @@
     params.task_graph_runner = task_graph_runner;
     params.settings = &settings;
     scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
         new LayerTreeHostForTesting(test_hooks, &params, mode));
     scoped_ptr<TaskRunnerProvider> task_runner_provider =
         TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
     scoped_ptr<Proxy> proxy;
     if (mode == CompositorMode::Threaded) {
       DCHECK(impl_task_runner.get());
       scoped_ptr<ProxyMain> proxy_main = ProxyMainForTest::CreateThreaded(
-          test_hooks, layer_tree_host.get(), task_runner_provider.get(),
-          std::move(external_begin_frame_source));
+          test_hooks, layer_tree_host.get(), task_runner_provider.get());
       proxy = std::move(proxy_main);
     } else {
-      proxy = SingleThreadProxyForTest::Create(
-          test_hooks, layer_tree_host.get(), client, task_runner_provider.get(),
-          std::move(external_begin_frame_source));
+      proxy =
+          SingleThreadProxyForTest::Create(test_hooks, layer_tree_host.get(),
+                                           client, task_runner_provider.get());
     }
-    layer_tree_host->InitializeForTesting(std::move(task_runner_provider),
-                                          std::move(proxy));
+    layer_tree_host->InitializeForTesting(
+        std::move(task_runner_provider), std::move(proxy),
+        std::move(external_begin_frame_source));
     return layer_tree_host;
   }
 
   scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) override {
     return LayerTreeHostImplForTesting::Create(
         test_hooks_, settings(), host_impl_client, task_runner_provider(),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
         task_graph_runner(), rendering_stats_instrumentation());
   }
@@ skipping 449 matching lines @@
       static_cast<ThreadedChannel*>(GetProxyMainForTest()->channel_main());
   ProxyImpl* proxy_impl = threaded_channel->GetProxyImplForTesting();
 
   // We check for null ProxyImpl since ProxyImpl exists in the ThreadedChannel
   // only after it is initialized.
   DCHECK(proxy_impl);
   return static_cast<ProxyImplForTest*>(proxy_impl);
 }
 
 }  // namespace cc