cc :: Reland compute if layer is drawn 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 326 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 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 15 matching lines @@
   // opacity is 0.
   if (!layer->background_filters().IsEmpty())
     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 !layer->opacity() && !layer->HasPotentiallyRunningOpacityAnimation() &&
+  return !layer->EffectiveOpacity() &&
+         !layer->HasPotentiallyRunningOpacityAnimation() &&
          !layer->OpacityCanAnimateOnImplThread();
 }
 
 template <typename LayerType>
 static bool LayerShouldBeSkipped(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).
@@ skipping 29 matching lines @@
       TransformToScreenIsKnown(backface_test_layer, tree) &&
       IsLayerBackFaceVisible(backface_test_layer, tree))
     return true;
 
   return false;
 }
 
 template <typename LayerType>
 void FindLayersThatNeedUpdates(
     LayerType* layer,
-    const TransformTree& tree,
-    bool subtree_is_visible_from_ancestor,
+    const TransformTree& transform_tree,
+    const EffectTree& effect_tree,
     typename LayerType::LayerListType* update_layer_list,
     std::vector<LayerType*>* visible_layer_list) {
+  DCHECK_GE(layer->effect_tree_index(), 0);
   bool layer_is_drawn =
-      layer->HasCopyRequest() ||
-      (subtree_is_visible_from_ancestor && !layer->hide_layer_and_subtree());
+      effect_tree.Node(layer->effect_tree_index())->data.is_drawn;
 
-  if (layer->parent() && SubtreeShouldBeSkipped(layer, layer_is_drawn, tree))
+  if (layer->parent() &&
+      SubtreeShouldBeSkipped(layer, layer_is_drawn, transform_tree))
     return;
 
-  if (!LayerShouldBeSkipped(layer, layer_is_drawn, tree)) {
+  if (!LayerShouldBeSkipped(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())
     update_layer_list->push_back(mask_layer);
   if (LayerType* replica_layer = layer->replica_layer()) {
     if (LayerType* 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), tree, layer_is_drawn,
+    FindLayersThatNeedUpdates(layer->child_at(i), transform_tree, effect_tree,
                               update_layer_list, visible_layer_list);
   }
 }
 
 template <typename LayerType>
 void UpdateRenderSurfacesWithEffectTreeInternal(EffectTree* effect_tree,
                                                 LayerType* layer) {
   EffectNode* node = effect_tree->Node(layer->effect_tree_index());
 
   if (node->owner_id == layer->id() && node->data.has_render_surface)
@@ skipping 201 matching lines @@
     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);
   ComputeTransforms(&property_trees->transform_tree);
   ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
                can_render_to_separate_surface);
   ComputeEffects(&property_trees->effect_tree);
 
-  const bool subtree_is_visible_from_ancestor = true;
   FindLayersThatNeedUpdates(root_layer, property_trees->transform_tree,
-                            subtree_is_visible_from_ancestor, update_layer_list,
+                            property_trees->effect_tree, update_layer_list,
                             visible_layer_list);
   CalculateVisibleRects<LayerType>(
       *visible_layer_list, property_trees->clip_tree,
       property_trees->transform_tree, can_render_to_separate_surface);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(
     Layer* root_layer,
     const Layer* page_scale_layer,
     const Layer* inner_viewport_scroll_layer,
@@ skipping 481 matching lines @@
 
 void UpdateElasticOverscrollInPropertyTrees(
     PropertyTrees* property_trees,
     const Layer* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInPropertyTreesInternal(
       property_trees, overscroll_elasticity_layer, elastic_overscroll);
 }
 
 }  // namespace cc