cc: Unused resources should be given back to the child compositor

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"
@@ skipping 59 matching lines @@
   // 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);
     setUpdateRect(gfx::UnionRects(updateRect(), damage_in_layer));
   }
 
-  // Save the resources from the last frame.
-  ResourceProvider::ResourceIdSet new_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);
+  const ResourceProvider::ResourceIdMap& resource_map =
+      resource_provider->getChildToParentMap(child_id_);
 
   // Remap resource ids in the current frame's quads to the parent's namespace.
   bool invalid_frame = false;
+  ResourceProvider::ResourceIdSet used_resources;
   DrawQuad::ResourceIteratorCallback remap_callback = base::Bind(
       &ResourceRemapHelper,
       &invalid_frame,
-      resource_provider->getChildToParentMap(child_id_),
-      &new_resources);
+      resource_map,
+      &used_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[j];
       quad->IterateResources(remap_callback);
     }
   }
 
   // If the frame has invalid data in it, don't display it.
-  if (invalid_frame) {
-    // Keep the resources given to us this frame.
-    for (ResourceProvider::ResourceIdSet::iterator it = new_resources.begin();
-         it != new_resources.end();
-         ++it)
-      resources_.insert(*it);
+  if (invalid_frame)
     return;
-  }
-
-  // Save the resources that this layer owns now.
-  ResourceProvider::ResourceIdSet previous_frame_resources;
-  previous_frame_resources.swap(resources_);
-  resources_.swap(new_resources);
 
   // 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.
+  // Release unused resources 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();
+  for (ResourceProvider::ResourceIdMap::const_iterator it =
+           resource_map.begin();
+       it != resource_map.end();
        ++it) {
-    bool resource_is_not_in_current_frame =
-        resources_.find(*it) == resources_.end();
+    bool resource_is_not_in_current_frame = !used_resources.count(it->second);
     if (resource_is_not_in_current_frame)
-      unused_resources.push_back(*it);
+      unused_resources.push_back(it->second);

[piman, 2013/03/04 17:20:45]

How do these get fed back into the next frame if it starts needing them again?

[danakj, 2013/03/04 17:39:27]

If the next frame needs them, I would expect it to include them in the
TransferableResources for that frame.

   }
   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();
@@ skipping 210 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