Rename cc property tree node owner_id to owning_layer_id.

cc/trees/draw_property_utils.cc

 // Copyright 2014 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/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 28 matching lines @@
 static void ValidateRenderSurfaceForLayer(LayerImpl* layer) {
   // This test verifies that there are no cases where a LayerImpl needs
   // a render surface, but doesn't have one.
   if (layer->has_render_surface())
     return;
 
   DCHECK(!IsRootLayer(layer)) << "layer: " << layer->id();
   EffectNode* effect_node =
       layer->layer_tree_impl()->property_trees()->effect_tree.Node(
           layer->effect_tree_index());
-  if (effect_node->owner_id != layer->id())
+  if (effect_node->owning_layer_id != layer->id())
     return;
   DCHECK_EQ(effect_node->mask_layer_id, EffectTree::kInvalidNodeId)
       << "layer: " << layer->id();
   DCHECK(effect_node->filters.IsEmpty());
   DCHECK(effect_node->background_filters.IsEmpty());
 }
 #endif
 
 static const EffectNode* ContentsTargetEffectNode(
     const int effect_tree_index,
@@ skipping 452 matching lines @@
   const TransformNode* node = tree.Node(transform_tree_index);
   return !node->is_invertible || !node->ancestors_are_invertible;
 }
 
 template <typename LayerType>
 static int TransformTreeIndexForBackfaceVisibility(LayerType* layer,
                                                    const TransformTree& tree) {
   if (!layer->use_parent_backface_visibility())
     return layer->transform_tree_index();
   const TransformNode* node = tree.Node(layer->transform_tree_index());
-  return layer->id() == node->owner_id ? tree.parent(node)->id : node->id;
+  return layer->id() == node->owning_layer_id ? tree.parent(node)->id
+                                              : node->id;
 }
 
 static bool IsTargetSpaceTransformBackFaceVisible(
     Layer* layer,
     int transform_tree_index,
     const PropertyTrees* property_trees) {
   // We do not skip back face invisible layers on main thread as target space
   // transform will not be available here.
   return false;
 }
@@ skipping 99 matching lines @@
 void UpdateRenderSurfaceForLayer(EffectTree* effect_tree,
                                  bool non_root_surfaces_enabled,
                                  LayerImpl* layer) {
   if (!non_root_surfaces_enabled) {
     layer->SetHasRenderSurface(IsRootLayer(layer));
     return;
   }
 
   EffectNode* node = effect_tree->Node(layer->effect_tree_index());
 
-  if (node->owner_id == layer->id() && node->has_render_surface)
+  if (node->owning_layer_id == layer->id() && node->has_render_surface)
     layer->SetHasRenderSurface(true);
   else
     layer->SetHasRenderSurface(false);
 }
 }  // namespace
 
 template <typename LayerType>
 static inline bool LayerShouldBeSkippedInternal(
     LayerType* layer,
     const TransformTree& transform_tree,
@@ skipping 411 matching lines @@
 
 void ComputeVisibleRects(LayerImpl* root_layer,
                          PropertyTrees* property_trees,
                          bool can_render_to_separate_surface,
                          LayerImplList* visible_layer_list) {
   for (auto* layer : *root_layer->layer_tree_impl()) {
     UpdateRenderSurfaceForLayer(&property_trees->effect_tree,
                                 can_render_to_separate_surface, layer);
     EffectNode* node =
         property_trees->effect_tree.Node(layer->effect_tree_index());
-    if (node->owner_id == layer->id())
+    if (node->owning_layer_id == layer->id())
       node->render_surface = layer->render_surface();
 #if DCHECK_IS_ON()
     if (can_render_to_separate_surface)
       ValidateRenderSurfaceForLayer(layer);
 #endif
   }
   ComputeVisibleRectsInternal(root_layer, property_trees,
                               can_render_to_separate_surface,
                               visible_layer_list);
 }
@@ skipping 373 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc