cc: Rename LayerImpl::is_drawn_render_surface_layer_list_member

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 166 matching lines @@
 }
 
 ScrollAndScaleSet::ScrollAndScaleSet()
     : page_scale_delta(1.f),
       top_controls_delta(0.f),
       has_scrolled_by_wheel(false),
       has_scrolled_by_touch(false) {}
 
 ScrollAndScaleSet::~ScrollAndScaleSet() {}
 
-static inline void SetMaskLayersAreDrawnRenderSurfaceLayerListMembers(
+static inline void SetMaskLayersContributeToDrawnRenderSurface(
     RenderSurfaceImpl* surface,
     PropertyTrees* property_trees) {
   LayerImpl* mask_layer = surface->MaskLayer();
   if (mask_layer) {
-    mask_layer->set_is_drawn_render_surface_layer_list_member(true);
+    mask_layer->set_contributes_to_drawn_render_surface(true);
     draw_property_utils::ComputeMaskDrawProperties(mask_layer, property_trees);
   }
 }
 
-static inline void ClearMaskLayersAreDrawnRenderSurfaceLayerListMembers(
+static inline void ClearMaskLayersContributeToDrawnRenderSurface(
     RenderSurfaceImpl* surface) {
   LayerImpl* mask_layer = surface->MaskLayer();
   if (mask_layer)
-    mask_layer->set_is_drawn_render_surface_layer_list_member(false);
+    mask_layer->set_contributes_to_drawn_render_surface(false);
 }
 
 static bool CdpPerfTracingEnabled() {
   bool tracing_enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED("cdp.perf", &tracing_enabled);
   return tracing_enabled;
 }
 
 static float TranslationFromActiveTreeLayerScreenSpaceTransform(
     LayerImpl* pending_tree_layer) {
@@ skipping 114 matching lines @@
     LayerTreeImpl* layer_tree_impl,
     PropertyTrees* property_trees,
     RenderSurfaceList* render_surface_list,
     bool can_render_to_separate_surface) {
   EffectTree& effect_tree = property_trees->effect_tree;
   for (int i = EffectTree::kContentsRootNodeId;
        i < static_cast<int>(effect_tree.size()); ++i) {
     if (RenderSurfaceImpl* render_surface = effect_tree.GetRenderSurface(i)) {
       render_surface->set_is_render_surface_list_member(false);
       render_surface->reset_num_contributors();
-      ClearMaskLayersAreDrawnRenderSurfaceLayerListMembers(render_surface);
+      ClearMaskLayersContributeToDrawnRenderSurface(render_surface);
     }
   }
 
   RenderSurfaceImpl* root_surface =
       effect_tree.GetRenderSurface(EffectTree::kContentsRootNodeId);
   // The root surface always gets added to the render surface  list.
   AddSurfaceToRenderSurfaceList(root_surface, render_surface_list,
                                 property_trees);
   // For all non-skipped layers, add their target to the render surface list if
   // it's not already been added, and add their content rect to the target
   // surface's accumulated content rect.
   for (LayerImpl* layer : *layer_tree_impl) {
-    layer->set_is_drawn_render_surface_layer_list_member(false);
+    layer->set_contributes_to_drawn_render_surface(false);
 
     bool is_root = layer_tree_impl->IsRootLayer(layer);
 
     bool skip_draw_properties_computation =
         draw_property_utils::LayerShouldBeSkippedForDrawPropertiesComputation(
             layer, property_trees->transform_tree, property_trees->effect_tree);
 
     const TransformNode* transform_node =
         property_trees->transform_tree.Node(layer->transform_tree_index());
     bool skip_for_invertibility = !transform_node->ancestors_are_invertible;
@@ skipping 12 matching lines @@
         layer, layer_is_drawn, property_trees);
     if (!layer_should_be_drawn)
       continue;
 
     RenderSurfaceImpl* render_target = layer->render_target();
     if (!render_target->is_render_surface_list_member()) {
       AddSurfaceToRenderSurfaceList(render_target, render_surface_list,
                                     property_trees);
     }
 
-    layer->set_is_drawn_render_surface_layer_list_member(true);
+    layer->set_contributes_to_drawn_render_surface(true);
 
     // The layer contributes its drawable content rect to its render target.
     render_target->AccumulateContentRectFromContributingLayer(layer);
     render_target->increment_num_contributors();
   }
 }
 
 static void ComputeSurfaceContentRects(LayerTreeImpl* layer_tree_impl,
                                        PropertyTrees* property_trees,
                                        RenderSurfaceList* render_surface_list,
@@ skipping 37 matching lines @@
     bool is_root =
         surface->EffectTreeIndex() == EffectTree::kContentsRootNodeId;
     RenderSurfaceImpl* target_surface = surface->render_target();
     if (!is_root && (surface->content_rect().IsEmpty() ||
                      !target_surface->is_render_surface_list_member())) {
       surface->set_is_render_surface_list_member(false);
       removed_surface = true;
       target_surface->decrement_num_contributors();
       continue;
     }
-    SetMaskLayersAreDrawnRenderSurfaceLayerListMembers(surface, property_trees);
+    SetMaskLayersContributeToDrawnRenderSurface(surface, property_trees);
     final_surface_list->push_back(surface);
   }
   if (removed_surface) {
     for (LayerImpl* layer : *layer_tree_impl) {
-      if (layer->is_drawn_render_surface_layer_list_member()) {
+      if (layer->contributes_to_drawn_render_surface()) {
         RenderSurfaceImpl* render_target = layer->render_target();
         if (!render_target->is_render_surface_list_member()) {
-          layer->set_is_drawn_render_surface_layer_list_member(false);
+          layer->set_contributes_to_drawn_render_surface(false);
           render_target->decrement_num_contributors();
         }
       }
     }
   }
 }
 
 static void CalculateRenderSurfaceLayerList(
     LayerTreeImpl* layer_tree_impl,
     PropertyTrees* property_trees,
@@ skipping 203 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