cc: Delete the RendererClient class.

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 1499 matching lines @@
   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.
-    SetFullRootLayerDamage();
+    SetFullViewportDamage();
     SetNeedsRedraw();
   }
 }
 
 void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   if (damage_rect.IsEmpty())
     return;
   NotifySwapPromiseMonitorsOfSetNeedsRedraw();
   client_->SetNeedsRedrawRectOnImplThread(damage_rect);
 }
@@ skipping 51 matching lines @@
   external_viewport_ = viewport;
 
   {
     base::AutoReset<bool> resourceless_software_draw_reset(
         &resourceless_software_draw_, resourceless_software_draw);
 
     // For resourceless software draw, always set full damage to ensure they
     // always swap. Otherwise, need to set redraw for any changes to draw
     // parameters.
     if (transform_changed || viewport_changed || resourceless_software_draw_) {
-      SetFullRootLayerDamage();
+      SetFullViewportDamage();
       SetNeedsRedraw();
       active_tree_->set_needs_update_draw_properties();
     }
 
     if (resourceless_software_draw) {
       client_->OnCanDrawStateChanged(CanDraw());
     }
 
     client_->OnDrawForOutputSurface(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.
-    SetFullRootLayerDamage();
+    SetFullViewportDamage();
   }
 }
 
 void LayerTreeHostImpl::OnCanDrawStateChangedForTree() {
   client_->OnCanDrawStateChanged(CanDraw());
 }
 
 CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
   CompositorFrameMetadata metadata;
   metadata.device_scale_factor = active_tree_->painted_device_scale_factor() *
@@ skipping 466 matching lines @@
   DidVisibilityChange(this, visible_);
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
 
   // If we just became visible, we have to ensure that we draw high res tiles,
   // to prevent checkerboard/low res flashes.
   if (visible_) {
     // TODO(crbug.com/469175): Replace with RequiresHighResToDraw.
     SetRequiresHighResToDraw();
   } else {
     EvictAllUIResources();
+    // Call PrepareTiles to evict tiles when we become invisible.
+    PrepareTiles();
   }
 
-  // Call PrepareTiles to evict tiles when we become invisible.
-  if (!visible)
-    PrepareTiles();
-
   // Update visibility for the compositor context provider.
   if (output_surface_) {
     UpdateVisibilityForContextProvider(id_, output_surface_->context_provider(),
                                        visible);
   }
 }
 
 void LayerTreeHostImpl::SetNeedsOneBeginImplFrame() {
   // TODO(miletus): This is just the compositor-thread-side call to the
   // SwapPromiseMonitor to say something happened that may cause a swap in the
@@ skipping 41 matching lines @@
     recycle_tree_->RecreateResources();
 }
 
 void LayerTreeHostImpl::CreateAndSetRenderer() {
   DCHECK(!renderer_);
   DCHECK(output_surface_);
   DCHECK(resource_provider_);
 
   DCHECK(output_surface_->capabilities().delegated_rendering);
   renderer_ = base::MakeUnique<DelegatingRenderer>(
-      this, &settings_.renderer_settings, output_surface_,
-      resource_provider_.get());
+      &settings_.renderer_settings, output_surface_, resource_provider_.get());
   renderer_->SetVisible(visible_);
-  SetFullRootLayerDamage();
+  SetFullViewportDamage();
 
   // See note in LayerTreeImpl::UpdateDrawProperties.  Renderer needs to be
   // initialized to get max texture size.  Also, after releasing resources,
   // trees need another update to generate new ones.
   active_tree_->set_needs_update_draw_properties();
   if (pending_tree_)
     pending_tree_->set_needs_update_draw_properties();
   client_->UpdateRendererCapabilitiesOnImplThread();
 }
 
@@ skipping 227 matching lines @@
                        device_viewport_size.width(), "height",
                        device_viewport_size.height());
 
   if (pending_tree_)
     active_tree_->SetViewportSizeInvalid();
 
   device_viewport_size_ = device_viewport_size;
 
   UpdateViewportContainerSizes();
   client_->OnCanDrawStateChanged(CanDraw());
-  SetFullRootLayerDamage();
+  SetFullViewportDamage();
   active_tree_->set_needs_update_draw_properties();
 }
 
 const gfx::Rect LayerTreeHostImpl::ViewportRectForTilePriority() const {
   if (viewport_rect_for_tile_priority_.IsEmpty())
     return DeviceViewport();
 
   return viewport_rect_for_tile_priority_;
 }
 
@@ skipping 10 matching lines @@
 
 const gfx::Transform& LayerTreeHostImpl::DrawTransform() const {
   return external_transform_;
 }
 
 void LayerTreeHostImpl::DidChangeTopControlsPosition() {
   UpdateViewportContainerSizes();
   SetNeedsRedraw();
   SetNeedsOneBeginImplFrame();
   active_tree_->set_needs_update_draw_properties();
-  SetFullRootLayerDamage();
+  SetFullViewportDamage();
 }
 
 float LayerTreeHostImpl::TopControlsHeight() const {
   return active_tree_->top_controls_height();
 }
 
 void LayerTreeHostImpl::SetCurrentTopControlsShownRatio(float ratio) {
   if (active_tree_->SetCurrentTopControlsShownRatio(ratio))
     DidChangeTopControlsPosition();
 }
@@ skipping 753 matching lines @@
 void LayerTreeHostImpl::SetSynchronousInputHandlerRootScrollOffset(
     const gfx::ScrollOffset& root_offset) {
   bool changed = active_tree_->DistributeRootScrollOffset(root_offset);
   if (!changed)
     return;
 
   client_->SetNeedsCommitOnImplThread();
   // After applying the synchronous input handler's scroll offset, tell it what
   // we ended up with.
   UpdateRootLayerStateForSynchronousInputHandler();
-  SetFullRootLayerDamage();
+  SetFullViewportDamage();
   SetNeedsRedraw();
 }
 
 void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
   active_tree_->ClearCurrentlyScrollingLayer();
   did_lock_scrolling_layer_ = false;
   scroll_affects_scroll_handler_ = false;
   accumulated_root_overscroll_ = gfx::Vector2dF();
 }
 
@@ skipping 165 matching lines @@
       active_tree_->page_scale_factor()->PullDeltaForMainThread();
   scroll_info->top_controls_delta =
       active_tree()->top_controls_shown_ratio()->PullDeltaForMainThread();
   scroll_info->elastic_overscroll_delta =
       active_tree_->elastic_overscroll()->PullDeltaForMainThread();
   scroll_info->swap_promises.swap(swap_promises_for_main_thread_scroll_update_);
 
   return scroll_info;
 }
 
-void LayerTreeHostImpl::SetFullRootLayerDamage() {
+void LayerTreeHostImpl::SetFullViewportDamage() {
   SetViewportDamage(gfx::Rect(DrawViewportSize()));
 }
 
 void LayerTreeHostImpl::ScrollViewportInnerFirst(gfx::Vector2dF scroll_delta) {
   DCHECK(InnerViewportScrollLayer());
   LayerImpl* scroll_layer = InnerViewportScrollLayer();
 
   gfx::Vector2dF unused_delta = scroll_layer->ScrollBy(scroll_delta);
   if (!unused_delta.IsZero() && OuterViewportScrollLayer())
     OuterViewportScrollLayer()->ScrollBy(unused_delta);
@@ skipping 268 matching lines @@
   state->EndDictionary();
 }
 
 void LayerTreeHostImpl::SetDebugState(
     const LayerTreeDebugState& new_debug_state) {
   if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
     return;
 
   debug_state_ = new_debug_state;
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
-  SetFullRootLayerDamage();
+  SetFullViewportDamage();
 }
 
 void LayerTreeHostImpl::CreateUIResource(UIResourceId uid,
                                          const UIResourceBitmap& bitmap) {
   DCHECK_GT(uid, 0);
 
   // Allow for multiple creation requests with the same UIResourceId.  The
   // previous resource is simply deleted.
   ResourceId id = ResourceIdForUIResource(uid);
   if (id)
@@ skipping 360 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();
 }
 
 }  // namespace cc