Chromium roll (https://codereview.chromium.org/976353002)

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 <limits>
 #include <vector>
 
@@ skipping 107 matching lines @@
 
   typedef CalcDrawPropsInputs<LayerImpl, LayerImplList> CalcDrawPropsImplInputs;
   typedef CalcDrawPropsInputsForTesting<LayerImpl, LayerImplList>
       CalcDrawPropsImplInputsForTesting;
   static void CalculateDrawProperties(CalcDrawPropsImplInputs* inputs);
 
   template <typename LayerType>
   static bool RenderSurfaceContributesToTarget(LayerType*,
                                                int target_surface_layer_id);
 
-  template <typename LayerType>
-  static void CallFunctionForSubtree(
-      LayerType* root_layer,
-      const base::Callback<void(LayerType* layer)>& function);
+  template <typename LayerType, typename Function>
+  static void CallFunctionForSubtree(LayerType* layer,
+                                     const Function& function);
 
   // Returns a layer with the given id if one exists in the subtree starting
   // from the given root layer (including mask and replica layers).
   template <typename LayerType>
   static LayerType* FindLayerInSubtree(LayerType* root_layer, int layer_id);
 
   static Layer* get_layer_as_raw_ptr(const LayerList& layers, size_t index) {
     return layers[index].get();
   }
 
@@ skipping 56 matching lines @@
     return root_layer->replica_layer();
 
   for (size_t i = 0; i < root_layer->children().size(); ++i) {
     if (LayerType* found = FindLayerInSubtree(
             get_layer_as_raw_ptr(root_layer->children(), i), layer_id))
       return found;
   }
   return NULL;
 }
 
-template <typename LayerType>
-void LayerTreeHostCommon::CallFunctionForSubtree(
-    LayerType* root_layer,
-    const base::Callback<void(LayerType* layer)>& function) {
-  function.Run(root_layer);
+template <typename LayerType, typename Function>
+void LayerTreeHostCommon::CallFunctionForSubtree(LayerType* layer,
+                                                 const Function& function) {
+  function(layer);
 
-  if (LayerType* mask_layer = root_layer->mask_layer())
-    function.Run(mask_layer);
-  if (LayerType* replica_layer = root_layer->replica_layer()) {
-    function.Run(replica_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.Run(mask_layer);
+      function(mask_layer);
   }
 
-  for (size_t i = 0; i < root_layer->children().size(); ++i) {
-    CallFunctionForSubtree(get_layer_as_raw_ptr(root_layer->children(), i),
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    CallFunctionForSubtree(get_layer_as_raw_ptr(layer->children(), i),
                            function);
   }
 }
 
 template <typename LayerType, typename RenderSurfaceLayerListType>
 LayerTreeHostCommon::CalcDrawPropsInputsForTesting<LayerType,
                                                    RenderSurfaceLayerListType>::
     CalcDrawPropsInputsForTesting(
         LayerType* root_layer,
         const gfx::Size& device_viewport_size,
@@ skipping 44 matching lines @@
           true,
           render_surface_layer_list,
           0) {
   DCHECK(root_layer);
   DCHECK(render_surface_layer_list);
 }
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_COMMON_H_