cc : Make CallFunctionForSubtree on impl use layer iterator

cc/trees/layer_tree_host_common.h

 // Copyright 2011 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.
 
 #ifndef CC_TREES_LAYER_TREE_HOST_COMMON_H_
 #define CC_TREES_LAYER_TREE_HOST_COMMON_H_
 
 #include <stddef.h>
 
 #include <limits>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "cc/base/cc_export.h"
+#include "cc/layers/layer.h"
 #include "cc/layers/layer_collections.h"
+#include "cc/layers/layer_impl.h"
+#include "cc/trees/layer_tree_host.h"
+#include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 namespace proto {
 class ScrollUpdateInfo;
 class ScrollAndScaleSet;
@@ skipping 97 matching lines @@
   static void PreCalculateMetaInformationForTesting(Layer* root_layer);
 
   static void CalculateDrawProperties(CalcDrawPropsImplInputs* inputs);
   static void CalculateDrawProperties(
       CalcDrawPropsImplInputsForTesting* inputs);
 
   template <typename LayerType>
   static bool RenderSurfaceContributesToTarget(LayerType*,
                                                int target_surface_layer_id);
 
-  template <typename LayerType, typename Function>
-  static void CallFunctionForSubtree(LayerType* layer,
-                                     const Function& function);
+  template <typename Function>
+  static void CallFunctionForEveryLayer(LayerTreeHost* layer,
+                                        const Function& function);
+
+  template <typename Function>
+  static void CallFunctionForEveryLayer(LayerTreeImpl* layer,
+                                        const Function& function);
 
   static Layer* get_layer_as_raw_ptr(const LayerList& layers, size_t index) {
     return layers[index].get();
   }
 
   static LayerImpl* get_layer_as_raw_ptr(const LayerImplList& layers,
                                          size_t index) {
     return layers[index];
   }
 
@@ skipping 39 matching lines @@
   //      surface, and
   //  (2) The layer's render surface is not the same as the target surface.
   //
   // Otherwise, the layer just contributes itself to the target surface.
 
   return layer->render_target() == layer &&
          layer->id() != target_surface_layer_id;
 }
 
 template <typename LayerType, typename Function>
-void LayerTreeHostCommon::CallFunctionForSubtree(LayerType* layer,
-                                                 const Function& function) {
+static void CallFunctionForLayer(LayerType* layer, const Function& function) {
   function(layer);
 
   if (LayerType* mask_layer = layer->mask_layer())
     function(mask_layer);
   if (LayerType* replica_layer = layer->replica_layer()) {
     function(replica_layer);
     if (LayerType* mask_layer = replica_layer->mask_layer())
       function(mask_layer);
   }
+}
+
+template <typename Function>
+static void CallFunctionForEveryLayerInternal(Layer* layer,
+                                              const Function& function) {
+  CallFunctionForLayer(layer, function);
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
-    CallFunctionForSubtree(get_layer_as_raw_ptr(layer->children(), i),
-                           function);
+    CallFunctionForEveryLayerInternal(layer->children()[i].get(), function);
   }
 }
 
+template <typename Function>
+void LayerTreeHostCommon::CallFunctionForEveryLayer(LayerTreeHost* host,
+                                                    const Function& function) {
+  CallFunctionForEveryLayerInternal(host->root_layer(), function);
+}
+
+template <typename Function>
+void LayerTreeHostCommon::CallFunctionForEveryLayer(LayerTreeImpl* host_impl,
+                                                    const Function& function) {
+  for (auto* layer : *host_impl)
+    CallFunctionForLayer(layer, function);
+}
+
 CC_EXPORT PropertyTrees* GetPropertyTrees(Layer* layer);
 CC_EXPORT PropertyTrees* GetPropertyTrees(LayerImpl* layer);
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_COMMON_H_