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

cc/trees/layer_tree_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 362 matching lines @@
       gfx::SizeF bounds = gfx::SizeF(layer->bounds());
       if (clip_node->clip.size() != bounds) {
         clip_node->clip.set_size(bounds);
         clip_tree->set_needs_update(true);
       }
     }
   }
 }
 
 void LayerTreeImpl::SetPropertyTrees(PropertyTrees* property_trees) {
-  EffectTree::StableIdRenderSurfaceList stable_id_render_surface_list =
-      property_trees_.effect_tree.CreateStableIdRenderSurfaceList();
   property_trees_ = *property_trees;
-  property_trees_.effect_tree.UpdateRenderSurfaceEffectIds(
-      stable_id_render_surface_list, this);
   property_trees->effect_tree.PushCopyRequestsTo(&property_trees_.effect_tree);
   property_trees_.is_main_thread = false;
   property_trees_.is_active = IsActiveTree();
   property_trees_.transform_tree.set_source_to_parent_updates_allowed(false);
+  if (property_trees_.effect_tree.needs_update_render_surfaces())
+    set_needs_update_draw_properties();
   // The value of some effect node properties (like is_drawn) depends on
   // whether we are on the active tree or not. So, we need to update the
   // effect tree.
   if (IsActiveTree())
     property_trees_.effect_tree.set_needs_update(true);
 }
 
 void LayerTreeImpl::UpdatePropertyTreesForBoundsDelta() {
   DCHECK(IsActiveTree());
   LayerImpl* inner_container = InnerViewportContainerLayer();
@@ skipping 95 matching lines @@
   target_tree->has_ever_been_drawn_ = false;
 }
 
 void LayerTreeImpl::MoveChangeTrackingToLayers() {
   // We need to update the change tracking on property trees before we move it
   // onto the layers.
   property_trees_.UpdateChangeTracking();
   for (auto* layer : *this) {
     if (layer->LayerPropertyChanged())
       layer->NoteLayerPropertyChanged();
-    if (layer->render_surface() &&
-        layer->render_surface()->AncestorPropertyChanged())
-      layer->render_surface()->NoteAncestorPropertyChanged();
+  }
+  EffectTree& effect_tree = property_trees_.effect_tree;
+  for (int id = EffectTree::kContentsRootNodeId;
+       id < static_cast<int>(effect_tree.size()); ++id) {
+    RenderSurfaceImpl* render_surface = effect_tree.GetRenderSurface(id);
+    if (render_surface && render_surface->AncestorPropertyChanged())
+      render_surface->NoteAncestorPropertyChanged();
   }
 }
 
 void LayerTreeImpl::ForceRecalculateRasterScales() {
   for (auto* layer : picture_layers_)
     layer->ResetRasterScale();
 }
 
 LayerImplList::const_iterator LayerTreeImpl::begin() const {
   return layer_list_.cbegin();
@@ skipping 521 matching lines @@
 
       if (it.represents_itself()) {
         it->draw_properties().occlusion_in_content_space =
             occlusion_tracker.GetCurrentOcclusionForLayer(it->DrawTransform());
       }
 
       if (it.represents_contributing_render_surface()) {
         const RenderSurfaceImpl* occlusion_surface =
             occlusion_tracker.OcclusionSurfaceForContributingSurface();
         gfx::Transform draw_transform;
+        RenderSurfaceImpl* render_surface = it->render_surface();
         if (occlusion_surface) {
           // We are calculating transform between two render surfaces. So, we
           // need to apply the surface contents scale at target and remove the
           // surface contents scale at source.
-          property_trees()->GetToTarget(
-              it->render_surface()->TransformTreeIndex(),
-              occlusion_surface->EffectTreeIndex(), &draw_transform);
+          property_trees()->GetToTarget(render_surface->TransformTreeIndex(),
+                                        occlusion_surface->EffectTreeIndex(),
+                                        &draw_transform);
           const EffectNode* effect_node = property_trees()->effect_tree.Node(
-              it->render_surface()->EffectTreeIndex());
+              render_surface->EffectTreeIndex());
           draw_property_utils::ConcatInverseSurfaceContentsScale(
               effect_node, &draw_transform);
         }
 
         Occlusion occlusion =
             occlusion_tracker.GetCurrentOcclusionForContributingSurface(
                 draw_transform);
-        it->render_surface()->set_occlusion_in_content_space(occlusion);
+        render_surface->set_occlusion_in_content_space(occlusion);
         // Masks are used to draw the contributing surface, so should have
         // the same occlusion as the surface (nothing inside the surface
         // occludes them).
-        if (LayerImpl* mask = it->render_surface()->MaskLayer()) {
+        if (LayerImpl* mask = render_surface->MaskLayer()) {
           mask->draw_properties().occlusion_in_content_space =
               occlusion_tracker.GetCurrentOcclusionForContributingSurface(
                   draw_transform * it->DrawTransform());
         }
       }
 
       occlusion_tracker.LeaveLayer(it);
     }
 
     unoccluded_screen_space_region_ =
@@ skipping 679 matching lines @@
     return false;
 
   return layer_space_region.Contains(
       gfx::ToRoundedPoint(hit_test_point_in_layer_space));
 }
 
 static const gfx::Transform SurfaceScreenSpaceTransform(
     const LayerImpl* layer) {
   const PropertyTrees* property_trees =
       layer->layer_tree_impl()->property_trees();
-  DCHECK(layer->render_surface());
+  RenderSurfaceImpl* render_surface = layer->render_surface();
+  DCHECK(render_surface);
   return layer->is_drawn_render_surface_layer_list_member()
-             ? layer->render_surface()->screen_space_transform()
+             ? render_surface->screen_space_transform()
              : property_trees
                    ->ToScreenSpaceTransformWithoutSurfaceContentsScale(
-                       layer->render_surface()->TransformTreeIndex(),
-                       layer->render_surface()->EffectTreeIndex());
+                       render_surface->TransformTreeIndex(),
+                       render_surface->EffectTreeIndex());
 }
 
 static bool PointIsClippedByAncestorClipNode(
     const gfx::PointF& screen_space_point,
     const LayerImpl* layer) {
   // We need to visit all ancestor clip nodes to check this. Checking with just
   // the combined clip stored at a clip node is not enough because parent
   // combined clip can sometimes be smaller than current combined clip. This can
   // happen when we have transforms like rotation that inflate the combined
   // clip's bounds. Also, the point can be clipped by the content rect of an
@@ skipping 17 matching lines @@
 
       gfx::Transform screen_space_transform =
           transform_tree.ToScreen(clip_node->transform_id);
       if (!PointHitsRect(screen_space_point, screen_space_transform, clip,
                          NULL)) {
         return true;
       }
     }
     const LayerImpl* clip_node_owner =
         layer->layer_tree_impl()->LayerById(clip_node->owning_layer_id);
-    if (clip_node_owner->render_surface() &&
-        !PointHitsRect(
-            screen_space_point, SurfaceScreenSpaceTransform(clip_node_owner),
-            clip_node_owner->render_surface()->content_rect(), NULL)) {
+    RenderSurfaceImpl* render_surface = clip_node_owner->render_surface();
+    if (render_surface &&
+        !PointHitsRect(screen_space_point,
+                       SurfaceScreenSpaceTransform(clip_node_owner),
+                       render_surface->content_rect(), NULL)) {
       return true;
     }
   }
   return false;
 }
 
 static bool PointIsClippedBySurfaceOrClipRect(
     const gfx::PointF& screen_space_point,
     const LayerImpl* layer) {
   // Walk up the layer tree and hit-test any render_surfaces and any layer
@@ skipping 264 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc