cc: Receive and remap resources to the parent.

cc/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/delegated_renderer_layer_impl.h"
 
+#include "base/bind.h"
 #include "cc/append_quads_data.h"
 #include "cc/delegated_frame_data.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/render_pass_sink.h"
 
 namespace cc {
 
@@ skipping 12 matching lines @@
   return !render_passes_in_draw_order_.empty();
 }
 
 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(
+    const ResourceProvider::ResourceIdMap& child_to_parent_map,
+    ResourceProvider::ResourceIdSet *remapped_resources,
+    ResourceProvider::ResourceId id) {
+
+  ResourceProvider::ResourceIdMap::const_iterator it =
+      child_to_parent_map.find(id);
+  DCHECK(it != child_to_parent_map.end());
+  DCHECK(it->first == id);
+
+  ResourceProvider::ResourceId remapped_id = it->second;
+  remapped_resources->insert(remapped_id);
+  return remapped_id;
+}
+
 void DelegatedRendererLayerImpl::SetFrameData(
     scoped_ptr<DelegatedFrameData> frame_data,
-    gfx::RectF damage_in_frame) {
+    gfx::RectF damage_in_frame,
+    TransferableResourceArray* resources_for_ack) {
+  // 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());
+  // If the render pass list is empty, the resource list better be empty too.
+  DCHECK(!frame_data->render_pass_list.empty() ||
+         frame_data->resource_list.empty());

[piman, 2013/02/27 23:09:39]

What happens if that's not the case? It seems harmless for the purpose of this
function (the extra resources would be returned immediately).

In particular, in the case where we
SetFrameData(frame_data_with_passes_and_resources) and then
SetFrameData(frame_data_with_no_passes) without a commit in the middle, we'll
collect resources but end up with no passes

If we want to check that the renderer doesn't generate such a case, a better
place for the DCHECK would be in the DelegatingRenderer

[danakj, 2013/02/28 02:51:05]

Right, with the merging you mentioned in DRLayer.cc this makes a lot of sense.

+
   CreateChildIdIfNeeded();
   DCHECK(child_id_);
 
   // 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();
     DCHECK(!new_root_pass->output_rect.IsEmpty());

[piman, 2013/02/27 23:09:39]

nit: this is tested above, so you can remove.

     gfx::RectF damage_in_layer = MathUtil::mapClippedRect(
         DelegatedFrameToLayerSpaceTransform(new_root_pass->output_rect.size()),
         damage_in_frame);
     setUpdateRect(gfx::UnionRects(updateRect(), damage_in_layer));
   }
 
-  // TODO(danakj): Convert the resource ids the render passes and return data
-  // for a frame ack.
+  // Save the resources from the last frame.
+  ResourceProvider::ResourceIdSet previous_frame_resources;
+  previous_frame_resources.swap(resources_);
+
+  // Receive the current frame's resources from the child compositor.
+  ResourceProvider* resource_provider = layerTreeImpl()->resource_provider();
+  resource_provider->receiveFromChild(child_id_, frame_data->resource_list);
+
+  // Remap resource ids in the current frame's quads to the parent's namespace.
+  DrawQuad::ResourceRemapCallback remap_callback = base::Bind(
+      &ResourceRemapHelper,
+      resource_provider->getChildToParentMap(child_id_),
+      &resources_);
+  for (size_t i = 0; i < frame_data->render_pass_list.size(); ++i) {
+    RenderPass* pass = frame_data->render_pass_list[i];
+    for (size_t j = 0; j < pass->quad_list.size(); ++j) {
+      DrawQuad* quad = pass->quad_list[i];

[piman, 2013/02/28 02:28:33]

s/quad_list[i]/quad_list[j]/

+      quad->RemapResources(remap_callback);
+    }
+  }
+  // Save the remapped quads on the layer. This steals the quads and render
+  // passes from the frame_data.
   SetRenderPasses(frame_data->render_pass_list);
+
+  // Release the resources from the previous frame to prepare them for transport
+  // back to the child compositor.
+  ResourceProvider::ResourceIdArray unused_resources;
+  for (ResourceProvider::ResourceIdSet::iterator it =
+           previous_frame_resources.begin();
+       it != previous_frame_resources.end();
+       ++it) {
+    bool resource_is_not_in_current_frame =
+        resources_.find(*it) == resources_.end();
+    if (resource_is_not_in_current_frame)
+      unused_resources.push_back(*it);
+  }
+  resource_provider->prepareSendToChild(
+      child_id_, unused_resources, resources_for_ack);
 }
 
 void DelegatedRendererLayerImpl::SetDisplaySize(gfx::Size size) {
   if (display_size_ == size)
     return;
   display_size_ = size;
   noteLayerPropertyChanged();
 }
 
 void DelegatedRendererLayerImpl::SetRenderPasses(
@@ skipping 207 matching lines @@
 void DelegatedRendererLayerImpl::ClearChildId() {
   if (!child_id_)
     return;
 
   ResourceProvider* resource_provider = layerTreeImpl()->resource_provider();
   resource_provider->destroyChild(child_id_);
   child_id_ = 0;
 }
 
 }  // namespace cc