cc: Remove DrawQuad::IterateResoruces

cc/layers/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/layers/delegated_renderer_layer_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 
 bool DelegatedRendererLayerImpl::HasDelegatedContent() const { return true; }
 
 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.
   return render_passes_in_draw_order_.size() > 1;
 }
 
-static ResourceId ResourceRemapHelper(
-    bool* invalid_frame,
-    const ResourceProvider::ResourceIdMap& child_to_parent_map,
-    ResourceProvider::ResourceIdSet* resources_in_frame,
-    ResourceId id) {
-  ResourceProvider::ResourceIdMap::const_iterator it =
-      child_to_parent_map.find(id);
-  if (it == child_to_parent_map.end()) {
-    *invalid_frame = true;
-    return 0;
-  }
-
-  DCHECK_EQ(it->first, id);
-  ResourceId remapped_id = it->second;
-  resources_in_frame->insert(id);
-  return remapped_id;
-}
-
 void DelegatedRendererLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   LayerImpl::PushPropertiesTo(layer);
 
   DelegatedRendererLayerImpl* delegated_layer =
       static_cast<DelegatedRendererLayerImpl*>(layer);
 
   // If we have a new child_id to give to the active layer, it should
   // have already deleted its old child_id.
   DCHECK(delegated_layer->child_id_ == 0 ||
          delegated_layer->child_id_ == child_id_);
@@ skipping 52 matching lines @@
 #if defined(COMPILER_MSVC)
   resources_in_frame.reserve(reserve_size);
 #elif defined(COMPILER_GCC)
   // Pre-standard hash-tables only implement resize, which behaves similarly
   // to reserve for these keys. Resizing to 0 may also be broken (particularly
   // on stlport).
   // TODO(jbauman): Replace with reserve when C++11 is supported everywhere.
   if (reserve_size)
     resources_in_frame.resize(reserve_size);
 #endif
-  DrawQuad::ResourceIteratorCallback remap_resources_to_parent_callback =
-      base::Bind(&ResourceRemapHelper,
-                 &invalid_frame,
-                 resource_map,
-                 &resources_in_frame);
   for (const auto& pass : render_pass_list) {
-    for (const auto& quad : pass->quad_list)
-      quad->IterateResources(remap_resources_to_parent_callback);
+    for (const auto& quad : pass->quad_list) {
+      for (ResourceId& resource_id : quad->resources) {
+        ResourceProvider::ResourceIdMap::const_iterator it =
+            resource_map.find(resource_id);
+        if (it == resource_map.end()) {
+          invalid_frame = true;
+          resource_id = 0;
+          continue;

[piman, 2015/05/28 19:35:46]

You can break here actually.

[vmpstr, 2015/05/28 22:36:58]

Done. Should resource_id be set to 0 here? It's inconsistent with
cc/surfaces/surface_aggregator.cc and it makes more sense to leave the id
untouched to me, but I'm a bit unsure if that value being reset to 0 is
important here.

+        }
+
+        DCHECK_EQ(it->first, resource_id);
+        ResourceId remapped_id = it->second;
+        resources_in_frame.insert(resource_id);
+        resource_id = remapped_id;
+      }
+    }
   }
 
   if (invalid_frame) {
     // Declare we are still using the last frame's resources. Drops ownership of
     // any invalid resources, keeping only those in use by the active tree.
     resource_provider->DeclareUsedResourcesFromChild(child_id_, resources_);
     return;
   }
 
   // Save the new frame's resources, but don't give them to the ResourceProvider
@@ skipping 371 matching lines @@
   if (own_child_id_) {
     ResourceProvider* provider = layer_tree_impl()->resource_provider();
     provider->DestroyChild(child_id_);
   }
 
   resources_.clear();
   child_id_ = 0;
 }
 
 }  // namespace cc