cc : Use same layer skipping functions in DrawPropertyUtils and LTHC

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 234 matching lines @@
 
 static inline bool IsRootLayer(const Layer* layer) {
   return !layer->parent();
 }
 
 static inline bool IsRootLayer(const LayerImpl* layer) {
   return layer->layer_tree_impl()->IsRootLayer(layer);
 }
 
 template <typename LayerType>
-static inline bool LayerIsInExisting3DRenderingContext(LayerType* layer) {
-  return layer->Is3dSorted() && layer->parent() &&
-         layer->parent()->Is3dSorted() &&
-         (layer->parent()->sorting_context_id() == layer->sorting_context_id());
-}
-
-static bool IsLayerBackFaceVisible(LayerImpl* layer,
-                                   const TransformTree& transform_tree) {
-  // The current W3C spec on CSS transforms says that backface visibility should
-  // be determined differently depending on whether the layer is in a "3d
-  // rendering context" or not. For Chromium code, we can determine whether we
-  // are in a 3d rendering context by checking if the parent preserves 3d.
-
-  if (LayerIsInExisting3DRenderingContext(layer)) {
-    return draw_property_utils::DrawTransform(layer, transform_tree)
-        .IsBackFaceVisible();
-  }
-
-  // In this case, either the layer establishes a new 3d rendering context, or
-  // is not in a 3d rendering context at all.
-  return layer->transform().IsBackFaceVisible();
-}
-
-static bool IsSurfaceBackFaceVisible(LayerImpl* layer,
-                                     const gfx::Transform& draw_transform) {
-  return layer->layer_tree_impl()
-      ->property_trees()
-      ->effect_tree.Node(layer->effect_tree_index())
-      ->data.hidden_by_backface_visibility;
-}
-
-static bool LayerShouldBeSkipped(LayerImpl* layer,
-                                 bool layer_is_drawn,
-                                 const TransformTree& transform_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;
-
-  if (!layer->DrawsContent() || layer->bounds().IsEmpty())
-    return true;
-
-  LayerImpl* backface_test_layer = layer;
-  if (layer->use_parent_backface_visibility()) {
-    DCHECK(!IsRootLayer(layer));
-    DCHECK(!layer->parent()->use_parent_backface_visibility());
-    backface_test_layer = layer->parent();
-  }
-
-  // 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 (!backface_test_layer->double_sided() &&
-      IsLayerBackFaceVisible(backface_test_layer, transform_tree))
-    return true;
-
-  return false;
-}
-
-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) {
-  // 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.
-  TransformNode* node =
-      layer->layer_tree_impl()->property_trees()->transform_tree.Node(
-          layer->transform_tree_index());
-  bool has_invertible_transform =
-      node->data.is_invertible && node->data.ancestors_are_invertible;
-  if (!(has_invertible_transform ||
-        layer->HasPotentiallyRunningTransformAnimation()))
-    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).
-  if (layer->layer_or_descendant_has_touch_handler())
-    return false;
-
-  // If the layer is not drawn, then skip it and its subtree.
-  if (!layer_is_drawn)
-    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())
-    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->EffectiveOpacity();
-}
-
 static inline void MarkLayerWithRenderSurfaceLayerListId(
     LayerImpl* layer,
     int current_render_surface_layer_list_id) {
   layer->draw_properties().last_drawn_render_surface_layer_list_id =
       current_render_surface_layer_list_id;
   layer->set_layer_or_descendant_is_drawn(
       !!current_render_surface_layer_list_id);
 }
 
 static inline void MarkMasksWithRenderSurfaceLayerListId(
@@ skipping 259 matching lines @@
 void CalculateRenderTarget(LayerImpl* layer,
                            PropertyTrees* property_trees,
                            bool subtree_visible_from_ancestor,
                            bool can_render_to_separate_surface) {
   bool layer_is_drawn;
   DCHECK_GE(layer->effect_tree_index(), 0);
   layer_is_drawn = property_trees->effect_tree.Node(layer->effect_tree_index())
                        ->data.is_drawn;
 
   // The root layer cannot be skipped.
-  if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) {
+  if (!IsRootLayer(layer) &&
+      draw_property_utils::LayerShouldBeSkipped(
+          layer, layer_is_drawn, property_trees->transform_tree)) {
     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()) << IsRootLayer(layer)
                                     << can_render_to_separate_surface
                                     << layer->has_render_surface();
     layer->draw_properties().render_target = layer;
 
     if (layer->mask_layer())
       layer->mask_layer()->draw_properties().render_target = layer;
 
     if (layer->replica_layer() && layer->replica_layer()->mask_layer())
       layer->replica_layer()->mask_layer()->draw_properties().render_target =
           layer;
 
   } else {
     DCHECK(!IsRootLayer(layer));
     layer->draw_properties().render_target = layer->parent()->render_target();
   }
-
   for (size_t i = 0; i < layer->children().size(); ++i) {
     CalculateRenderTarget(
         LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i),
         property_trees, layer_is_drawn, can_render_to_separate_surface);
   }
 }
 
 void CalculateRenderSurfaceLayerList(
     LayerImpl* layer,
     PropertyTrees* property_trees,
@@ skipping 18 matching lines @@
   // layer's subtree.
 
   // |can_render_to_separate_surface| and |current_render_surface_layer_list_id|
   // are settings that should stay the same during recursion.
   bool layer_is_drawn = false;
   DCHECK_GE(layer->effect_tree_index(), 0);
   layer_is_drawn = property_trees->effect_tree.Node(layer->effect_tree_index())
                        ->data.is_drawn;
 
   // The root layer cannot be skipped.
-  if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) {
+  if (!IsRootLayer(layer) &&
+      draw_property_utils::LayerShouldBeSkipped(
+          layer, layer_is_drawn, property_trees->transform_tree)) {
     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());
     draw_property_utils::ComputeSurfaceDrawProperties(property_trees,
                                                       layer->render_surface());
 
-    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 {
       bool contributes_to_drawn_surface =
           property_trees->effect_tree.ContributesToDrawnSurface(
               layer->effect_tree_index());
       layer->render_surface()->set_contributes_to_drawn_surface(
@@ skipping 16 matching lines @@
         nearest_occlusion_immune_ancestor);
     layer->ClearRenderSurfaceLayerList();
 
     render_surface_layer_list->push_back(layer);
 
     descendants = &(layer->render_surface()->layer_list());
   }
 
   size_t descendants_size = descendants->size();
 
-  bool layer_should_be_skipped = LayerShouldBeSkipped(
+  bool layer_should_be_skipped = !draw_property_utils::LayerNeedsUpdate(
       layer, layer_is_drawn, property_trees->transform_tree);
   if (!layer_should_be_skipped) {
     MarkLayerWithRenderSurfaceLayerListId(layer,
                                           current_render_surface_layer_list_id);
     descendants->push_back(layer);
   }
 
 
   // Clear the old accumulated content rect of surface.
   if (render_to_separate_surface)
@@ skipping 195 matching lines @@
   }
 
   if (should_measure_property_tree_performance) {
     TRACE_EVENT_BEGIN0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                        "LayerTreeHostCommon::CalculateDrawProperties");
   }
 
   DCHECK(inputs->can_render_to_separate_surface ==
          inputs->property_trees->non_root_surfaces_enabled);
   const bool subtree_visible_from_ancestor = true;
+  for (auto* layer : *inputs->root_layer->layer_tree_impl())
+    layer->draw_properties().render_target = nullptr;
   CalculateRenderTarget(inputs->root_layer, inputs->property_trees,
                         subtree_visible_from_ancestor,
                         inputs->can_render_to_separate_surface);
   for (LayerImpl* layer : visible_layer_list) {
     draw_property_utils::ComputeLayerDrawProperties(
         layer, inputs->property_trees, inputs->layers_always_allowed_lcd_text,
         inputs->can_use_lcd_text);
     if (layer->mask_layer())
       ComputeMaskLayerDrawProperties(layer, layer->mask_layer());
     LayerImpl* replica_mask_layer =
@@ skipping 97 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