cc : Simplify layer skipping logic

cc/trees/draw_property_utils.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/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 264 matching lines @@
 }
 
 static inline bool TransformToScreenIsKnown(LayerImpl* layer,
                                             int transform_tree_index,
                                             const TransformTree& tree) {
   return true;
 }
 
 template <typename LayerType>
 static bool LayerNeedsUpdateInternal(LayerType* layer,
-                                     bool layer_is_drawn,
                                      const TransformTree& tree) {
   // Layers can be skipped if any of these conditions are met.
   //   - is not drawn due to it or one of its ancestors being hidden (or having
   //     no copy requests).
   //   - does not draw content.
   //   - is transparent.
   //   - has empty bounds
   //   - the layer is not double-sided, but its back face is visible.
   //
   // Some additional conditions need to be computed at a later point after the
   // recursion is finished.
   //   - the intersection of render_surface content and layer clip_rect is empty
   //   - the visible_layer_rect is empty
   //
   // Note, if the layer should not have been drawn due to being fully
   // transparent, we would have skipped the entire subtree and never made it
   // into this function, so it is safe to omit this check here.
-  if (!layer_is_drawn)
-    return false;
-
   if (!layer->DrawsContent() || layer->bounds().IsEmpty())
     return false;
 
   // The layer should not be drawn if (1) it is not double-sided and (2) the
   // back of the layer is known to be facing the screen.
   if (layer->should_check_backface_visibility()) {
     int backface_transform_id =
         TransformTreeIndexForBackfaceVisibility(layer, tree);
     // A layer with singular transform is not drawn. So, we can assume that its
     // backface is not visible.
     if (TransformToScreenIsKnown(layer, backface_transform_id, tree) &&
         !HasSingularTransform(backface_transform_id, tree) &&
         IsLayerBackFaceVisible(layer, backface_transform_id, tree))
       return false;
   }
 
   return true;
 }
 
 void FindLayersThatNeedUpdates(LayerTreeImpl* layer_tree_impl,
                                const TransformTree& transform_tree,
                                const EffectTree& effect_tree,
                                LayerImplList* update_layer_list,
                                std::vector<LayerImpl*>* visible_layer_list) {
   for (auto* layer_impl : *layer_tree_impl) {
-    bool layer_is_drawn =
-        effect_tree.Node(layer_impl->effect_tree_index())->data.is_drawn;
-
     if (!IsRootLayer(layer_impl) &&
-        LayerShouldBeSkipped(layer_impl, layer_is_drawn, transform_tree,
-                             effect_tree))
+        LayerShouldBeSkipped(layer_impl, transform_tree, effect_tree))
       continue;
 
-    if (LayerNeedsUpdate(layer_impl, layer_is_drawn, transform_tree)) {
+    if (LayerNeedsUpdate(layer_impl, transform_tree)) {
       visible_layer_list->push_back(layer_impl);
       update_layer_list->push_back(layer_impl);
     }
 
     if (LayerImpl* mask_layer = layer_impl->mask_layer())
       update_layer_list->push_back(mask_layer);
     if (LayerImpl* replica_layer = layer_impl->replica_layer()) {
       if (LayerImpl* mask_layer = replica_layer->mask_layer())
         update_layer_list->push_back(mask_layer);
     }
@@ skipping 21 matching lines @@
                                             Layer* layer) {
   UpdateRenderSurfaceForLayer(effect_tree, true, layer);
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     UpdateRenderSurfacesForLayersRecursive(effect_tree, layer->child_at(i));
   }
 }
 
 }  // namespace
 
-static inline bool LayerShouldBeSkipped(Layer* layer,
-                                        bool layer_is_drawn,
-                                        const TransformTree& transform_tree,
-                                        const EffectTree& effect_tree) {
+template <typename LayerType>
+static inline bool LayerShouldBeSkippedInternal(
+    LayerType* layer,
+    const TransformTree& transform_tree,
+    const EffectTree& effect_tree) {
   const TransformNode* transform_node =
       transform_tree.Node(layer->transform_tree_index());
   const EffectNode* effect_node = effect_tree.Node(layer->effect_tree_index());
 
-  // If the layer transform is not invertible, it should not be drawn.
-  if (!transform_node->data.node_and_ancestors_are_animated_or_invertible)
-    return true;
-
-  // When we need to do a readback/copy of a layer's output, we can not skip
-  // it or any of its ancestors.
-  if (effect_node->data.num_copy_requests_in_subtree > 0)
-    return false;
-
-  // If the layer is not drawn, then skip it and its subtree.
-  if (!effect_node->data.is_drawn)
-    return true;
-
-  if (!transform_node->data.to_screen_is_potentially_animated &&
-      effect_node->data.hidden_by_backface_visibility)
-    return true;
-
-  // If layer has a background filter, don't skip the layer, even it the
-  // opacity is 0.
-  if (effect_node->data.node_or_ancestor_has_background_filters)
-    return false;
-
-  // If the opacity is being animated then the opacity on the main thread is
-  // unreliable (since the impl thread may be using a different opacity), so it
-  // should not be trusted.
-  // In particular, it should not cause the subtree to be skipped.
-  // Similarly, for layers that might animate opacity using an impl-only
-  // animation, their subtree should also not be skipped.
-  return !effect_node->data.screen_space_opacity &&
-         !effect_node->data.to_screen_opacity_is_animated;
+  bool layer_is_drawn = effect_tree.property_trees()->is_active
+                            ? effect_node->data.is_drawn_on_active
+                            : effect_node->data.is_drawn_on_main_and_pending;
+  // If the layer transform is not invertible, it should be skipped.
+  // TODO(ajuma): Correctly process subtrees with singular transform for the
+  // case where we may animate to a non-singular transform and wish to
+  // pre-raster.
+  return !transform_node->data.node_and_ancestors_are_animated_or_invertible ||
+         effect_node->data.hidden_by_backface_visibility || !layer_is_drawn;
 }
 
 bool LayerShouldBeSkipped(LayerImpl* layer,
-                          bool layer_is_drawn,
                           const TransformTree& transform_tree,
                           const EffectTree& effect_tree) {
-  const TransformNode* transform_node =
-      transform_tree.Node(layer->transform_tree_index());
-  const EffectNode* effect_node = effect_tree.Node(layer->effect_tree_index());
-  // If the layer transform is not invertible, it should not be drawn.
-  // TODO(ajuma): Correctly process subtrees with singular transform for the
-  // case where we may animate to a non-singular transform and wish to
-  // pre-raster.
-  if (!transform_node->data.node_and_ancestors_are_animated_or_invertible)
-    return true;
+  return LayerShouldBeSkippedInternal(layer, transform_tree, effect_tree);
+}
 
-  // When we need to do a readback/copy of a layer's output, we can not skip
-  // it or any of its ancestors.
-  if (effect_node->data.num_copy_requests_in_subtree > 0)
-    return false;
-
-  // If the layer is not drawn, then skip it and its subtree.
-  if (!effect_node->data.is_drawn)
-    return true;
-
-  if (effect_node->data.hidden_by_backface_visibility)
-    return true;
-
-  // If layer is on the pending tree and opacity is being animated then
-  // this subtree can't be skipped as we need to create, prioritize and
-  // include tiles for this layer when deciding if tree can be activated.
-  if (!transform_tree.property_trees()->is_active &&
-      effect_node->data.to_screen_opacity_is_animated)
-    return false;
-
-  // If layer has a background filter, don't skip the layer, even it the
-  // opacity is 0.
-  if (effect_node->data.node_or_ancestor_has_background_filters)
-    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 !effect_node->data.screen_space_opacity;
+bool LayerShouldBeSkipped(Layer* layer,
+                          const TransformTree& transform_tree,
+                          const EffectTree& effect_tree) {
+  return LayerShouldBeSkippedInternal(layer, transform_tree, effect_tree);
 }
 
 void FindLayersThatNeedUpdates(LayerTreeHost* layer_tree_host,
                                const TransformTree& transform_tree,
                                const EffectTree& effect_tree,
                                LayerList* update_layer_list) {
   LayerTreeHostCommon::CallFunctionForEveryLayer(
       layer_tree_host,
       [&](Layer* layer) {
-        bool layer_is_drawn =
-            effect_tree.Node(layer->effect_tree_index())->data.is_drawn;
-
         if (!IsRootLayer(layer) &&
-            LayerShouldBeSkipped(layer, layer_is_drawn, transform_tree,
-                                 effect_tree))
+            LayerShouldBeSkipped(layer, transform_tree, effect_tree))
           return;
 
-        if (LayerNeedsUpdate(layer, layer_is_drawn, transform_tree)) {
+        if (LayerNeedsUpdate(layer, transform_tree)) {
           update_layer_list->push_back(layer);
         }
 
         // Append mask layers to the update layer list. They don't have valid
         // visible rects, so need to get added after the above calculation.
         // Replica layers don't need to be updated.
         if (Layer* mask_layer = layer->mask_layer())
           update_layer_list->push_back(mask_layer);
         if (Layer* replica_layer = layer->replica_layer()) {
           if (Layer* mask_layer = replica_layer->mask_layer())
@@ skipping 278 matching lines @@
       ValidateRenderSurfaceForLayer(layer);
 #endif
   }
   LayerImplList update_layer_list;
   ComputeVisibleRectsInternal(root_layer, property_trees,
                               can_render_to_separate_surface,
                               &update_layer_list, visible_layer_list);
 }
 
 bool LayerNeedsUpdate(Layer* layer,
-                      bool layer_is_drawn,
                       const TransformTree& tree) {
-  return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree);
+  return LayerNeedsUpdateInternal(layer, tree);
 }
 
 bool LayerNeedsUpdate(LayerImpl* layer,
-                      bool layer_is_drawn,
                       const TransformTree& tree) {
-  return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree);
+  return LayerNeedsUpdateInternal(layer, tree);
 }
 
 gfx::Transform DrawTransform(const LayerImpl* layer,
                              const TransformTree& tree) {
   const TransformNode* node = tree.Node(layer->transform_tree_index());
   gfx::Transform xform;
   const bool owns_non_root_surface =
       !IsRootLayer(layer) && layer->has_render_surface();
   if (!owns_non_root_surface) {
     // If you're not the root, or you don't own a surface, you need to apply
@@ skipping 360 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc