cc: Delete the Renderer base 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 1016 matching lines @@
 
   if (!active_tree_->has_transparent_background()) {
     frame->render_passes.back()->has_transparent_background = false;
     AppendQuadsToFillScreen(
         active_tree_->RootScrollLayerDeviceViewportBounds(),
         frame->render_passes.back().get(), active_tree_->RootRenderSurface(),
         active_tree_->background_color(), unoccluded_screen_space_region);
   }
 
   RemoveRenderPasses(frame);
-  renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
+  // If we're making a frame to draw, it better have at least one render pass.
+  DCHECK(!frame->render_passes.empty());
 
   if (have_copy_request) {
     // Any copy requests left in the tree are not going to get serviced, and
     // should be aborted.
     active_tree()->property_trees()->effect_tree.ClearCopyRequests();
 
     // Draw properties depend on copy requests.
     active_tree()->set_needs_update_draw_properties();
   }
 
-  // If we're making a frame to draw, it better have at least one render pass.
-  DCHECK(!frame->render_passes.empty());
-
   if (active_tree_->has_ever_been_drawn()) {
     UMA_HISTOGRAM_COUNTS_100(
         "Compositing.RenderPass.AppendQuadData.NumMissingTiles",
         num_missing_tiles);
     UMA_HISTOGRAM_COUNTS_100(
         "Compositing.RenderPass.AppendQuadData.NumIncompleteTiles",
         num_incomplete_tiles);
     UMA_HISTOGRAM_COUNTS(
         "Compositing.RenderPass.AppendQuadData."
         "CheckerboardedNoRecordingContentArea",
@@ skipping 474 matching lines @@
 
 void LayerTreeHostImpl::DidReceiveTextureInUseResponses(
     const gpu::TextureInUseResponses& responses) {
   NOTREACHED();
 }
 
 void LayerTreeHostImpl::ReclaimResources(
     const ReturnedResourceArray& resources) {
   // TODO(piman): We may need to do some validation on this ack before
   // processing it.
-  if (renderer_)
-    renderer_->ReclaimResources(resources);
+  if (resource_provider_)
+    resource_provider_->ReceiveReturnsFromParent(resources);
 
   // In OOM, we now might be able to release more resources that were held
   // because they were exported.
   if (resource_pool_) {
     if (resource_pool_->memory_usage_bytes()) {
       const size_t kMegabyte = 1024 * 1024;
 
       // This is a good time to log memory usage. A chunk of work has just
       // completed but none of the memory used for that work has likely been
       // freed.
@@ skipping 155 matching lines @@
 
   // Because the contents of the HUD depend on everything else in the frame, the
   // contents of its texture are updated as the last thing before the frame is
   // drawn.
   if (active_tree_->hud_layer()) {
     TRACE_EVENT0("cc", "DrawLayers.UpdateHudTexture");
     active_tree_->hud_layer()->UpdateHudTexture(draw_mode,
                                                 resource_provider_.get());
   }
 
-  renderer_->DrawFrame(&frame->render_passes,
-                       active_tree_->device_scale_factor(), gfx::ColorSpace(),
-                       DeviceViewport(), DeviceViewport());
+  renderer_->DrawFrame(&frame->render_passes);
   // The render passes should be consumed by the renderer.
   DCHECK(frame->render_passes.empty());
 
   // 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++) {
     (*frame->render_surface_layer_list)[i]
         ->render_surface()
@@ skipping 416 matching lines @@
   if (recycle_tree_)
     recycle_tree_->RecreateResources();
 }
 
 void LayerTreeHostImpl::CreateAndSetRenderer() {
   DCHECK(!renderer_);
   DCHECK(output_surface_);
   DCHECK(resource_provider_);
 
   DCHECK(output_surface_->capabilities().delegated_rendering);
-  renderer_ = base::MakeUnique<DelegatingRenderer>(
-      &settings_.renderer_settings, output_surface_, resource_provider_.get());
-  renderer_->SetVisible(visible_);
+  renderer_ = base::MakeUnique<DelegatingRenderer>(output_surface_,
+                                                   resource_provider_.get());
   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 1889 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