cc: Add LayerTreeHost::InitParams for LayerTreeHost creation.

cc/layers/layer_unittest.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/layers/layer.h"
 
 #include "base/thread_task_runner_handle.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 26 matching lines @@
     EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times((expect)); \
     code_to_test;                                                           \
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());               \
   } while (false)
 
 namespace cc {
 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());
   MOCK_METHOD0(SetNeedsUpdateLayers, void());
   MOCK_METHOD0(SetNeedsFullTreeSync, void());
 };
 
 class MockLayerPainter : public LayerPainter {
  public:
   void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) override {}
 };
 
 class LayerTest : public testing::Test {
  public:
   LayerTest()
       : host_impl_(&proxy_, &shared_bitmap_manager_, &task_graph_runner_),
         fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 
  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 {
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());
     EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
     parent_ = nullptr;
     child1_ = nullptr;
     child2_ = nullptr;
     child3_ = nullptr;
     grand_child1_ = nullptr;
@@ skipping 848 matching lines @@
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
 class LayerTreeHostFactory {
  public:
   LayerTreeHostFactory()
       : client_(FakeLayerTreeHostClient::DIRECT_3D),
         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:
   FakeLayerTreeHostClient client_;
   scoped_ptr<TestSharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<TestGpuMemoryBufferManager> gpu_memory_buffer_manager_;
 };
 
 void AssertLayerTreeHostMatchesForSubtree(Layer* layer, LayerTreeHost* host) {
   EXPECT_EQ(host, layer->layer_tree_host());
@@ skipping 354 matching lines @@
   // When the layer is destroyed, the other three requests should be aborted.
   layer = nullptr;
   EXPECT_EQ(1, did_receive_first_result_from_this_source);
   EXPECT_EQ(1, did_receive_result_from_different_source);
   EXPECT_EQ(1, did_receive_result_from_anonymous_source);
   EXPECT_EQ(1, did_receive_second_result_from_this_source);
 }
 
 }  // namespace
 }  // namespace cc