Compute if a layer is drawn without LayerTree hierarchy

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 1452 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->opacity() != 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 792 matching lines @@
   }
 }
 
 enum PropertyTreeOption {
   BUILD_PROPERTY_TREES_IF_NEEDED,
   DONT_BUILD_PROPERTY_TREES
 };
 
 void CalculateRenderTargetInternal(LayerImpl* layer,
                                    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) {
+    layer_is_drawn = layer->IsDrawnFromPropertyTrees();
+  } else {
+    layer_is_drawn = (subtree_visible_from_ancestor && layer->opacity() != 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);
+        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;
+  if (use_property_trees) {
+    layer_is_drawn = layer->IsDrawnFromPropertyTrees();
+  } else {
+    layer_is_drawn = (subtree_visible_from_ancestor && layer->opacity() != 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 =
       IsRootLayer(layer) ||
       (can_render_to_separate_surface && layer->render_surface());
 
   if (render_to_separate_surface) {
     DCHECK(layer->render_surface());
 
+    bool contributes_to_drawn_surface;
     if (use_property_trees) {
       RenderSurfaceDrawProperties draw_properties;
       ComputeSurfaceDrawPropertiesUsingPropertyTrees(
           layer->render_surface(), property_trees, &draw_properties);
       // TODO(ajuma): Once property tree verification is removed, make the above
       // call directly set the surface's properties, so that the copying below
       // is no longer needed.
       layer->render_surface()->SetIsClipped(draw_properties.is_clipped);
       layer->render_surface()->SetDrawOpacity(draw_properties.draw_opacity);
       layer->render_surface()->SetDrawTransform(draw_properties.draw_transform);
       layer->render_surface()->SetScreenSpaceTransform(
           draw_properties.screen_space_transform);
       layer->render_surface()->SetReplicaDrawTransform(
           draw_properties.replica_draw_transform);
       layer->render_surface()->SetReplicaScreenSpaceTransform(
           draw_properties.replica_screen_space_transform);
       layer->render_surface()->SetClipRect(draw_properties.clip_rect);
+      // All drawn layers contribute to drawn surface.
+      // Exception : Layers that are hidden and are drawn only for the sake of
+      // copy requests.
+      contributes_to_drawn_surface =
+          layer_is_drawn && !(layer->IsHidden() && layer->HasCopyRequest());

[ajuma, 2016/01/15 15:02:46]

This seems almost equivalent to:
layer_is_drawn && !layer->IsHidden()

except the latter says hidden layers with background filters don't contribute to
a drawn surface and the former says they do unless the have a copy request? Do
background filters currently affect whether a layer contributes to a drawn
surface?

[jaydasika, 2016/01/15 18:23:05]

Is we have R->R1->R2, render surfaces R1 and R2 are hidden and R1 has copy
request, R1, R2 are drawn, only R2 should contribute to drawn surface (as its
target is R1 and it should contribute), R1 shouldn't (as its target is R and it
shouldn't contribute). So, layer_is_drawn && !layer->IsHidden() won't work for
this case.   

[ajuma, 2016/01/15 18:48:16]

Hmm, true. layer_is_drawn (roughly, ignoring background filters and animations
which I don't think the current code uses here) amounts to "effect node has
screen space opacity non-0 or contributes to copy request". layer->IsHidden() is
"effect node has screen space opacity 0". So contributes_to_drawn_surface
amounts to "effect node has screen space opacity non-0 or contributes to copy
request, and either the effect node has screen space opacity non-0 or the layer
doesn't have a copy request". That's pretty confusing :)  Could this be made
simpler or clearer somehow?

+    } else {
+      contributes_to_drawn_surface =
+          subtree_visible_from_ancestor && layer->opacity() != 0.f;
     }
 
     if (!layer->double_sided() &&
         IsSurfaceBackFaceVisible(layer,
                                  layer->render_surface()->draw_transform())) {
       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|.
       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, 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 193 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