SubtreeShouldBeSkipped uses information from property trees

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 268 matching lines @@
                                             const TransformTree& tree) {
   return true;
 }
 
 template <typename LayerType>
 static bool HasInvertibleOrAnimatedTransform(LayerType* layer) {
   return layer->transform_is_invertible() ||
          layer->HasPotentiallyRunningTransformAnimation();
 }
 
-static inline bool SubtreeShouldBeSkipped(LayerImpl* layer,
-                                          bool layer_is_drawn,
-                                          const TransformTree& tree) {
+static inline bool LayerShouldBeSkipped(LayerImpl* layer,
+                                        bool layer_is_drawn,
+                                        const TransformTree& transform_tree) {
+  const TransformNode* transform_node =
+      transform_tree.Node(layer->transform_tree_index());
+  const EffectTree& effect_tree = transform_tree.property_trees()->effect_tree;
+  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 (!HasInvertibleOrAnimatedTransform(layer))
+  bool has_inherited_invertible_or_animated_transform =
+      (transform_node->data.is_invertible &&
+       transform_node->data.ancestors_are_invertible) ||
+      transform_node->data.to_screen_is_animated;
+  if (!has_inherited_invertible_or_animated_transform)
     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 (layer->num_copy_requests_in_target_subtree() > 0)
-    return false;
-
-  // We cannot skip the the subtree if a descendant has a touch handler
-  // or the hit testing code will break (it requires fresh transforms, etc).
-  // Though we don't need visible rect for hit testing, we need render surface's
-  // drawable content rect which depends on layer's drawable content rect which
-  // in turn depends on layer's clip rect that is computed while computing
-  // visible rects.
-  if (layer->layer_or_descendant_has_touch_handler())
+  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 (!layer_is_drawn)
+  if (!effect_node->data.is_drawn)
     return true;
 
-  if (layer->render_surface() && !layer->double_sided() &&
-      IsSurfaceBackFaceVisible(layer, tree))
+  if (!layer->double_sided() &&

[ajuma, 2016/03/30 17:10:11]

I think it's the surface's double-sidedness that matters here, not the layer's
(and the surface's double-sidedness is accounted for in the value stored on the
effect node), since the in the old subtree version of this we only considered
the double-sidedness of layers that owned surfaces. Please add a test for this.

[sunxd, 2016/03/31 16:55:57]

I think it would be fine, as property_tree takes the job to verify if an effect
node has a render surface. And in fact, I think we can even move the double
sided check into property tree updates.

+      effect_node->data.node_or_ancestor_has_backface_visible_surface)
     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 (layer->layer_tree_impl()->IsPendingTree() &&
-      layer->HasPotentiallyRunningOpacityAnimation())
+  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 (!layer->background_filters().IsEmpty())
+  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 !layer->EffectiveOpacity();
+  return !effect_node->data.screen_space_opacity;
 }
 
 static inline bool SubtreeShouldBeSkipped(Layer* layer,
                                           bool layer_is_drawn,
                                           const TransformTree& tree) {
   // If the layer transform is not invertible, it should not be drawn.
   if (!layer->transform_is_invertible() &&
       !layer->HasPotentiallyRunningTransformAnimation())
     return true;
 
@@ skipping 21 matching lines @@
   // 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 !layer->EffectiveOpacity() &&
          !layer->HasPotentiallyRunningOpacityAnimation() &&
          !layer->OpacityCanAnimateOnImplThread();
 }
 
 template <typename LayerType>
-static bool LayerShouldBeSkipped(LayerType* layer,
-                                 bool layer_is_drawn,
-                                 const TransformTree& tree) {
+static bool LayerNeedsUpdate(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 true;
+    return false;
 
   if (!layer->DrawsContent() || layer->bounds().IsEmpty())
-    return true;
+    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 true;
+      return false;
   }
 
-  return false;
+  return true;
 }
 
-template <typename LayerType>
-void FindLayersThatNeedUpdates(
-    LayerType* layer,
-    const TransformTree& transform_tree,
-    const EffectTree& effect_tree,
-    typename LayerType::LayerListType* update_layer_list,
-    std::vector<LayerType*>* visible_layer_list) {
+void FindLayersThatNeedUpdates(Layer* layer,
+                               const TransformTree& transform_tree,
+                               const EffectTree& effect_tree,
+                               LayerList* update_layer_list,
+                               std::vector<Layer*>* visible_layer_list) {
   DCHECK_GE(layer->effect_tree_index(), 0);
   bool layer_is_drawn =
       effect_tree.Node(layer->effect_tree_index())->data.is_drawn;
 
   if (layer->parent() &&
       SubtreeShouldBeSkipped(layer, layer_is_drawn, transform_tree))
     return;
 
-  if (!LayerShouldBeSkipped(layer, layer_is_drawn, transform_tree)) {
+  if (LayerNeedsUpdate(layer, layer_is_drawn, transform_tree)) {
     visible_layer_list->push_back(layer);
     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 (LayerType* mask_layer = layer->mask_layer())
+  if (Layer* mask_layer = layer->mask_layer())
     update_layer_list->push_back(mask_layer);
-  if (LayerType* replica_layer = layer->replica_layer()) {
-    if (LayerType* mask_layer = replica_layer->mask_layer())
+  if (Layer* replica_layer = layer->replica_layer()) {
+    if (Layer* mask_layer = replica_layer->mask_layer())
       update_layer_list->push_back(mask_layer);
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     FindLayersThatNeedUpdates(layer->child_at(i), transform_tree, effect_tree,
                               update_layer_list, visible_layer_list);
   }
 }
 
+void FindLayersThatNeedUpdates(LayerImpl* layer,
+                               const TransformTree& transform_tree,
+                               const EffectTree& effect_tree,
+                               LayerImplList* update_layer_list,
+                               std::vector<LayerImpl*>* visible_layer_list) {
+  DCHECK_GE(layer->effect_tree_index(), 0);
+  for (auto* layer_impl : *layer->layer_tree_impl()) {
+    bool layer_is_drawn =
+        effect_tree.Node(layer->effect_tree_index())->data.is_drawn;
+
+    if (layer_impl->parent() &&
+        LayerShouldBeSkipped(layer_impl, layer_is_drawn, transform_tree))
+      continue;
+
+    if (LayerNeedsUpdate(layer_impl, layer_is_drawn, transform_tree)) {
+      visible_layer_list->push_back(layer_impl);
+      update_layer_list->push_back(layer_impl);
+    }
+
+    if (LayerImpl* mask_layer = layer->mask_layer())
+      update_layer_list->push_back(mask_layer);
+    if (LayerImpl* replica_layer = layer->replica_layer()) {
+      if (LayerImpl* mask_layer = replica_layer->mask_layer())
+        update_layer_list->push_back(mask_layer);
+    }
+  }
+}
+
 template <typename LayerType>
 void UpdateRenderSurfaceForLayer(EffectTree* effect_tree,
                                  bool non_root_surfaces_enabled,
                                  LayerType* layer) {
   if (!non_root_surfaces_enabled) {
     layer->SetHasRenderSurface(!layer->parent());
     return;
   }
   EffectNode* node = effect_tree->Node(layer->effect_tree_index());
 
@@ skipping 655 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