cc: Receive and remap resources to the parent.

cc/delegated_renderer_layer_impl.cc

Index: cc/delegated_renderer_layer_impl.cc
diff --git a/cc/delegated_renderer_layer_impl.cc b/cc/delegated_renderer_layer_impl.cc
index db32adbad188358dea051d037b989e5c1216bc56..3abc2e873eb4a2b889d95cffd95e4d039642a73a 100644
--- a/cc/delegated_renderer_layer_impl.cc
+++ b/cc/delegated_renderer_layer_impl.cc
@@ -4,6 +4,7 @@
 
 #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"
@@ -36,9 +37,32 @@ bool DelegatedRendererLayerImpl::hasContributingDelegatedRenderPasses() const {
   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_);
 
@@ -53,9 +77,44 @@ void DelegatedRendererLayerImpl::SetFrameData(
     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) {