cc: Delete the RendererClient class.

cc/surfaces/display.cc

 // Copyright 2014 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/surfaces/display.h"
 
 #include <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 94 matching lines @@
     scheduler_->SetNewRootSurface(id);
 }
 
 void Display::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "Display::SetVisible", "visible", visible);
   if (renderer_)
     renderer_->SetVisible(visible);
   if (scheduler_)
     scheduler_->SetVisible(visible);
   visible_ = visible;
+
+  if (!visible) {
+    // Damage tracker needs a full reset as renderer resources are dropped when
+    // not visible.
+    if (aggregator_ && !current_surface_id_.is_null())
+      aggregator_->SetFullDamageForSurface(current_surface_id_);
+  }
 }
 
 void Display::Resize(const gfx::Size& size) {
   if (size == current_surface_size_)
     return;
 
   TRACE_EVENT0("cc", "Display::Resize");
 
   // Need to ensure all pending swaps have executed before the window is
   // resized, or D3D11 will scale the swap output.
@@ skipping 40 matching lines @@
       output_surface_->context_provider(), bitmap_manager_,
       gpu_memory_buffer_manager_, nullptr, settings_.highp_threshold_min,
       settings_.texture_id_allocation_chunk_size,
       output_surface_->capabilities().delegated_sync_points_required,
       settings_.use_gpu_memory_buffer_resources,
       settings_.buffer_to_texture_target_map));
 
   if (output_surface_->context_provider()) {
     DCHECK(texture_mailbox_deleter_);
     renderer_ = base::MakeUnique<GLRenderer>(
-        this, &settings_, output_surface_.get(), resource_provider_.get(),
+        &settings_, output_surface_.get(), resource_provider_.get(),
         texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
   } else if (output_surface_->vulkan_context_provider()) {
 #if defined(ENABLE_VULKAN)
     DCHECK(texture_mailbox_deleter_);
     renderer_ = base::MakeUnique<VulkanRenderer>(
-        this, &settings_, output_surface_.get(), resource_provider_.get(),
+        &settings_, output_surface_.get(), resource_provider_.get(),
         texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
 #else
     NOTREACHED();
 #endif
   } else {
     auto renderer = base::MakeUnique<SoftwareRenderer>(
-        this, &settings_, output_surface_.get(), resource_provider_.get());
+        &settings_, output_surface_.get(), resource_provider_.get());
     software_renderer_ = renderer.get();
     renderer_ = std::move(renderer);
   }
 
   renderer_->SetEnlargePassTextureAmount(enlarge_texture_amount_);
   renderer_->SetVisible(visible_);
 
   // TODO(jbauman): Outputting an incomplete quad list doesn't work when using
   // overlays.
   bool output_partial_list = renderer_->Capabilities().using_partial_swap &&
@@ skipping 192 matching lines @@
 void Display::SetExternalTilePriorityConstraints(
     const gfx::Rect& viewport_rect,
     const gfx::Transform& transform) {
   NOTREACHED();
 }
 
 void Display::SetTreeActivationCallback(const base::Closure& callback) {
   NOTREACHED();
 }
 
-void Display::SetFullRootLayerDamage() {
-  if (aggregator_ && !current_surface_id_.is_null())
-    aggregator_->SetFullDamageForSurface(current_surface_id_);
-}
-
 void Display::OnSurfaceDamaged(const SurfaceId& surface_id, bool* changed) {
   if (aggregator_ &&
       aggregator_->previous_contained_surfaces().count(surface_id)) {
     Surface* surface = surface_manager_->GetSurfaceForId(surface_id);
     if (surface) {
       const CompositorFrame& current_frame = surface->GetEligibleFrame();
       if (!current_frame.delegated_frame_data ||
           current_frame.delegated_frame_data->resource_list.empty()) {
         aggregator_->ReleaseResources(surface_id);
       }
@@ skipping 14 matching lines @@
 const SurfaceId& Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 void Display::ForceImmediateDrawAndSwapIfPossible() {
   if (scheduler_)
     scheduler_->ForceImmediateSwapIfPossible();
 }
 
 }  // namespace cc