cc: Remove the LayerTreeHost abstraction.

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/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 68 matching lines @@
   EXPECT_FALSE(                                                                \
       grand_child->GetLayerTree()->LayerNeedsPushPropertiesForTesting(         \
           grand_child.get()));
 
 namespace cc {
 
 namespace {
 
 class MockLayerTree : public LayerTree {
  public:
-  MockLayerTree(LayerTreeHostInProcess::InitParams* params,
+  MockLayerTree(LayerTreeHost::InitParams* params,
                 LayerTreeHost* layer_tree_host)
       : LayerTree(params->mutator_host, layer_tree_host) {}
   ~MockLayerTree() override {}
 
   MOCK_METHOD0(SetNeedsFullTreeSync, void());
 };
 
-class MockLayerTreeHost : public LayerTreeHostInProcess {
+class MockLayerTreeHost : public LayerTreeHost {
  public:
   MockLayerTreeHost(LayerTreeHostSingleThreadClient* single_thread_client,
-                    LayerTreeHostInProcess::InitParams* params)
-      : LayerTreeHostInProcess(
+                    LayerTreeHost::InitParams* params)
+      : LayerTreeHost(
             params,
             CompositorMode::SINGLE_THREADED,
             base::MakeUnique<StrictMock<MockLayerTree>>(params, this)) {
     InitializeSingleThreaded(single_thread_client,
                              base::ThreadTaskRunnerHandle::Get());
   }
 
   MOCK_METHOD0(SetNeedsCommit, void());
   MOCK_METHOD0(SetNeedsUpdateLayers, void());
 };
@@ skipping 10 matching lines @@
     host_impl_.animation_host()->AddAnimationTimeline(timeline_impl_);
   }
 
   const LayerTreeSettings& settings() { return settings_; }
   scoped_refptr<AnimationTimeline> timeline_impl() { return timeline_impl_; }
 
  protected:
   void SetUp() override {
     animation_host_ = AnimationHost::CreateForTesting(ThreadInstance::MAIN);
 
-    LayerTreeHostInProcess::InitParams params;
+    LayerTreeHost::InitParams params;
     params.client = &fake_client_;
     params.settings = &settings_;
     params.task_graph_runner = &task_graph_runner_;
     params.mutator_host = animation_host_.get();
 
     layer_tree_host_.reset(
         new StrictMock<MockLayerTreeHost>(&single_thread_client_, &params));
     layer_tree_ = static_cast<StrictMock<MockLayerTree>*>(
         layer_tree_host_->GetLayerTree());
   }
@@ skipping 889 matching lines @@
 }
 
 class LayerTreeHostFactory {
  public:
   std::unique_ptr<LayerTreeHost> Create(MutatorHost* mutator_host) {
     return Create(LayerTreeSettings(), mutator_host);
   }
 
   std::unique_ptr<LayerTreeHost> Create(LayerTreeSettings settings,
                                         MutatorHost* mutator_host) {
-    LayerTreeHostInProcess::InitParams params;
+    LayerTreeHost::InitParams params;
     params.client = &client_;
     params.task_graph_runner = &task_graph_runner_;
     params.settings = &settings;
     params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
     params.mutator_host = mutator_host;
 
-    return LayerTreeHostInProcess::CreateSingleThreaded(&single_thread_client_,
-                                                        &params);
+    return LayerTreeHost::CreateSingleThreaded(&single_thread_client_, &params);
   }
 
  private:
   FakeLayerTreeHostClient client_;
   StubLayerTreeHostSingleThreadClient single_thread_client_;
   TestTaskGraphRunner task_graph_runner_;
 };
 
 void AssertLayerTreeHostMatchesForSubtree(Layer* layer, LayerTreeHost* host) {
   EXPECT_EQ(host, layer->GetLayerTreeHostForTesting());
@@ skipping 365 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