cc : Stop pushing layers from hidden subtrees at commit

cc/trees/property_tree_builder.cc

 // Copyright 2014 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.
 
 #include "cc/trees/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 644 matching lines @@
         NumLayerOrDescendantsThatDrawContentRecursive(child_layer);
   }
   return num_descendants_that_draw_content;
 }
 
 static inline float EffectiveOpacity(Layer* layer) {
   return layer->EffectiveOpacity();
 }
 
 static inline float EffectiveOpacity(LayerImpl* layer) {
-  return layer->test_properties()->hide_layer_and_subtree
-             ? 0.f
-             : layer->test_properties()->opacity;
+  return layer->test_properties()->opacity;
 }
 
 static inline float Opacity(Layer* layer) {
   return layer->opacity();
 }
 
 static inline float Opacity(LayerImpl* layer) {
   return layer->test_properties()->opacity;
 }
 
@@ skipping 19 matching lines @@
 
 static inline const FilterOperations& BackgroundFilters(LayerImpl* layer) {
   return layer->test_properties()->background_filters;
 }
 
 static inline bool HideLayerAndSubtree(Layer* layer) {
   return layer->hide_layer_and_subtree();
 }
 
 static inline bool HideLayerAndSubtree(LayerImpl* layer) {
-  return layer->test_properties()->hide_layer_and_subtree;
+  return false;
 }
 
 static inline bool AlwaysUseActiveTreeOpacity(Layer* layer) {
   return layer->AlwaysUseActiveTreeOpacity();
 }
 
 static inline bool AlwaysUseActiveTreeOpacity(LayerImpl* layer) {
   return false;
 }
 
@@ skipping 128 matching lines @@
     copy_requests->push_back(std::move(request));
   layer->test_properties()->copy_requests.clear();
 }
 
 static void SetSubtreeHasCopyRequest(Layer* layer,
                                      bool subtree_has_copy_request) {
   layer->SetSubtreeHasCopyRequest(subtree_has_copy_request);
 }
 
 static void SetSubtreeHasCopyRequest(LayerImpl* layer,
-                                     bool subtree_has_copy_request) {
-  layer->test_properties()->subtree_has_copy_request = subtree_has_copy_request;
-}
+                                     bool subtree_has_copy_request) {}
 
 static bool SubtreeHasCopyRequest(Layer* layer) {
   return layer->SubtreeHasCopyRequest();
 }
 
 static bool SubtreeHasCopyRequest(LayerImpl* layer) {
-  return layer->test_properties()->subtree_has_copy_request;
+  return false;
 }
 
 template <typename LayerType>
 bool UpdateSubtreeHasCopyRequestRecursive(LayerType* layer) {
   bool subtree_has_copy_request = false;
   if (HasCopyRequest(layer))
     subtree_has_copy_request = true;
   for (size_t i = 0; i < Children(layer).size(); ++i) {
     LayerType* current_child = ChildAt(layer, i);
     subtree_has_copy_request |=
@@ skipping 256 matching lines @@
 }
 
 static void SetLayerPropertyChangedForChild(Layer* parent, Layer* child) {
   if (parent->subtree_property_changed())
     child->SetSubtreePropertyChanged();
 }
 
 static void SetLayerPropertyChangedForChild(LayerImpl* parent,
                                             LayerImpl* child) {}
 
+static bool SubtreeIsHidden(Layer* layer) {
+  return !SubtreeHasCopyRequest(layer) && layer->parent() &&
+         layer->hide_layer_and_subtree();
+}
+
+static bool SubtreeIsHidden(LayerImpl* layer) {
+  return false;
+}
+
+static void SetIsHidden(Layer* layer, bool is_hidden) {
+  layer->SetIsHidden(is_hidden);
+}
+
+static void SetIsHidden(LayerImpl* layer, bool is_hidden) {}
+
+template <typename LayerType>
+void AddPropertyTreeNodesIfNeeded(
+    LayerType* layer,
+    const DataForRecursion<LayerType>& data_from_parent,
+    DataForRecursion<LayerType>* data_for_children) {
+  DCHECK(!data_for_children->is_hidden);
+  layer->set_property_tree_sequence_number(
+      data_from_parent.property_trees->sequence_number);
+  bool created_render_surface =
+      AddEffectNodeIfNeeded(data_from_parent, layer, data_for_children);
+
+  if (created_render_surface)
+    data_for_children->render_target = data_for_children->effect_tree_parent;
+
+  bool created_transform_node = AddTransformNodeIfNeeded(
+      data_from_parent, layer, created_render_surface, data_for_children);
+  AddClipNodeIfNeeded(data_from_parent, layer, created_transform_node,
+                      data_for_children);
+
+  AddScrollNodeIfNeeded(data_from_parent, layer, data_for_children);
+
+  SetBackfaceVisibilityTransform(layer, created_transform_node);
+  SetSafeOpaqueBackgroundColor(data_from_parent, layer, data_for_children);
+}
+
 template <typename LayerType>
 void BuildPropertyTreesInternal(
     LayerType* layer,
     const DataForRecursion<LayerType>& data_from_parent) {
-  layer->set_property_tree_sequence_number(
-      data_from_parent.property_trees->sequence_number);
-
   DataForRecursion<LayerType> data_for_children(data_from_parent);
 
-  bool created_render_surface =
-      AddEffectNodeIfNeeded(data_from_parent, layer, &data_for_children);
+  data_for_children.is_hidden =
+      data_from_parent.is_hidden || SubtreeIsHidden(layer);
 
-  if (created_render_surface)
-    data_for_children.render_target = data_for_children.effect_tree_parent;
+  SetIsHidden(layer, data_for_children.is_hidden);
 
-  bool created_transform_node = AddTransformNodeIfNeeded(
-      data_from_parent, layer, created_render_surface, &data_for_children);
-  AddClipNodeIfNeeded(data_from_parent, layer, created_transform_node,
-                      &data_for_children);
-
-  AddScrollNodeIfNeeded(data_from_parent, layer, &data_for_children);
-
-  SetBackfaceVisibilityTransform(layer, created_transform_node);
-  SetSafeOpaqueBackgroundColor(data_from_parent, layer, &data_for_children);
+  // We do not create property tree nodes for hidden layers.
+  if (!data_for_children.is_hidden)
+    AddPropertyTreeNodesIfNeeded(layer, data_from_parent, &data_for_children);
 
   for (size_t i = 0; i < Children(layer).size(); ++i) {
     LayerType* current_child = ChildAt(layer, i);
     SetLayerPropertyChangedForChild(layer, current_child);
     if (!ScrollParent(current_child)) {
       BuildPropertyTreesInternal(current_child, data_for_children);
     } else {
       // The child should be included in its scroll parent's list of scroll
       // children.
       DCHECK(ScrollChildren(ScrollParent(current_child))->count(current_child));
     }
   }
 
   if (ScrollChildren(layer)) {
     for (LayerType* scroll_child : *ScrollChildren(layer)) {
       DCHECK_EQ(ScrollParent(scroll_child), layer);
       DCHECK(Parent(scroll_child));
       data_for_children.effect_tree_parent =
           Parent(scroll_child)->effect_tree_index();
       data_for_children.render_target =
           Parent(scroll_child)->effect_tree_index();
       BuildPropertyTreesInternal(scroll_child, data_for_children);
     }
   }
 
-  if (MaskLayer(layer)) {
+  if (!data_for_children.is_hidden && MaskLayer(layer)) {
     MaskLayer(layer)->set_property_tree_sequence_number(
         data_from_parent.property_trees->sequence_number);
     MaskLayer(layer)->set_offset_to_transform_parent(
         layer->offset_to_transform_parent());
     MaskLayer(layer)->SetTransformTreeIndex(layer->transform_tree_index());
     MaskLayer(layer)->SetClipTreeIndex(layer->clip_tree_index());
     MaskLayer(layer)->SetEffectTreeIndex(layer->effect_tree_index());
     MaskLayer(layer)->SetScrollTreeIndex(layer->scroll_tree_index());
   }
 }
@@ skipping 179 matching lines @@
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
   property_trees->effect_tree.CreateOrReuseRenderSurfaces(
       &render_surfaces, root_layer->layer_tree_impl());
   property_trees->ResetCachedData();
 }
 
 }  // namespace cc