cc: Rename LayerImpl::render_surface to GetRenderSurface

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 100 matching lines @@
         MathUtil::MapEnclosedRectWith2dAxisAlignedTransform(transform,
                                                             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());
-  RenderSurfaceImpl* new_target_surface = new_target->render_surface();
+  DCHECK(new_target->GetRenderSurface());
+  RenderSurfaceImpl* new_target_surface = new_target->GetRenderSurface();
   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();
   }
@@ skipping 41 matching lines @@
   stack_[last_index].occlusion_from_outside_target.Union(
       TransformSurfaceOpaqueRegion(
           stack_[last_index - 1].occlusion_from_inside_target, false,
           gfx::Rect(), old_target_to_new_target_transform));
 }
 
 void OcclusionTracker::FinishedRenderTarget(const LayerImpl* finished_target) {
   // Make sure we know about the target surface.
   EnterRenderTarget(finished_target);
 
-  RenderSurfaceImpl* surface = finished_target->render_surface();
+  RenderSurfaceImpl* surface = finished_target->GetRenderSurface();
 
   // Readbacks always happen on render targets so we only need to check
   // for readbacks here.
   bool target_is_only_for_copy_request =
       surface->HasCopyRequest() && finished_target->IsHidden();
 
   // If the occlusion within the surface can not be applied to things outside of
   // the surface's subtree, then clear the occlusion here so it won't be used.
   if (surface->MaskLayer() || surface->draw_opacity() < 1 ||
       !surface->UsesDefaultBlendMode() || target_is_only_for_copy_request ||
@@ skipping 53 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();
+  DCHECK(new_target->GetRenderSurface());
+  RenderSurfaceImpl* new_surface = new_target->GetRenderSurface();
   bool surface_will_be_at_top_after_pop =
       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 =
@@ skipping 100 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