cc: Rename LayerTreeHost to LayerTreeHostInProcess.

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 <stddef.h>
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation_host.h"
@@ skipping 872 matching lines @@
 
   TestTaskGraphRunner task_graph_runner_;
   FakeLayerTreeHostClient fake_client_;
   std::unique_ptr<FakeLayerTreeHost> layer_tree_host_;
 };
 
 namespace {
 
 class MockLayerTree : public LayerTree {
  public:
-  MockLayerTree(LayerTreeHost::InitParams* params,
+  MockLayerTree(LayerTreeHostInProcess::InitParams* params,
                 LayerTreeHost* layer_tree_host)
       : LayerTree(std::move(params->animation_host), layer_tree_host) {}
   ~MockLayerTree() override {}
 
   MOCK_METHOD0(SetNeedsFullTreeSync, void());
 };
 
-class MockLayerTreeHost : public LayerTreeHost {
+class MockLayerTreeHost : public LayerTreeHostInProcess {
  public:
   MockLayerTreeHost(LayerTreeHostSingleThreadClient* single_thread_client,
-                    LayerTreeHost::InitParams* params)
-      : LayerTreeHost(
+                    LayerTreeHostInProcess::InitParams* params)
+      : LayerTreeHostInProcess(
             params,
             CompositorMode::SINGLE_THREADED,
             base::MakeUnique<StrictMock<MockLayerTree>>(params, this)) {
     InitializeSingleThreaded(single_thread_client,
                              base::ThreadTaskRunnerHandle::Get(), nullptr);
   }
 
   MOCK_METHOD0(SetNeedsCommit, void());
   MOCK_METHOD0(SetNeedsUpdateLayers, void());
 };
 
 class LayerTest : public testing::Test {
  public:
   LayerTest()
       : host_impl_(LayerTreeSettings(),
                    &task_runner_provider_,
                    &shared_bitmap_manager_,
                    &task_graph_runner_) {
     timeline_impl_ =
         AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
     timeline_impl_->set_is_impl_only(true);
     host_impl_.animation_host()->AddAnimationTimeline(timeline_impl_);
   }
 
   const LayerTreeSettings& settings() { return settings_; }
   scoped_refptr<AnimationTimeline> timeline_impl() { return timeline_impl_; }
 
  protected:
   void SetUp() override {
-    LayerTreeHost::InitParams params;
+    LayerTreeHostInProcess::InitParams params;
     params.client = &fake_client_;
     params.settings = &settings_;
     params.task_graph_runner = &task_graph_runner_;
     params.animation_host =
         AnimationHost::CreateForTesting(ThreadInstance::MAIN);
 
     layer_tree_host_.reset(
         new StrictMock<MockLayerTreeHost>(&single_thread_client_, &params));
     layer_tree_ = static_cast<StrictMock<MockLayerTree>*>(
         layer_tree_host_->GetLayerTree());
@@ skipping 915 matching lines @@
   EXPECT_EQ(replica.get(), replica->mask_layer()->parent());
 }
 
 class LayerTreeHostFactory {
  public:
   std::unique_ptr<LayerTreeHost> Create() {
     return Create(LayerTreeSettings());
   }
 
   std::unique_ptr<LayerTreeHost> Create(LayerTreeSettings settings) {
-    LayerTreeHost::InitParams params;
+    LayerTreeHostInProcess::InitParams params;
     params.client = &client_;
     params.shared_bitmap_manager = &shared_bitmap_manager_;
     params.task_graph_runner = &task_graph_runner_;
     params.gpu_memory_buffer_manager = &gpu_memory_buffer_manager_;
     params.settings = &settings;
     params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
     params.animation_host =
         AnimationHost::CreateForTesting(ThreadInstance::MAIN);
-    return LayerTreeHost::CreateSingleThreaded(&single_thread_client_, &params);
+    return LayerTreeHostInProcess::CreateSingleThreaded(&single_thread_client_,
+                                                        &params);
   }
 
  private:
   FakeLayerTreeHostClient client_;
   StubLayerTreeHostSingleThreadClient single_thread_client_;
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
   TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
 };
 
@@ skipping 662 matching lines @@
   EXPECT_EQ(MutableProperty::kNone, impl_layer->mutable_properties());
 
   test_layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_EQ(ElementId(2, 0), impl_layer->element_id());
   EXPECT_EQ(MutableProperty::kTransform, impl_layer->mutable_properties());
 }
 
 }  // namespace
 }  // namespace cc