Rename cc property tree node owner_id to owning_layer_id.

Also added brief documentation on the primary node id fields. While it's
slightly redundant IMO it's still helpful for new folks reading the code
given how many different types of ids are in the code base.

BUG=674258
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_trusty_blink_rel

Review-Url: https://codereview.chromium.org/2612883002
Cr-Commit-Position: refs/heads/master@{#441541}

cc/input/scroll_state.cc

@@ -30,7 +30,7 @@ void ScrollState::DistributeToScrollChainDescendant() {
   if (!scroll_chain_.empty()) {
     const ScrollNode* next = scroll_chain_.front();
     scroll_chain_.pop_front();
-    layer_tree_impl_->LayerById(next->owner_id)->DistributeScroll(this);
+    layer_tree_impl_->LayerById(next->owning_layer_id)->DistributeScroll(this);
   }
 }
 

cc/layers/layer_utils.cc

@@ -87,7 +87,7 @@ bool LayerUtils::GetAnimationBounds(const LayerImpl& layer_in, gfx::BoxF* out) {
   for (; transform_tree.parent(transform_node);
        transform_node = transform_tree.parent(transform_node)) {
     LayerImpl* layer =
-        layer_in.layer_tree_impl()->LayerById(transform_node->owner_id);
+        layer_in.layer_tree_impl()->LayerById(transform_node->owning_layer_id);
 
     // Filter animation bounds are unimplemented, see function
     // HasAncestorFilterAnimation() for reference.

cc/trees/clip_node.cc

@@ -13,7 +13,7 @@ namespace cc {
 ClipNode::ClipNode()
     : id(-1),
       parent_id(-1),
-      owner_id(-1),
+      owning_layer_id(-1),
       clip_type(ClipType::NONE),
       transform_id(-1),
       target_transform_id(-1),
@@ -27,8 +27,8 @@ ClipNode::ClipNode(const ClipNode& other) = default;
 
 bool ClipNode::operator==(const ClipNode& other) const {
   return id == other.id && parent_id == other.parent_id &&
-         owner_id == other.owner_id && clip_type == other.clip_type &&
-         clip == other.clip &&
+         owning_layer_id == other.owning_layer_id &&
+         clip_type == other.clip_type && clip == other.clip &&
          combined_clip_in_target_space == other.combined_clip_in_target_space &&
          clip_in_target_space == other.clip_in_target_space &&
          transform_id == other.transform_id &&
@@ -45,7 +45,7 @@ bool ClipNode::operator==(const ClipNode& other) const {
 void ClipNode::AsValueInto(base::trace_event::TracedValue* value) const {
   value->SetInteger("id", id);
   value->SetInteger("parent_id", parent_id);
-  value->SetInteger("owner_id", owner_id);
+  value->SetInteger("owning_layer_id", owning_layer_id);
   value->SetInteger("clip_type", static_cast<int>(clip_type));
   MathUtil::AddToTracedValue("clip", clip, value);
   value->SetInteger("transform_id", transform_id);

cc/trees/clip_node.h

@@ -20,9 +20,12 @@ struct CC_EXPORT ClipNode {
   ClipNode();
   ClipNode(const ClipNode& other);
 
+  // The node index of this node in the clip tree node vector.
   int id;
+  // The node index of the parent node in the clip tree node vector.
   int parent_id;
-  int owner_id;
+  // The layer id of the layer that owns this node.
+  int owning_layer_id;
 
   enum class ClipType {
     // The node doesn't contribute a new clip. It exists only for caching clips

cc/trees/draw_property_utils.cc

@@ -46,7 +46,7 @@ static void ValidateRenderSurfaceForLayer(LayerImpl* layer) {
   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();
@@ -519,7 +519,8 @@ static int TransformTreeIndexForBackfaceVisibility(LayerType* layer,
   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(
@@ -639,7 +640,7 @@ void UpdateRenderSurfaceForLayer(EffectTree* effect_tree,
 
   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);
@@ -1071,7 +1072,7 @@ void ComputeVisibleRects(LayerImpl* root_layer,
                                 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)

cc/trees/effect_node.cc

@@ -12,7 +12,7 @@ namespace cc {
 EffectNode::EffectNode()
     : id(-1),
       parent_id(-1),
-      owner_id(-1),
+      owning_layer_id(-1),
       opacity(1.f),
       screen_space_opacity(1.f),
       blend_mode(SkBlendMode::kSrcOver),
@@ -40,7 +40,7 @@ EffectNode::EffectNode(const EffectNode& other) = default;
 
 bool EffectNode::operator==(const EffectNode& other) const {
   return id == other.id && parent_id == other.parent_id &&
-         owner_id == other.owner_id && opacity == other.opacity &&
+         owning_layer_id == other.owning_layer_id && opacity == other.opacity &&
          screen_space_opacity == other.screen_space_opacity &&
          has_render_surface == other.has_render_surface &&
          surface_is_clipped == other.surface_is_clipped &&
@@ -70,7 +70,7 @@ bool EffectNode::operator==(const EffectNode& other) const {
 void EffectNode::AsValueInto(base::trace_event::TracedValue* value) const {
   value->SetInteger("id", id);
   value->SetInteger("parent_id", parent_id);
-  value->SetInteger("owner_id", owner_id);
+  value->SetInteger("owning_layer_id", owning_layer_id);
   value->SetDouble("opacity", opacity);
   value->SetBoolean("has_render_surface", has_render_surface);
   value->SetBoolean("surface_is_clipped", surface_is_clipped);

cc/trees/effect_node.h

@@ -25,9 +25,12 @@ struct CC_EXPORT EffectNode {
   EffectNode();
   EffectNode(const EffectNode& other);
 
+  // The node index of this node in the effect tree node vector.
   int id;
+  // The node index of the parent node in the effect tree node vector.
   int parent_id;
-  int owner_id;
+  // The layer id of the layer that owns this node.
+  int owning_layer_id;
 
   float opacity;
   float screen_space_opacity;

cc/trees/layer_tree_host_common_unittest.cc

@@ -9613,7 +9613,7 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceClipsSubtree) {
       root->layer_tree_impl()->property_trees()->transform_tree;
   TransformNode* transform_node =
       transform_tree.Node(significant_transform->transform_tree_index());
-  EXPECT_EQ(transform_node->owner_id, significant_transform->id());
+  EXPECT_EQ(transform_node->owning_layer_id, significant_transform->id());
 
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_FALSE(significant_transform->has_render_surface());
@@ -10487,7 +10487,7 @@ TEST_F(LayerTreeHostCommonTest, ScrollTreeBuilderTest) {
   ScrollNode* property_tree_root = expected_scroll_tree.Node(0);
   property_tree_root->id = kRootPropertyTreeNodeId;
   property_tree_root->parent_id = kInvalidPropertyTreeNodeId;
-  property_tree_root->owner_id = kInvalidPropertyTreeNodeId;
+  property_tree_root->owning_layer_id = kInvalidPropertyTreeNodeId;
   property_tree_root->scrollable = false;
   property_tree_root->main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
@@ -10497,7 +10497,7 @@ TEST_F(LayerTreeHostCommonTest, ScrollTreeBuilderTest) {
   // The node owned by root1
   ScrollNode scroll_root1;
   scroll_root1.id = 1;
-  scroll_root1.owner_id = root1->id();
+  scroll_root1.owning_layer_id = root1->id();
   scroll_root1.user_scrollable_horizontal = true;
   scroll_root1.user_scrollable_vertical = true;
   scroll_root1.transform_id = root1->transform_tree_index();
@@ -10506,7 +10506,7 @@ TEST_F(LayerTreeHostCommonTest, ScrollTreeBuilderTest) {
   // The node owned by parent2
   ScrollNode scroll_parent2;
   scroll_parent2.id = 2;
-  scroll_parent2.owner_id = parent2->id();
+  scroll_parent2.owning_layer_id = parent2->id();
   scroll_parent2.scrollable = true;
   scroll_parent2.main_thread_scrolling_reasons =
       parent2->main_thread_scrolling_reasons();
@@ -10522,7 +10522,7 @@ TEST_F(LayerTreeHostCommonTest, ScrollTreeBuilderTest) {
   // The node owned by child6
   ScrollNode scroll_child6;
   scroll_child6.id = 3;
-  scroll_child6.owner_id = child6->id();
+  scroll_child6.owning_layer_id = child6->id();
   scroll_child6.main_thread_scrolling_reasons =
       child6->main_thread_scrolling_reasons();
   scroll_child6.should_flatten = true;
@@ -10534,7 +10534,7 @@ TEST_F(LayerTreeHostCommonTest, ScrollTreeBuilderTest) {
   // The node owned by child7, child7 also owns a transform node
   ScrollNode scroll_child7;
   scroll_child7.id = 4;
-  scroll_child7.owner_id = child7->id();
+  scroll_child7.owning_layer_id = child7->id();
   scroll_child7.scrollable = true;
   scroll_child7.scroll_clip_layer_bounds = parent3->bounds();
   scroll_child7.bounds = child7->bounds();
@@ -10546,7 +10546,7 @@ TEST_F(LayerTreeHostCommonTest, ScrollTreeBuilderTest) {
   // The node owned by grand_child11, grand_child11 also owns a transform node
   ScrollNode scroll_grand_child11;
   scroll_grand_child11.id = 5;
-  scroll_grand_child11.owner_id = grand_child11->id();
+  scroll_grand_child11.owning_layer_id = grand_child11->id();
   scroll_grand_child11.scrollable = true;
   scroll_grand_child11.user_scrollable_horizontal = true;
   scroll_grand_child11.user_scrollable_vertical = true;
@@ -10556,7 +10556,7 @@ TEST_F(LayerTreeHostCommonTest, ScrollTreeBuilderTest) {
   // The node owned by parent5
   ScrollNode scroll_parent5;
   scroll_parent5.id = 8;
-  scroll_parent5.owner_id = parent5->id();
+  scroll_parent5.owning_layer_id = parent5->id();
   scroll_parent5.contains_non_fast_scrollable_region = true;
   scroll_parent5.bounds = gfx::Size(10, 10);
   scroll_parent5.should_flatten = true;

cc/trees/layer_tree_host_impl.cc

@@ -165,7 +165,7 @@ bool IsScrolledBy(LayerImpl* child, LayerImpl* ancestor) {
       child->layer_tree_impl()->property_trees()->scroll_tree;
   for (ScrollNode* scroll_node = scroll_tree.Node(child->scroll_tree_index());
        scroll_node; scroll_node = scroll_tree.parent(scroll_node)) {
-    if (scroll_node->owner_id == ancestor->id())
+    if (scroll_node->owning_layer_id == ancestor->id())
       return true;
   }
   return false;
@@ -2463,7 +2463,7 @@ InputHandler::ScrollStatus LayerTreeHostImpl::TryScroll(
         inverse_screen_space_transform, screen_space_point, &clipped);
     if (!clipped &&
         active_tree()
-            ->LayerById(scroll_node->owner_id)
+            ->LayerById(scroll_node->owning_layer_id)
             ->non_fast_scrollable_region()
             .Contains(gfx::ToRoundedPoint(hit_test_point_in_layer_space))) {
       TRACE_EVENT0("cc",
@@ -2545,7 +2545,7 @@ LayerImpl* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
       if (status.thread == InputHandler::SCROLL_ON_IMPL_THREAD &&
           !potentially_scrolling_layer_impl) {
         potentially_scrolling_layer_impl =
-            active_tree_->LayerById(scroll_node->owner_id);
+            active_tree_->LayerById(scroll_node->owning_layer_id);
       }
     }
   }
@@ -2586,7 +2586,7 @@ static bool IsClosestScrollAncestor(LayerImpl* child,
   for (; scroll_tree.parent(scroll_node);
        scroll_node = scroll_tree.parent(scroll_node)) {
     if (scroll_node->scrollable)
-      return scroll_node->owner_id == scroll_ancestor->id();
+      return scroll_node->owning_layer_id == scroll_ancestor->id();
   }
   return false;
 }
@@ -2747,7 +2747,7 @@ gfx::Vector2dF LayerTreeHostImpl::ComputeScrollDelta(
     adjusted_scroll.set_y(0);
 
   gfx::ScrollOffset old_offset =
-      scroll_tree.current_scroll_offset(scroll_node->owner_id);
+      scroll_tree.current_scroll_offset(scroll_node->owning_layer_id);
   gfx::ScrollOffset new_offset = scroll_tree.ClampScrollOffsetToLimits(
       old_offset + gfx::ScrollOffset(adjusted_scroll), scroll_node);
 
@@ -2771,11 +2771,12 @@ bool LayerTreeHostImpl::ScrollAnimationCreate(ScrollNode* scroll_node,
   scroll_tree.set_currently_scrolling_node(scroll_node->id);
 
   gfx::ScrollOffset current_offset =
-      scroll_tree.current_scroll_offset(scroll_node->owner_id);
+      scroll_tree.current_scroll_offset(scroll_node->owning_layer_id);
   gfx::ScrollOffset target_offset = scroll_tree.ClampScrollOffsetToLimits(
       current_offset + gfx::ScrollOffset(delta), scroll_node);
   DCHECK_EQ(
-      ElementId(active_tree()->LayerById(scroll_node->owner_id)->element_id()),
+      ElementId(
+          active_tree()->LayerById(scroll_node->owning_layer_id)->element_id()),
       scroll_node->element_id);
 
   mutator_host_->ImplOnlyScrollAnimationCreate(
@@ -2832,7 +2833,8 @@ InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
           continue;
 
         if (viewport()->MainScrollLayer() &&
-            scroll_node->owner_id == viewport()->MainScrollLayer()->id()) {
+            scroll_node->owning_layer_id ==
+                viewport()->MainScrollLayer()->id()) {
           gfx::Vector2dF scrolled =
               viewport()->ScrollAnimated(pending_delta, delayed_by);
           // Viewport::ScrollAnimated returns pending_delta as long as it
@@ -2899,11 +2901,11 @@ gfx::Vector2dF LayerTreeHostImpl::ScrollNodeWithViewportSpaceDelta(
 
   // Apply the scroll delta.
   gfx::ScrollOffset previous_offset =
-      scroll_tree->current_scroll_offset(scroll_node->owner_id);
+      scroll_tree->current_scroll_offset(scroll_node->owning_layer_id);
   scroll_tree->ScrollBy(scroll_node, local_end_point - local_start_point,
                         active_tree());
   gfx::ScrollOffset scrolled =
-      scroll_tree->current_scroll_offset(scroll_node->owner_id) -
+      scroll_tree->current_scroll_offset(scroll_node->owning_layer_id) -
       previous_offset;
 
   // Get the end point in the layer's content space so we can apply its
@@ -2929,12 +2931,12 @@ static gfx::Vector2dF ScrollNodeWithLocalDelta(
     LayerTreeImpl* layer_tree_impl) {
   ScrollTree& scroll_tree = layer_tree_impl->property_trees()->scroll_tree;
   gfx::ScrollOffset previous_offset =
-      scroll_tree.current_scroll_offset(scroll_node->owner_id);
+      scroll_tree.current_scroll_offset(scroll_node->owning_layer_id);
   gfx::Vector2dF delta = local_delta;
   delta.Scale(1.f / page_scale_factor);
   scroll_tree.ScrollBy(scroll_node, delta, layer_tree_impl);
   gfx::ScrollOffset scrolled =
-      scroll_tree.current_scroll_offset(scroll_node->owner_id) -
+      scroll_tree.current_scroll_offset(scroll_node->owning_layer_id) -
       previous_offset;
   gfx::Vector2dF consumed_scroll(scrolled.x(), scrolled.y());
   consumed_scroll.Scale(page_scale_factor);
@@ -2980,15 +2982,15 @@ void LayerTreeHostImpl::ApplyScroll(ScrollNode* scroll_node,
 
   bool is_viewport_scroll_layer =
       viewport()->MainScrollLayer() &&
-      scroll_node->owner_id == viewport()->MainScrollLayer()->id();
+      scroll_node->owning_layer_id == viewport()->MainScrollLayer()->id();
 
   // This is needed if the scroll chains up to the viewport without going
   // through the outer viewport scroll layer. This can happen if we scroll an
   // element that's not a descendant of the document.rootScroller. In that case
   // we want to scroll the inner viewport -- to allow panning while zoomed --
   // but also move browser controls if needed.
   bool is_inner_viewport_scroll_layer =
-      scroll_node->owner_id == InnerViewportScrollLayer()->id();
+      scroll_node->owning_layer_id == InnerViewportScrollLayer()->id();
 
   if (is_viewport_scroll_layer || is_inner_viewport_scroll_layer) {
     Viewport::ScrollResult result = viewport()->ScrollBy(
@@ -3097,7 +3099,7 @@ InputHandlerScrollResult LayerTreeHostImpl::ScrollBy(
   DistributeScrollDelta(scroll_state);
 
   active_tree_->SetCurrentlyScrollingLayer(active_tree_->LayerById(
-      scroll_state->current_native_scrolling_node()->owner_id));
+      scroll_state->current_native_scrolling_node()->owning_layer_id));
   did_lock_scrolling_layer_ =
       scroll_state->delta_consumed_for_scroll_sequence();
 
@@ -3853,7 +3855,8 @@ bool LayerTreeHostImpl::ScrollAnimationUpdateTarget(
     const gfx::Vector2dF& scroll_delta,
     base::TimeDelta delayed_by) {
   DCHECK_EQ(
-      ElementId(active_tree()->LayerById(scroll_node->owner_id)->element_id()),
+      ElementId(
+          active_tree()->LayerById(scroll_node->owning_layer_id)->element_id()),
       scroll_node->element_id);
 
   return mutator_host_->ImplOnlyScrollAnimationUpdateTarget(

cc/trees/layer_tree_impl.cc

@@ -368,7 +368,7 @@ static void UpdateClipTreeForBoundsDeltaOnLayer(LayerImpl* layer,
   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);
@@ -599,7 +599,8 @@ 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 {
@@ -609,7 +610,7 @@ int LayerTreeImpl::LastScrolledLayerId() const {
 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)
@@ -1793,7 +1794,7 @@ static bool PointIsClippedByAncestorClipNode(
           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 =
@@ -1808,7 +1809,7 @@ static bool PointIsClippedByAncestorClipNode(
       }
     }
     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),