Add buffer_to_texture_target_map to LayerTreeSettings

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/message_loop/message_loop.h"
@@ skipping 701 matching lines @@
   layer_tree_host()->SetViewportSize(device_root_bounds);
   layer_tree_host()->root_layer()->SetIsDrawable(true);
   layer_tree_host()->SetElementIdsForTesting();
 }
 
 void LayerTreeTest::Timeout() {
   timed_out_ = true;
   EndTest();
 }
 
+void LayerTreeTest::InitializeRendererSettings(
+    RendererSettings* renderer_settings) {
+  // Spend less time waiting for BeginFrame because the output is
+  // mocked out.
+  renderer_settings->refresh_rate = 200.0;
+  renderer_settings->buffer_to_texture_target_map =
+      DefaultBufferToTextureTargetMapForTesting();
+}
+
 void LayerTreeTest::RealEndTest() {
   // TODO(mithro): Make this method only end when not inside an impl frame.
   bool main_frame_will_happen =
       layer_tree_host_
           ? layer_tree_host_->proxy()->MainFrameWillHappenForTesting()
           : false;
 
   if (main_frame_will_happen && !timed_out_) {
     main_task_runner_->PostTask(
         FROM_HERE,
@@ skipping 86 matching lines @@
 
   image_worker_ = base::MakeUnique<base::Thread>("ImageWorker");
   ASSERT_TRUE(image_worker_->Start());
 
   shared_bitmap_manager_.reset(new TestSharedBitmapManager);
   gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager);
   task_graph_runner_.reset(new TestTaskGraphRunner);
 
   // Spend less time waiting for BeginFrame because the output is
   // 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_.renderer_settings.buffer_to_texture_target_map =
+  settings_.buffer_to_texture_target_map =
       DefaultBufferToTextureTargetMapForTesting();
   InitializeSettings(&settings_);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::BindOnce(&LayerTreeTest::DoBeginTest, base::Unretained(this)));
 
   base::RunLoop().Run();
   DestroyLayerTreeHost();
 
@@ skipping 18 matching lines @@
       std::move(shared_context_provider), std::move(worker_context_provider));
   compositor_frame_sink->SetClient(compositor_frame_sink_client_.get());
   layer_tree_host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
 }
 
 std::unique_ptr<TestCompositorFrameSink>
 LayerTreeTest::CreateCompositorFrameSink(
     scoped_refptr<ContextProvider> compositor_context_provider,
     scoped_refptr<ContextProvider> worker_context_provider) {
   constexpr bool disable_display_vsync = false;
+  RendererSettings renderer_settings;
+  InitializeRendererSettings(&renderer_settings);

[danakj, 2017/05/25 15:27:18]

It feels a bit too easy for a patch author to forget to call this when
overriding CreateCompositorFrameSink.

What if we pass RendererSettings to CreateCompositorFrameSink instead? Then a
new test overriding it would see the settings there and it would be much harder
to not use them and get the things set by this method?

It would mean moving this call up to RequestNewCompositorFrameSink instead.

[Alex Z., 2017/05/25 17:39:15]

Done.

   bool synchronous_composite =
       !HasImplThread() &&
       !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
   return base::MakeUnique<TestCompositorFrameSink>(
       compositor_context_provider, std::move(worker_context_provider),
-      shared_bitmap_manager(), gpu_memory_buffer_manager(),
-      layer_tree_host()->GetSettings().renderer_settings, impl_task_runner_,
-      synchronous_composite, disable_display_vsync);
+      shared_bitmap_manager(), gpu_memory_buffer_manager(), renderer_settings,
+      impl_task_runner_, synchronous_composite, disable_display_vsync);
 }
 
 std::unique_ptr<OutputSurface>
 LayerTreeTest::CreateDisplayOutputSurfaceOnThread(
     scoped_refptr<ContextProvider> compositor_context_provider) {
   // By default the Display shares a context with the LayerTreeHostImpl.
   return FakeOutputSurface::Create3d(std::move(compositor_context_provider));
 }
 
 void LayerTreeTest::DestroyLayerTreeHost() {
@@ skipping 16 matching lines @@
   DCHECK(task_runner_provider()->IsMainThread() ||
          task_runner_provider()->IsMainThreadBlocked());
   return layer_tree_host_.get();
 }
 
 Proxy* LayerTreeTest::proxy() {
   return layer_tree_host() ? layer_tree_host()->proxy() : NULL;
 }
 
 }  // namespace cc