Create RenderSurface on Effect Tree

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 326e507fc822e6c055f19079280b42eb4706b4ed..c6d9e1d4aca4f8664532534c609680a5307d8918 100644
--- a/cc/trees/draw_property_utils.cc
+++ b/cc/trees/draw_property_utils.cc
@@ -20,6 +20,30 @@ namespace cc {
 
 namespace {
 
+#if DCHECK_IS_ON()
+template <typename LayerType>
+static void ValidateRenderSurfaces(LayerType* layer) {
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    ValidateRenderSurfaces(layer->child_at(i));
+  }
+
+  // This test verifies that there are no cases where a LayerImpl needs
+  // a render surface, but doesn't have one.
+  if (layer->has_render_surface())
+    return;
+
+  DCHECK(layer->filters().IsEmpty()) << "layer: " << layer->id();
+  DCHECK(layer->background_filters().IsEmpty()) << "layer: " << layer->id();
+  DCHECK(layer->parent()) << "layer: " << layer->id();
+  if (layer->parent()->replica_layer() == layer)
+    return;
+  DCHECK(!layer->mask_layer()) << "layer: " << layer->id();
+  DCHECK(!layer->replica_layer()) << "layer: " << layer->id();
+  DCHECK(!layer->is_root_for_isolated_group()) << "layer: " << layer->id();
+  DCHECK(!layer->HasCopyRequest()) << "layer: " << layer->id();
+}
+#endif
+
 template <typename LayerType>
 void CalculateVisibleRects(const std::vector<LayerType*>& visible_layer_list,
                            const ClipTree& clip_tree,
@@ -438,6 +462,47 @@ void FindLayersThatNeedUpdates(
   }
 }
 
+void UpdateRenderSurfacesWithEffectTree(EffectTree* effect_tree,
+                                        Layer* layer,
+                                        int effect_tree_id) {
+  if (layer->effect_tree_index() != effect_tree_id) {
+    effect_tree_id = layer->effect_tree_index();
+    layer->SetHasRenderSurface(
+        effect_tree->Node(effect_tree_id)->data.has_render_surface);
+  } else {
+    layer->SetHasRenderSurface(false);
+  }
+
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    UpdateRenderSurfacesWithEffectTree(effect_tree, layer->child_at(i),
+                                       effect_tree_id);
+  }
+}
+
+void UpdateRenderSurfacesWithEffectTree(EffectTree* effect_tree,
+                                        bool non_root_surfaces_enabled,
+                                        LayerImpl* layer,
+                                        int effect_tree_id) {
+  if (!non_root_surfaces_enabled) {
+    if (!layer->parent()) {
+      layer->SetHasRenderSurface(true);
+    } else {
+      layer->SetHasRenderSurface(false);
+    }
+  } else if (layer->effect_tree_index() != effect_tree_id) {
+    effect_tree_id = layer->effect_tree_index();
+    layer->SetHasRenderSurface(
+        effect_tree->Node(effect_tree_id)->data.has_render_surface);
+  } else {
+    layer->SetHasRenderSurface(false);
+  }
+
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    UpdateRenderSurfacesWithEffectTree(effect_tree, non_root_surfaces_enabled,
+                                       layer->child_at(i), effect_tree_id);
+  }
+}
+
 }  // namespace
 
 static void ResetIfHasNanCoordinate(gfx::RectF* rect) {
@@ -500,7 +565,6 @@ void ComputeClips(ClipTree* clip_tree,
           parent_to_current,
           parent_clip_node->data.combined_clip_in_target_space);
     }
-
     // Only nodes affected by ancestor clips will have their clip adjusted due
     // to intersecting with an ancestor clip. But, we still need to propagate
     // the combined clip to our children because if they are clipped, they may
@@ -523,7 +587,6 @@ void ComputeClips(ClipTree* clip_tree,
       ResetIfHasNanCoordinate(&clip_node->data.combined_clip_in_target_space);
       continue;
     }
-
     bool use_only_parent_clip = !clip_node->data.applies_local_clip;
     if (use_only_parent_clip) {
       clip_node->data.combined_clip_in_target_space =
@@ -645,6 +708,11 @@ void BuildPropertyTreesAndComputeVisibleRects(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, page_scale_factor, device_scale_factor,
       viewport, device_transform, property_trees);
+  UpdateRenderSurfacesWithEffectTree(&property_trees->effect_tree, root_layer,
+                                     0);
+#if DCHECK_IS_ON()
+  ValidateRenderSurfaces(root_layer);
+#endif
   ComputeVisibleRectsUsingPropertyTrees(root_layer, property_trees,
                                         can_render_to_separate_surface,
                                         update_layer_list);
@@ -685,6 +753,13 @@ void ComputeVisibleRectsUsingPropertyTrees(LayerImpl* root_layer,
                                            PropertyTrees* property_trees,
                                            bool can_render_to_separate_surface,
                                            LayerImplList* visible_layer_list) {
+  UpdateRenderSurfacesWithEffectTree(&property_trees->effect_tree,
+                                     can_render_to_separate_surface, root_layer,
+                                     0);
+#if DCHECK_IS_ON()
+  if (can_render_to_separate_surface)
+    ValidateRenderSurfaces(root_layer);
+#endif
   LayerImplList update_layer_list;
   ComputeVisibleRectsUsingPropertyTreesInternal(
       root_layer, property_trees, can_render_to_separate_surface,