cc : Stop calculating visible rects on main thread

cc/trees/draw_property_utils.cc

Index: cc/trees/draw_property_utils.cc
diff --git a/cc/trees/draw_property_utils.cc b/cc/trees/draw_property_utils.cc
index f6e4b14d92457a9fd68b5102fbc19cfff830b94c..8be077aef4b84a6b09bbbe4499d6499e1017e4b7 100644
--- a/cc/trees/draw_property_utils.cc
+++ b/cc/trees/draw_property_utils.cc
@@ -441,40 +441,6 @@ static bool LayerNeedsUpdate(LayerType* layer,
   return true;
 }
 
-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 (!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);
-  }
-}
-
 void FindLayersThatNeedUpdates(LayerImpl* layer,
                                const TransformTree& transform_tree,
                                const EffectTree& effect_tree,
@@ -690,13 +656,12 @@ void ComputeEffects(EffectTree* effect_tree) {
   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;
@@ -712,37 +677,76 @@ static void ComputeVisibleRectsInternal(
   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 BuildPropertyTreesAndComputeVisibleRects(
-    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) {
-  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);
+void UpdateRenderSurfaces(Layer* root_layer, PropertyTrees* 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 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);
+  ComputeTransforms(&property_trees->transform_tree);
+  ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
+               can_render_to_separate_surface);
+  ComputeEffects(&property_trees->effect_tree);
+}
+
+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)) {
+    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.

[ajuma, 2016/04/04 20:47:18]

This comment doesn't apply anymore (since we're not making up a list of layers
that need visible rects). So we could just add these layers above.

[jaydasika, 2016/04/04 21:29:17]

Done.

+  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);
+  }
+}
+
+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());

[ajuma, 2016/04/04 20:47:17]

Can we avoid this copy? Maybe use templating so that CalculateVisibleRects
doesn't care whether it gets a list of pointers or a list of ScopedRefPtrs?

[jaydasika, 2016/04/04 21:29:16]

Done.

+  }
+  CalculateVisibleRects(visible_layer_list, property_trees->clip_tree,
+                        property_trees->transform_tree,
+                        can_render_to_separate_surface);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(
@@ -768,16 +772,6 @@ void BuildPropertyTreesAndComputeVisibleRects(
                       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,