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 360 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,
+    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.
-  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;
+  // 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 ||
+         !effect_node->data.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, layer_is_drawn, 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,
+                          bool layer_is_drawn,
+                          const TransformTree& transform_tree,
+                          const EffectTree& effect_tree) {
+  return LayerShouldBeSkippedInternal(layer, layer_is_drawn, 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 =
@@ skipping 183 matching lines @@
     } else if (!can_render_to_separate_surface) {
       node->data.target_id = 1;
     } else if (effect_tree->parent(node)->data.has_render_surface) {
       node->data.target_id = node->parent_id;
     } else {
       node->data.target_id = effect_tree->parent(node)->data.target_id;
     }
   }
 }
 
-void ComputeEffects(EffectTree* effect_tree) {
+bool ComputeEffects(EffectTree* effect_tree) {
   if (!effect_tree->needs_update())
-    return;
-  for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i)
+    return false;
+  bool has_transparent_node_with_animating_opacity = false;
+  for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i) {
     effect_tree->UpdateEffects(i);
+    EffectNode* node = effect_tree->Node(i);
+    has_transparent_node_with_animating_opacity =
+        !node->data.opacity && node->data.has_animated_opacity;
+  }
   effect_tree->set_needs_update(false);
+  return has_transparent_node_with_animating_opacity;
 }
 
 static void ComputeVisibleRectsInternal(
     LayerImpl* root_layer,
     PropertyTrees* property_trees,
     bool can_render_to_separate_surface,
     LayerImplList* update_layer_list,
     std::vector<LayerImpl*>* visible_layer_list) {
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
     property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
     property_trees->transform_tree.set_needs_update(true);
   }
   if (property_trees->transform_tree.needs_update())
     property_trees->clip_tree.set_needs_update(true);
   UpdateRenderTarget(&property_trees->effect_tree,
                      property_trees->non_root_surfaces_enabled);
   ComputeTransforms(&property_trees->transform_tree);
   ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
                can_render_to_separate_surface);
-  ComputeEffects(&property_trees->effect_tree);
+  bool needs_update_again_after_activation =
+      ComputeEffects(&property_trees->effect_tree);
+  if (!property_trees->is_active)
+    property_trees->effect_tree.set_needs_update(
+        needs_update_again_after_activation);

[ajuma, 2016/04/13 19:53:06]

This would also make us update every frame on the main thread, I think? How
about adding this logic to LayerTreeImpl::SetPropertyTrees (and unconditionally
setting needs_update to true for the EffectTree if the LayerTreeImpl is the
active tree)?

[jaydasika, 2016/04/13 20:21:24]

This function is called only on compositor thread.

[ajuma, 2016/04/13 20:34:18]

Ah, ok. But then what about when trees are pushed directly from the main thread
to the active tree? What triggers an update there?

[jaydasika, 2016/04/13 20:53:07]

Ah! I forgot that case. I think its better to do what you suggested(set needs
update in SetPropertyTrees) rather than replicating this logic in one more
place.

 
   FindLayersThatNeedUpdates(
       root_layer->layer_tree_impl(), property_trees->transform_tree,
       property_trees->effect_tree, update_layer_list, visible_layer_list);
   CalculateVisibleRects<LayerImpl>(
       *visible_layer_list, property_trees->clip_tree,
       property_trees->transform_tree, can_render_to_separate_surface);
 }
 
 void UpdateRenderSurfaces(Layer* root_layer, PropertyTrees* property_trees) {
@@ skipping 455 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