cc: Add LayerTreeHost::InitParams for LayerTreeHost creation.

Instead of passing in a number of things to the LayerTreeHost constructor,
use a struct to simplify the code a bit, and make this more readable. This
also makes it easy to maintain a development branch that adds new things.

TBR=jam@ for API usage update in android_webview/, components/, and content/

BUG=436952

Review URL: https://codereview.chromium.org/1126253005

Cr-Commit-Position: refs/heads/master@{#329164}

13 files changed, 197 insertions, 146 deletions

diff --git a/cc/layers/layer_unittest.cc b/cc/layers/layer_unittest.cc
index bae8185..6b4d36b 100644
--- a/cc/layers/layer_unittest.cc
+++ b/cc/layers/layer_unittest.cc
@@ -44,10 +44,11 @@ namespace {
 
 class MockLayerTreeHost : public LayerTreeHost {
  public:
-  explicit MockLayerTreeHost(FakeLayerTreeHostClient* client)
-      : LayerTreeHost(client, nullptr, nullptr, nullptr, LayerTreeSettings()) {
-    InitializeSingleThreaded(client, base::ThreadTaskRunnerHandle::Get(),
-                             nullptr);
+  MockLayerTreeHost(LayerTreeHostSingleThreadClient* single_thread_client,
+                    LayerTreeHost::InitParams* params)
+      : LayerTreeHost(params) {
+    InitializeSingleThreaded(single_thread_client,
+                             base::ThreadTaskRunnerHandle::Get(), nullptr);
   }
 
   MOCK_METHOD0(SetNeedsCommit, void());
@@ -68,7 +69,12 @@ class LayerTest : public testing::Test {
 
  protected:
   void SetUp() override {
-    layer_tree_host_.reset(new StrictMock<MockLayerTreeHost>(&fake_client_));
+    LayerTreeHost::InitParams params;
+    LayerTreeSettings settings;
+    params.client = &fake_client_;
+    params.settings = &settings;
+    layer_tree_host_.reset(
+        new StrictMock<MockLayerTreeHost>(&fake_client_, &params));
   }
 
   void TearDown() override {
@@ -937,18 +943,16 @@ class LayerTreeHostFactory {
         shared_bitmap_manager_(new TestSharedBitmapManager),
         gpu_memory_buffer_manager_(new TestGpuMemoryBufferManager) {}
 
-  scoped_ptr<LayerTreeHost> Create() {
-    return LayerTreeHost::CreateSingleThreaded(
-        &client_, &client_, shared_bitmap_manager_.get(),
-        gpu_memory_buffer_manager_.get(), nullptr, LayerTreeSettings(),
-        base::ThreadTaskRunnerHandle::Get(), nullptr);
-  }
+  scoped_ptr<LayerTreeHost> Create() { return Create(LayerTreeSettings()); }
 
   scoped_ptr<LayerTreeHost> Create(LayerTreeSettings settings) {
-    return LayerTreeHost::CreateSingleThreaded(
-        &client_, &client_, shared_bitmap_manager_.get(),
-        gpu_memory_buffer_manager_.get(), nullptr, settings,
-        base::ThreadTaskRunnerHandle::Get(), nullptr);
+    LayerTreeHost::InitParams params;
+    params.client = &client_;
+    params.shared_bitmap_manager = shared_bitmap_manager_.get();
+    params.gpu_memory_buffer_manager = gpu_memory_buffer_manager_.get();
+    params.settings = &settings;
+    params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
+    return LayerTreeHost::CreateSingleThreaded(&client_, &params);
   }
 
  private:
diff --git a/cc/layers/picture_layer_unittest.cc b/cc/layers/picture_layer_unittest.cc
index 917a36f..3707012 100644
--- a/cc/layers/picture_layer_unittest.cc
+++ b/cc/layers/picture_layer_unittest.cc
@@ -129,14 +129,18 @@ TEST(PictureLayerTest, NonMonotonicSourceFrameNumber) {
   MockContentLayerClient client;
   scoped_refptr<FakePictureLayer> layer = FakePictureLayer::Create(&client);
 
-  scoped_ptr<LayerTreeHost> host1 = LayerTreeHost::CreateSingleThreaded(
-      &host_client1, &host_client1, shared_bitmap_manager.get(), nullptr,
-      nullptr, settings, base::ThreadTaskRunnerHandle::Get(), nullptr);
+  LayerTreeHost::InitParams params;
+  params.client = &host_client1;
+  params.shared_bitmap_manager = shared_bitmap_manager.get();
+  params.settings = &settings;
+  params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
+  scoped_ptr<LayerTreeHost> host1 =
+      LayerTreeHost::CreateSingleThreaded(&host_client1, &params);
   host_client1.SetLayerTreeHost(host1.get());
 
-  scoped_ptr<LayerTreeHost> host2 = LayerTreeHost::CreateSingleThreaded(
-      &host_client2, &host_client2, shared_bitmap_manager.get(), nullptr,
-      nullptr, settings, base::ThreadTaskRunnerHandle::Get(), nullptr);
+  params.client = &host_client2;
+  scoped_ptr<LayerTreeHost> host2 =
+      LayerTreeHost::CreateSingleThreaded(&host_client2, &params);
   host_client2.SetLayerTreeHost(host2.get());
 
   // The PictureLayer is put in one LayerTreeHost.
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index cee0c9b..97d1c80 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -64,8 +64,8 @@ LayerImpl* LayerImplForScrollAreaAndScrollbar(FakeLayerTreeHost* host,
 class FakeResourceTrackingLayerTreeHost : public FakeLayerTreeHost {
  public:
   FakeResourceTrackingLayerTreeHost(FakeLayerTreeHostClient* client,
-                                    const LayerTreeSettings& settings)
-      : FakeLayerTreeHost(client, settings),
+                                    LayerTreeHost::InitParams* params)
+      : FakeLayerTreeHost(client, params),
         next_id_(1),
         total_ui_resource_created_(0),
         total_ui_resource_deleted_(0) {
@@ -121,8 +121,13 @@ class ScrollbarLayerTest : public testing::Test {
  public:
   ScrollbarLayerTest() : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {
     layer_tree_settings_.single_thread_proxy_scheduler = false;
-    layer_tree_host_.reset(new FakeResourceTrackingLayerTreeHost(
-        &fake_client_, layer_tree_settings_));
+
+    LayerTreeHost::InitParams params;
+    params.client = &fake_client_;
+    params.settings = &layer_tree_settings_;
+
+    layer_tree_host_.reset(
+        new FakeResourceTrackingLayerTreeHost(&fake_client_, &params));
     fake_client_.SetLayerTreeHost(layer_tree_host_.get());
     // Force output surface creation for renderer capabilities.
     layer_tree_host_->Composite(base::TimeTicks());
diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc
index 3bd90ec..c33db7c 100644
--- a/cc/layers/texture_layer_unittest.cc
+++ b/cc/layers/texture_layer_unittest.cc
@@ -54,16 +54,26 @@ gpu::Mailbox MailboxFromChar(char value) {
 
 class MockLayerTreeHost : public LayerTreeHost {
  public:
-  explicit MockLayerTreeHost(FakeLayerTreeHostClient* client)
-      : LayerTreeHost(client, nullptr, nullptr, nullptr, LayerTreeSettings()) {
-    InitializeSingleThreaded(client, base::ThreadTaskRunnerHandle::Get(),
-                             nullptr);
+  static scoped_ptr<MockLayerTreeHost> Create(FakeLayerTreeHostClient* client) {
+    LayerTreeHost::InitParams params;
+    params.client = client;
+    LayerTreeSettings settings;
+    params.settings = &settings;
+    return make_scoped_ptr(new MockLayerTreeHost(client, &params));
   }
 
   MOCK_METHOD0(SetNeedsCommit, void());
   MOCK_METHOD0(SetNeedsUpdateLayers, void());
   MOCK_METHOD0(StartRateLimiter, void());
   MOCK_METHOD0(StopRateLimiter, void());
+
+ private:
+  MockLayerTreeHost(FakeLayerTreeHostClient* client,
+                    LayerTreeHost::InitParams* params)
+      : LayerTreeHost(params) {
+    InitializeSingleThreaded(client, base::ThreadTaskRunnerHandle::Get(),
+                             nullptr);
+  }
 };
 
 class FakeTextureLayerClient : public TextureLayerClient {
@@ -180,7 +190,7 @@ class TextureLayerTest : public testing::Test {
 
  protected:
   void SetUp() override {
-    layer_tree_host_.reset(new MockLayerTreeHost(&fake_client_));
+    layer_tree_host_ = MockLayerTreeHost::Create(&fake_client_);
     EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
     layer_tree_host_->SetViewportSize(gfx::Size(10, 10));
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());
@@ -908,7 +918,7 @@ class TextureLayerImplWithMailboxTest : public TextureLayerTest {
 
   void SetUp() override {
     TextureLayerTest::SetUp();
-    layer_tree_host_.reset(new MockLayerTreeHost(&fake_client_));
+    layer_tree_host_ = MockLayerTreeHost::Create(&fake_client_);
     EXPECT_TRUE(host_impl_.InitializeRenderer(FakeOutputSurface::Create3d()));
   }
 
diff --git a/cc/layers/tiled_layer_unittest.cc b/cc/layers/tiled_layer_unittest.cc
index b81e031..6a83413 100644
--- a/cc/layers/tiled_layer_unittest.cc
+++ b/cc/layers/tiled_layer_unittest.cc
@@ -94,15 +94,19 @@ class TiledLayerTest : public testing::Test {
   void SetUp() override {
     impl_thread_.Start();
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
-    layer_tree_host_ = LayerTreeHost::CreateThreaded(
-        &synchonous_output_surface_client_, shared_bitmap_manager_.get(),
-        nullptr, nullptr, settings_, base::ThreadTaskRunnerHandle::Get(),
-        impl_thread_.task_runner(), nullptr);
-    synchonous_output_surface_client_.SetLayerTreeHost(layer_tree_host_.get());
+    LayerTreeHost::InitParams params;
+    params.client = &synchronous_output_surface_client_;
+    params.shared_bitmap_manager = shared_bitmap_manager_.get();
+    params.settings = &settings_;
+    params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
+
+    layer_tree_host_ =
+        LayerTreeHost::CreateThreaded(impl_thread_.task_runner(), &params);
+    synchronous_output_surface_client_.SetLayerTreeHost(layer_tree_host_.get());
     proxy_ = layer_tree_host_->proxy();
     resource_manager_ = PrioritizedResourceManager::Create(proxy_);
     layer_tree_host_->SetLayerTreeHostClientReady();
-    CHECK(synchonous_output_surface_client_.EnsureOutputSurfaceCreated());
+    CHECK(synchronous_output_surface_client_.EnsureOutputSurfaceCreated());
 
     layer_tree_host_->SetRootLayer(Layer::Create());
 
@@ -241,7 +245,7 @@ class TiledLayerTest : public testing::Test {
   scoped_ptr<ResourceUpdateQueue> queue_;
   PriorityCalculator priority_calculator_;
   base::Thread impl_thread_;
-  SynchronousOutputSurfaceClient synchonous_output_surface_client_;
+  SynchronousOutputSurfaceClient synchronous_output_surface_client_;
   scoped_ptr<LayerTreeHost> layer_tree_host_;
   scoped_ptr<FakeLayerTreeHostImpl> host_impl_;
   scoped_ptr<PrioritizedResourceManager> resource_manager_;
diff --git a/cc/test/fake_layer_tree_host.cc b/cc/test/fake_layer_tree_host.cc
index 143d22e..428753d 100644
--- a/cc/test/fake_layer_tree_host.cc
+++ b/cc/test/fake_layer_tree_host.cc
@@ -6,10 +6,10 @@
 
 namespace cc {
 FakeLayerTreeHost::FakeLayerTreeHost(FakeLayerTreeHostClient* client,
-                                     const LayerTreeSettings& settings)
-    : LayerTreeHost(client, NULL, NULL, NULL, settings),
+                                     LayerTreeHost::InitParams* params)
+    : LayerTreeHost(params),
       client_(client),
-      host_impl_(settings, &proxy_, &manager_, nullptr),
+      host_impl_(*params->settings, &proxy_, &manager_, nullptr),
       needs_commit_(false) {
   client_->SetLayerTreeHost(this);
 }
@@ -18,13 +18,16 @@ scoped_ptr<FakeLayerTreeHost> FakeLayerTreeHost::Create(
     FakeLayerTreeHostClient* client) {
   LayerTreeSettings settings;
   settings.verify_property_trees = true;
-  return make_scoped_ptr(new FakeLayerTreeHost(client, settings));
+  return Create(client, settings);
 }
 
 scoped_ptr<FakeLayerTreeHost> FakeLayerTreeHost::Create(
     FakeLayerTreeHostClient* client,
     const LayerTreeSettings& settings) {
-  return make_scoped_ptr(new FakeLayerTreeHost(client, settings));
+  LayerTreeHost::InitParams params;
+  params.client = client;
+  params.settings = &settings;
+  return make_scoped_ptr(new FakeLayerTreeHost(client, &params));
 }
 
 FakeLayerTreeHost::~FakeLayerTreeHost() {
diff --git a/cc/test/fake_layer_tree_host.h b/cc/test/fake_layer_tree_host.h
index 858574f..f44f840 100644
--- a/cc/test/fake_layer_tree_host.h
+++ b/cc/test/fake_layer_tree_host.h
@@ -53,7 +53,7 @@ class FakeLayerTreeHost : public LayerTreeHost {
 
  protected:
   FakeLayerTreeHost(FakeLayerTreeHostClient* client,
-                    const LayerTreeSettings& settings);
+                    LayerTreeHost::InitParams* params);
 
  private:
   FakeImplProxy proxy_;
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index e782f08..dad0045 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -470,10 +470,14 @@ class LayerTreeHostForTesting : public LayerTreeHost {
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
       scoped_ptr<BeginFrameSource> external_begin_frame_source) {
+    LayerTreeHost::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;
     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,
@@ -497,8 +501,8 @@ class LayerTreeHostForTesting : public LayerTreeHost {
       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());
+        shared_bitmap_manager(), gpu_memory_buffer_manager(),
+        task_graph_runner(), rendering_stats_instrumentation());
   }
 
   void SetNeedsCommit() override {
@@ -510,23 +514,10 @@ class LayerTreeHostForTesting : public LayerTreeHost {
   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),
-        test_hooks_(test_hooks),
-        test_started_(false) {}
+  LayerTreeHostForTesting(TestHooks* test_hooks,
+                          LayerTreeHost::InitParams* params)
+      : LayerTreeHost(params), 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_;
 };
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index db20fa8..3a59805 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -54,61 +54,48 @@ static base::StaticAtomicSequenceNumber s_layer_tree_host_sequence_number;
 
 namespace cc {
 
+LayerTreeHost::InitParams::InitParams() {
+}
+
+LayerTreeHost::InitParams::~InitParams() {
+}
+
 scoped_ptr<LayerTreeHost> LayerTreeHost::CreateThreaded(
-    LayerTreeHostClient* 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) {
-  DCHECK(main_task_runner.get());
+    InitParams* params) {
+  DCHECK(params->main_task_runner.get());
   DCHECK(impl_task_runner.get());
-  scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(
-      client, shared_bitmap_manager, gpu_memory_buffer_manager,
-      task_graph_runner, settings));
-  layer_tree_host->InitializeThreaded(main_task_runner,
-                                      impl_task_runner,
-                                      external_begin_frame_source.Pass());
+  DCHECK(params->settings);
+  scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(params));
+  layer_tree_host->InitializeThreaded(
+      params->main_task_runner, impl_task_runner,
+      params->external_begin_frame_source.Pass());
   return layer_tree_host.Pass();
 }
 
 scoped_ptr<LayerTreeHost> LayerTreeHost::CreateSingleThreaded(
-    LayerTreeHostClient* client,
     LayerTreeHostSingleThreadClient* single_thread_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_ptr<BeginFrameSource> external_begin_frame_source) {
-  scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(
-      client, shared_bitmap_manager, gpu_memory_buffer_manager,
-      task_graph_runner, settings));
-  layer_tree_host->InitializeSingleThreaded(single_thread_client,
-                                            main_task_runner,
-                                            external_begin_frame_source.Pass());
+    InitParams* params) {
+  DCHECK(params->settings);
+  scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(params));
+  layer_tree_host->InitializeSingleThreaded(
+      single_thread_client, params->main_task_runner,
+      params->external_begin_frame_source.Pass());
   return layer_tree_host.Pass();
 }
 
-LayerTreeHost::LayerTreeHost(
-    LayerTreeHostClient* client,
-    SharedBitmapManager* shared_bitmap_manager,
-    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-    TaskGraphRunner* task_graph_runner,
-    const LayerTreeSettings& settings)
+LayerTreeHost::LayerTreeHost(InitParams* params)
     : micro_benchmark_controller_(this),
       next_ui_resource_id_(1),
       inside_begin_main_frame_(false),
       needs_full_tree_sync_(true),
       needs_meta_info_recomputation_(true),
-      client_(client),
+      client_(params->client),
       source_frame_number_(0),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
       output_surface_lost_(true),
-      settings_(settings),
-      debug_state_(settings.initial_debug_state),
+      settings_(*params->settings),
+      debug_state_(settings_.initial_debug_state),
       top_controls_shrink_blink_size_(false),
       top_controls_height_(0.f),
       top_controls_shown_ratio_(0.f),
@@ -127,9 +114,9 @@ LayerTreeHost::LayerTreeHost(
       in_paint_layer_contents_(false),
       id_(s_layer_tree_host_sequence_number.GetNext() + 1),
       next_commit_forces_redraw_(false),
-      shared_bitmap_manager_(shared_bitmap_manager),
-      gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
-      task_graph_runner_(task_graph_runner),
+      shared_bitmap_manager_(params->shared_bitmap_manager),
+      gpu_memory_buffer_manager_(params->gpu_memory_buffer_manager),
+      task_graph_runner_(params->task_graph_runner),
       surface_id_namespace_(0u),
       next_surface_sequence_(1u) {
   if (settings_.accelerated_animation_enabled)
diff --git a/cc/trees/layer_tree_host.h b/cc/trees/layer_tree_host.h
index f9667e3..1b88cff 100644
--- a/cc/trees/layer_tree_host.h
+++ b/cc/trees/layer_tree_host.h
@@ -71,26 +71,29 @@ struct ScrollAndScaleSet;
 
 class CC_EXPORT LayerTreeHost {
  public:
+  // TODO(sad): InitParams should be a movable type so that it can be
+  // std::move()d to the Create* functions.
+  struct CC_EXPORT InitParams {
+    LayerTreeHostClient* client = nullptr;
+    SharedBitmapManager* shared_bitmap_manager = nullptr;
+    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager = nullptr;
+    TaskGraphRunner* task_graph_runner = nullptr;
+    LayerTreeSettings const* settings = nullptr;
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner;
+    scoped_ptr<BeginFrameSource> external_begin_frame_source;
+
+    InitParams();
+    ~InitParams();
+  };
+
   // The SharedBitmapManager will be used on the compositor thread.
   static scoped_ptr<LayerTreeHost> CreateThreaded(
-      LayerTreeHostClient* 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);
+      InitParams* params);
 
   static scoped_ptr<LayerTreeHost> CreateSingleThreaded(
-      LayerTreeHostClient* client,
       LayerTreeHostSingleThreadClient* single_thread_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_ptr<BeginFrameSource> external_begin_frame_source);
+      InitParams* params);
   virtual ~LayerTreeHost();
 
   void SetLayerTreeHostClientReady();
@@ -313,11 +316,7 @@ class CC_EXPORT LayerTreeHost {
   }
 
  protected:
-  LayerTreeHost(LayerTreeHostClient* client,
-                SharedBitmapManager* shared_bitmap_manager,
-                gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-                TaskGraphRunner* task_graph_runner,
-                const LayerTreeSettings& settings);
+  explicit LayerTreeHost(InitParams* params);
   void InitializeThreaded(
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
@@ -331,6 +330,17 @@ class CC_EXPORT LayerTreeHost {
     output_surface_lost_ = is_lost;
   }
 
+  // shared_bitmap_manager(), gpu_memory_buffer_manager(), and
+  // task_graph_runner() return valid values only until the LayerTreeHostImpl is
+  // created in CreateLayerTreeHostImpl().
+  SharedBitmapManager* shared_bitmap_manager() const {
+    return shared_bitmap_manager_;
+  }
+  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager() const {
+    return gpu_memory_buffer_manager_;
+  }
+  TaskGraphRunner* task_graph_runner() const { return task_graph_runner_; }
+
   MicroBenchmarkController micro_benchmark_controller_;
 
  private:
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index df01000..6901d9cd 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -2431,9 +2431,9 @@ SINGLE_THREAD_TEST_F(LayerTreeHostTestCompositeImmediatelyStateTransitions);
 class LayerTreeHostWithProxy : public LayerTreeHost {
  public:
   LayerTreeHostWithProxy(FakeLayerTreeHostClient* client,
-                         const LayerTreeSettings& settings,
-                         scoped_ptr<FakeProxy> proxy)
-      : LayerTreeHost(client, NULL, NULL, NULL, settings) {
+                         scoped_ptr<FakeProxy> proxy,
+                         LayerTreeHost::InitParams* params)
+      : LayerTreeHost(params) {
     proxy->SetLayerTreeHost(this);
     client->SetLayerTreeHost(this);
     InitializeForTesting(proxy.Pass());
@@ -2453,7 +2453,10 @@ TEST(LayerTreeHostTest, LimitPartialUpdates) {
     settings.impl_side_painting = false;
     settings.max_partial_texture_updates = 10;
 
-    LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
+    LayerTreeHost::InitParams params;
+    params.client = &client;
+    params.settings = &settings;
+    LayerTreeHostWithProxy host(&client, proxy.Pass(), &params);
 
     EXPECT_EQ(0u, host.MaxPartialTextureUpdates());
   }
@@ -2471,7 +2474,10 @@ TEST(LayerTreeHostTest, LimitPartialUpdates) {
     settings.impl_side_painting = false;
     settings.max_partial_texture_updates = 10;
 
-    LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
+    LayerTreeHost::InitParams params;
+    params.client = &client;
+    params.settings = &settings;
+    LayerTreeHostWithProxy host(&client, proxy.Pass(), &params);
 
     EXPECT_EQ(5u, host.MaxPartialTextureUpdates());
   }
@@ -2489,7 +2495,10 @@ TEST(LayerTreeHostTest, LimitPartialUpdates) {
     settings.impl_side_painting = false;
     settings.max_partial_texture_updates = 10;
 
-    LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
+    LayerTreeHost::InitParams params;
+    params.client = &client;
+    params.settings = &settings;
+    LayerTreeHostWithProxy host(&client, proxy.Pass(), &params);
 
     EXPECT_EQ(10u, host.MaxPartialTextureUpdates());
   }
@@ -2505,9 +2514,13 @@ TEST(LayerTreeHostTest, PartialUpdatesWithGLRenderer) {
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
-  scoped_ptr<LayerTreeHost> host = LayerTreeHost::CreateSingleThreaded(
-      &client, &client, shared_bitmap_manager.get(), NULL, NULL, settings,
-      base::ThreadTaskRunnerHandle::Get(), nullptr);
+  LayerTreeHost::InitParams params;
+  params.client = &client;
+  params.shared_bitmap_manager = shared_bitmap_manager.get();
+  params.settings = &settings;
+  params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
+  scoped_ptr<LayerTreeHost> host =
+      LayerTreeHost::CreateSingleThreaded(&client, &params);
   client.SetLayerTreeHost(host.get());
   host->Composite(base::TimeTicks::Now());
 
@@ -2524,9 +2537,13 @@ TEST(LayerTreeHostTest, PartialUpdatesWithSoftwareRenderer) {
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
-  scoped_ptr<LayerTreeHost> host = LayerTreeHost::CreateSingleThreaded(
-      &client, &client, shared_bitmap_manager.get(), NULL, NULL, settings,
-      base::ThreadTaskRunnerHandle::Get(), nullptr);
+  LayerTreeHost::InitParams params;
+  params.client = &client;
+  params.shared_bitmap_manager = shared_bitmap_manager.get();
+  params.settings = &settings;
+  params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
+  scoped_ptr<LayerTreeHost> host =
+      LayerTreeHost::CreateSingleThreaded(&client, &params);
   client.SetLayerTreeHost(host.get());
   host->Composite(base::TimeTicks::Now());
 
@@ -2543,9 +2560,13 @@ TEST(LayerTreeHostTest, PartialUpdatesWithDelegatingRendererAndGLContent) {
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
-  scoped_ptr<LayerTreeHost> host = LayerTreeHost::CreateSingleThreaded(
-      &client, &client, shared_bitmap_manager.get(), NULL, NULL, settings,
-      base::ThreadTaskRunnerHandle::Get(), nullptr);
+  LayerTreeHost::InitParams params;
+  params.client = &client;
+  params.shared_bitmap_manager = shared_bitmap_manager.get();
+  params.settings = &settings;
+  params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
+  scoped_ptr<LayerTreeHost> host =
+      LayerTreeHost::CreateSingleThreaded(&client, &params);
   client.SetLayerTreeHost(host.get());
   host->Composite(base::TimeTicks::Now());
 
@@ -2563,9 +2584,13 @@ TEST(LayerTreeHostTest,
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
-  scoped_ptr<LayerTreeHost> host = LayerTreeHost::CreateSingleThreaded(
-      &client, &client, shared_bitmap_manager.get(), NULL, NULL, settings,
-      base::ThreadTaskRunnerHandle::Get(), nullptr);
+  LayerTreeHost::InitParams params;
+  params.client = &client;
+  params.shared_bitmap_manager = shared_bitmap_manager.get();
+  params.settings = &settings;
+  params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
+  scoped_ptr<LayerTreeHost> host =
+      LayerTreeHost::CreateSingleThreaded(&client, &params);
   client.SetLayerTreeHost(host.get());
   host->Composite(base::TimeTicks::Now());
 
diff --git a/cc/trees/layer_tree_host_unittest_no_message_loop.cc b/cc/trees/layer_tree_host_unittest_no_message_loop.cc
index 0b68ffb..ef948f7 100644
--- a/cc/trees/layer_tree_host_unittest_no_message_loop.cc
+++ b/cc/trees/layer_tree_host_unittest_no_message_loop.cc
@@ -105,8 +105,11 @@ class LayerTreeHostNoMessageLoopTest
     settings.single_thread_proxy_scheduler = false;
     settings.verify_property_trees = true;
     settings.raster_enabled = false;
-    layer_tree_host_ = LayerTreeHost::CreateSingleThreaded(
-        this, this, nullptr, nullptr, nullptr, settings, nullptr, nullptr);
+
+    LayerTreeHost::InitParams params;
+    params.client = this;
+    params.settings = &settings;
+    layer_tree_host_ = LayerTreeHost::CreateSingleThreaded(this, &params);
     layer_tree_host_->SetViewportSize(size_);
     layer_tree_host_->SetRootLayer(root_layer_);
   }
diff --git a/cc/trees/layer_tree_host_unittest_scroll.cc b/cc/trees/layer_tree_host_unittest_scroll.cc
index 46cc3e6..4e77a2d 100644
--- a/cc/trees/layer_tree_host_unittest_scroll.cc
+++ b/cc/trees/layer_tree_host_unittest_scroll.cc
@@ -1129,9 +1129,14 @@ TEST(LayerTreeHostFlingTest, DidStopFlingingThread) {
   ASSERT_TRUE(impl_thread.task_runner().get());
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
-  scoped_ptr<LayerTreeHost> layer_tree_host = LayerTreeHost::CreateThreaded(
-      &client, shared_bitmap_manager.get(), NULL, NULL, settings,
-      base::ThreadTaskRunnerHandle::Get(), impl_thread.task_runner(), nullptr);
+
+  LayerTreeHost::InitParams params;
+  params.client = &client;
+  params.shared_bitmap_manager = shared_bitmap_manager.get();
+  params.settings = &settings;
+  params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
+  scoped_ptr<LayerTreeHost> layer_tree_host =
+      LayerTreeHost::CreateThreaded(impl_thread.task_runner(), &params);
 
   impl_thread.task_runner()->PostTask(
       FROM_HERE, base::Bind(&BindInputHandlerOnCompositorThread,