cc: Return resources to child compositor via a Callback.

cc/layers/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/layers/delegated_renderer_layer.h"
 
 #include "cc/layers/delegated_renderer_layer_client.h"
 #include "cc/layers/delegated_renderer_layer_impl.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass_draw_quad.h"
@@ skipping 46 matching lines @@
 }
 
 void DelegatedRendererLayer::PushPropertiesTo(LayerImpl* impl) {
   Layer::PushPropertiesTo(impl);
 
   DelegatedRendererLayerImpl* delegated_impl =
       static_cast<DelegatedRendererLayerImpl*>(impl);
 
   delegated_impl->SetDisplaySize(display_size_);
 
+  delegated_impl->CreateChildIdIfNeeded(
+      base::Bind(&DelegatedRendererLayer::ReceiveUnusedResources, this));

[piman, 2013/09/20 01:55:01]

Layer is only RefCounted, not RefCountedThreadSafe. Also, it would mean we keep
a reference to this layer on the impl thread, which means we might destroy it
there, along with (potentially) its subtree. I suspect a ton of layers won't
like that.

[danakj, 2013/09/20 14:54:52]

Oh, right. I will use a WeakPtrFactory.

[danakj, 2013/09/20 15:39:21]

Ugh thread issues. The right way to do this is to use a Holder class with a
BlockingTaskRunner and a post task. I'll see if I can avoid going all the way to
that for now.

[danakj, 2013/09/20 17:35:12]

Ok done. Used a WeakPtrFactory and a BlockingTaskRunner to ensure the weakptr is
destroyed on the right thread. This allows us to have the Layer destruction
timing unchanged.

+
   if (frame_data_)
     delegated_impl->SetFrameData(frame_data_.Pass(), damage_in_frame_);
   frame_data_.reset();
   damage_in_frame_ = gfx::RectF();
 
-  delegated_impl->CollectUnusedResources(
-      &unused_resources_for_child_compositor_);
-
+  // The ResourceProvider will have the new frame as soon as we push it to the
+  // pending tree. So unused resources will be returned as well.
   if (client_)
     client_->DidCommitFrameData();
 
-  // TODO(danakj): TakeUnusedResourcesForChildCompositor requires a push
-  // properties to happen in order to collect unused resources returned
+  // TODO(danakj): The DidCommitFrameData() notification requires a push
+  // properties to happen in order to notify about unused resources returned
   // from the parent compositor. crbug.com/259090
   needs_push_properties_ = true;
 }
 
 void DelegatedRendererLayer::SetDisplaySize(gfx::Size size) {
   if (display_size_ == size)
     return;
   display_size_ = size;
   SetNeedsCommit();
 }
 
 void DelegatedRendererLayer::SetFrameData(
     scoped_ptr<DelegatedFrameData> new_frame_data) {
+  DCHECK(new_frame_data);
+
   if (frame_data_) {
     // Copy the resources from the last provided frame into the unused resources
     // list, as the new frame will provide its own resources.
     TransferableResource::ReturnResources(
         frame_data_->resource_list,
         &unused_resources_for_child_compositor_);
   }
   frame_data_ = new_frame_data.Pass();
   if (!frame_data_->render_pass_list.empty()) {
     RenderPass* root_pass = frame_data_->render_pass_list.back();
@@ skipping 26 matching lines @@
   // The active frame needs to be replaced and resources returned before the
   // commit is called complete.
   SetNextCommitWaitsForActivation();
 }
 
 void DelegatedRendererLayer::TakeUnusedResourcesForChildCompositor(
     ReturnedResourceArray* array) {
   DCHECK(array->empty());
   array->clear();
 
+  base::AutoLock lock(unused_resources_lock_);
   array->swap(unused_resources_for_child_compositor_);
 }
 
+void DelegatedRendererLayer::ReceiveUnusedResources(
+    const ReturnedResourceArray& unused) {
+  base::AutoLock lock(unused_resources_lock_);
+  unused_resources_for_child_compositor_.insert(
+      unused_resources_for_child_compositor_.end(),
+      unused.begin(),
+      unused.end());
+}
+
 }  // namespace cc