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

cc/delegated_renderer_layer.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.h"
 
 #include "cc/delegated_frame_data.h"
 #include "cc/delegated_renderer_layer_impl.h"
 
 namespace cc {
@@ skipping 19 matching lines @@
 }
 
 void DelegatedRendererLayer::pushPropertiesTo(LayerImpl* impl) {
   Layer::pushPropertiesTo(impl);
 
   DelegatedRendererLayerImpl* delegated_impl =
       static_cast<DelegatedRendererLayerImpl*>(impl);
 
   delegated_impl->SetDisplaySize(display_size_);
 
-  if (!frame_data_)
-    return;
-
-  if (frame_size_.IsEmpty()) {
+  if (!frame_data_) {
+    delegated_impl->SetFrameData(scoped_ptr<DelegatedFrameData>(),
+                                 gfx::Rect(),
+                                 &unused_resources_for_child_compositor_);
+  } else if (frame_size_.IsEmpty()) {
     scoped_ptr<DelegatedFrameData> empty_frame(new DelegatedFrameData);
     delegated_impl->SetFrameData(empty_frame.Pass(),
                                  gfx::Rect(),
                                  &unused_resources_for_child_compositor_);
   } else {
     delegated_impl->SetFrameData(frame_data_.Pass(),
                                  damage_in_frame_,
                                  &unused_resources_for_child_compositor_);
   }
   frame_data_.reset();
@@ skipping 14 matching lines @@
     // it may use resources that were transferred in the last frame.
     new_frame_data->resource_list.insert(new_frame_data->resource_list.end(),
                                          frame_data_->resource_list.begin(),
                                          frame_data_->resource_list.end());
   }
   frame_data_ = new_frame_data.Pass();
   if (!frame_data_->render_pass_list.empty()) {
     RenderPass* root_pass = frame_data_->render_pass_list.back();
     damage_in_frame_.Union(root_pass->damage_rect);
     frame_size_ = root_pass->output_rect.size();
+
+    for (size_t i = 0; i < unused_resources_for_child_compositor_.size(); ++i) {
+      frame_data_->resource_list.push_back(
+          unused_resources_for_child_compositor_[i]);
+    }
+    unused_resources_for_child_compositor_.clear();

[piman, 2013/03/05 19:30:51]

Note: we have some area for optimization here - maybe tackle later on - for
cases where we will SetFrameData and then TakeUnusedResourcesForChildCompositor
before the commit (e.g. resize case), which might cause resources to accumulate
for a long time. Worth a comment / todo.

[danakj, 2013/03/05 19:39:14]

sgtm

   } else {
     frame_size_ = gfx::Size();
   }
   setNeedsCommit();
 }
 
 void DelegatedRendererLayer::TakeUnusedResourcesForChildCompositor(
     TransferableResourceArray* array) {
   DCHECK(array->empty());
   array->clear();
 
   array->swap(unused_resources_for_child_compositor_);
 }
 
 }  // namespace cc