Remove external begin frame source parameter and settings

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/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/element_animations.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/switches.h"
 #include "cc/blimp/image_serialization_processor.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/output/buffer_to_texture_target_map.h"
 #include "cc/proto/compositor_message_to_impl.pb.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/begin_frame_args_test.h"
-#include "cc/test/fake_external_begin_frame_source.h"

[danakj, 2016/09/20 18:19:21]

Can you move the impl of this to the one test that uses it now?

[enne (OOO), 2016/09/20 18:34:26]

Will punt.  This is used in scheduler_unittest and display_scheduler_unittest. 
I think I can remove it from scheduler_unittest but that's a larger patch.  I'll
follow up and do that.

 #include "cc/test/fake_image_serialization_processor.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/test_compositor_frame_sink.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_host_single_thread_client.h"
 #include "cc/trees/layer_tree_impl.h"
@@ skipping 310 matching lines @@
       TestHooks* test_hooks,
       CompositorMode mode,
       LayerTreeHostClientForTesting* client,
       RemoteProtoChannel* remote_proto_channel,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       const LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
-      std::unique_ptr<BeginFrameSource> external_begin_frame_source,
       ImageSerializationProcessor* image_serialization_processor) {
     LayerTreeHostInProcess::InitParams params;
     params.client = client;
     params.shared_bitmap_manager = shared_bitmap_manager;
     params.gpu_memory_buffer_manager = gpu_memory_buffer_manager;
     params.task_graph_runner = task_graph_runner;
     params.settings = &settings;
     params.image_serialization_processor = image_serialization_processor;
 
     params.animation_host =
         AnimationHost::CreateForTesting(ThreadInstance::MAIN);
     std::unique_ptr<LayerTreeHostForTesting> layer_tree_host(
         new LayerTreeHostForTesting(test_hooks, &params, mode));
     std::unique_ptr<TaskRunnerProvider> task_runner_provider =
         TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
     std::unique_ptr<Proxy> proxy;
     switch (mode) {
       case CompositorMode::SINGLE_THREADED:
         proxy = SingleThreadProxy::Create(layer_tree_host.get(), client,
                                           task_runner_provider.get());
         break;
       case CompositorMode::THREADED:
         DCHECK(impl_task_runner.get());
         proxy = ProxyMain::CreateThreaded(layer_tree_host.get(),
                                           task_runner_provider.get());
         break;
       case CompositorMode::REMOTE:
-        DCHECK(!external_begin_frame_source);
         // The Remote LayerTreeHost on the client has the impl task runner.
         if (task_runner_provider->HasImplThread()) {
           proxy = base::MakeUnique<RemoteChannelImpl>(
               layer_tree_host.get(), remote_proto_channel,
               task_runner_provider.get());
         } else {
           proxy = ProxyMain::CreateRemote(remote_proto_channel,
                                           layer_tree_host.get(),
                                           task_runner_provider.get());
         }
         break;
     }
-    layer_tree_host->InitializeForTesting(
-        std::move(task_runner_provider), std::move(proxy),
-        std::move(external_begin_frame_source));
+    layer_tree_host->InitializeForTesting(std::move(task_runner_provider),
+                                          std::move(proxy));
     return layer_tree_host;
   }
 
   std::unique_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) override {
     std::unique_ptr<LayerTreeHostImpl> host_impl =
         LayerTreeHostImplForTesting::Create(
             test_hooks_, GetSettings(), host_impl_client,
             GetTaskRunnerProvider(), shared_bitmap_manager(),
             gpu_memory_buffer_manager(), task_graph_runner(),
@@ skipping 218 matching lines @@
 void LayerTreeTest::DoBeginTest() {
   client_ = LayerTreeHostClientForTesting::Create(this);
 
   DCHECK(!impl_thread_ || impl_thread_->task_runner().get());
 
   if (IsRemoteTest()) {
     DCHECK(impl_thread_);
     layer_tree_host_ = LayerTreeHostForTesting::Create(
         this, mode_, client_.get(), &remote_proto_channel_bridge_.channel_main,
         nullptr, nullptr, task_graph_runner_.get(), settings_,
-        base::ThreadTaskRunnerHandle::Get(), nullptr, nullptr,
+        base::ThreadTaskRunnerHandle::Get(), nullptr,
         image_serialization_processor_.get());
     DCHECK(remote_proto_channel_bridge_.channel_main.HasReceiver());
 
     LayerTreeSettings settings = settings_;
     settings.abort_commit_before_compositor_frame_sink_creation = false;
     remote_client_layer_tree_host_ = LayerTreeHostForTesting::Create(
         this, mode_, client_.get(), &remote_proto_channel_bridge_.channel_impl,
         nullptr, nullptr, task_graph_runner_.get(), settings,
         base::ThreadTaskRunnerHandle::Get(), impl_thread_->task_runner(),
-        nullptr, image_serialization_processor_.get());
+        image_serialization_processor_.get());
     DCHECK(remote_proto_channel_bridge_.channel_impl.HasReceiver());
   } else {
     layer_tree_host_ = LayerTreeHostForTesting::Create(
         this, mode_, client_.get(), nullptr, shared_bitmap_manager_.get(),
         gpu_memory_buffer_manager_.get(), task_graph_runner_.get(), settings_,
         base::ThreadTaskRunnerHandle::Get(),
-        impl_thread_ ? impl_thread_->task_runner() : nullptr, nullptr,
+        impl_thread_ ? impl_thread_->task_runner() : nullptr,
         image_serialization_processor_.get());
   }
 
   ASSERT_TRUE(layer_tree_host_);
 
   main_task_runner_ =
       layer_tree_host_->GetTaskRunnerProvider()->MainThreadTaskRunner();
   impl_task_runner_ =
       layer_tree_host_->GetTaskRunnerProvider()->ImplThreadTaskRunner();
   if (!impl_task_runner_) {
@@ skipping 148 matching lines @@
   // mocked out.
   settings_.renderer_settings.refresh_rate = 200.0;
   settings_.background_animation_rate = 200.0;
   // Disable latency recovery to make the scheduler more predictable in its
   // actions and less dependent on timings to make decisions.
   settings_.enable_latency_recovery = false;
   settings_.verify_clip_tree_calculations = true;
   settings_.verify_transform_tree_calculations = true;
   settings_.renderer_settings.buffer_to_texture_target_map =
       DefaultBufferToTextureTargetMapForTesting();
-  // The TestCompositorFrameSink will provide a BeginFrameSource.
-  settings_.use_compositor_frame_sink_begin_frame_source = true;
   InitializeSettings(&settings_);
-  DCHECK(settings_.use_compositor_frame_sink_begin_frame_source);
-  DCHECK(!settings_.use_external_begin_frame_source);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&LayerTreeTest::DoBeginTest, base::Unretained(this)));
 
   base::RunLoop().Run();
   DestroyLayerTreeHost();
 
   timeout_.Cancel();
 
@@ skipping 83 matching lines @@
 }
 
 LayerTreeHost* LayerTreeTest::remote_client_layer_tree_host() {
   DCHECK(IsRemoteTest());
   DCHECK(task_runner_provider()->IsMainThread() ||
          task_runner_provider()->IsMainThreadBlocked());
   return remote_client_layer_tree_host_.get();
 }
 
 }  // namespace cc