cc: Main thread skip single layers instead of subtrees

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:
   static gfx::Rect CalculateVisibleRect(const gfx::Rect& target_surface_rect,
                                         const gfx::Rect& layer_bound_rect,
                                         const gfx::Transform& transform);
 
   struct CC_EXPORT CalcDrawPropsMainInputsForTesting {
    public:
     CalcDrawPropsMainInputsForTesting(Layer* root_layer,
                                       const gfx::Size& device_viewport_size,
@@ skipping 83 matching lines @@
   static void CalculateDrawProperties(CalcDrawPropsImplInputs* inputs);
   static void CalculateDrawProperties(
       CalcDrawPropsImplInputsForTesting* inputs);
 
   template <typename LayerType>
   static bool RenderSurfaceContributesToTarget(LayerType*,
                                                int target_surface_layer_id);
 
   template <typename Function>
   static void CallFunctionForEveryLayer(LayerTreeHost* layer,
-                                        const Function& function);
+                                        const Function& function,
+                                        const CallFunctionLayerType& type);
 
   template <typename Function>
   static void CallFunctionForEveryLayer(LayerTreeImpl* layer,
-                                        const Function& function);
+                                        const Function& function,
+                                        const CallFunctionLayerType& type);
 
   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>
-static void CallFunctionForLayer(LayerType* layer, const Function& function) {
+static void CallFunctionForLayer(LayerType* layer,
+                                 const Function& function,
+                                 const CallFunctionLayerType& type) {

[Ian Vollick, 2016/04/06 19:42:26]

This CallFunctionForLayer stuff seems reasonable (it's what we have today), but
if we had an iterator, couldn't we use std::for_each with an early out? (I don't
feel strongly about this).

[sunxd, 2016/04/07 15:37:13]

I think we can, but at some time when layer list is behind the flag, we still
have to support tree structure, this function can be a wrapper: for Layer it
uses tree hierarchy, for LayerImpl it uses for_each (line 258).

[Ian Vollick, 2016/04/07 17:20:25]

Well, the iterator is meant to be the wrapper that hides the actual
layer/layerimpl data structure.

Say we wrote a cc::Layer iterator and updated LayerTreeHost in the same way that
we updated LayerTreeImpl. (We'd also have to teach the iterator to visit mask
and replica layers).

Every call to CallFunctionForEveryLayer(LayerTreeImpl* lti, const Function& f)
could be replaced with

for (auto* layer : *host_impl)
  f(layer);

And the LayerTreeHost analog would look about the same

for (auto* layer : *host)
  f(layer);

And we wouldn't always need a function f, we could just do the work on layer in
the body of the for loop. Bottom line: once we have iterators
CallFunctionForEveryLayer isn't as useful a utility function as it once was.

This would mean updating all the call sites, but you're doing that anyhow by
adding the type param, so the churn should be similar.

   function(layer);
 
-  if (LayerType* mask_layer = layer->mask_layer())
+  LayerType* mask_layer = layer->mask_layer();
+  if ((type & CallFunctionLayerType::MASK_LAYER) && mask_layer)
     function(mask_layer);
-  if (LayerType* replica_layer = layer->replica_layer()) {
+  LayerType* replica_layer = layer->replica_layer();
+  if ((type & CallFunctionLayerType::REPLICA_LAYER) && replica_layer) {
     function(replica_layer);
-    if (LayerType* mask_layer = replica_layer->mask_layer())
+    mask_layer = replica_layer->mask_layer();
+    if ((type & CallFunctionLayerType::MASK_LAYER) && mask_layer)
       function(mask_layer);
   }
 }
 
 template <typename Function>
-static void CallFunctionForEveryLayerInternal(Layer* layer,
-                                              const Function& function) {
-  CallFunctionForLayer(layer, 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);
+    CallFunctionForEveryLayerInternal(layer->children()[i].get(), function,
+                                      type);
   }
 }
 
 template <typename Function>
-void LayerTreeHostCommon::CallFunctionForEveryLayer(LayerTreeHost* host,
-                                                    const Function& function) {
-  CallFunctionForEveryLayerInternal(host->root_layer(), 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) {
+void LayerTreeHostCommon::CallFunctionForEveryLayer(
+    LayerTreeImpl* host_impl,
+    const Function& function,
+    const CallFunctionLayerType& type) {
   for (auto* layer : *host_impl)
-    CallFunctionForLayer(layer, function);
+    CallFunctionForLayer(layer, function, type);
 }
 
 CC_EXPORT PropertyTrees* GetPropertyTrees(Layer* layer);
 CC_EXPORT PropertyTrees* GetPropertyTrees(LayerImpl* layer);
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_COMMON_H_