Fork cc::OutputSurface into cc::CompositorFrameSink.

cc/trees/layer_tree_host_impl.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/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 179 matching lines @@
     TaskRunnerProvider* task_runner_provider,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     TaskGraphRunner* task_graph_runner,
     std::unique_ptr<AnimationHost> animation_host,
     int id)
     : client_(client),
       task_runner_provider_(task_runner_provider),
       current_begin_frame_tracker_(BEGINFRAMETRACKER_FROM_HERE),
-      output_surface_(nullptr),
+      compositor_frame_sink_(nullptr),
       need_update_gpu_rasterization_status_(false),
       content_is_suitable_for_gpu_rasterization_(true),
       has_gpu_rasterization_trigger_(false),
       use_gpu_rasterization_(false),
       use_msaa_(false),
       gpu_rasterization_status_(GpuRasterizationStatus::OFF_DEVICE),
       input_handler_client_(NULL),
       did_lock_scrolling_layer_(false),
       wheel_scrolling_(false),
       scroll_affects_scroll_handler_(false),
@@ skipping 54 matching lines @@
                                  settings.top_controls_hide_threshold);
 }
 
 LayerTreeHostImpl::~LayerTreeHostImpl() {
   DCHECK(task_runner_provider_->IsImplThread());
   TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                                      "cc::LayerTreeHostImpl", id_);
 
   // It is released before shutdown.
-  DCHECK(!output_surface_);
+  DCHECK(!compositor_frame_sink_);
 
   DCHECK(!resource_provider_);
   DCHECK(!resource_pool_);
   DCHECK(!tile_task_manager_);
   DCHECK(!single_thread_synchronous_task_graph_runner_);
   DCHECK(!image_decode_controller_);
 
   if (input_handler_client_) {
     input_handler_client_->WillShutdown();
     input_handler_client_ = NULL;
@@ skipping 36 matching lines @@
 
 void LayerTreeHostImpl::BeginCommit() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::BeginCommit");
 
   // Ensure all textures are returned so partial texture updates can happen
   // during the commit.
   // TODO(ericrk): We should not need to ForceReclaimResources when using
   // Impl-side-painting as it doesn't upload during commits. However,
   // Display::Draw currently relies on resource being reclaimed to block drawing
   // between BeginCommit / Swap. See crbug.com/489515.
-  if (output_surface_)
-    output_surface_->ForceReclaimResources();
+  if (compositor_frame_sink_)
+    compositor_frame_sink_->ForceReclaimResources();
 
   if (!CommitToActiveTree())
     CreatePendingTree();
 }
 
 void LayerTreeHostImpl::CommitComplete() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
 
   if (CommitToActiveTree()) {
     // We have to activate animations here or "IsActive()" is true on the layers
@@ skipping 39 matching lines @@
 
   micro_benchmark_controller_.DidCompleteCommit();
 }
 
 bool LayerTreeHostImpl::CanDraw() const {
   // Note: If you are changing this function or any other function that might
   // affect the result of CanDraw, make sure to call
   // client_->OnCanDrawStateChanged in the proper places and update the
   // NotifyIfCanDrawChanged test.
 
-  if (!output_surface_) {
-    TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no output surface",
+  if (!compositor_frame_sink_) {
+    TRACE_EVENT_INSTANT0("cc",
+                         "LayerTreeHostImpl::CanDraw no CompositorFrameSink",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   // TODO(boliu): Make draws without layers work and move this below
   // |resourceless_software_draw_| check. Tracked in crbug.com/264967.
   if (active_tree_->LayerListIsEmpty()) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no root layer",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
@@ skipping 284 matching lines @@
 }
 
 void LayerTreeHostImpl::FrameData::AppendRenderPass(
     std::unique_ptr<RenderPass> render_pass) {
   render_passes.push_back(std::move(render_pass));
 }
 
 DrawMode LayerTreeHostImpl::GetDrawMode() const {
   if (resourceless_software_draw_) {
     return DRAW_MODE_RESOURCELESS_SOFTWARE;
-  } else if (output_surface_->context_provider()) {
+  } else if (compositor_frame_sink_->context_provider()) {
     return DRAW_MODE_HARDWARE;
   } else {
     return DRAW_MODE_SOFTWARE;
   }
 }
 
 static void AppendQuadsForRenderSurfaceLayer(
     RenderPass* target_render_pass,
     LayerImpl* layer,
     const RenderPass* contributing_render_pass,
@@ skipping 90 matching lines @@
   // frame at all.
   RenderSurfaceImpl* root_surface = active_tree_->RootRenderSurface();
   bool root_surface_has_no_visible_damage =
       !root_surface->damage_tracker()->current_damage_rect().Intersects(
           root_surface->content_rect());
   bool root_surface_has_contributing_layers =
       !root_surface->layer_list().empty();
   bool hud_wants_to_draw_ = active_tree_->hud_layer() &&
                             active_tree_->hud_layer()->IsAnimatingHUDContents();
   bool resources_must_be_resent =
-      output_surface_->capabilities().can_force_reclaim_resources;
+      compositor_frame_sink_->capabilities().can_force_reclaim_resources;
   if (root_surface_has_contributing_layers &&
       root_surface_has_no_visible_damage &&
       !active_tree_->property_trees()->effect_tree.HasCopyRequests() &&
       !resources_must_be_resent && !hud_wants_to_draw_) {
     TRACE_EVENT0("cc",
                  "LayerTreeHostImpl::CalculateRenderPasses::EmptyDamageRect");
     frame->has_no_damage = true;
     DCHECK(!resourceless_software_draw_);
     return DRAW_SUCCESS;
   }
@@ skipping 213 matching lines @@
 
   TRACE_EVENT_END2("cc", "LayerTreeHostImpl::CalculateRenderPasses",
                    "draw_result", draw_result, "missing tiles",
                    num_missing_tiles);
 
   // Draw has to be successful to not drop the copy request layer.
   // When we have a copy request for a layer, we need to draw even if there
   // would be animating checkerboards, because failing under those conditions
   // triggers a new main frame, which may cause the copy request layer to be
   // destroyed.
-  // TODO(weiliangc): Test copy request w/ output surface recreation. Would
+  // TODO(weiliangc): Test copy request w/ CompositorFrameSink recreation. Would
   // trigger this DCHECK.
   DCHECK(!have_copy_request || draw_result == DRAW_SUCCESS);
 
   // TODO(crbug.com/564832): This workaround to prevent creating unnecessarily
   // persistent render passes. When a copy request is made, it may force a
   // separate render pass for the layer, which will persist until a new commit
   // removes it. Force a commit after copy requests, to remove extra render
   // passes.
   if (have_copy_request)
     client_->SetNeedsCommitOnImplThread();
@@ skipping 396 matching lines @@
       viewport_rect_for_tile_priority_in_view_space;
 
   viewport_rect_for_tile_priority_ =
       viewport_rect_for_tile_priority_in_view_space;
 
   if (tile_priority_params_changed) {
     active_tree_->set_needs_update_draw_properties();
     if (pending_tree_)
       pending_tree_->set_needs_update_draw_properties();
 
-    // Compositor, not OutputSurface, is responsible for setting damage and
-    // triggering redraw for constraint changes.
+    // Compositor, not CompositorFrameSink, is responsible for setting damage
+    // and triggering redraw for constraint changes.
     SetFullViewportDamage();
     SetNeedsRedraw();
   }
 }
 
 void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   if (damage_rect.IsEmpty())
     return;
   NotifySwapPromiseMonitorsOfSetNeedsRedraw();
   client_->SetNeedsRedrawRectOnImplThread(damage_rect);
@@ skipping 29 matching lines @@
           static_cast<int>(resource_pool_->memory_usage_bytes() / kMegabyte));
     }
 
     resource_pool_->CheckBusyResources();
     resource_pool_->ReduceResourceUsage();
   }
 
   // If we're not visible, we likely released resources, so we want to
   // aggressively flush here to make sure those DeleteTextures make it to the
   // GPU process to free up the memory.
-  if (output_surface_->context_provider() && !visible_) {
-    output_surface_->context_provider()->ContextGL()->ShallowFlushCHROMIUM();
+  if (compositor_frame_sink_->context_provider() && !visible_) {
+    compositor_frame_sink_->context_provider()
+        ->ContextGL()
+        ->ShallowFlushCHROMIUM();
   }
 }
 
 void LayerTreeHostImpl::OnDraw(const gfx::Transform& transform,
                                const gfx::Rect& viewport,
                                bool resourceless_software_draw) {
   DCHECK(!resourceless_software_draw_);
   const bool transform_changed = external_transform_ != transform;
   const bool viewport_changed = external_viewport_ != viewport;
 
@@ skipping 10 matching lines @@
     if (transform_changed || viewport_changed || resourceless_software_draw_) {
       SetFullViewportDamage();
       SetNeedsRedraw();
       active_tree_->set_needs_update_draw_properties();
     }
 
     if (resourceless_software_draw) {
       client_->OnCanDrawStateChanged(CanDraw());
     }
 
-    client_->OnDrawForOutputSurface(resourceless_software_draw_);
+    client_->OnDrawForCompositorFrameSink(resourceless_software_draw_);
   }
 
   if (resourceless_software_draw) {
     active_tree_->set_needs_update_draw_properties();
     client_->OnCanDrawStateChanged(CanDraw());
     // This draw may have reset all damage, which would lead to subsequent
     // incorrect hardware draw, so explicitly set damage for next hardware
     // draw as well.
     SetFullViewportDamage();
   }
@@ skipping 65 matching lines @@
 
   if (frame->has_no_damage) {
     DCHECK(!resourceless_software_draw_);
 
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
     active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS);
     return false;
   }
 
   fps_counter_->SaveTimeStamp(CurrentBeginFrameArgs().frame_time,
-                              !output_surface_->context_provider());
+                              !compositor_frame_sink_->context_provider());
   rendering_stats_instrumentation_->IncrementFrameCount(1);
 
   memory_history_->SaveEntry(tile_manager_.memory_stats_from_last_assign());
 
   if (debug_state_.ShowHudRects()) {
     debug_rect_history_->SaveDebugRectsForCurrentFrame(
         active_tree(), active_tree_->hud_layer(),
         *frame->render_surface_layer_list, debug_state_);
   }
 
@@ skipping 52 matching lines @@
     }
   }
 
   auto data = base::MakeUnique<DelegatedFrameData>();
   resource_provider_->PrepareSendToParent(resources, &data->resource_list);
   data->render_pass_list = std::move(frame->render_passes);
 
   CompositorFrame compositor_frame;
   compositor_frame.metadata = std::move(metadata);
   compositor_frame.delegated_frame_data = std::move(data);
-  output_surface_->SwapBuffers(std::move(compositor_frame));
+  compositor_frame_sink_->SwapBuffers(std::move(compositor_frame));
 
   // The next frame should start by assuming nothing has changed, and changes
   // are noted as they occur.
   // TODO(boliu): If we did a temporary software renderer frame, propogate the
   // damage forward to the next frame.
   for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
     auto* surface = (*frame->render_surface_layer_list)[i]->render_surface();
     surface->damage_tracker()->DidDrawDamagedArea();
   }
   active_tree_->ResetAllChangeTracking();
@@ skipping 34 matching lines @@
 }
 
 void LayerTreeHostImpl::SetContentIsSuitableForGpuRasterization(bool flag) {
   if (content_is_suitable_for_gpu_rasterization_ != flag) {
     content_is_suitable_for_gpu_rasterization_ = flag;
     need_update_gpu_rasterization_status_ = true;
   }
 }
 
 bool LayerTreeHostImpl::CanUseGpuRasterization() {
-  if (!(output_surface_ && output_surface_->context_provider() &&
-        output_surface_->worker_context_provider()))
+  if (!(compositor_frame_sink_ && compositor_frame_sink_->context_provider() &&
+        compositor_frame_sink_->worker_context_provider()))
     return false;
 
   ContextProvider* context_provider =
-      output_surface_->worker_context_provider();
+      compositor_frame_sink_->worker_context_provider();
   ContextProvider::ScopedContextLock scoped_context(context_provider);
   if (!context_provider->GrContext())
     return false;
 
   return true;
 }
 
 bool LayerTreeHostImpl::UpdateGpuRasterizationStatus() {
-  // TODO(danakj): Can we avoid having this run when there's no output surface?
+  // TODO(danakj): Can we avoid having this run when there's no
+  // CompositorFrameSink?
   // For now just early out and leave things unchanged, we'll come back here
-  // when we get an output surface.
-  if (!output_surface_)
+  // when we get an CompositorFrameSink.
+  if (!compositor_frame_sink_)
     return false;
 
   int requested_msaa_samples = RequestedMSAASampleCount();
   int max_msaa_samples = 0;
   ContextProvider* compositor_context_provider =
-      output_surface_->context_provider();
+      compositor_frame_sink_->context_provider();
   if (compositor_context_provider) {
     const auto& caps = compositor_context_provider->ContextCapabilities();
     if (!caps.msaa_is_slow)
       max_msaa_samples = caps.max_samples;
   }
 
   bool use_gpu = false;
   bool use_msaa = false;
   bool using_msaa_for_complex_content =
       requested_msaa_samples > 0 && max_msaa_samples >= requested_msaa_samples;
@@ skipping 125 matching lines @@
     anchor.ResetViewportToAnchoredPosition();
   }
 }
 
 void LayerTreeHostImpl::SynchronouslyInitializeAllTiles() {
   // Only valid for the single-threaded non-scheduled/synchronous case
   // using the zero copy raster worker pool.
   single_thread_synchronous_task_graph_runner_->RunUntilIdle();
 }
 
-void LayerTreeHostImpl::DidLoseOutputSurface() {
+void LayerTreeHostImpl::DidLoseCompositorFrameSink() {
   if (resource_provider_)
-    resource_provider_->DidLoseOutputSurface();
-  client_->DidLoseOutputSurfaceOnImplThread();
+    resource_provider_->DidLoseContextProvider();
+  client_->DidLoseCompositorFrameSinkOnImplThread();
 }
 
 bool LayerTreeHostImpl::HaveRootScrollLayer() const {
   return !!InnerViewportScrollLayer();
 }
 
 LayerImpl* LayerTreeHostImpl::InnerViewportScrollLayer() const {
   return active_tree_->InnerViewportScrollLayer();
 }
 
@@ skipping 181 matching lines @@
   if (recycle_tree_)
     recycle_tree_->RecreateResources();
 }
 
 void LayerTreeHostImpl::CreateTileManagerResources() {
   CreateResourceAndRasterBufferProvider(&raster_buffer_provider_,
                                         &resource_pool_);
 
   if (use_gpu_rasterization_) {
     image_decode_controller_ = base::MakeUnique<GpuImageDecodeController>(
-        output_surface_->worker_context_provider(),
+        compositor_frame_sink_->worker_context_provider(),
         settings_.renderer_settings.preferred_tile_format,
         settings_.gpu_decoded_image_budget_bytes);
   } else {
     image_decode_controller_ = base::MakeUnique<SoftwareImageDecodeController>(
         settings_.renderer_settings.preferred_tile_format,
         settings_.software_decoded_image_budget_bytes);
   }
 
   // Pass the single-threaded synchronous task graph runner to the worker pool
   // if we're in synchronous single-threaded mode.
@@ skipping 19 matching lines @@
 
 void LayerTreeHostImpl::CreateResourceAndRasterBufferProvider(
     std::unique_ptr<RasterBufferProvider>* raster_buffer_provider,
     std::unique_ptr<ResourcePool>* resource_pool) {
   DCHECK(GetTaskRunner());
   // TODO(vmpstr): Make this a DCHECK (or remove) when crbug.com/419086 is
   // resolved.
   CHECK(resource_provider_);
 
   ContextProvider* compositor_context_provider =
-      output_surface_->context_provider();
+      compositor_frame_sink_->context_provider();
   if (!compositor_context_provider) {
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(), GetTaskRunner(),
                              ResourcePool::kDefaultExpirationDelay);
 
     *raster_buffer_provider =
         BitmapRasterBufferProvider::Create(resource_provider_.get());
     return;
   }
 
   ContextProvider* worker_context_provider =
-      output_surface_->worker_context_provider();
+      compositor_frame_sink_->worker_context_provider();
   if (use_gpu_rasterization_) {
     DCHECK(worker_context_provider);
 
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(), GetTaskRunner(),
                              ResourcePool::kDefaultExpirationDelay);
 
     int msaa_sample_count = use_msaa_ ? RequestedMSAASampleCount() : 0;
 
     *raster_buffer_provider = base::MakeUnique<GpuRasterBufferProvider>(
@@ skipping 54 matching lines @@
 
 void LayerTreeHostImpl::CleanUpTileManagerAndUIResources() {
   ClearUIResources();
   tile_manager_.FinishTasksAndCleanUp();
   resource_pool_ = nullptr;
   tile_task_manager_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
   image_decode_controller_ = nullptr;
 }
 
-void LayerTreeHostImpl::ReleaseOutputSurface() {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::ReleaseOutputSurface");
+void LayerTreeHostImpl::ReleaseCompositorFrameSink() {
+  TRACE_EVENT0("cc", "LayerTreeHostImpl::ReleaseCompositorFrameSink");
 
-  if (!output_surface_)
+  if (!compositor_frame_sink_)
     return;
 
   // Since we will create a new resource provider, we cannot continue to use
   // the old resources (i.e. render_surfaces and texture IDs). Clear them
   // before we destroy the old resource provider.
   ReleaseTreeResources();
 
   // Note: ui resource cleanup uses the |resource_provider_|.
   CleanUpTileManagerAndUIResources();
   resource_provider_ = nullptr;
 
-  // Release any context visibility before we destroy the OutputSurface.
+  // Release any context visibility before we destroy the CompositorFrameSink.
   if (visible_)
     SetCompositorContextVisibility(false);
   // Worker context visibility is based on both LTHI visibility as well as
   // memory policy, so we directly check |worker_context_visibility_| here,
   // rather than just relying on |visibility_|.
   if (worker_context_visibility_)
     SetWorkerContextVisibility(false);
 
-  // Detach from the old output surface and reset |output_surface_| pointer
-  // as this surface is going to be destroyed independent of if binding the
-  // new output surface succeeds or not.
-  output_surface_->DetachFromClient();
-  output_surface_ = nullptr;
+  // Detach from the old CompositorFrameSink and reset |compositor_frame_sink_|
+  // pointer as this surface is going to be destroyed independent of if binding
+  // the new CompositorFrameSink succeeds or not.
+  compositor_frame_sink_->DetachFromClient();
+  compositor_frame_sink_ = nullptr;
 
-  // We don't know if the next OutputSurface will support GPU rasterization.
-  // Make sure to clear the flag so that we force a re-computation.
+  // We don't know if the next CompositorFrameSink will support GPU
+  // rasterization. Make sure to clear the flag so that we force a
+  // re-computation.
   use_gpu_rasterization_ = false;
 }
 
-bool LayerTreeHostImpl::InitializeRenderer(OutputSurface* output_surface) {
-  DCHECK(output_surface->capabilities().delegated_rendering);
+bool LayerTreeHostImpl::InitializeRenderer(
+    CompositorFrameSink* compositor_frame_sink) {
+  DCHECK(compositor_frame_sink->capabilities().delegated_rendering);
   TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
 
-  ReleaseOutputSurface();
-  if (!output_surface->BindToClient(this)) {
+  ReleaseCompositorFrameSink();
+  if (!compositor_frame_sink->BindToClient(this)) {
     // Avoid recreating tree resources because we might not have enough
     // information to do this yet (eg. we don't have a TileManager at this
     // point).
     return false;
   }
 
   // When using software compositing, change to the limits specified for it.
   // Since this is a one way trip, we don't need to worry about going back to
   // GPU compositing.
-  if (!output_surface->context_provider())
+  if (!compositor_frame_sink->context_provider())
     SetMemoryPolicy(settings_.software_memory_policy);
 
-  output_surface_ = output_surface;
+  compositor_frame_sink_ = compositor_frame_sink;
   resource_provider_ = base::MakeUnique<ResourceProvider>(
-      output_surface_->context_provider(), shared_bitmap_manager_,
+      compositor_frame_sink_->context_provider(), shared_bitmap_manager_,
       gpu_memory_buffer_manager_,
       task_runner_provider_->blocking_main_thread_task_runner(),
       settings_.renderer_settings.highp_threshold_min,
       settings_.renderer_settings.texture_id_allocation_chunk_size,
-      output_surface_->capabilities().delegated_sync_points_required,
+      compositor_frame_sink_->capabilities().delegated_sync_points_required,
       settings_.renderer_settings.use_gpu_memory_buffer_resources, false,
       settings_.renderer_settings.buffer_to_texture_target_map);
 
   // Make sure the main context visibility is restored. Worker context
   // visibility will be set via the memory policy update in
   // CreateTileManagerResources below.
   if (visible_)
     SetCompositorContextVisibility(true);
 
   // Since the new context may be capable of MSAA, update status here. We don't
   // need to check the return value since we are recreating all resources
   // already.
   UpdateGpuRasterizationStatus();
 
-  // See note in LayerTreeImpl::UpdateDrawProperties, new OutputSurface means a
-  // new max texture size which affects draw properties. Also, if the draw
-  // properties were up to date, layers still lost resources and we need to
+  // See note in LayerTreeImpl::UpdateDrawProperties, new CompositorFrameSink
+  // means a new max texture size which affects draw properties. Also, if the
+  // draw properties were up to date, layers still lost resources and we need to
   // UpdateDrawProperties() after calling RecreateTreeResources().
   active_tree_->set_needs_update_draw_properties();
   if (pending_tree_)
     pending_tree_->set_needs_update_draw_properties();
 
   CreateTileManagerResources();
   RecreateTreeResources();
 
   // TODO(brianderson): Don't use a hard-coded parent draw time.
   base::TimeDelta parent_draw_time =
       (!settings_.use_external_begin_frame_source &&
-       output_surface_->capabilities().adjust_deadline_for_parent)
+       compositor_frame_sink_->capabilities().adjust_deadline_for_parent)
           ? BeginFrameArgs::DefaultEstimatedParentDrawTime()
           : base::TimeDelta();
   client_->SetEstimatedParentDrawTime(parent_draw_time);
 
-  DCHECK_EQ(1, output_surface_->capabilities().max_frames_pending);
+  DCHECK_EQ(1, compositor_frame_sink_->capabilities().max_frames_pending);
   client_->OnCanDrawStateChanged(CanDraw());
 
   SetFullViewportDamage();
   // There will not be anything to draw here, so set high res
   // to avoid checkerboards, typically when we are recovering
   // from lost context.
   // TODO(crbug.com/469175): Replace with RequiresHighResToDraw.
   SetRequiresHighResToDraw();
 
   return true;
@@ skipping 1788 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 void LayerTreeHostImpl::SetCompositorContextVisibility(bool is_visible) {
-  if (!output_surface_)
+  if (!compositor_frame_sink_)
     return;
 
-  auto* compositor_context = output_surface_->context_provider();
+  auto* compositor_context = compositor_frame_sink_->context_provider();
   if (!compositor_context)
     return;
 
   DCHECK_NE(is_visible, !!compositor_context_visibility_);
 
   if (is_visible) {
     compositor_context_visibility_ =
         compositor_context->CacheController()->ClientBecameVisible();
   } else {
     compositor_context->CacheController()->ClientBecameNotVisible(
         std::move(compositor_context_visibility_));
   }
 }
 
 void LayerTreeHostImpl::SetWorkerContextVisibility(bool is_visible) {
-  if (!output_surface_)
+  if (!compositor_frame_sink_)
     return;
 
-  auto* worker_context = output_surface_->worker_context_provider();
+  auto* worker_context = compositor_frame_sink_->worker_context_provider();
   if (!worker_context)
     return;
 
   // TODO(ericrk): This check is here because worker context visibility is a
   // bit less controlled, being settable both by memory policy changes as well
   // as direct visibility changes. We should simplify this. crbug.com/642154
   if (is_visible == !!worker_context_visibility_)
     return;
 
   ContextProvider::ScopedContextLock hold(worker_context);
   if (is_visible) {
     worker_context_visibility_ =
         worker_context->CacheController()->ClientBecameVisible();
   } else {
     worker_context->CacheController()->ClientBecameNotVisible(
         std::move(worker_context_visibility_));
   }
 }
 
 }  // namespace cc