cc: Abstract the LayerTreeHost.

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
 #include <unordered_set>
@@ skipping 485 matching lines @@
 
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   params.shared_bitmap_manager = HostSharedBitmapManager::current();
   params.gpu_memory_buffer_manager = BrowserGpuMemoryBufferManager::current();
   params.task_graph_runner = g_task_graph_runner.Pointer();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.settings = &settings;
   params.animation_host = cc::AnimationHost::CreateMainInstance();
   host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
-  DCHECK(!host_->visible());
+  DCHECK(!host_->IsVisible());
   host_->GetLayerTree()->SetRootLayer(root_window_->GetLayer());
-  host_->set_surface_client_id(surface_id_allocator_->client_id());
+  host_->SetSurfaceClientId(surface_id_allocator_->client_id());
   host_->GetLayerTree()->SetViewportSize(size_);
   host_->GetLayerTree()->set_has_transparent_background(
       has_transparent_background_);
   host_->GetLayerTree()->SetDeviceScaleFactor(device_scale_factor_);
 
   if (needs_animate_)
     host_->SetNeedsAnimate();
 }
 
 void CompositorImpl::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "CompositorImpl::SetVisible", "visible", visible);
   if (!visible) {
-    DCHECK(host_->visible());
+    DCHECK(host_->IsVisible());
 
     // Make a best effort to try to complete pending readbacks.
     // TODO(crbug.com/637035): Consider doing this in a better way,
     // ideally with the guarantee of readbacks completing.
     if (display_.get() && HavePendingReadbacks())
       display_->ForceImmediateDrawAndSwapIfPossible();
 
     host_->SetVisible(false);
     host_->ReleaseOutputSurface();
     pending_swapbuffers_ = 0;
@@ skipping 23 matching lines @@
   root_window_->GetLayer()->SetBounds(size);
 }
 
 void CompositorImpl::SetHasTransparentBackground(bool flag) {
   has_transparent_background_ = flag;
   if (host_)
     host_->GetLayerTree()->set_has_transparent_background(flag);
 }
 
 void CompositorImpl::SetNeedsComposite() {
-  if (!host_->visible())
+  if (!host_->IsVisible())
     return;
   TRACE_EVENT0("compositor", "Compositor::SetNeedsComposite");
   host_->SetNeedsAnimate();
 }
 
 void CompositorImpl::UpdateLayerTreeHost() {
   client_->UpdateLayerTreeHost();
   if (needs_animate_) {
     needs_animate_ = false;
     root_window_->Animate(base::TimeTicks::Now());
@@ skipping 17 matching lines @@
   LOG(ERROR) << "Failed to init OutputSurface for compositor.";
   LOG_IF(FATAL, ++num_successive_context_creation_failures_ >= 2)
       << "Too many context creation failures. Giving up... ";
   HandlePendingOutputSurfaceRequest();
 }
 
 void CompositorImpl::HandlePendingOutputSurfaceRequest() {
   DCHECK(output_surface_request_pending_);
 
   // We might have been made invisible now.
-  if (!host_->visible())
+  if (!host_->IsVisible())
     return;
 
 #if defined(ENABLE_VULKAN)
   CreateVulkanOutputSurface()
   if (display_)
     return;
 #endif
 
   DCHECK(surface_handle_ != gpu::kNullSurfaceHandle);
   ContextProviderFactoryImpl::GetInstance()->RequestGpuChannelHost(base::Bind(
@@ skipping 43 matching lines @@
     case ui::ContextProviderFactory::GpuChannelHostResult::
         FAILURE_FACTORY_SHUTDOWN:
       break;
     case ui::ContextProviderFactory::GpuChannelHostResult::
         FAILURE_GPU_PROCESS_INITIALIZATION_FAILED:
       // TODO(khushalsagar): Retry or have a fallback path after
       // crbug.com/643282 is resolved.
       break;
     case ui::ContextProviderFactory::GpuChannelHostResult::SUCCESS:
       // We don't need the context anymore if we are invisible.
-      if (!host_->visible())
+      if (!host_->IsVisible())
         return;
 
       DCHECK(window_);
       DCHECK_NE(surface_handle_, gpu::kNullSurfaceHandle);
       scoped_refptr<cc::ContextProvider> context_provider =
           ContextProviderFactoryImpl::GetInstance()
               ->CreateDisplayContextProvider(
                   surface_handle_, GetCompositorContextSharedMemoryLimits(),
                   GetCompositorContextAttributes(has_transparent_background_),
                   false /*support_locking*/, false /*automatic_flushes*/,
@@ skipping 27 matching lines @@
   auto* task_runner = base::ThreadTaskRunnerHandle::Get().get();
   std::unique_ptr<ExternalBeginFrameSource> begin_frame_source(
       new ExternalBeginFrameSource(this));
   std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
       begin_frame_source.get(), task_runner,
       display_output_surface->capabilities().max_frames_pending));
 
   display_.reset(new cc::Display(
       HostSharedBitmapManager::current(),
       BrowserGpuMemoryBufferManager::current(),
-      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)));
 
   std::unique_ptr<cc::SurfaceDisplayOutputSurface> delegated_output_surface(
       vulkan_context_provider ? new cc::SurfaceDisplayOutputSurface(
                                     manager, surface_id_allocator_.get(),
                                     display_.get(), vulkan_context_provider)
                               : new cc::SurfaceDisplayOutputSurface(
                                     manager, surface_id_allocator_.get(),
                                     display_.get(), context_provider, nullptr));
@@ skipping 41 matching lines @@
   DCHECK_GT(pending_swapbuffers_, 0U);
   pending_swapbuffers_--;
   client_->OnSwapBuffersCompleted(pending_swapbuffers_);
 }
 
 void CompositorImpl::DidAbortSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidAbortSwapBuffers");
   // This really gets called only once from
   // SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() when the
   // context was lost.
-  if (host_->visible())
+  if (host_->IsVisible())
     host_->SetNeedsCommit();
   client_->OnSwapBuffersCompleted(0);
 }
 
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
 void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
   readback_layer_tree_->AddChild(layer);
@@ skipping 16 matching lines @@
   if (needs_begin_frames_ == needs_begin_frames)
     return;
 
   needs_begin_frames_ = needs_begin_frames;
   if (needs_begin_frames_)
     root_window_->RequestVSyncUpdate();
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
-  if (!host_->visible())
+  if (!host_->IsVisible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content