cc: Abstract the LayerTreeHost.

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 386 matching lines @@
     layer_tree_host->InitializeForTesting(
         std::move(task_runner_provider), std::move(proxy),
         std::move(external_begin_frame_source));
     return layer_tree_host;
   }
 
   std::unique_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) override {
     std::unique_ptr<LayerTreeHostImpl> host_impl =
         LayerTreeHostImplForTesting::Create(
-            test_hooks_, settings(), host_impl_client, task_runner_provider(),
-            shared_bitmap_manager(), gpu_memory_buffer_manager(),
-            task_graph_runner(), rendering_stats_instrumentation());
+            test_hooks_, GetSettings(), host_impl_client,
+            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();
   }
 
@@ skipping 223 matching lines @@
         this, mode_, client_.get(), nullptr, shared_bitmap_manager_.get(),
         gpu_memory_buffer_manager_.get(), task_graph_runner_.get(), settings_,
         base::ThreadTaskRunnerHandle::Get(),
         impl_thread_ ? impl_thread_->task_runner() : nullptr, nullptr,
         image_serialization_processor_.get());
   }
 
   ASSERT_TRUE(layer_tree_host_);
 
   main_task_runner_ =
-      layer_tree_host_->task_runner_provider()->MainThreadTaskRunner();
+      layer_tree_host_->GetTaskRunnerProvider()->MainThreadTaskRunner();
   impl_task_runner_ =
-      layer_tree_host_->task_runner_provider()->ImplThreadTaskRunner();
+      layer_tree_host_->GetTaskRunnerProvider()->ImplThreadTaskRunner();
   if (!impl_task_runner_) {
     // For tests, if there's no impl thread, make things easier by just giving
     // the main thread task runner.
     impl_task_runner_ = main_task_runner_;
   }
 
   if (timeout_seconds_) {
     timeout_.Reset(base::Bind(&LayerTreeTest::Timeout, base::Unretained(this)));
     main_task_runner_->PostDelayedTask(
         FROM_HERE, timeout_.callback(),
@@ skipping 185 matching lines @@
     layer_tree_host_->SetOutputSurface(std::move(delegating_output_surface));
   }
 }
 
 std::unique_ptr<TestDelegatingOutputSurface>
 LayerTreeTest::CreateDelegatingOutputSurface(
     scoped_refptr<ContextProvider> compositor_context_provider,
     scoped_refptr<ContextProvider> worker_context_provider) {
   bool synchronous_composite =
       !HasImplThread() &&
-      !layer_tree_host()->settings().single_thread_proxy_scheduler;
+      !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
   // Disable reclaim resources by default to act like the Display lives
   // out-of-process.
   bool force_disable_reclaim_resources = true;
   return base::MakeUnique<TestDelegatingOutputSurface>(
       compositor_context_provider, std::move(worker_context_provider),
       CreateDisplayOutputSurface(compositor_context_provider),
       shared_bitmap_manager(), gpu_memory_buffer_manager(),
-      layer_tree_host()->settings().renderer_settings, ImplThreadTaskRunner(),
-      synchronous_composite, force_disable_reclaim_resources);
+      layer_tree_host()->GetSettings().renderer_settings,
+      ImplThreadTaskRunner(), synchronous_composite,
+      force_disable_reclaim_resources);
 }
 
 std::unique_ptr<OutputSurface> LayerTreeTest::CreateDisplayOutputSurface(
     scoped_refptr<ContextProvider> compositor_context_provider) {
   // By default the Display shares a context with the LayerTreeHostImpl.
   return FakeOutputSurface::Create3d(std::move(compositor_context_provider));
 }
 
 void LayerTreeTest::DestroyLayerTreeHost() {
   if (layer_tree_host_ && layer_tree_host_->GetLayerTree()->root_layer())
@@ skipping 42 matching lines @@
   // thread. In the remote mode, the impl thread of the compositor lives on
   // the client, so return the task runner provider owned by the remote client
   // LayerTreeHost.
   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->task_runner_provider();
+  return host->GetTaskRunnerProvider();
 }
 
 LayerTreeHost* 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