Compute if a layer is drawn without LayerTree hierarchy

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 493 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->opacity() != 1.f && layer->should_flatten_transform() &&
+  if (layer->EffectiveOpacity() != 1.f && layer->should_flatten_transform() &&
       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->opacity() != 1.f;
+  const bool has_transparency = layer->EffectiveOpacity() != 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->opacity();
-  node.data.screen_space_opacity = layer->opacity();
+  node.data.opacity = layer->EffectiveOpacity();
   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();
 
   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 =
           data_from_ancestor.transform_tree->next_available_id();
     }
     node.data.clip_id = data_from_ancestor.clip_tree_parent;
 
-    node.data.screen_space_opacity *=
-        data_from_ancestor.effect_tree->Node(parent_id)
-            ->data.screen_space_opacity;
+    EffectNode* parent = data_from_ancestor.effect_tree->Node(parent_id);
+    node.data.screen_space_opacity_is_animating =
+        parent->data.screen_space_opacity_is_animating || has_animated_opacity;
   } else {
     // Root render surface acts the unbounded and untransformed to draw content
     // into. Transform node created from root layer (includes device scale
     // factor) and clip node created from root layer (include viewports) applies
     // to root render surface's content, but not root render surface itself.
     node.data.transform_id = kRootPropertyTreeNodeId;
     node.data.clip_id = kRootPropertyTreeNodeId;
+    node.data.screen_space_opacity_is_animating = has_animated_opacity;
   }
   data_for_children->effect_tree_parent =
       data_for_children->effect_tree->Insert(node, parent_id);
   layer->SetEffectTreeIndex(data_for_children->effect_tree_parent);
   if (should_create_render_surface) {
     data_for_children->compound_transform_since_render_target =
         gfx::Transform();
     data_for_children->axis_align_since_render_target = true;
   }
   return should_create_render_surface;
@@ skipping 19 matching lines @@
     layer->set_draw_blend_mode(SkXfermode::kSrcOver_Mode);
   } else {
     layer->set_draw_blend_mode(layer->blend_mode());
   }
 
   bool created_transform_node = AddTransformNodeIfNeeded(
       data_from_parent, layer, created_render_surface, &data_for_children);
   AddClipNodeIfNeeded(data_from_parent, layer, created_render_surface,
                       created_transform_node, &data_for_children);
 
-  data_for_children.is_hidden =
-      layer->hide_layer_and_subtree() || data_from_parent.is_hidden;
-  layer->set_is_hidden_from_property_trees(data_for_children.is_hidden);
-
   for (size_t i = 0; i < layer->children().size(); ++i) {
     if (!layer->child_at(i)->scroll_parent()) {
       DataForRecursionFromChild<LayerType> data_from_child;
       BuildPropertyTreesInternal(layer->child_at(i), data_for_children,
                                  &data_from_child);
       data_to_parent->Merge(data_from_child);
     } else {
       // The child should be included in its scroll parent's list of scroll
       // children.
       DCHECK(layer->child_at(i)->scroll_parent()->scroll_children()->count(
@@ skipping 95 matching lines @@
   root_clip.data.clip = gfx::RectF(viewport);
   root_clip.data.transform_id = kRootPropertyTreeNodeId;
   data_for_recursion.clip_tree_parent =
       data_for_recursion.clip_tree->Insert(root_clip, kRootPropertyTreeNodeId);
 
   DataForRecursionFromChild<LayerType> data_from_child;
   BuildPropertyTreesInternal(root_layer, data_for_recursion, &data_from_child);
   property_trees->needs_rebuild = false;
 
   // The transform tree is kept up-to-date as it is built, but the
-  // combined_clips stored in the clip tree aren't computed during tree
-  // building.
+  // combined_clips stored in the clip tree and the screen_space_opacity and
+  // is_drawn in the effect tree aren't computed during tree building.
   property_trees->transform_tree.set_needs_update(false);
   property_trees->clip_tree.set_needs_update(true);
-  property_trees->effect_tree.set_needs_update(false);
+  property_trees->effect_tree.set_needs_update(true);
 }
 
 void PropertyTreeBuilder::BuildPropertyTrees(
     Layer* root_layer,
     const Layer* page_scale_layer,
     const Layer* inner_viewport_scroll_layer,
     const Layer* outer_viewport_scroll_layer,
     const Layer* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
@@ skipping 21 matching lines @@
     const gfx::Transform& device_transform,
     PropertyTrees* property_trees) {
   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);
 }
 
 }  // namespace cc