cc : Stop calculating visible rects 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 423 matching lines @@
     // backface is not visible.
     if (TransformToScreenIsKnown(layer, backface_transform_id, tree) &&
         !HasSingularTransform(backface_transform_id, tree) &&
         IsLayerBackFaceVisible(layer, backface_transform_id, tree))
       return false;
   }
 
   return true;
 }
 
-void FindLayersThatNeedUpdates(Layer* layer,
-                               const TransformTree& transform_tree,
-                               const EffectTree& effect_tree,
-                               LayerList* update_layer_list,
-                               std::vector<Layer*>* visible_layer_list) {
+static void FindLayersThatNeedUpdates(Layer* layer,
+                                      const TransformTree& transform_tree,
+                                      const EffectTree& effect_tree,
+                                      LayerList* update_layer_list) {
   DCHECK_GE(layer->effect_tree_index(), 0);
   bool layer_is_drawn =
       effect_tree.Node(layer->effect_tree_index())->data.is_drawn;
 
   if (!IsRootLayer(layer) &&
       SubtreeShouldBeSkipped(layer, layer_is_drawn, transform_tree))
     return;
 
   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 (Layer* mask_layer = layer->mask_layer())
     update_layer_list->push_back(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);
+                              update_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()) {
@@ skipping 198 matching lines @@
 }
 
 void ComputeEffects(EffectTree* effect_tree) {
   if (!effect_tree->needs_update())
     return;
   for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i)
     effect_tree->UpdateEffects(i);
   effect_tree->set_needs_update(false);
 }
 
-template <typename LayerType>
 static void ComputeVisibleRectsInternal(
-    LayerType* root_layer,
+    LayerImpl* root_layer,
     PropertyTrees* property_trees,
     bool can_render_to_separate_surface,
-    typename LayerType::LayerListType* update_layer_list,
-    std::vector<LayerType*>* visible_layer_list) {
+    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);
   ComputeTransforms(&property_trees->transform_tree);
   ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
                can_render_to_separate_surface);
   ComputeEffects(&property_trees->effect_tree);
 
   FindLayersThatNeedUpdates(root_layer, property_trees->transform_tree,
                             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);
+  CalculateVisibleRects(*visible_layer_list, property_trees->clip_tree,
+                        property_trees->transform_tree,
+                        can_render_to_separate_surface);
+}
+
+void Update(Layer* root_layer,
+            PropertyTrees* property_trees,
+            bool can_render_to_separate_surface,
+            LayerList* update_layer_list) {
+  UpdateRenderSurfacesForLayersRecursive(&property_trees->effect_tree,
+                                         root_layer);
+#if DCHECK_IS_ON()
+  ValidateRenderSurfacesRecursive(root_layer);
+#endif
+  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);
+  ComputeTransforms(&property_trees->transform_tree);
+  ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
+               can_render_to_separate_surface);
+  ComputeEffects(&property_trees->effect_tree);
+  FindLayersThatNeedUpdates(root_layer, property_trees->transform_tree,
+                            property_trees->effect_tree, update_layer_list);
+}
+
+void ComputeVisibleRectsForTesting(PropertyTrees* property_trees,
+                                   bool can_render_to_separate_surface,
+                                   LayerList* update_layer_list) {
+  std::vector<Layer*> visible_layer_list;
+  for (auto layer : *update_layer_list) {
+    visible_layer_list.push_back(layer.get());
+  }
+  CalculateVisibleRects(visible_layer_list, property_trees->clip_tree,
+                        property_trees->transform_tree,
+                        can_render_to_separate_surface);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(

[jaydasika, 2016/04/02 02:54:10]

Wanted to delete this function but calling the function in property tree builder
directly from layer_tree_host_common_test is giving a linker error that I don't
understand.

[ajuma, 2016/04/04 14:15:05]

It's probably just that PropertyTreeBuilder isn't declared with CC_EXPORT.

[jaydasika, 2016/04/04 18:41:09]

That was the reason. Thanks 

     Layer* root_layer,
     const Layer* page_scale_layer,
     const Layer* inner_viewport_scroll_layer,
     const Layer* outer_viewport_scroll_layer,
     const Layer* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
-    bool can_render_to_separate_surface,
-    PropertyTrees* property_trees,
-    LayerList* update_layer_list) {
+    PropertyTrees* property_trees) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees);
-  UpdateRenderSurfacesForLayersRecursive(&property_trees->effect_tree,
-                                         root_layer);
-#if DCHECK_IS_ON()
-  ValidateRenderSurfacesRecursive(root_layer);
-#endif
-  ComputeVisibleRects(root_layer, property_trees,
-                      can_render_to_separate_surface, update_layer_list);
 }
 
 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,
     const gfx::Transform& device_transform,
     bool can_render_to_separate_surface,
     PropertyTrees* property_trees,
     LayerImplList* visible_layer_list) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees);
   ComputeVisibleRects(root_layer, property_trees,
                       can_render_to_separate_surface, visible_layer_list);
 }
 
-void ComputeVisibleRects(Layer* root_layer,
-                         PropertyTrees* property_trees,
-                         bool can_render_to_separate_surface,
-                         LayerList* update_layer_list) {
-  std::vector<Layer*> visible_layer_list;
-  ComputeVisibleRectsInternal(root_layer, property_trees,
-                              can_render_to_separate_surface, update_layer_list,
-                              &visible_layer_list);
-}
-
 void ComputeVisibleRects(LayerImpl* root_layer,
                          PropertyTrees* property_trees,
                          bool can_render_to_separate_surface,
                          LayerImplList* visible_layer_list) {
   for (auto* layer : *root_layer->layer_tree_impl()) {
     UpdateRenderSurfaceForLayer(&property_trees->effect_tree,
                                 can_render_to_separate_surface, layer);
 #if DCHECK_IS_ON()
     if (can_render_to_separate_surface)
       ValidateRenderSurfaceForLayer(layer);
@@ skipping 385 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