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

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 273 matching lines @@
 
 static void ComputeInitialRenderSurfaceLayerList(
     LayerTreeImpl* layer_tree_impl,
     PropertyTrees* property_trees,
     LayerImplList* render_surface_layer_list,
     bool can_render_to_separate_surface) {
   // Add all non-skipped surfaces to the initial render surface layer list. Add
   // all non-skipped layers to the layer list of their target surface, and
   // add their content rect to their target surface's accumulated content rect.
   for (LayerImpl* layer : *layer_tree_impl) {
-    if (layer->render_surface()) {
-      layer->ClearRenderSurfaceLayerList();
-      ClearMaskLayersAreDrawnRenderSurfaceLayerListMembers(
-          layer->render_surface());
+    RenderSurfaceImpl* render_surface = layer->render_surface();
+    if (render_surface) {
+      render_surface->ClearLayerLists();
+      ClearMaskLayersAreDrawnRenderSurfaceLayerListMembers(render_surface);
     }
     layer->set_is_drawn_render_surface_layer_list_member(false);
 
     bool is_root = layer_tree_impl->IsRootLayer(layer);
     bool skip_layer = !is_root && draw_property_utils::LayerShouldBeSkipped(
                                       layer, property_trees->transform_tree,
                                       property_trees->effect_tree);
     if (skip_layer)
       continue;
 
     bool render_to_separate_surface =
-        is_root || (can_render_to_separate_surface && layer->render_surface());
+        is_root || (can_render_to_separate_surface && render_surface);
 
     if (render_to_separate_surface) {
-      DCHECK(layer->render_surface());
-      DCHECK(layer->render_target() == layer->render_surface());
-      RenderSurfaceImpl* surface = layer->render_surface();
-      surface->ClearAccumulatedContentRect();
+      DCHECK(render_surface);
+      DCHECK(layer->render_target() == render_surface);
+      render_surface->ClearAccumulatedContentRect();
       render_surface_layer_list->push_back(layer);
       if (is_root) {
         // The root surface does not contribute to any other surface, it has no
         // target.
-        layer->render_surface()->set_contributes_to_drawn_surface(false);
+        render_surface->set_contributes_to_drawn_surface(false);
       } else {
-        surface->render_target()->layer_list().push_back(layer);
+        render_surface->render_target()->layer_list().push_back(layer);
         bool contributes_to_drawn_surface =
             property_trees->effect_tree.ContributesToDrawnSurface(
                 layer->effect_tree_index());
-        layer->render_surface()->set_contributes_to_drawn_surface(
+        render_surface->set_contributes_to_drawn_surface(
             contributes_to_drawn_surface);
       }
 
       draw_property_utils::ComputeSurfaceDrawProperties(property_trees,
-                                                        surface);
+                                                        render_surface);
 
       // Ignore occlusion from outside the surface when surface contents need to
       // be fully drawn. Layers with copy-request need to be complete.  We could
       // be smarter about layers with filters that move pixels and exclude
       // regions where both layers and the filters are occluded, but this seems
       // like overkill.
       // TODO(senorblanco): make this smarter for the SkImageFilter case (check
       // for pixel-moving filters)
-      const FilterOperations& filters = surface->Filters();
-      bool is_occlusion_immune = surface->HasCopyRequest() ||
+      const FilterOperations& filters = render_surface->Filters();
+      bool is_occlusion_immune = render_surface->HasCopyRequest() ||
                                  filters.HasReferenceFilter() ||
                                  filters.HasFilterThatMovesPixels();
       if (is_occlusion_immune) {
-        surface->SetNearestOcclusionImmuneAncestor(surface);
+        render_surface->SetNearestOcclusionImmuneAncestor(render_surface);
       } else if (is_root) {
-        surface->SetNearestOcclusionImmuneAncestor(nullptr);
+        render_surface->SetNearestOcclusionImmuneAncestor(nullptr);
       } else {
-        surface->SetNearestOcclusionImmuneAncestor(
-            surface->render_target()->nearest_occlusion_immune_ancestor());
+        render_surface->SetNearestOcclusionImmuneAncestor(
+            render_surface->render_target()
+                ->nearest_occlusion_immune_ancestor());
       }
     }
     bool layer_is_drawn =
         property_trees->effect_tree.Node(layer->effect_tree_index())->is_drawn;
     bool layer_should_be_drawn = draw_property_utils::LayerNeedsUpdate(
         layer, layer_is_drawn, property_trees);
     if (!layer_should_be_drawn)
       continue;
 
     layer->set_is_drawn_render_surface_layer_list_member(true);
     layer->render_target()->layer_list().push_back(layer);
 
     // The layer contributes its drawable content rect to its render target.
     layer->render_target()->AccumulateContentRectFromContributingLayer(layer);
   }
 }
 
 static void ComputeSurfaceContentRects(LayerTreeImpl* layer_tree_impl,
                                        PropertyTrees* property_trees,
                                        LayerImplList* render_surface_layer_list,
                                        int max_texture_size) {
   // Walk the list backwards, accumulating each surface's content rect into its
   // target's content rect.
   for (LayerImpl* layer : base::Reversed(*render_surface_layer_list)) {
+    RenderSurfaceImpl* render_surface = layer->render_surface();
     if (layer_tree_impl->IsRootLayer(layer)) {
       // The root layer's surface content rect is always the entire viewport.
-      layer->render_surface()->SetContentRectToViewport();
+      render_surface->SetContentRectToViewport();
       continue;
     }
-    RenderSurfaceImpl* surface = layer->render_surface();
+
     // Now all contributing drawable content rect has been accumulated to this
     // render surface, calculate the content rect.
-    surface->CalculateContentRectFromAccumulatedContentRect(max_texture_size);
+    render_surface->CalculateContentRectFromAccumulatedContentRect(
+        max_texture_size);
 
     // Now the render surface's content rect is calculated correctly, it could
     // contribute to its render target.
-    surface->render_target()
-        ->AccumulateContentRectFromContributingRenderSurface(surface);
+    render_surface->render_target()
+        ->AccumulateContentRectFromContributingRenderSurface(render_surface);
   }
 }
 
 static void ComputeListOfNonEmptySurfaces(LayerTreeImpl* layer_tree_impl,
                                           PropertyTrees* property_trees,
                                           LayerImplList* initial_surface_list,
                                           LayerImplList* final_surface_list) {
   // Walk the initial surface list forwards. The root surface and each
   // surface with a non-empty content rect go into the final render surface
   // layer list. Surfaces with empty content rects or whose target isn't in
@@ skipping 249 matching lines @@
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc