Rename cc property tree node owner_id to owning_layer_id.

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.cpp

 // Copyright 2015 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 "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/playback/compositing_display_item.h"
@@ skipping 670 matching lines @@
 void PropertyTreeManager::setupRootClipNode() {
   // cc is hardcoded to use clip node index 1 for viewport clip.
   cc::ClipTree& clipTree = m_propertyTrees.clip_tree;
   clipTree.clear();
   m_propertyTrees.clip_id_to_index_map.clear();
   cc::ClipNode& clipNode =
       *clipTree.Node(clipTree.Insert(cc::ClipNode(), kRealRootNodeId));
   DCHECK_EQ(clipNode.id, kSecondaryRootNodeId);
 
   clipNode.resets_clip = true;
-  clipNode.owner_id = m_rootLayer->id();
+  clipNode.owning_layer_id = m_rootLayer->id();
   clipNode.clip_type = cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP;
   clipNode.clip = gfx::RectF(
       gfx::SizeF(m_rootLayer->GetLayerTree()->device_viewport_size()));
   clipNode.transform_id = kRealRootNodeId;
   clipNode.target_transform_id = kRealRootNodeId;
   clipNode.target_effect_id = kSecondaryRootNodeId;
-  m_propertyTrees.clip_id_to_index_map[clipNode.owner_id] = clipNode.id;
+  m_propertyTrees.clip_id_to_index_map[clipNode.owning_layer_id] = clipNode.id;
 
   m_clipNodeMap.set(ClipPaintPropertyNode::root(), clipNode.id);
   m_rootLayer->SetClipTreeIndex(clipNode.id);
 }
 
 void PropertyTreeManager::setupRootEffectNode() {
   // cc is hardcoded to use effect node index 1 for root render surface.
   cc::EffectTree& effectTree = m_propertyTrees.effect_tree;
   effectTree.clear();
   m_propertyTrees.effect_id_to_index_map.clear();
   cc::EffectNode& effectNode =
       *effectTree.Node(effectTree.Insert(cc::EffectNode(), kInvalidNodeId));
   DCHECK_EQ(effectNode.id, kSecondaryRootNodeId);
-  effectNode.owner_id = m_rootLayer->id();
+  effectNode.owning_layer_id = m_rootLayer->id();
   effectNode.transform_id = kRealRootNodeId;
   effectNode.clip_id = kSecondaryRootNodeId;
   effectNode.has_render_surface = true;
-  m_propertyTrees.effect_id_to_index_map[effectNode.owner_id] = effectNode.id;
+  m_propertyTrees.effect_id_to_index_map[effectNode.owning_layer_id] =
+      effectNode.id;
 
   m_effectStack.append(
       BlinkEffectAndCcIdPair{EffectPaintPropertyNode::root(), effectNode.id});
   m_rootLayer->SetEffectTreeIndex(effectNode.id);
 }
 
 void PropertyTreeManager::setupRootScrollNode() {
   cc::ScrollTree& scrollTree = m_propertyTrees.scroll_tree;
   scrollTree.clear();
   m_propertyTrees.scroll_id_to_index_map.clear();
   cc::ScrollNode& scrollNode =
       *scrollTree.Node(scrollTree.Insert(cc::ScrollNode(), kRealRootNodeId));
   DCHECK_EQ(scrollNode.id, kSecondaryRootNodeId);
-  scrollNode.owner_id = m_rootLayer->id();
+  scrollNode.owning_layer_id = m_rootLayer->id();
   scrollNode.transform_id = kSecondaryRootNodeId;
-  m_propertyTrees.scroll_id_to_index_map[scrollNode.owner_id] = scrollNode.id;
+  m_propertyTrees.scroll_id_to_index_map[scrollNode.owning_layer_id] =
+      scrollNode.id;
 
   m_scrollNodeMap.set(ScrollPaintPropertyNode::root(), scrollNode.id);
   m_rootLayer->SetScrollTreeIndex(scrollNode.id);
 }
 
 int PropertyTreeManager::compositorIdForTransformNode(
     const TransformPaintPropertyNode* transformNode) {
   DCHECK(transformNode);
   // TODO(crbug.com/645615): Remove the failsafe here.
   if (!transformNode)
@@ skipping 46 matching lines @@
 
   auto it = m_clipNodeMap.find(clipNode);
   if (it != m_clipNodeMap.end())
     return it->value;
 
   scoped_refptr<cc::Layer> dummyLayer = cc::Layer::Create();
   int parentId = compositorIdForClipNode(clipNode->parent());
   int id = clipTree().Insert(cc::ClipNode(), parentId);
 
   cc::ClipNode& compositorNode = *clipTree().Node(id);
-  compositorNode.owner_id = dummyLayer->id();
-  m_propertyTrees.clip_id_to_index_map[compositorNode.owner_id] = id;
+  compositorNode.owning_layer_id = dummyLayer->id();
+  m_propertyTrees.clip_id_to_index_map[compositorNode.owning_layer_id] = id;
 
   // TODO(jbroman): Don't discard rounded corners.
   compositorNode.clip = clipNode->clipRect().rect();
   compositorNode.transform_id =
       compositorIdForTransformNode(clipNode->localTransformSpace());
   compositorNode.target_transform_id = kRealRootNodeId;
   compositorNode.target_effect_id = kSecondaryRootNodeId;
   compositorNode.clip_type = cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP;
   compositorNode.layers_are_clipped = true;
   compositorNode.layers_are_clipped_when_surfaces_disabled = true;
@@ skipping 19 matching lines @@
     return kSecondaryRootNodeId;
 
   auto it = m_scrollNodeMap.find(scrollNode);
   if (it != m_scrollNodeMap.end())
     return it->value;
 
   int parentId = compositorIdForScrollNode(scrollNode->parent());
   int id = scrollTree().Insert(cc::ScrollNode(), parentId);
 
   cc::ScrollNode& compositorNode = *scrollTree().Node(id);
-  compositorNode.owner_id = parentId;
-  m_propertyTrees.scroll_id_to_index_map[compositorNode.owner_id] = id;
+  compositorNode.owning_layer_id = parentId;
+  m_propertyTrees.scroll_id_to_index_map[compositorNode.owning_layer_id] = id;
 
   compositorNode.scrollable = true;
 
   compositorNode.scroll_clip_layer_bounds.SetSize(scrollNode->clip().width(),
                                                   scrollNode->clip().height());
   compositorNode.bounds.SetSize(scrollNode->bounds().width(),
                                 scrollNode->bounds().height());
   compositorNode.user_scrollable_horizontal =
       scrollNode->userScrollableHorizontal();
   compositorNode.user_scrollable_vertical =
@@ skipping 115 matching lines @@
   // We currently create dummy layers to host effect nodes and corresponding
   // render surfaces. This should be removed once cc implements better support
   // for freestanding property trees.
   scoped_refptr<cc::Layer> dummyLayer = nextEffect->ensureDummyLayer();
   m_rootLayer->AddChild(dummyLayer);
 
   int outputClipId = compositorIdForClipNode(nextEffect->outputClip());
 
   cc::EffectNode& effectNode = *effectTree().Node(effectTree().Insert(
       cc::EffectNode(), compositorIdForCurrentEffectNode()));
-  effectNode.owner_id = dummyLayer->id();
+  effectNode.owning_layer_id = dummyLayer->id();
   effectNode.clip_id = outputClipId;
   // Every effect is supposed to have render surface enabled for grouping,
   // but we can get away without one if the effect is opacity-only and has only
   // one compositing child with kSrcOver blend mode. This is both for
   // optimization and not introducing sub-pixel differences in layout tests.
   // See PropertyTreeManager::switchToEffectNode() and above where we
   // retrospectively enable render surface when more than one compositing child
   // or a child with exotic blend mode is detected.
   // TODO(crbug.com/504464): There is ongoing work in cc to delay render surface
   // decision until later phase of the pipeline. Remove premature optimization
   // here once the work is ready.
   if (!nextEffect->filter().isEmpty() ||
       nextEffect->blendMode() != SkBlendMode::kSrcOver)
     effectNode.has_render_surface = true;
   effectNode.opacity = nextEffect->opacity();
   effectNode.filters = nextEffect->filter().asCcFilterOperations();
   effectNode.blend_mode = nextEffect->blendMode();
-  m_propertyTrees.effect_id_to_index_map[effectNode.owner_id] = effectNode.id;
+  m_propertyTrees.effect_id_to_index_map[effectNode.owning_layer_id] =
+      effectNode.id;
   m_effectStack.append(BlinkEffectAndCcIdPair{nextEffect, effectNode.id});
 
   dummyLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
   dummyLayer->SetTransformTreeIndex(kSecondaryRootNodeId);
   dummyLayer->SetClipTreeIndex(outputClipId);
   dummyLayer->SetEffectTreeIndex(effectNode.id);
   dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
 }
 
 }  // namespace
@@ skipping 191 matching lines @@
 #ifndef NDEBUG
 void PaintArtifactCompositor::showDebugData() {
   LOG(ERROR) << layersAsJSON(LayerTreeIncludesDebugInfo)
                     ->toPrettyJSONString()
                     .utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink