Rename cc property tree node owner_id to owning_layer_id.

cc/trees/property_tree_builder.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/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 320 matching lines @@
 
 template <typename LayerType>
 static void SetSurfaceIsClipped(DataForRecursion<LayerType>* data_for_children,
                                 bool apply_ancestor_clip,
                                 LayerType* layer) {
   // A surface with unclipped descendants cannot be clipped by its ancestor
   // clip at draw time since the unclipped descendants aren't affected by the
   // ancestor clip.
   EffectNode* effect_node = data_for_children->property_trees->effect_tree.Node(
       data_for_children->render_target);
-  DCHECK_EQ(effect_node->owner_id, layer->id());
+  DCHECK_EQ(effect_node->owning_layer_id, layer->id());
   effect_node->surface_is_clipped =
       apply_ancestor_clip && !NumUnclippedDescendants(layer);
   // The ancestor clip should propagate to children only if the surface doesn't
   // apply the clip.
   data_for_children->apply_ancestor_clip =
       apply_ancestor_clip && !effect_node->surface_is_clipped;
 }
 
 template <typename LayerType>
 void AddClipNodeIfNeeded(const DataForRecursion<LayerType>& data_from_ancestor,
@@ skipping 64 matching lines @@
       transform_parent = data_for_children->transform_fixed_parent;
     }
     ClipNode node;
     node.clip = gfx::RectF(gfx::PointF() + layer->offset_to_transform_parent(),
                            gfx::SizeF(layer->bounds()));
     node.transform_id = transform_parent->transform_tree_index();
     node.target_effect_id = data_for_children->render_target;
     node.target_transform_id = data_for_children->property_trees->effect_tree
                                    .Node(data_for_children->render_target)
                                    ->transform_id;
-    node.owner_id = layer->id();
+    node.owning_layer_id = layer->id();
 
     if (apply_ancestor_clip || layer_clips_subtree) {
       // Surfaces reset the rect used for layer clipping. At other nodes, layer
       // clipping state from ancestors must continue to get propagated.
       node.layer_clipping_uses_only_local_clip =
           (created_render_surface && NumUnclippedDescendants(layer) == 0) ||
           !apply_ancestor_clip;
     } else {
       // Otherwise, we're either unclipped, or exist only in order to apply our
       // parent's clips in our space.
@@ skipping 296 matching lines @@
   }
 
   node->needs_local_transform_update = true;
   data_from_ancestor.property_trees->transform_tree.UpdateTransforms(node->id);
 
   layer->set_offset_to_transform_parent(gfx::Vector2dF());
 
   // Flattening (if needed) will be handled by |node|.
   layer->set_should_flatten_transform_from_property_tree(false);
 
-  node->owner_id = layer->id();
+  node->owning_layer_id = layer->id();
 
   return true;
 }
 
 static inline bool HasPotentialOpacityAnimation(Layer* layer) {
   return HasPotentiallyRunningOpacityAnimation(layer) ||
          layer->OpacityCanAnimateOnImplThread();
 }
 
 static inline bool HasPotentialOpacityAnimation(LayerImpl* layer) {
@@ skipping 264 matching lines @@
 
   if (!requires_node) {
     layer->SetEffectTreeIndex(parent_id);
     data_for_children->effect_tree_parent = parent_id;
     data_for_children->compound_transform_since_render_target *=
         Transform(layer);
     return false;
   }
 
   EffectNode node;
-  node.owner_id = layer->id();
+  node.owning_layer_id = layer->id();
   if (AlwaysUseActiveTreeOpacity(layer)) {
     data_for_children->property_trees->always_use_active_tree_opacity_effect_ids
-        .push_back(node.owner_id);
+        .push_back(node.owning_layer_id);
   }
 
   node.opacity = Opacity(layer);
   node.blend_mode = BlendMode(layer);
   node.unscaled_mask_target_size = layer->bounds();
   node.has_render_surface = should_create_render_surface;
   node.has_copy_request = HasCopyRequest(layer);
   node.filters = Filters(layer);
   node.background_filters = BackgroundFilters(layer);
   node.filters_origin = FiltersOrigin(layer);
@@ skipping 77 matching lines @@
       (main_thread_scrolling_reasons !=
            MainThreadScrollingReason::kNotScrollingOnMain &&
        (has_different_main_thread_scrolling_reasons ||
         data_from_ancestor
             .scroll_tree_parent_created_by_uninheritable_criteria));
 
   if (!requires_node) {
     data_for_children->scroll_tree_parent = parent_id;
   } else {
     ScrollNode node;
-    node.owner_id = layer->id();
+    node.owning_layer_id = layer->id();
     node.scrollable = scrollable;
     node.main_thread_scrolling_reasons = main_thread_scrolling_reasons;
     node.contains_non_fast_scrollable_region =
         contains_non_fast_scrollable_region;
     gfx::Size clip_bounds;
     if (layer->scroll_clip_layer()) {
       clip_bounds = layer->scroll_clip_layer()->bounds();
       DCHECK(layer->scroll_clip_layer()->transform_tree_index() !=
              kInvalidPropertyTreeNodeId);
       node.max_scroll_offset_affected_by_page_scale =
@@ skipping 162 matching lines @@
         layer->offset_to_transform_parent());
     MaskLayer(layer)->SetTransformTreeIndex(layer->transform_tree_index());
     MaskLayer(layer)->SetClipTreeIndex(layer->clip_tree_index());
     MaskLayer(layer)->SetEffectTreeIndex(layer->effect_tree_index());
     MaskLayer(layer)->SetScrollTreeIndex(layer->scroll_tree_index());
   }
 
   EffectNode* effect_node = data_for_children.property_trees->effect_tree.Node(
       data_for_children.effect_tree_parent);
 
-  if (effect_node->owner_id == layer->id()) {
+  if (effect_node->owning_layer_id == layer->id()) {
     if (effect_node->has_copy_request)
       data_to_parent->num_copy_requests_in_subtree++;
     effect_node->num_copy_requests_in_subtree =
         data_to_parent->num_copy_requests_in_subtree;
   }
 }
 
 }  // namespace
 
 void CC_EXPORT
@@ skipping 181 matching lines @@
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
   property_trees->ResetCachedData();
 }
 
 }  // namespace cc