cc: Rename LayerImpl::render_surface to GetRenderSurface

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 259 matching lines @@
   if (scrollbar_needs_animation) {
     ScrollbarAnimationController* controller =
         layer_tree_host_impl_->ScrollbarAnimationControllerForId(
             scroll_layer_id);
     if (controller)
       controller->DidScrollUpdate(scroll_layer_size_did_change);
   }
 }
 
 RenderSurfaceImpl* LayerTreeImpl::RootRenderSurface() const {
-  return layer_list_.empty() ? nullptr : layer_list_[0]->render_surface();
+  return layer_list_.empty() ? nullptr : layer_list_[0]->GetRenderSurface();
 }
 
 bool LayerTreeImpl::LayerListIsEmpty() const {
   return layer_list_.empty();
 }
 
 void LayerTreeImpl::SetRootLayerForTesting(std::unique_ptr<LayerImpl> layer) {
   if (root_layer_for_testing_ && layer.get() != root_layer_for_testing_)
     RemoveLayer(root_layer_for_testing_->id());
   root_layer_for_testing_ = layer.get();
@@ skipping 751 matching lines @@
           base::StringPrintf("Compositing.%s.NumRenderSurfaces", client_name),
           base::saturated_cast<int>(render_surface_layer_list_.size()));
     }
   }
 
   {
     TRACE_EVENT2("cc", "LayerTreeImpl::UpdateDrawProperties::Occlusion",
                  "IsActive", IsActiveTree(), "SourceFrameNumber",
                  source_frame_number_);
     OcclusionTracker occlusion_tracker(
-        layer_list_[0]->render_surface()->content_rect());
+        layer_list_[0]->GetRenderSurface()->content_rect());
     occlusion_tracker.set_minimum_tracking_size(
         settings().minimum_occlusion_tracking_size);
 
     // LayerIterator is used here instead of CallFunctionForEveryLayer to only
     // UpdateTilePriorities on layers that will be visible (and thus have valid
     // draw properties) and not because any ordering is required.
     LayerIterator end = LayerIterator::End(&render_surface_layer_list_);
     for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list_);
          it != end; ++it) {
       occlusion_tracker.EnterLayer(it);
 
       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();
+        RenderSurfaceImpl* render_surface = it->GetRenderSurface();
         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(render_surface->TransformTreeIndex(),
                                         occlusion_surface->EffectTreeIndex(),
                                         &draw_transform);
           const EffectNode* effect_node = property_trees()->effect_tree.Node(
               render_surface->EffectTreeIndex());
           draw_property_utils::ConcatInverseSurfaceContentsScale(
@@ skipping 702 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();
-  RenderSurfaceImpl* render_surface = layer->render_surface();
+  RenderSurfaceImpl* render_surface = layer->GetRenderSurface();
   DCHECK(render_surface);
   return layer->is_drawn_render_surface_layer_list_member()
              ? render_surface->screen_space_transform()
              : property_trees
                    ->ToScreenSpaceTransformWithoutSurfaceContentsScale(
                        render_surface->TransformTreeIndex(),
                        render_surface->EffectTreeIndex());
 }
 
 static bool PointIsClippedByAncestorClipNode(
@@ skipping 24 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);
-    RenderSurfaceImpl* render_surface = clip_node_owner->render_surface();
+    RenderSurfaceImpl* render_surface = clip_node_owner->GetRenderSurface();
     if (render_surface &&
         !PointHitsRect(screen_space_point,
                        SurfaceScreenSpaceTransform(clip_node_owner),
                        render_surface->content_rect(), NULL)) {
       return true;
     }
   }
   return false;
 }
 
@@ skipping 266 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