aura: Allow delegated frames to be used by more than one impl layer.

cc/layers/delegated_renderer_layer_impl.cc

 // Copyright 2012 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/layers/delegated_renderer_layer_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 15 matching lines @@
       have_render_passes_to_push_(false),
       child_id_(0),
       own_child_id_(false) {
 }
 
 DelegatedRendererLayerImpl::~DelegatedRendererLayerImpl() {
   ClearRenderPasses();
   ClearChildId();
 }
 
-bool DelegatedRendererLayerImpl::HasDelegatedContent() const {
-  return !render_passes_in_draw_order_.empty();
-}
+bool DelegatedRendererLayerImpl::HasDelegatedContent() const { return true; }
 
 bool DelegatedRendererLayerImpl::HasContributingDelegatedRenderPasses() const {
   // The root RenderPass for the layer is merged with its target
   // RenderPass in each frame. So we only have extra RenderPasses
   // to merge when we have a non-root RenderPass present.
   return render_passes_in_draw_order_.size() > 1;
 }
 
 static ResourceProvider::ResourceId ResourceRemapHelper(
     bool* invalid_frame,
@@ skipping 45 matching lines @@
     const ReturnCallback& return_callback) {
   if (child_id_)
     return;
 
   ResourceProvider* resource_provider = layer_tree_impl()->resource_provider();
   child_id_ = resource_provider->CreateChild(return_callback);
   own_child_id_ = true;
 }
 
 void DelegatedRendererLayerImpl::SetFrameData(
-    scoped_ptr<DelegatedFrameData> frame_data,
+    const DelegatedFrameData* frame_data,
     gfx::RectF damage_in_frame) {
+  DCHECK(child_id_) << "CreateChildIdIfNeeded must be called first.";
   DCHECK(frame_data);
-  DCHECK(child_id_) << "CreateChildIdIfNeeded must be called first.";
-
+  DCHECK(!frame_data->render_pass_list.empty());
   // A frame with an empty root render pass is invalid.
-  DCHECK(frame_data->render_pass_list.empty() ||
-         !frame_data->render_pass_list.back()->output_rect.IsEmpty());
+  DCHECK(!frame_data->render_pass_list.back()->output_rect.IsEmpty());
 
   ResourceProvider* resource_provider = layer_tree_impl()->resource_provider();
     const ResourceProvider::ResourceIdMap& resource_map =
         resource_provider->GetChildToParentMap(child_id_);
 
   resource_provider->ReceiveFromChild(child_id_, frame_data->resource_list);
 
+  ScopedPtrVector<RenderPass> render_pass_list;
+  RenderPass::CopyAll(frame_data->render_pass_list, &render_pass_list);
+
   bool invalid_frame = false;
   ResourceProvider::ResourceIdArray resources_in_frame;
   DrawQuad::ResourceIteratorCallback remap_resources_to_parent_callback =
       base::Bind(&ResourceRemapHelper,
                  &invalid_frame,
                  resource_map,
                  &resources_in_frame);
-  for (size_t i = 0; i < frame_data->render_pass_list.size(); ++i) {
-    RenderPass* pass = frame_data->render_pass_list[i];
+  for (size_t i = 0; i < render_pass_list.size(); ++i) {
+    RenderPass* pass = render_pass_list[i];
     for (size_t j = 0; j < pass->quad_list.size(); ++j) {
       DrawQuad* quad = pass->quad_list[j];
       quad->IterateResources(remap_resources_to_parent_callback);
     }
   }
 
   if (invalid_frame) {
     // Declare we are still using the last frame's resources.
     resource_provider->DeclareUsedResourcesFromChild(child_id_, resources_);
     return;
   }
 
   // Declare we are using the new frame's resources.
   resources_.swap(resources_in_frame);
   resource_provider->DeclareUsedResourcesFromChild(child_id_, resources_);
 
   // Display size is already set so we can compute what the damage rect
   // will be in layer space.
-  if (!frame_data->render_pass_list.empty()) {
-    RenderPass* new_root_pass = frame_data->render_pass_list.back();
-    gfx::RectF damage_in_layer = MathUtil::MapClippedRect(
-        DelegatedFrameToLayerSpaceTransform(
-            new_root_pass->output_rect.size()),
-        damage_in_frame);
-    set_update_rect(gfx::UnionRects(update_rect(), damage_in_layer));
-  }
+  RenderPass* new_root_pass = render_pass_list.back();
+  gfx::Size frame_size = new_root_pass->output_rect.size();
+  gfx::RectF damage_in_layer = MathUtil::MapClippedRect(
+      DelegatedFrameToLayerSpaceTransform(frame_size), damage_in_frame);
+  set_update_rect(gfx::UnionRects(update_rect(), damage_in_layer));
 
-  // Save the remapped quads on the layer. This steals the quads and render
-  // passes from the frame_data.
-  SetRenderPasses(&frame_data->render_pass_list);
+  SetRenderPasses(&render_pass_list);
   have_render_passes_to_push_ = true;
 }
 
 void DelegatedRendererLayerImpl::SetDisplaySize(gfx::Size size) {
   if (display_size_ == size)
     return;
   display_size_ = size;
   NoteLayerPropertyChanged();
 }
 
 void DelegatedRendererLayerImpl::SetRenderPasses(
     ScopedPtrVector<RenderPass>* render_passes_in_draw_order) {
   ClearRenderPasses();
 
   for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
     ScopedPtrVector<RenderPass>::iterator to_take =
         render_passes_in_draw_order->begin() + i;
     render_passes_index_by_id_.insert(
         std::pair<RenderPass::Id, int>((*to_take)->id, i));
     scoped_ptr<RenderPass> taken_render_pass =
         render_passes_in_draw_order->take(to_take);
     render_passes_in_draw_order_.push_back(taken_render_pass.Pass());
   }
 
   // Give back an empty array instead of nulls.
   render_passes_in_draw_order->clear();
 }
 
 void DelegatedRendererLayerImpl::ClearRenderPasses() {
-  // TODO(danakj): Release the resources back to the nested compositor.
   render_passes_index_by_id_.clear();
   render_passes_in_draw_order_.clear();
 }
 
 scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return DelegatedRendererLayerImpl::Create(
       tree_impl, id()).PassAs<LayerImpl>();
 }
 
@@ skipping 66 matching lines @@
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
     return false;
   return LayerImpl::WillDraw(draw_mode, resource_provider);
 }
 
 void DelegatedRendererLayerImpl::AppendQuads(
     QuadSink* quad_sink,
     AppendQuadsData* append_quads_data) {
   AppendRainbowDebugBorder(quad_sink, append_quads_data);
 
+  // This list will be empty after a lost context until a new frame arrives.
   if (render_passes_in_draw_order_.empty())
     return;
 
   RenderPass::Id target_render_pass_id = append_quads_data->render_pass_id;
 
   const RenderPass* root_delegated_render_pass =
       render_passes_in_draw_order_.back();
 
   DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin());
   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
@@ skipping 190 matching lines @@
 
   if (own_child_id_) {
     ResourceProvider* provider = layer_tree_impl()->resource_provider();
     provider->DestroyChild(child_id_);
   }
 
   child_id_ = 0;
 }
 
 }  // namespace cc