cc: Remove DelegatingRenderer.

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 32 matching lines @@
 #include "cc/input/top_controls_manager.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/layers/scrollbar_layer_impl_base.h"
 #include "cc/layers/surface_layer_impl.h"
 #include "cc/layers/viewport.h"
+#include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/copy_output_request.h"
-#include "cc/output/delegating_renderer.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/raster/bitmap_raster_buffer_provider.h"
 #include "cc/raster/gpu_raster_buffer_provider.h"
 #include "cc/raster/one_copy_raster_buffer_provider.h"
 #include "cc/raster/raster_buffer_provider.h"
 #include "cc/raster/synchronous_task_graph_runner.h"
@@ skipping 204 matching lines @@
 
 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(!renderer_);
   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 96 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 (!renderer_) {
-    TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no renderer",
+  if (!output_surface_) {
+    TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no output surface",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
-  // Must have an OutputSurface if |renderer_| is not NULL.
-  DCHECK(output_surface_);
-
   // 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;
   }
 
   if (resourceless_software_draw_)
     return true;
@@ skipping 960 matching lines @@
 
   // Check for a non-null active tree to avoid doing this during shutdown.
   if (active_tree_ && !client_->IsInsideDraw() && tile->required_for_draw()) {
     // The LayerImpl::NotifyTileStateChanged() should damage the layer, so this
     // redraw will make those tiles be displayed.
     SetNeedsRedraw();
   }
 }
 
 void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
+  DCHECK(task_runner_provider_->IsImplThread());
+
   SetManagedMemoryPolicy(policy);
 
   // This is short term solution to synchronously drop tile resources when
   // using synchronous compositing to avoid memory usage regression.
   // TODO(boliu): crbug.com/499004 to track removing this.
   if (!policy.bytes_limit_when_visible && resource_pool_ &&
       settings_.using_synchronous_renderer_compositor) {
     ReleaseTreeResources();
     CleanUpTileManagerAndUIResources();
 
@@ skipping 12 matching lines @@
   DCHECK(task_runner_provider_->IsImplThread());
   tree_activation_callback_ = callback;
 }
 
 void LayerTreeHostImpl::SetManagedMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
   if (cached_managed_memory_policy_ == policy)
     return;
 
   ManagedMemoryPolicy old_policy = ActualManagedMemoryPolicy();
-
   cached_managed_memory_policy_ = policy;
   ManagedMemoryPolicy actual_policy = ActualManagedMemoryPolicy();
 
   if (old_policy == actual_policy)
     return;
 
-  if (!task_runner_provider_->HasImplThread()) {
-    // In single-thread mode, this can be called on the main thread by
-    // GLRenderer::OnMemoryAllocationChanged.
-    DebugScopedSetImplThread impl_thread(task_runner_provider_);
-    UpdateTileManagerMemoryPolicy(actual_policy);
-  } else {
-    DCHECK(task_runner_provider_->IsImplThread());
-    UpdateTileManagerMemoryPolicy(actual_policy);
-  }
+  UpdateTileManagerMemoryPolicy(actual_policy);
 
   // If there is already enough memory to draw everything imaginable and the
   // new memory limit does not change this, then do not re-commit. Don't bother
   // skipping commits if this is not visible (commits don't happen when not
   // visible, there will almost always be a commit when this becomes visible).
   bool needs_commit = true;
   if (visible() &&
       actual_policy.bytes_limit_when_visible >= max_memory_needed_bytes_ &&
       old_policy.bytes_limit_when_visible >= max_memory_needed_bytes_ &&
       actual_policy.priority_cutoff_when_visible ==
@@ skipping 247 matching lines @@
                            "step", "SwapBuffers");
     // Only add the latency component once for renderer swap, not the browser
     // swap.
     if (!latency.FindLatency(ui::INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT, 0,
                              nullptr)) {
       latency.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT,
                                0, 0);
     }
   }
 
-  renderer_->DrawFrame(std::move(metadata), std::move(frame->render_passes));
+  // Collect all resource ids in the render passes into a single array.
+  ResourceProvider::ResourceIdArray resources;
+  for (const auto& render_pass : frame->render_passes) {
+    for (auto* quad : render_pass->quad_list) {
+      for (ResourceId resource_id : quad->resources)
+        resources.push_back(resource_id);
+    }
+  }
+
+  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));
 
   // 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 406 matching lines @@
 }
 
 void LayerTreeHostImpl::RecreateTreeResources() {
   active_tree_->RecreateResources();
   if (pending_tree_)
     pending_tree_->RecreateResources();
   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>(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();
-}
-
 void LayerTreeHostImpl::CreateTileManagerResources() {
   CreateResourceAndRasterBufferProvider(&raster_buffer_provider_,
                                         &resource_pool_);
 
   if (use_gpu_rasterization_) {
     image_decode_controller_ = base::MakeUnique<GpuImageDecodeController>(
         output_surface_->worker_context_provider(),
         settings_.renderer_settings.preferred_tile_format,
         settings_.gpu_decoded_image_budget_bytes);
   } else {
@@ skipping 124 matching lines @@
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ReleaseOutputSurface");
 
   if (!output_surface_)
     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: order is important here.
-  renderer_ = nullptr;
+  // Note: ui resource cleanup uses the |resource_provider_|.
   CleanUpTileManagerAndUIResources();
   resource_provider_ = nullptr;
 
   // Release any context visibility before we destroy the OutputSurface.
   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;
 
   // 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.
   use_gpu_rasterization_ = false;
 }
 
 bool LayerTreeHostImpl::InitializeRenderer(OutputSurface* output_surface) {
+  DCHECK(output_surface->capabilities().delegated_rendering);
   TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
 
   ReleaseOutputSurface();
   if (!output_surface->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;
   }
 
@@ skipping 12 matching lines @@
   // 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();
 
-  CreateAndSetRenderer();
+  // 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
+  // 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)
           ? BeginFrameArgs::DefaultEstimatedParentDrawTime()
           : base::TimeDelta();
   client_->SetEstimatedParentDrawTime(parent_draw_time);
 
   DCHECK_EQ(1, output_surface_->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;
 }
 
 void LayerTreeHostImpl::SetBeginFrameSource(BeginFrameSource* source) {
@@ skipping 1812 matching lines @@
   if (is_visible) {
     worker_context_visibility_ =
         worker_context->CacheController()->ClientBecameVisible();
   } else {
     worker_context->CacheController()->ClientBecameNotVisible(
         std::move(worker_context_visibility_));
   }
 }
 
 }  // namespace cc