cc: Main thread skip single layers instead of subtrees

cc/trees/layer_tree_host_common.h

Index: cc/trees/layer_tree_host_common.h
diff --git a/cc/trees/layer_tree_host_common.h b/cc/trees/layer_tree_host_common.h
index 892521cd4bd9dee71f19736091fcdefa25ebbbe5..fa1e6005279c0570a489e18b0b2d8e514aaf9a95 100644
--- a/cc/trees/layer_tree_host_common.h
+++ b/cc/trees/layer_tree_host_common.h
@@ -36,6 +36,13 @@ 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,
@@ -139,11 +146,13 @@ class CC_EXPORT LayerTreeHostCommon {
 
   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();
@@ -203,39 +212,51 @@ bool LayerTreeHostCommon::RenderSurfaceContributesToTarget(
 }
 
 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);