cc :: Reland compute if layer is drawn from property trees

cc/trees/layer_tree_host_common.cc

 // 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.
 
 #include "cc/trees/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 650 matching lines @@
     return false;
 
   // If layer has a background filter, don't skip the layer, even it the
   // opacity is 0.
   if (!layer->background_filters().IsEmpty())
     return false;
 
   // The opacity of a layer always applies to its children (either implicitly
   // via a render surface or explicitly if the parent preserves 3D), so the
   // entire subtree can be skipped if this layer is fully transparent.
-  return !layer->opacity();
+  return !layer->EffectiveOpacity();
 }
 
 static inline void SavePaintPropertiesLayer(LayerImpl* layer) {}
 
 // This function returns a translation matrix that can be applied on a vector
 // that's in the layer's target surface coordinate, while the position offset is
 // specified in some ancestor layer's coordinate.
 gfx::Transform ComputeSizeDeltaCompensation(
     LayerImpl* layer,
     LayerImpl* container,
@@ skipping 826 matching lines @@
       data_from_ancestor.in_subtree_of_page_scale_layer;
   data_for_children.subtree_can_use_lcd_text =
       data_from_ancestor.subtree_can_use_lcd_text;
 
   // Layers that are marked as hidden will hide themselves and their subtree.
   // Exception: Layers with copy requests, whether hidden or not, must be drawn
   // anyway.  In this case, we will inform their subtree they are visible to get
   // the right results.
   const bool layer_is_visible =
       data_from_ancestor.subtree_is_visible_from_ancestor &&
-      !layer->hide_layer_and_subtree();
+      layer->EffectiveOpacity() != 0;
   const bool layer_is_drawn = layer_is_visible || layer->HasCopyRequest();
 
   // The root layer cannot skip CalcDrawProperties.
   if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) {
     return;
   }
 
   // We need to circumvent the normal recursive flow of information for clip
   // children (they don't inherit their direct ancestor's clip information).
   // This is unfortunate, and would be unnecessary if we were to formally
@@ skipping 791 matching lines @@
                                      inputs->can_use_lcd_text);
   }
 }
 
 enum PropertyTreeOption {
   BUILD_PROPERTY_TREES_IF_NEEDED,
   DONT_BUILD_PROPERTY_TREES
 };
 
 void CalculateRenderTargetInternal(LayerImpl* layer,
+                                   PropertyTrees* property_trees,
                                    bool subtree_visible_from_ancestor,
-                                   bool can_render_to_separate_surface) {
-  const bool layer_is_visible =
-      subtree_visible_from_ancestor && !layer->hide_layer_and_subtree();
-  const bool layer_is_drawn = layer_is_visible || layer->HasCopyRequest();
+                                   bool can_render_to_separate_surface,
+                                   bool use_property_trees) {
+  bool layer_is_drawn;
+  if (use_property_trees) {
+    DCHECK_GE(layer->effect_tree_index(), 0);
+    layer_is_drawn =
+        property_trees->effect_tree.Node(layer->effect_tree_index())
+            ->data.is_drawn;
+  } else {
+    layer_is_drawn =
+        (subtree_visible_from_ancestor && layer->EffectiveOpacity() != 0) ||
+        layer->HasCopyRequest();
+  }
 
   // The root layer cannot be skipped.
   if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) {
     layer->draw_properties().render_target = nullptr;
     return;
   }
 
   bool render_to_separate_surface =
       IsRootLayer(layer) ||
       (can_render_to_separate_surface && layer->render_surface());
@@ skipping 12 matching lines @@
           layer;
 
   } else {
     DCHECK(layer->parent());
     layer->draw_properties().render_target = layer->parent()->render_target();
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     CalculateRenderTargetInternal(
         LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i),
-        layer_is_drawn, can_render_to_separate_surface);
+        property_trees, layer_is_drawn, can_render_to_separate_surface,
+        use_property_trees);
   }
 }
 
 void CalculateRenderSurfaceLayerListInternal(
     LayerImpl* layer,
     PropertyTrees* property_trees,
     LayerImplList* render_surface_layer_list,
     LayerImplList* descendants,
     RenderSurfaceImpl* nearest_occlusion_immune_ancestor,
     bool subtree_visible_from_ancestor,
@@ skipping 10 matching lines @@
   // |render_surface_layer_list| is the top level RenderSurfaceLayerList.
 
   // |descendants| is used to determine what's in current layer's render
   // surface's layer list.
 
   // |subtree_visible_from_ancestor| is set during recursion to affect current
   // layer's subtree.
 
   // |can_render_to_separate_surface| and |current_render_surface_layer_list_id|
   // are settings that should stay the same during recursion.
-
-  // Layers that are marked as hidden will hide themselves and their subtree.
-  // Exception: Layers with copy requests, whether hidden or not, must be drawn
-  // anyway.  In this case, we will inform their subtree they are visible to get
-  // the right results.
-  const bool layer_is_visible =
-      subtree_visible_from_ancestor && !layer->hide_layer_and_subtree();
-  const bool layer_is_drawn = layer_is_visible || layer->HasCopyRequest();
+  bool layer_is_drawn = false;
+  if (use_property_trees) {
+    DCHECK_GE(layer->effect_tree_index(), 0);
+    layer_is_drawn =
+        property_trees->effect_tree.Node(layer->effect_tree_index())
+            ->data.is_drawn;
+  } else {
+    layer_is_drawn =
+        (subtree_visible_from_ancestor && layer->EffectiveOpacity() != 0) ||
+        layer->HasCopyRequest();
+  }
 
   // The root layer cannot be skipped.
   if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) {
     if (layer->render_surface())
       layer->ClearRenderSurfaceLayerList();
     layer->draw_properties().render_target = nullptr;
     return;
   }
 
   bool render_to_separate_surface =
@@ skipping 28 matching lines @@
       layer->ClearRenderSurfaceLayerList();
       layer->draw_properties().render_target = nullptr;
       return;
     }
 
     if (IsRootLayer(layer)) {
       // The root surface does not contribute to any other surface, it has no
       // target.
       layer->render_surface()->set_contributes_to_drawn_surface(false);
     } else {
-      // Even if the |layer_is_drawn|, it only contributes to a drawn surface
-      // when the |layer_is_visible|.
+      bool contributes_to_drawn_surface =
+          use_property_trees
+              ? property_trees->effect_tree.ContributesToDrawnSurface(
+                    layer->effect_tree_index())
+              : subtree_visible_from_ancestor &&
+                    layer->EffectiveOpacity() != 0.f;
       layer->render_surface()->set_contributes_to_drawn_surface(
-          layer_is_visible);
+          contributes_to_drawn_surface);
     }
 
     // Ignore occlusion from outside the surface when surface contents need to
     // be fully drawn. Layers with copy-request need to be complete.
     // We could be smarter about layers with replica and exclude regions
     // where both layer and the replica are occluded, but this seems like an
     // overkill. The same is true for layers with filters that move pixels.
     // TODO(senorblanco): make this smarter for the SkImageFilter case (check
     // for pixel-moving filters)
     if (layer->HasCopyRequest() || layer->has_replica() ||
@@ skipping 144 matching lines @@
 
   if (layer->HasContributingDelegatedRenderPasses()) {
     layer->render_target()
         ->render_surface()
         ->AddContributingDelegatedRenderPassLayer(layer);
   }
 }
 
 void CalculateRenderTarget(
     LayerTreeHostCommon::CalcDrawPropsImplInputs* inputs) {
-  CalculateRenderTargetInternal(inputs->root_layer, true,
-                                inputs->can_render_to_separate_surface);
+  CalculateRenderTargetInternal(
+      inputs->root_layer, inputs->property_trees, true,
+      inputs->can_render_to_separate_surface,
+      inputs->verify_property_trees || inputs->use_property_trees);
 }
 
 void CalculateRenderSurfaceLayerList(
     LayerTreeHostCommon::CalcDrawPropsImplInputs* inputs) {
   const bool subtree_visible_from_ancestor = true;
   DCHECK_EQ(
       inputs->current_render_surface_layer_list_id,
       inputs->root_layer->layer_tree_impl()->current_render_surface_list_id());
   CalculateRenderSurfaceLayerListInternal(
       inputs->root_layer, inputs->property_trees,
@@ skipping 199 matching lines @@
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc