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

cc/trees/occlusion_tracker.cc

 // Copyright 2012 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/occlusion_tracker.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 101 matching lines @@
                                                             region.GetRect(i));
     if (have_clip_rect)
       transformed_rect.Intersect(clip_rect_in_new_target);
     transformed_region.Union(transformed_rect);
   }
   return transformed_region;
 }
 
 void OcclusionTracker::EnterRenderTarget(const LayerImpl* new_target) {
   DCHECK(new_target->has_render_surface());
-  if (!stack_.empty() && stack_.back().target == new_target->render_surface())
+  RenderSurfaceImpl* new_target_surface = new_target->render_surface();
+  if (!stack_.empty() && stack_.back().target == new_target_surface)
     return;
 
   const RenderSurfaceImpl* old_target_surface = NULL;
   const RenderSurfaceImpl* old_occlusion_immune_ancestor = NULL;
   if (!stack_.empty()) {
     old_target_surface = stack_.back().target;
     old_occlusion_immune_ancestor =
         old_target_surface->nearest_occlusion_immune_ancestor();
   }
   const RenderSurfaceImpl* new_occlusion_immune_ancestor =
-      new_target->render_surface()->nearest_occlusion_immune_ancestor();
+      new_target_surface->nearest_occlusion_immune_ancestor();
 
-  stack_.push_back(StackObject(new_target->render_surface()));
+  stack_.push_back(StackObject(new_target_surface));
 
   // We copy the screen occlusion into the new RenderSurfaceImpl subtree, but we
   // never copy in the occlusion from inside the target, since we are looking
   // at a new RenderSurfaceImpl target.
 
   // If entering an unoccluded subtree, do not carry forward the outside
   // occlusion calculated so far.
   bool entering_unoccluded_subtree =
       new_occlusion_immune_ancestor &&
       new_occlusion_immune_ancestor != old_occlusion_immune_ancestor;
 
   gfx::Transform inverse_new_target_screen_space_transform(
       // Note carefully, not used if screen space transform is uninvertible.
       gfx::Transform::kSkipInitialization);
   bool have_transform_from_screen_to_new_target =
-      new_target->render_surface()->screen_space_transform().GetInverse(
+      new_target_surface->screen_space_transform().GetInverse(
           &inverse_new_target_screen_space_transform);
 
   bool entering_root_target =
       new_target->layer_tree_impl()->IsRootLayer(new_target);
 
   bool copy_outside_occlusion_forward =
       stack_.size() > 1 &&
       !entering_unoccluded_subtree &&
       have_transform_from_screen_to_new_target &&
       !entering_root_target;
@@ skipping 86 matching lines @@
     occlusion_rect.Inset(shrink_left, shrink_top, shrink_right, shrink_bottom);
 
     occlusion_from_inside_target->Union(occlusion_rect);
   }
 }
 
 void OcclusionTracker::LeaveToRenderTarget(const LayerImpl* new_target) {
   DCHECK(!stack_.empty());
   size_t last_index = stack_.size() - 1;
   DCHECK(new_target->has_render_surface());
+  RenderSurfaceImpl* new_surface = new_target->render_surface();
   bool surface_will_be_at_top_after_pop =
-      stack_.size() > 1 &&
-      stack_[last_index - 1].target == new_target->render_surface();
+      stack_.size() > 1 && stack_[last_index - 1].target == new_surface;
 
   // We merge the screen occlusion from the current RenderSurfaceImpl subtree
   // out to its parent target RenderSurfaceImpl. The target occlusion can be
   // merged out as well but needs to be transformed to the new target.
 
   const RenderSurfaceImpl* old_surface = stack_[last_index].target;
 
   SimpleEnclosedRegion old_occlusion_from_inside_target_in_new_target =
       TransformSurfaceOpaqueRegion(
           stack_[last_index].occlusion_from_inside_target,
@@ skipping 19 matching lines @@
         old_occlusion_from_inside_target_in_new_target);
     // TODO(danakj): Strictly this should subtract the inside target occlusion
     // before union.
     if (!new_target->layer_tree_impl()->IsRootLayer(new_target)) {
       stack_[last_index - 1].occlusion_from_outside_target.Union(
           old_occlusion_from_outside_target_in_new_target);
     }
     stack_.pop_back();
   } else {
     // Replace the top of the stack with the new pushed surface.
-    stack_.back().target = new_target->render_surface();
+    stack_.back().target = new_surface;
     stack_.back().occlusion_from_inside_target =
         old_occlusion_from_inside_target_in_new_target;
     if (!new_target->layer_tree_impl()->IsRootLayer(new_target)) {
       stack_.back().occlusion_from_outside_target =
           old_occlusion_from_outside_target_in_new_target;
     } else {
       stack_.back().occlusion_from_outside_target.Clear();
     }
   }
 
@@ skipping 58 matching lines @@
   DCHECK(layer_tree->RootRenderSurface() == stack_.back().target);
   const SimpleEnclosedRegion& occluded =
       stack_.back().occlusion_from_inside_target;
   Region visible_region(screen_space_clip_rect_);
   for (size_t i = 0; i < occluded.GetRegionComplexity(); ++i)
     visible_region.Subtract(occluded.GetRect(i));
   return visible_region;
 }
 
 }  // namespace cc