cc: Move render surface ownership from layers to the effect tree

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 16 matching lines @@
 namespace {
 
 static bool IsRootLayer(const Layer* layer) {
   return !layer->parent();
 }
 
 static bool IsRootLayer(const LayerImpl* layer) {
   return layer->layer_tree_impl()->IsRootLayer(layer);
 }
 
-#if DCHECK_IS_ON()
-static void ValidateRenderSurfaceForLayer(LayerImpl* layer) {
-  // 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(!IsRootLayer(layer)) << "layer: " << layer->id();
-  EffectNode* effect_node =
-      layer->layer_tree_impl()->property_trees()->effect_tree.Node(
-          layer->effect_tree_index());
-  if (effect_node->owning_layer_id != layer->id())
-    return;
-  DCHECK_EQ(effect_node->mask_layer_id, EffectTree::kInvalidNodeId)
-      << "layer: " << layer->id();
-  DCHECK(effect_node->filters.IsEmpty());
-  DCHECK(effect_node->background_filters.IsEmpty());
-}
-#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);
+  return effect_tree.GetRenderSurface(effect_tree_index)
+             ? effect_node
+             : effect_tree.Node(effect_node->target_id);
 }
 
 bool ComputeClipRectInTargetSpace(const LayerImpl* layer,
                                   const ClipNode* clip_node,
                                   const PropertyTrees* property_trees,
                                   int target_node_id,
                                   bool for_visible_rect_calculation,
                                   gfx::RectF* clip_rect_in_target_space) {
   DCHECK(layer->clip_tree_index() == clip_node->id);
   DCHECK(clip_node->target_transform_id != target_node_id);
@@ skipping 635 matching lines @@
       continue;
 
     bool layer_is_drawn =
         effect_tree.Node(layer_impl->effect_tree_index())->is_drawn;
 
     if (LayerNeedsUpdate(layer_impl, layer_is_drawn, property_trees))
       visible_layer_list->push_back(layer_impl);
   }
 }
 
-void UpdateRenderSurfaceForLayer(EffectTree* effect_tree,
-                                 bool non_root_surfaces_enabled,
-                                 LayerImpl* layer) {
-  if (!non_root_surfaces_enabled) {
-    layer->SetHasRenderSurface(IsRootLayer(layer));
-    return;
-  }
-
-  EffectNode* node = effect_tree->Node(layer->effect_tree_index());
-
-  if (node->owning_layer_id == layer->id() && node->has_render_surface)
-    layer->SetHasRenderSurface(true);
-  else
-    layer->SetHasRenderSurface(false);
-}
 }  // namespace
 
 template <typename LayerType>
 static inline bool LayerShouldBeSkippedInternal(
     LayerType* layer,
     const TransformTree& transform_tree,
     const EffectTree& effect_tree) {
   const TransformNode* transform_node =
       transform_tree.Node(layer->transform_tree_index());
   const EffectNode* effect_node = effect_tree.Node(layer->effect_tree_index());
@@ skipping 261 matching lines @@
     return;
   for (int i = EffectTree::kContentsRootNodeId;
        i < static_cast<int>(effect_tree->size()); ++i)
     effect_tree->UpdateEffects(i);
   effect_tree->set_needs_update(false);
 }
 
 static void ComputeClipsWithEffectTree(PropertyTrees* property_trees) {
   EffectTree* effect_tree = &property_trees->effect_tree;
   const ClipTree* clip_tree = &property_trees->clip_tree;
-  EffectNode* root_effect_node = effect_tree->Node(1);
+  EffectNode* root_effect_node =
+      effect_tree->Node(EffectTree::kContentsRootNodeId);
   const RenderSurfaceImpl* root_render_surface =
-      root_effect_node->render_surface;
+      effect_tree->GetRenderSurface(EffectTree::kContentsRootNodeId);
   gfx::Rect root_clip =
       gfx::ToEnclosingRect(clip_tree->Node(root_effect_node->clip_id)->clip);
   if (root_render_surface->is_clipped())
     DCHECK(root_clip == root_render_surface->clip_rect())
         << "clip on root render surface: "
         << root_render_surface->clip_rect().ToString()
         << " v.s. root effect node's clip: " << root_clip.ToString();
   for (int i = 2; i < static_cast<int>(effect_tree->size()); ++i) {
     EffectNode* effect_node = effect_tree->Node(i);
     const EffectNode* target_node = effect_tree->Node(effect_node->target_id);
     bool include_viewport_clip = false;
     bool include_expanding_clips = false;
     ConditionalClip accumulated_clip_rect = ComputeAccumulatedClip(
         property_trees, include_viewport_clip, include_expanding_clips,
         effect_node->clip_id, target_node->id);
     gfx::RectF accumulated_clip = accumulated_clip_rect.clip_rect;
-    const RenderSurfaceImpl* render_surface = effect_node->render_surface;
+    const RenderSurfaceImpl* render_surface = effect_tree->GetRenderSurface(i);
     if (render_surface && render_surface->is_clipped()) {
       DCHECK(gfx::ToEnclosingRect(accumulated_clip) ==
              render_surface->clip_rect())
           << " render surface's clip rect: "
           << render_surface->clip_rect().ToString()
           << " v.s. accumulated clip: "
           << gfx::ToEnclosingRect(accumulated_clip).ToString();
     }
   }
 }
@@ skipping 29 matching lines @@
   gfx::RectF accumulated_clip = accumulated_clip_rect.clip_rect;
 
   DCHECK(layer->clip_rect() == gfx::ToEnclosingRect(accumulated_clip))
       << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index()
       << " layer clip: " << layer->clip_rect().ToString() << " v.s. "
       << gfx::ToEnclosingRect(accumulated_clip).ToString()
       << " and clip node clip: "
       << gfx::ToEnclosingRect(clip_node->clip_in_target_space).ToString();
 }
 
-static void ComputeVisibleRectsInternal(
-    LayerImpl* root_layer,
-    PropertyTrees* property_trees,
-    bool can_render_to_separate_surface,
-    std::vector<LayerImpl*>* visible_layer_list) {
+void ComputeVisibleRects(LayerImpl* root_layer,
+                         PropertyTrees* property_trees,
+                         bool can_render_to_separate_surface,
+                         LayerImplList* visible_layer_list) {
+  bool render_surfaces_need_update = false;
   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);
+    render_surfaces_need_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);
   }
+
+  if (render_surfaces_need_update) {
+    property_trees->effect_tree.UpdateRenderSurfaces(
+        root_layer->layer_tree_impl(),
+        property_trees->non_root_surfaces_enabled);
+  }
   UpdateRenderTarget(&property_trees->effect_tree,
                      property_trees->non_root_surfaces_enabled);
   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);
 
   FindLayersThatNeedUpdates(root_layer->layer_tree_impl(), property_trees,
                             visible_layer_list);
@@ skipping 46 matching lines @@
 
 void VerifyClipTreeCalculations(const LayerImplList& layer_list,
                                 PropertyTrees* property_trees) {
   if (property_trees->non_root_surfaces_enabled) {
     ComputeClipsWithEffectTree(property_trees);
   }
   for (auto* layer : layer_list)
     ComputeLayerClipRect(property_trees, layer);
 }
 
-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);
-    EffectNode* node =
-        property_trees->effect_tree.Node(layer->effect_tree_index());
-    if (node->owning_layer_id == layer->id()) {
-      node->render_surface = layer->render_surface();
-      if (node->render_surface)
-        node->render_surface->set_effect_tree_index(node->id);
-    }
-#if DCHECK_IS_ON()
-    if (can_render_to_separate_surface)
-      ValidateRenderSurfaceForLayer(layer);
-#endif
-  }
-  ComputeVisibleRectsInternal(root_layer, property_trees,
-                              can_render_to_separate_surface,
-                              visible_layer_list);
-}
-
 gfx::Rect ComputeLayerVisibleRectDynamic(const PropertyTrees* property_trees,
                                          const LayerImpl* layer) {
   int effect_ancestor_with_copy_request =
       property_trees->effect_tree.ClosestAncestorWithCopyRequest(
           layer->effect_tree_index());
   bool non_root_copy_request =
       effect_ancestor_with_copy_request > EffectTree::kContentsRootNodeId;
   gfx::Rect layer_content_rect = gfx::Rect(layer->bounds());
   gfx::RectF accumulated_clip_in_root_space;
   if (non_root_copy_request) {
@@ skipping 362 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