cc: Make CallFunctionForEveryLayer use LayerListIterator

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>
@@ skipping 18 matching lines @@
 namespace proto {
 class ScrollUpdateInfo;
 class ScrollAndScaleSet;
 }
 
 class LayerImpl;
 class Layer;
 class SwapPromise;
 class PropertyTrees;
 
-enum CallFunctionLayerType : uint32_t {
-  BASIC_LAYER = 0,
-  MASK_LAYER = 1,
-  REPLICA_LAYER = 2,
-  ALL_LAYERS = MASK_LAYER | REPLICA_LAYER
-};
-
 class CC_EXPORT LayerTreeHostCommon {
  public:
   struct CC_EXPORT CalcDrawPropsMainInputsForTesting {
    public:
     CalcDrawPropsMainInputsForTesting(Layer* root_layer,
                                       const gfx::Size& device_viewport_size,
                                       const gfx::Transform& device_transform,
                                       float device_scale_factor,
                                       float page_scale_factor,
                                       const Layer* page_scale_layer,
@@ skipping 75 matching lines @@
   static void PreCalculateMetaInformation(Layer* root_layer);
   static void PreCalculateMetaInformationForTesting(LayerImpl* root_layer);
   static void PreCalculateMetaInformationForTesting(Layer* root_layer);
 
   static void CalculateDrawProperties(CalcDrawPropsImplInputs* inputs);
   static void CalculateDrawProperties(
       CalcDrawPropsImplInputsForTesting* inputs);
 
   template <typename Function>
   static void CallFunctionForEveryLayer(LayerTreeHost* layer,
-                                        const Function& function,
-                                        const CallFunctionLayerType& type);
+                                        const Function& function);
 
   template <typename Function>
   static void CallFunctionForEveryLayer(LayerTreeImpl* layer,
-                                        const Function& function,
-                                        const CallFunctionLayerType& type);
+                                        const Function& function);
 
   struct CC_EXPORT ScrollUpdateInfo {
     int layer_id;
     // TODO(miletus): Use ScrollOffset once LayerTreeHost/Blink fully supports
     // franctional scroll offset.
     gfx::Vector2d scroll_delta;
 
     bool operator==(const ScrollUpdateInfo& other) const;
 
     void ToProtobuf(proto::ScrollUpdateInfo* proto) const;
@@ skipping 13 matching lines @@
 
   bool EqualsForTesting(const ScrollAndScaleSet& other) const;
   void ToProtobuf(proto::ScrollAndScaleSet* proto) const;
   void FromProtobuf(const proto::ScrollAndScaleSet& proto);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScrollAndScaleSet);
 };
 
 template <typename LayerType, typename Function>
-static void CallFunctionForLayer(LayerType* layer,
-                                 const Function& function,
-                                 const CallFunctionLayerType& type) {
+static void CallFunctionForLayer(LayerType* layer, const Function& function) {
   function(layer);
 
-  LayerType* mask_layer = layer->mask_layer();
-  if ((type & CallFunctionLayerType::MASK_LAYER) && mask_layer)
+  if (LayerType* mask_layer = layer->mask_layer())
     function(mask_layer);
-  LayerType* replica_layer = layer->replica_layer();
-  if ((type & CallFunctionLayerType::REPLICA_LAYER) && replica_layer) {
+  if (LayerType* replica_layer = layer->replica_layer()) {
     function(replica_layer);
-    mask_layer = replica_layer->mask_layer();
-    if ((type & CallFunctionLayerType::MASK_LAYER) && mask_layer)
+    if (LayerType* mask_layer = replica_layer->mask_layer())
       function(mask_layer);
   }
 }
 
 template <typename Function>
-static void CallFunctionForEveryLayerInternal(
-    Layer* layer,
-    const Function& function,
-    const CallFunctionLayerType& type) {
-  CallFunctionForLayer(layer, function, type);
-
-  for (size_t i = 0; i < layer->children().size(); ++i) {
-    CallFunctionForEveryLayerInternal(layer->children()[i].get(), function,
-                                      type);
-  }
+void LayerTreeHostCommon::CallFunctionForEveryLayer(LayerTreeHost* host,
+                                                    const Function& function) {
+  for (auto* layer : *host)
+    CallFunctionForLayer(layer, function);
 }
 
 template <typename Function>
-void LayerTreeHostCommon::CallFunctionForEveryLayer(
-    LayerTreeHost* host,
-    const Function& function,
-    const CallFunctionLayerType& type) {
-  CallFunctionForEveryLayerInternal(host->root_layer(), function, type);
-}
-
-template <typename Function>
-void LayerTreeHostCommon::CallFunctionForEveryLayer(
-    LayerTreeImpl* host_impl,
-    const Function& function,
-    const CallFunctionLayerType& type) {
+void LayerTreeHostCommon::CallFunctionForEveryLayer(LayerTreeImpl* host_impl,
+                                                    const Function& function) {
   for (auto* layer : *host_impl)
-    CallFunctionForLayer(layer, function, type);
+    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_