Rename cc property tree node owner_id to owning_layer_id.

cc/trees/property_tree.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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 161 matching lines @@
     }
   }
 
   return true;
 }
 
 void TransformTree::OnTransformAnimated(const gfx::Transform& transform,
                                         int id,
                                         LayerTreeImpl* layer_tree_impl) {
   TransformNode* node = Node(id);
-  layer_tree_impl->AddToTransformAnimationsMap(node->owner_id, transform);
+  layer_tree_impl->AddToTransformAnimationsMap(node->owning_layer_id,
+                                               transform);
   if (node->local == transform) {
     return;
   }
   node->local = transform;
   node->needs_local_transform_update = true;
   node->transform_changed = true;
   property_trees()->changed = true;
   set_needs_update(true);
   layer_tree_impl->set_needs_update_draw_properties();
 }
@@ skipping 150 matching lines @@
 gfx::Vector2dF StickyPositionOffset(TransformTree* tree, TransformNode* node) {
   if (node->sticky_position_constraint_id == -1)
     return gfx::Vector2dF();
   const StickyPositionNodeData* sticky_data =
       tree->StickyPositionData(node->id);
   const LayerStickyPositionConstraint& constraint = sticky_data->constraints;
   ScrollNode* scroll_node =
       tree->property_trees()->scroll_tree.Node(sticky_data->scroll_ancestor);
   gfx::ScrollOffset scroll_offset =
       tree->property_trees()->scroll_tree.current_scroll_offset(
-          scroll_node->owner_id);
+          scroll_node->owning_layer_id);
   gfx::PointF scroll_position(scroll_offset.x(), scroll_offset.y());
   TransformNode* scroll_ancestor_transform_node =
       tree->Node(scroll_node->transform_id);
   if (scroll_ancestor_transform_node->scrolls) {
     // The scroll position does not include snapping which shifts the scroll
     // offset to align to a pixel boundary, we need to manually include it here.
     // In this case, snapping is caused by a scroll.
     scroll_position -= scroll_ancestor_transform_node->snap_amount;
   }
 
@@ skipping 465 matching lines @@
     layer_scale_factor *= transform_tree.page_scale_factor();
   effect_node->surface_contents_scale =
       MathUtil::ComputeTransform2dScaleComponents(
           transform_tree.ToScreen(transform_node->id), layer_scale_factor);
 }
 
 void EffectTree::OnOpacityAnimated(float opacity,
                                    int id,
                                    LayerTreeImpl* layer_tree_impl) {
   EffectNode* node = Node(id);
-  layer_tree_impl->AddToOpacityAnimationsMap(node->owner_id, opacity);
+  layer_tree_impl->AddToOpacityAnimationsMap(node->owning_layer_id, opacity);
   if (node->opacity == opacity)
     return;
   node->opacity = opacity;
   node->effect_changed = true;
   property_trees()->changed = true;
   property_trees()->effect_tree.set_needs_update(true);
   layer_tree_impl->set_needs_update_draw_properties();
 }
 
 void EffectTree::OnFilterAnimated(const FilterOperations& filters,
                                   int id,
                                   LayerTreeImpl* layer_tree_impl) {
   EffectNode* node = Node(id);
-  layer_tree_impl->AddToFilterAnimationsMap(node->owner_id, filters);
+  layer_tree_impl->AddToFilterAnimationsMap(node->owning_layer_id, filters);
   if (node->filters == filters)
     return;
   node->filters = filters;
   node->effect_changed = true;
   property_trees()->changed = true;
   property_trees()->effect_tree.set_needs_update(true);
   layer_tree_impl->set_needs_update_draw_properties();
 }
 
 void EffectTree::UpdateEffects(int id) {
@@ skipping 540 matching lines @@
 
 gfx::Vector2dF ScrollTree::ScrollBy(ScrollNode* scroll_node,
                                     const gfx::Vector2dF& scroll,
                                     LayerTreeImpl* layer_tree_impl) {
   gfx::ScrollOffset adjusted_scroll(scroll);
   if (!scroll_node->user_scrollable_horizontal)
     adjusted_scroll.set_x(0);
   if (!scroll_node->user_scrollable_vertical)
     adjusted_scroll.set_y(0);
   DCHECK(scroll_node->scrollable);
-  gfx::ScrollOffset old_offset = current_scroll_offset(scroll_node->owner_id);
+  gfx::ScrollOffset old_offset =
+      current_scroll_offset(scroll_node->owning_layer_id);
   gfx::ScrollOffset new_offset =
       ClampScrollOffsetToLimits(old_offset + adjusted_scroll, scroll_node);
-  if (SetScrollOffset(scroll_node->owner_id, new_offset))
-    layer_tree_impl->DidUpdateScrollOffset(scroll_node->owner_id);
+  if (SetScrollOffset(scroll_node->owning_layer_id, new_offset))
+    layer_tree_impl->DidUpdateScrollOffset(scroll_node->owning_layer_id);
 
   gfx::ScrollOffset unscrolled =
       old_offset + gfx::ScrollOffset(scroll) - new_offset;
   return gfx::Vector2dF(unscrolled.x(), unscrolled.y());
 }
 
 gfx::ScrollOffset ScrollTree::ClampScrollOffsetToLimits(
     gfx::ScrollOffset offset,
     ScrollNode* scroll_node) const {
   offset.SetToMin(MaxScrollOffset(scroll_node->id));
@@ skipping 326 matching lines @@
       float max_local_scale = std::max(local_scales.x(), local_scales.y());
       cached_data_.animation_scales[transform_node_id]
           .combined_maximum_animation_target_scale =
           max_local_scale * ancestor_maximum_target_scale;
       cached_data_.animation_scales[transform_node_id]
           .combined_starting_animation_scale =
           max_local_scale * ancestor_starting_animation_scale;
     } else {
       // TODO(sunxd): make LayerTreeImpl::MaximumTargetScale take layer id as
       // parameter.
-      LayerImpl* layer_impl = layer_tree_impl->LayerById(node->owner_id);
+      LayerImpl* layer_impl = layer_tree_impl->LayerById(node->owning_layer_id);
       layer_impl->GetMutatorHost()->MaximumTargetScale(
           layer_impl->element_id(), layer_impl->GetElementTypeForAnimation(),
           &cached_data_.animation_scales[transform_node_id]
                .local_maximum_animation_target_scale);
       layer_impl->GetMutatorHost()->AnimationStartScale(
           layer_impl->element_id(), layer_impl->GetElementTypeForAnimation(),
           &cached_data_.animation_scales[transform_node_id]
                .local_starting_animation_scale);
       gfx::Vector2dF local_scales =
           MathUtil::ComputeTransform2dScaleComponents(node->local, 0.f);
@@ skipping 200 matching lines @@
 
   const EffectNode* effect_node = effect_tree.Node(effect_id);
 
   bool success = GetFromTarget(transform_id, effect_id, transform);
   transform->Scale(effect_node->surface_contents_scale.x(),
                    effect_node->surface_contents_scale.y());
   return success;
 }
 
 }  // namespace cc