cc: Remove usage of ComputeVisibleRects on main thread

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 67 matching lines @@
 #endif
 
 static const EffectNode* ContentsTargetEffectNode(
     const int effect_tree_index,
     const EffectTree& effect_tree) {
   const EffectNode* effect_node = effect_tree.Node(effect_tree_index);
   return effect_node->render_surface ? effect_node
                                      : effect_tree.Node(effect_node->target_id);
 }
 
-template <typename LayerType>
-bool ComputeClipRectInTargetSpace(const LayerType* layer,
+bool ComputeClipRectInTargetSpace(const LayerImpl* layer,
                                   const ClipNode* clip_node,
                                   const PropertyTrees* property_trees,
                                   int target_node_id,
                                   gfx::RectF* clip_rect_in_target_space) {
   DCHECK(layer->clip_tree_index() == clip_node->id);
   DCHECK(clip_node->target_transform_id != target_node_id);
 
   const EffectTree& effect_tree = property_trees->effect_tree;
   const EffectNode* target_effect_node =
       ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree);
@@ skipping 245 matching lines @@
 
       if (!clip_rect_in_target_space.IsEmpty()) {
         layer->set_clip_rect(gfx::ToEnclosingRect(clip_rect_in_target_space));
       } else {
         layer->set_clip_rect(gfx::Rect());
       }
     }
   }
 }
 
-bool GetLayerClipRect(const scoped_refptr<Layer> layer,
-                      const ClipNode* clip_node,
-                      const PropertyTrees* property_trees,
-                      int target_node_id,
-                      gfx::RectF* clip_rect_in_target_space) {
-  return ComputeClipRectInTargetSpace(layer.get(), clip_node, property_trees,
-                                      target_node_id,
-                                      clip_rect_in_target_space);
-}
-
 bool GetLayerClipRect(const LayerImpl* layer,
                       const ClipNode* clip_node,
                       const PropertyTrees* property_trees,
                       int target_node_id,
                       gfx::RectF* clip_rect_in_target_space) {
   // This is equivalent of calling ComputeClipRectInTargetSpace.
   *clip_rect_in_target_space = gfx::RectF(layer->clip_rect());
   return property_trees->transform_tree.Node(target_node_id)
       ->ancestors_are_invertible;
 }
 
-template <typename LayerType>
-void CalculateVisibleRects(
-    const typename LayerType::LayerListType& visible_layer_list,
-    const PropertyTrees* property_trees,
-    bool non_root_surfaces_enabled) {
+void CalculateVisibleRects(const LayerImplList& visible_layer_list,
+                           const PropertyTrees* property_trees,
+                           bool non_root_surfaces_enabled) {
   const EffectTree& effect_tree = property_trees->effect_tree;
   const TransformTree& transform_tree = property_trees->transform_tree;
   const ClipTree& clip_tree = property_trees->clip_tree;
   for (auto& layer : visible_layer_list) {
     gfx::Size layer_bounds = layer->bounds();
 
     int effect_ancestor_with_copy_request =
         effect_tree.ClosestAncestorWithCopyRequest(layer->effect_tree_index());
     if (effect_ancestor_with_copy_request > 1) {
       // Non root copy request.
@@ skipping 167 matching lines @@
 
 template <typename LayerType>
 static int TransformTreeIndexForBackfaceVisibility(LayerType* layer,
                                                    const TransformTree& tree) {
   if (!layer->use_parent_backface_visibility())
     return layer->transform_tree_index();
   const TransformNode* node = tree.Node(layer->transform_tree_index());
   return layer->id() == node->owner_id ? tree.parent(node)->id : node->id;
 }
 
+static bool IsTargetSpaceTransformBackFaceVisible(Layer* layer,
+                                                  int transform_tree_index,
+                                                  const TransformTree& tree) {
+  // We do not skip back face invisible layers on main thread as target space
+  // transform will not be available here.
+  return false;
+}
+
+static bool IsTargetSpaceTransformBackFaceVisible(LayerImpl* layer,
+                                                  int transform_tree_index,
+                                                  const TransformTree& tree) {
+  return tree
+      .ToTarget(transform_tree_index, layer->render_target_effect_tree_index())
+      .IsBackFaceVisible();
+}
+
 template <typename LayerType>
 static bool IsLayerBackFaceVisible(LayerType* layer,
                                    int transform_tree_index,
                                    const TransformTree& tree) {
   const TransformNode* node = tree.Node(transform_tree_index);
   return layer->use_local_transform_for_backface_visibility()
              ? node->local.IsBackFaceVisible()
-             : tree.ToTarget(transform_tree_index,
-                             layer->render_target_effect_tree_index())
-                   .IsBackFaceVisible();
+             : IsTargetSpaceTransformBackFaceVisible(
+                   layer, transform_tree_index, tree);
 }
 
 static inline bool TransformToScreenIsKnown(Layer* layer,
                                             int transform_tree_index,
                                             const TransformTree& tree) {
   const TransformNode* node = tree.Node(transform_tree_index);
   return !node->to_screen_is_potentially_animated;
 }
 
 static inline bool TransformToScreenIsKnown(LayerImpl* layer,
@@ skipping 506 matching lines @@
   // Computation of clips uses surface contents scale which is updated while
   // computing effects. So, ComputeEffects should be before ComputeClips.
   ComputeEffects(&property_trees->effect_tree);
   ComputeClips(property_trees, can_render_to_separate_surface);
 
   FindLayersThatNeedUpdates(root_layer->layer_tree_impl(),
                             property_trees->transform_tree,
                             property_trees->effect_tree, visible_layer_list);
   CalculateClipRects<LayerImpl>(*visible_layer_list, property_trees,
                                 can_render_to_separate_surface);
-  CalculateVisibleRects<LayerImpl>(*visible_layer_list, property_trees,
-                                   can_render_to_separate_surface);
+  CalculateVisibleRects(*visible_layer_list, property_trees,
+                        can_render_to_separate_surface);
 }
 
 void UpdatePropertyTrees(PropertyTrees* property_trees,
                          bool can_render_to_separate_surface) {
   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);
     property_trees->effect_tree.set_needs_update(true);
   }
   ComputeTransforms(&property_trees->transform_tree);
   // Computation of clips uses surface contents scale which is updated while
   // computing effects. So, ComputeEffects should be before ComputeClips.
   ComputeEffects(&property_trees->effect_tree);
   ComputeClips(property_trees, can_render_to_separate_surface);
 }
 
-void ComputeVisibleRectsForTesting(PropertyTrees* property_trees,
-                                   bool can_render_to_separate_surface,
-                                   LayerList* update_layer_list) {
-  CalculateVisibleRects<Layer>(*update_layer_list, property_trees,
-                               can_render_to_separate_surface);
-}
-
 void BuildPropertyTreesAndComputeVisibleRects(
     LayerImpl* root_layer,
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
     const LayerImpl* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
@@ skipping 458 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