cc: Rename LayerTreeHost to LayerTreeHostInProcess.

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/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 323 matching lines @@
   }
 
  private:
   explicit LayerTreeHostClientForTesting(TestHooks* test_hooks)
       : test_hooks_(test_hooks) {}
 
   TestHooks* test_hooks_;
 };
 
 // Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
-class LayerTreeHostForTesting : public LayerTreeHost {
+class LayerTreeHostForTesting : public LayerTreeHostInProcess {
  public:
   static std::unique_ptr<LayerTreeHostForTesting> Create(
       TestHooks* test_hooks,
       CompositorMode mode,
       LayerTreeHostClientForTesting* client,
       RemoteProtoChannel* remote_proto_channel,
       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,
       std::unique_ptr<BeginFrameSource> external_begin_frame_source,
       ImageSerializationProcessor* image_serialization_processor) {
-    LayerTreeHost::InitParams params;
+    LayerTreeHostInProcess::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;
     params.image_serialization_processor = image_serialization_processor;
 
     params.animation_host =
         AnimationHost::CreateForTesting(ThreadInstance::MAIN);
     std::unique_ptr<LayerTreeHostForTesting> layer_tree_host(
@@ skipping 39 matching lines @@
             GetTaskRunnerProvider(), shared_bitmap_manager(),
             gpu_memory_buffer_manager(), task_graph_runner(),
             rendering_stats_instrumentation());
     input_handler_weak_ptr_ = host_impl->AsWeakPtr();
     return host_impl;
   }
 
   void SetNeedsCommit() override {
     if (!test_started_)
       return;
-    LayerTreeHost::SetNeedsCommit();
+    LayerTreeHostInProcess::SetNeedsCommit();
   }
 
   void SetNeedsUpdateLayers() override {
     if (!test_started_)
       return;
-    LayerTreeHost::SetNeedsUpdateLayers();
+    LayerTreeHostInProcess::SetNeedsUpdateLayers();
   }
 
   void set_test_started(bool started) { test_started_ = started; }
 
  private:
   LayerTreeHostForTesting(TestHooks* test_hooks,
-                          LayerTreeHost::InitParams* params,
+                          LayerTreeHostInProcess::InitParams* params,
                           CompositorMode mode)
-      : LayerTreeHost(params, mode),
+      : LayerTreeHostInProcess(params, mode),
         test_hooks_(test_hooks),
         test_started_(false) {}
 
   TestHooks* test_hooks_;
   bool test_started_;
 };
 
 class LayerTreeTestCompositorFrameSinkClient
     : public TestCompositorFrameSinkClient {
  public:
@@ skipping 461 matching lines @@
   LayerTreeHost* host = IsRemoteTest() ? remote_client_layer_tree_host_.get()
                                        : layer_tree_host_.get();
 
   // If this fails, the test has ended and there is no task runners to find
   // anymore.
   DCHECK(host);
 
   return host->GetTaskRunnerProvider();
 }
 
-LayerTreeHost* LayerTreeTest::layer_tree_host() {
+LayerTreeHostInProcess* LayerTreeTest::layer_tree_host() {
   DCHECK(task_runner_provider()->IsMainThread() ||
          task_runner_provider()->IsMainThreadBlocked());
   return layer_tree_host_.get();
 }
 
 LayerTreeHost* LayerTreeTest::remote_client_layer_tree_host() {
   DCHECK(IsRemoteTest());
   DCHECK(task_runner_provider()->IsMainThread() ||
          task_runner_provider()->IsMainThreadBlocked());
   return remote_client_layer_tree_host_.get();
 }
 
 }  // namespace cc