cc: Add LayerTreeHost::InitParams for LayerTreeHost creation.

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 435 matching lines @@
 
   TestHooks* test_hooks_;
 };
 
 // Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
 class LayerTreeHostForTesting : public LayerTreeHost {
  public:
   static scoped_ptr<LayerTreeHostForTesting> Create(
       TestHooks* test_hooks,
       LayerTreeHostClientForTesting* client,
-      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,
-      scoped_ptr<BeginFrameSource> external_begin_frame_source) {
+      LayerTreeHost::InitParams* params) {

[danakj, 2015/05/07 00:59:56]

I think maybe I prefer passing in all the things here, constructing the Params
inside this method, and then it doesn't happen that we pass
externalbeginframesource to something twice.. etc. That'd help make things a bit
more obvious.

alternately pull the EBFS out of the params into a local before passing on the
params.

[sadrul, 2015/05/07 04:39:25]

Done.

     scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
-        new LayerTreeHostForTesting(test_hooks, client, shared_bitmap_manager,
-                                    gpu_memory_buffer_manager,
-                                    task_graph_runner, settings));
+        new LayerTreeHostForTesting(test_hooks, params));
     if (impl_task_runner.get()) {
-      layer_tree_host->InitializeForTesting(
-          ThreadProxyForTest::Create(test_hooks,
-                                     layer_tree_host.get(),
-                                     main_task_runner,
-                                     impl_task_runner,
-                                     external_begin_frame_source.Pass()));
+      layer_tree_host->InitializeForTesting(ThreadProxyForTest::Create(
+          test_hooks, layer_tree_host.get(), params->main_task_runner,
+          impl_task_runner, params->external_begin_frame_source.Pass()));
     } else {
-      layer_tree_host->InitializeForTesting(
-          SingleThreadProxyForTest::Create(
-              test_hooks,
-              layer_tree_host.get(),
-              client,
-              main_task_runner,
-              external_begin_frame_source.Pass()));
+      layer_tree_host->InitializeForTesting(SingleThreadProxyForTest::Create(
+          test_hooks, layer_tree_host.get(), client, params->main_task_runner,
+          params->external_begin_frame_source.Pass()));
     }
     return layer_tree_host.Pass();
   }
 
   scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) override {
     return LayerTreeHostImplForTesting::Create(
         test_hooks_, settings(), host_impl_client, proxy(),
         shared_bitmap_manager_, gpu_memory_buffer_manager_, task_graph_runner_,
         rendering_stats_instrumentation());
   }
 
   void SetNeedsCommit() override {
     if (!test_started_)
       return;
     LayerTreeHost::SetNeedsCommit();
   }
 
   void set_test_started(bool started) { test_started_ = started; }
 
  private:
-  LayerTreeHostForTesting(
-      TestHooks* test_hooks,
-      LayerTreeHostClient* client,
-      SharedBitmapManager* shared_bitmap_manager,
-      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-      TaskGraphRunner* task_graph_runner,
-      const LayerTreeSettings& settings)
-      : LayerTreeHost(client, NULL, NULL, NULL, settings),
-        shared_bitmap_manager_(shared_bitmap_manager),
-        gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
-        task_graph_runner_(task_graph_runner),
+  LayerTreeHostForTesting(TestHooks* test_hooks,
+                          LayerTreeHost::InitParams* params)
+      : LayerTreeHost(params),
+        shared_bitmap_manager_(params->shared_bitmap_manager),
+        gpu_memory_buffer_manager_(params->gpu_memory_buffer_manager),
+        task_graph_runner_(params->task_graph_runner),
         test_hooks_(test_hooks),
         test_started_(false) {}
 
   SharedBitmapManager* shared_bitmap_manager_;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   TaskGraphRunner* task_graph_runner_;
   TestHooks* test_hooks_;
   bool test_started_;
 };
 
@@ skipping 136 matching lines @@
   client_ = LayerTreeHostClientForTesting::Create(this);
 
   scoped_ptr<FakeExternalBeginFrameSource> external_begin_frame_source;
   if (settings_.use_external_begin_frame_source) {
     external_begin_frame_source.reset(new FakeExternalBeginFrameSource(
         settings_.renderer_settings.refresh_rate));
     external_begin_frame_source_ = external_begin_frame_source.get();
   }
 
   DCHECK(!impl_thread_ || impl_thread_->task_runner().get());
+  LayerTreeHost::InitParams params;
+

[danakj, 2015/05/07 00:59:56]

nit: no whitespace

[sadrul, 2015/05/07 04:39:25]

Done.

+  params.client = client_.get();
+  params.shared_bitmap_manager = shared_bitmap_manager_.get();
+  params.gpu_memory_buffer_manager = gpu_memory_buffer_manager_.get();
+  params.task_graph_runner = task_graph_runner_.get();
+  params.settings = &settings_;
+  params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
+  params.external_begin_frame_source = external_begin_frame_source.Pass();
+
   layer_tree_host_ = LayerTreeHostForTesting::Create(
-      this, client_.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), task_graph_runner_.get(), settings_,
-      base::ThreadTaskRunnerHandle::Get(),
-      impl_thread_ ? impl_thread_->task_runner() : NULL,
-      external_begin_frame_source.Pass());
+      this, client_.get(), impl_thread_ ? impl_thread_->task_runner() : NULL,
+      &params);
   ASSERT_TRUE(layer_tree_host_);
 
   started_ = true;
   beginning_ = true;
   SetupTree();
   WillBeginTest();
   BeginTest();
   beginning_ = false;
   if (end_when_begin_returns_)
     RealEndTest();
@@ skipping 203 matching lines @@
 LayerTreeHost* LayerTreeTest::layer_tree_host() {
   // We check for a null proxy here as we sometimes ask for the layer tree host
   // when the proxy does not exist, often for checking settings after a test has
   // completed. For example, LTHPixelResourceTest::RunPixelResourceTest. See
   // elsewhere in this file for other examples.
   DCHECK(!proxy() || proxy()->IsMainThread() || proxy()->IsMainThreadBlocked());
   return layer_tree_host_.get();
 }
 
 }  // namespace cc