cc: Rename LayerImpl::render_surface to GetRenderSurface

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) {
-    RenderSurfaceImpl* render_surface = layer->render_surface();
+    RenderSurfaceImpl* render_surface = layer->GetRenderSurface();
     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);
@@ skipping 60 matching lines @@
   }
 }
 
 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();
+    RenderSurfaceImpl* render_surface = layer->GetRenderSurface();
     if (layer_tree_impl->IsRootLayer(layer)) {
       // The root layer's surface content rect is always the entire viewport.
       render_surface->SetContentRectToViewport();
       continue;
     }
 
     // Now all contributing drawable content rect has been accumulated to this
     // render surface, calculate the content rect.
     render_surface->CalculateContentRectFromAccumulatedContentRect(
         max_texture_size);
 
     // Now the render surface's content rect is calculated correctly, it could
     // contribute to its render target.
     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
   // the final list do not get added to the final list.
   for (LayerImpl* layer : *initial_surface_list) {
     bool is_root = layer_tree_impl->IsRootLayer(layer);
-    RenderSurfaceImpl* surface = layer->render_surface();
+    RenderSurfaceImpl* surface = layer->GetRenderSurface();
     RenderSurfaceImpl* target_surface = surface->render_target();
     if (!is_root && (surface->content_rect().IsEmpty() ||
                      target_surface->layer_list().empty())) {
       ClearIsDrawnRenderSurfaceLayerListMember(&surface->layer_list(),
                                                &property_trees->scroll_tree);
       surface->ClearLayerLists();
       if (!is_root) {
         LayerImplList& target_list = target_surface->layer_list();
         auto it = std::find(target_list.begin(), target_list.end(), layer);
         if (it != target_list.end()) {
@@ skipping 145 matching lines @@
     draw_property_utils::VerifyVisibleRectsCalculations(visible_layer_list,
                                                         inputs->property_trees);
 
   if (should_measure_property_tree_performance) {
     TRACE_EVENT_END0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                      "LayerTreeHostCommon::CalculateDrawProperties");
   }
 
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
-  DCHECK(inputs->root_layer->render_surface());
+  DCHECK(inputs->root_layer->GetRenderSurface());
 }
 
 void LayerTreeHostCommon::CalculateDrawPropertiesForTesting(
     CalcDrawPropsMainInputsForTesting* inputs) {
   LayerList update_layer_list;
   bool can_render_to_separate_surface = true;
   PropertyTrees* property_trees =
       inputs->root_layer->layer_tree_host()->property_trees();
   Layer* overscroll_elasticity_layer = nullptr;
   gfx::Vector2dF elastic_overscroll;
@@ skipping 69 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