cc : Add subtree is hidden bool to effect tree

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 649 matching lines @@
 }
 
 static inline int NumDescendantsThatDrawContent(Layer* layer) {
   return layer->NumDescendantsThatDrawContent();
 }
 
 static inline int NumDescendantsThatDrawContent(LayerImpl* layer) {
   return layer->test_properties()->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->opacity();
+}
+
+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;
+}
+
 template <typename LayerType>
 bool ShouldCreateRenderSurface(LayerType* layer,
                                gfx::Transform current_transform,
                                bool axis_aligned) {
   const bool preserves_2d_axis_alignment =
       (current_transform * layer->transform()).Preserves2dAxisAlignment() &&
       axis_aligned && layer->AnimationsPreserveAxisAlignment();
   const bool is_root = !layer->parent();
   if (is_root)
     return true;
@@ skipping 55 matching lines @@
 
   // If the layer has some translucency and does not have a preserves-3d
   // transform style.  This condition only needs a render surface if two or more
   // layers in the subtree overlap. But checking layer overlaps is unnecessarily
   // costly so instead we conservatively create a surface whenever at least two
   // layers draw content for this subtree.
   bool at_least_two_layers_in_subtree_draw_content =
       num_descendants_that_draw_content > 0 &&
       (layer->DrawsContent() || num_descendants_that_draw_content > 1);
 
-  if (layer->EffectiveOpacity() != 1.f && ShouldFlattenTransform(layer) &&
+  if (EffectiveOpacity(layer) != 1.f && ShouldFlattenTransform(layer) &&
       at_least_two_layers_in_subtree_draw_content) {
     TRACE_EVENT_INSTANT0(
         "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface opacity",
         TRACE_EVENT_SCOPE_THREAD);
     DCHECK(!is_root);
     return true;
   }
   // If the layer has isolation.
   // TODO(rosca): to be optimized - create separate rendering surface only when
   // the blending descendants might have access to the content behind this layer
@@ skipping 16 matching lines @@
 
   return false;
 }
 
 template <typename LayerType>
 bool AddEffectNodeIfNeeded(
     const DataForRecursion<LayerType>& data_from_ancestor,
     LayerType* layer,
     DataForRecursion<LayerType>* data_for_children) {
   const bool is_root = !layer->parent();
-  const bool has_transparency = layer->EffectiveOpacity() != 1.f;
+  const bool has_transparency = EffectiveOpacity(layer) != 1.f;
   const bool has_animated_opacity = IsAnimatingOpacity(layer);
   const bool should_create_render_surface = ShouldCreateRenderSurface(
       layer, data_from_ancestor.compound_transform_since_render_target,
       data_from_ancestor.axis_align_since_render_target);
   data_for_children->axis_align_since_render_target &=
       layer->AnimationsPreserveAxisAlignment();
 
   bool requires_node = is_root || has_transparency || has_animated_opacity ||
                        should_create_render_surface;
 
   int parent_id = data_from_ancestor.effect_tree_parent;
 
   if (!requires_node) {
     layer->SetEffectTreeIndex(parent_id);
     data_for_children->effect_tree_parent = parent_id;
     data_for_children->compound_transform_since_render_target *=
         layer->transform();
     return false;
   }
 
   EffectNode node;
   node.owner_id = layer->id();
-  node.data.opacity = layer->EffectiveOpacity();
+  node.data.opacity = layer->opacity();
   node.data.has_render_surface = should_create_render_surface;
   node.data.has_copy_request = layer->HasCopyRequest();
   node.data.has_background_filters = !layer->background_filters().IsEmpty();
   node.data.has_animated_opacity = has_animated_opacity;
   node.data.double_sided = DoubleSided(layer);
+  node.data.subtree_hidden = HideLayerAndSubtree(layer);
 
   if (!is_root) {
     // The effect node's transform id is used only when we create a render
     // surface. So, we can leave the default value when we don't create a render
     // surface.
     if (should_create_render_surface) {
       // In this case, we will create a transform node, so it's safe to use the
       // next available id from the transform tree as this effect node's
       // transform id.
       node.data.transform_id =
@@ skipping 423 matching lines @@
   if (SkColorGetA(color) != 255)
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       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);
 }
 
 }  // namespace cc