cc: Abstract the LayerTreeHost.

blimp/client/app/compositor/browser_compositor.cc

 // Copyright 2016 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 "blimp/client/app/compositor/browser_compositor.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "blimp/client/public/compositor/compositor_dependencies.h"
@@ skipping 73 matching lines @@
       compositor_dependencies_->GetGpuMemoryBufferManager();
   params.task_graph_runner = g_task_graph_runner.Pointer();
   cc::LayerTreeSettings settings;
   params.settings = &settings;
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.animation_host = cc::AnimationHost::CreateMainInstance();
   host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
 
   root_layer_->SetBackgroundColor(SK_ColorWHITE);
   host_->GetLayerTree()->SetRootLayer(root_layer_);
-  host_->set_surface_client_id(surface_id_allocator_->client_id());
+  host_->SetSurfaceClientId(surface_id_allocator_->client_id());
 }
 
 BrowserCompositor::~BrowserCompositor() {
   compositor_dependencies_->GetSurfaceManager()->InvalidateSurfaceClientId(
       surface_id_allocator_->client_id());
 }
 
 void BrowserCompositor::SetContentLayer(
     scoped_refptr<cc::Layer> content_layer) {
   root_layer_->RemoveAllChildren();
@@ skipping 10 matching lines @@
   // Update the display.
   if (display_) {
     display_->Resize(viewport_size_in_px_);
   }
 }
 
 void BrowserCompositor::SetAcceleratedWidget(gfx::AcceleratedWidget widget) {
   // Kill all references to the old widget.
   if (widget_ != gfx::kNullAcceleratedWidget) {
     // We are always visible if we have a widget.
-    DCHECK(host_->visible());
+    DCHECK(host_->IsVisible());
     host_->SetVisible(false);
     host_->ReleaseOutputSurface();
     display_.reset();
   }
 
   widget_ = gfx::kNullAcceleratedWidget;
 
   if (widget != gfx::kNullAcceleratedWidget) {
     widget_ = widget;
     host_->SetVisible(true);
@@ skipping 21 matching lines @@
 void BrowserCompositor::DidCompleteSwapBuffers() {
   if (!did_complete_swap_buffers_.is_null()) {
     did_complete_swap_buffers_.Run();
   }
 }
 
 void BrowserCompositor::HandlePendingOutputSurfaceRequest() {
   DCHECK(output_surface_request_pending_);
 
   // Can't handle the request right now since we don't have a widget.
-  if (!host_->visible())
+  if (!host_->IsVisible())
     return;
 
   DCHECK_NE(gfx::kNullAcceleratedWidget, widget_);
 
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager =
       compositor_dependencies_->GetGpuMemoryBufferManager();
 
   scoped_refptr<cc::ContextProvider> context_provider =
       BlimpContextProvider::Create(widget_, gpu_memory_buffer_manager);
 
   std::unique_ptr<cc::OutputSurface> display_output_surface =
       base::MakeUnique<DisplayOutputSurface>(context_provider);
 
   auto* task_runner = base::ThreadTaskRunnerHandle::Get().get();
   std::unique_ptr<cc::SyntheticBeginFrameSource> begin_frame_source(
       new cc::DelayBasedBeginFrameSource(
           base::MakeUnique<cc::DelayBasedTimeSource>(task_runner)));
   std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
       begin_frame_source.get(), task_runner,
       display_output_surface->capabilities().max_frames_pending));
 
   display_ = base::MakeUnique<cc::Display>(
       nullptr /*shared_bitmap_manager*/, gpu_memory_buffer_manager,
-      host_->settings().renderer_settings, std::move(begin_frame_source),
+      host_->GetSettings().renderer_settings, std::move(begin_frame_source),
       std::move(display_output_surface), std::move(scheduler),
       base::MakeUnique<cc::TextureMailboxDeleter>(task_runner));
   display_->SetVisible(true);
   display_->Resize(viewport_size_in_px_);
 
   // The Browser compositor and display share the same context provider.
   std::unique_ptr<cc::OutputSurface> delegated_output_surface =
       base::MakeUnique<cc::SurfaceDisplayOutputSurface>(
           compositor_dependencies_->GetSurfaceManager(),
           surface_id_allocator_.get(), display_.get(), context_provider,
           nullptr);
 
   host_->SetOutputSurface(std::move(delegated_output_surface));
 }
 
 }  // namespace client
 }  // namespace blimp