Rename cc property tree node owner_id to owning_layer_id.

cc/trees/layer_tree_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 350 matching lines @@
   std::unique_ptr<OwnedLayerImplList> ret = std::move(layers_);
   layers_.reset(new OwnedLayerImplList);
   return ret;
 }
 
 static void UpdateClipTreeForBoundsDeltaOnLayer(LayerImpl* layer,
                                                 ClipTree* clip_tree) {
   if (layer && layer->masks_to_bounds()) {
     ClipNode* clip_node = clip_tree->Node(layer->clip_tree_index());
     if (clip_node) {
-      DCHECK_EQ(layer->id(), clip_node->owner_id);
+      DCHECK_EQ(layer->id(), clip_node->owning_layer_id);
       gfx::SizeF bounds = gfx::SizeF(layer->bounds());
       if (clip_node->clip.size() != bounds) {
         clip_node->clip.set_size(bounds);
         clip_tree->set_needs_update(true);
       }
     }
   }
 }
 
 void LayerTreeImpl::SetPropertyTrees(PropertyTrees* property_trees) {
@@ skipping 210 matching lines @@
 LayerImpl* LayerTreeImpl::OuterViewportContainerLayer() const {
   return OuterViewportScrollLayer()
              ? OuterViewportScrollLayer()->scroll_clip_layer()
              : NULL;
 }
 
 LayerImpl* LayerTreeImpl::CurrentlyScrollingLayer() const {
   DCHECK(IsActiveTree());
   const ScrollNode* scroll_node =
       property_trees_.scroll_tree.CurrentlyScrollingNode();
-  return LayerById(scroll_node ? scroll_node->owner_id : Layer::INVALID_ID);
+  return LayerById(scroll_node ? scroll_node->owning_layer_id
+                               : Layer::INVALID_ID);
 }
 
 int LayerTreeImpl::LastScrolledLayerId() const {
   return last_scrolled_layer_id_;
 }
 
 void LayerTreeImpl::SetCurrentlyScrollingLayer(LayerImpl* layer) {
   ScrollTree& scroll_tree = property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
-  int old_id = scroll_node ? scroll_node->owner_id : Layer::INVALID_ID;
+  int old_id = scroll_node ? scroll_node->owning_layer_id : Layer::INVALID_ID;
   int new_id = layer ? layer->id() : Layer::INVALID_ID;
   int new_scroll_node_id = layer ? layer->scroll_tree_index() : -1;
   if (layer)
     last_scrolled_layer_id_ = new_id;
 
   if (old_id == new_id)
     return;
 
   ScrollbarAnimationController* old_animation_controller =
       layer_tree_host_impl_->ScrollbarAnimationControllerForId(old_id);
@@ skipping 1163 matching lines @@
 
   for (const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
        clip_node->id > 1; clip_node = clip_tree.parent(clip_node)) {
     if (clip_node->clip_type == ClipNode::ClipType::APPLIES_LOCAL_CLIP) {
       const TransformNode* transform_node =
           transform_tree.Node(clip_node->target_transform_id);
       gfx::Rect combined_clip_in_target_space =
           gfx::ToEnclosingRect(clip_node->combined_clip_in_target_space);
 
       const LayerImpl* target_layer =
-          layer->layer_tree_impl()->LayerById(transform_node->owner_id);
+          layer->layer_tree_impl()->LayerById(transform_node->owning_layer_id);
       DCHECK(transform_node->id == 0 || target_layer->render_surface() ||
              layer->layer_tree_impl()->is_in_resourceless_software_draw_mode());
       gfx::Transform surface_screen_space_transform =
           transform_node->id == 0 ||
                   (layer->layer_tree_impl()
                        ->is_in_resourceless_software_draw_mode())
               ? gfx::Transform()
               : SurfaceScreenSpaceTransform(target_layer);
       if (!PointHitsRect(screen_space_point, surface_screen_space_transform,
                          combined_clip_in_target_space, NULL)) {
         return true;
       }
     }
     const LayerImpl* clip_node_owner =
-        layer->layer_tree_impl()->LayerById(clip_node->owner_id);
+        layer->layer_tree_impl()->LayerById(clip_node->owning_layer_id);
     if (clip_node_owner->render_surface() &&
         !PointHitsRect(
             screen_space_point, SurfaceScreenSpaceTransform(clip_node_owner),
             clip_node_owner->render_surface()->content_rect(), NULL)) {
       return true;
     }
   }
   return false;
 }
 
@@ skipping 257 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc