cc: DelegatedRendererLayer creates a ChildId with the ResourceProvider

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 "cc/append_quads_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 {
 
 DelegatedRendererLayerImpl::DelegatedRendererLayerImpl(
     LayerTreeImpl* tree_impl, int id)
-    : LayerImpl(tree_impl, id) {
+    : LayerImpl(tree_impl, id),
+      child_id_(0) {
 }
 
 DelegatedRendererLayerImpl::~DelegatedRendererLayerImpl() {
   ClearRenderPasses();
+  ClearChildId();
 }
 
 bool DelegatedRendererLayerImpl::hasDelegatedContent() const {
   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.
@@ skipping 21 matching lines @@
   if (!render_passes_in_draw_order_.empty())
     render_passes_in_draw_order_.back()->damage_rect.Union(old_root_damage);
 }
 
 void DelegatedRendererLayerImpl::ClearRenderPasses() {
   // FIXME: Release the resources back to the nested compositor.
   render_passes_index_by_id_.clear();
   render_passes_in_draw_order_.clear();
 }
 
-scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::createLayerImpl(LayerTreeImpl* treeImpl)
-{
-    return DelegatedRendererLayerImpl::create(treeImpl, id()).PassAs<LayerImpl>();
+scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::createLayerImpl(
+    LayerTreeImpl* treeImpl) {
+  return DelegatedRendererLayerImpl::create(treeImpl, id()).PassAs<LayerImpl>();
 }
 
 void DelegatedRendererLayerImpl::didLoseOutputSurface() {
   ClearRenderPasses();
+  ClearChildId();
 }
 
 static inline int IndexToId(int index) { return index + 1; }
 static inline int IdToIndex(int id) { return id - 1; }
 
 RenderPass::Id DelegatedRendererLayerImpl::firstContributingRenderPassId()
     const {
   return RenderPass::Id(id(), IndexToId(0));
 }
 
@@ skipping 141 matching lines @@
     DCHECK(output_quad.get());
 
     quad_sink->append(output_quad.Pass(), *append_quads_data);
   }
 }
 
 const char* DelegatedRendererLayerImpl::layerTypeAsString() const {
   return "DelegatedRendererLayer";
 }
 
+void DelegatedRendererLayerImpl::CreateChildIdIfNeeded() {
+  if (child_id_)
+    return;
+
+  ResourceProvider* resource_provider = layerTreeImpl()->resource_provider();
+  child_id_ = resource_provider->createChild();
+}
+
+void DelegatedRendererLayerImpl::ClearChildId() {
+  if (!child_id_)
+    return;
+
+  ResourceProvider* resource_provider = layerTreeImpl()->resource_provider();
+  resource_provider->destroyChild(child_id_);
+  child_id_ = 0;
+}
+
 }  // namespace cc