Rename a few compositor property tree methods for clarity.

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 592 matching lines @@
   void setupRootEffectNode();
   void setupRootScrollNode();
 
   // A brief discourse on cc property tree nodes, identifiers, and current and
   // future design evolution envisioned:
   //
   // cc property trees identify nodes by their |id|, which implementation-wise
   // is actually its index in the property tree's vector of its node type. More
   // recent cc code now refers to these as 'node indices', or 'property tree
   // indices'. |parent_id| is the same sort of 'node index' of that node's
-  // parent, whereas |owner_id| is the layer id of the layer owning that node.
+  // parent.
   //
   // Note there are two other primary types of 'ids' referenced in cc property
   // tree related logic: (1) ElementId, also known Blink-side as
   // CompositorElementId, used by the animation system to allow tying an element
   // to its respective layer, and (2) layer ids. There are other ancillary ids
   // not relevant to any of the above, such as
   // cc::TransformNode::sorting_context_id
   // (a.k.a. blink::TransformPaintPropertyNode::renderingContextId()).
   //
   // There is a vision to move toward a world where cc property nodes have no
   // association with layers and instead have a |stable_id|. The id could come
   // from an ElementId in turn derived from the layout object responsible for
   // creating the property node.
   //
   // We would also like to explore moving to use a single shared property tree
   // representation across both cc and Blink. See
   // platform/graphics/paint/README.md for more.
   //
   // With the above as background, we can now state more clearly a description
-  // of the below set of compositor id generation methods: they take Blink paint
-  // property tree nodes as input and produce a corresponding cc 'node id',
-  // a.k.a., 'node index', for use as we build out the corresponding cc property
-  // tree representation.
+  // of the below set of compositor node methods: they take Blink paint property
+  // tree nodes as input, create a corresponding compositor property tree node
+  // if none yet exists, and return the compositor node's 'node id', a.k.a.,
+  // 'node index'.
 
-  int compositorIdForTransformNode(const TransformPaintPropertyNode*);
-  int compositorIdForClipNode(const ClipPaintPropertyNode*);
+  int ensureCompositorTransformNode(const TransformPaintPropertyNode*);
+  int ensureCompositorClipNode(const ClipPaintPropertyNode*);
+  int ensureCompositorScrollNode(const ScrollPaintPropertyNode*);
+
   int switchToEffectNode(const EffectPaintPropertyNode& nextEffect);
-  int compositorIdForCurrentEffectNode() const {
+  int getCurrentCompositorEffectNodeIndex() const {
     return m_effectStack.back().id;
   }
-  int compositorIdForScrollNode(const ScrollPaintPropertyNode*);
 
   // Scroll offset has special treatment in the transform and scroll trees.
   void updateScrollOffset(int layerId, int scrollId);
 
  private:
   void buildEffectNodesRecursively(const EffectPaintPropertyNode* nextEffect);
 
   cc::TransformTree& transformTree() { return m_propertyTrees.transform_tree; }
   cc::ClipTree& clipTree() { return m_propertyTrees.clip_tree; }
   cc::EffectTree& effectTree() { return m_propertyTrees.effect_tree; }
@@ skipping 110 matching lines @@
   DCHECK_EQ(scrollNode.id, kSecondaryRootNodeId);
   scrollNode.owning_layer_id = m_rootLayer->id();
   scrollNode.transform_id = kSecondaryRootNodeId;
   m_propertyTrees.layer_id_to_scroll_node_index[scrollNode.owning_layer_id] =
       scrollNode.id;
 
   m_scrollNodeMap.set(ScrollPaintPropertyNode::root(), scrollNode.id);
   m_rootLayer->SetScrollTreeIndex(scrollNode.id);
 }
 
-int PropertyTreeManager::compositorIdForTransformNode(
+int PropertyTreeManager::ensureCompositorTransformNode(
     const TransformPaintPropertyNode* transformNode) {
   DCHECK(transformNode);
   // TODO(crbug.com/645615): Remove the failsafe here.
   if (!transformNode)
     return kSecondaryRootNodeId;
 
   auto it = m_transformNodeMap.find(transformNode);
   if (it != m_transformNodeMap.end())
     return it->value;
 
   scoped_refptr<cc::Layer> dummyLayer = cc::Layer::Create();
-  int parentId = compositorIdForTransformNode(transformNode->parent());
+  int parentId = ensureCompositorTransformNode(transformNode->parent());
   int id = transformTree().Insert(cc::TransformNode(), parentId);
 
   cc::TransformNode& compositorNode = *transformTree().Node(id);
   transformTree().SetTargetId(id, kRealRootNodeId);
   transformTree().SetContentTargetId(id, kRealRootNodeId);
   compositorNode.source_node_id = parentId;
 
   FloatPoint3D origin = transformNode->origin();
   compositorNode.pre_local.matrix().setTranslate(-origin.x(), -origin.y(),
                                                  -origin.z());
@@ skipping 12 matching lines @@
   dummyLayer->SetEffectTreeIndex(kSecondaryRootNodeId);
   dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
   dummyLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
 
   auto result = m_transformNodeMap.set(transformNode, id);
   DCHECK(result.isNewEntry);
   transformTree().set_needs_update(true);
   return id;
 }
 
-int PropertyTreeManager::compositorIdForClipNode(
+int PropertyTreeManager::ensureCompositorClipNode(
     const ClipPaintPropertyNode* clipNode) {
   DCHECK(clipNode);
   // TODO(crbug.com/645615): Remove the failsafe here.
   if (!clipNode)
     return kSecondaryRootNodeId;
 
   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 parentId = ensureCompositorClipNode(clipNode->parent());
   int id = clipTree().Insert(cc::ClipNode(), parentId);
 
   cc::ClipNode& compositorNode = *clipTree().Node(id);
   compositorNode.owning_layer_id = dummyLayer->id();
   m_propertyTrees.layer_id_to_clip_node_index[compositorNode.owning_layer_id] =
       id;
 
   // TODO(jbroman): Don't discard rounded corners.
   compositorNode.clip = clipNode->clipRect().rect();
   compositorNode.transform_id =
-      compositorIdForTransformNode(clipNode->localTransformSpace());
+      ensureCompositorTransformNode(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;
 
   m_rootLayer->AddChild(dummyLayer);
   dummyLayer->SetTransformTreeIndex(compositorNode.transform_id);
   dummyLayer->SetClipTreeIndex(id);
   dummyLayer->SetEffectTreeIndex(kSecondaryRootNodeId);
   dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
   dummyLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
 
   auto result = m_clipNodeMap.set(clipNode, id);
   DCHECK(result.isNewEntry);
   clipTree().set_needs_update(true);
   return id;
 }
 
-int PropertyTreeManager::compositorIdForScrollNode(
+int PropertyTreeManager::ensureCompositorScrollNode(
     const ScrollPaintPropertyNode* scrollNode) {
   DCHECK(scrollNode);
   // TODO(crbug.com/645615): Remove the failsafe here.
   if (!scrollNode)
     return kSecondaryRootNodeId;
 
   auto it = m_scrollNodeMap.find(scrollNode);
   if (it != m_scrollNodeMap.end())
     return it->value;
 
-  int parentId = compositorIdForScrollNode(scrollNode->parent());
+  int parentId = ensureCompositorScrollNode(scrollNode->parent());
   int id = scrollTree().Insert(cc::ScrollNode(), parentId);
 
   cc::ScrollNode& compositorNode = *scrollTree().Node(id);
   compositorNode.owning_layer_id = parentId;
   m_propertyTrees
       .layer_id_to_scroll_node_index[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 =
       scrollNode->userScrollableVertical();
   compositorNode.transform_id =
-      compositorIdForTransformNode(scrollNode->scrollOffsetTranslation());
+      ensureCompositorTransformNode(scrollNode->scrollOffsetTranslation());
   compositorNode.main_thread_scrolling_reasons =
       scrollNode->mainThreadScrollingReasons();
 
   auto result = m_scrollNodeMap.set(scrollNode, id);
   DCHECK(result.isNewEntry);
   scrollTree().set_needs_update(true);
 
   return id;
 }
 
@@ skipping 59 matching lines @@
     m_effectStack.pop_back();
 
   // Now the current effect is the lowest common ancestor of previous effect
   // and the next effect. That implies it is an existing node that already has
   // at least one paint chunk or child effect, and we are going to either attach
   // another paint chunk or child effect to it. We can no longer omit render
   // surface for it even for opacity-only nodes.
   // See comments in PropertyTreeManager::buildEffectNodesRecursively().
   // TODO(crbug.com/504464): Remove premature optimization here.
   if (currentEffectNode() && currentEffectNode()->opacity() != 1.f) {
-    effectTree().Node(compositorIdForCurrentEffectNode())->has_render_surface =
-        true;
+    effectTree()
+        .Node(getCurrentCompositorEffectNodeIndex())
+        ->has_render_surface = true;
   }
 
   buildEffectNodesRecursively(&nextEffect);
 
-  return compositorIdForCurrentEffectNode();
+  return getCurrentCompositorEffectNodeIndex();
 }
 
 void PropertyTreeManager::buildEffectNodesRecursively(
     const EffectPaintPropertyNode* nextEffect) {
   if (nextEffect == currentEffectNode())
     return;
   DCHECK(nextEffect);
 
   buildEffectNodesRecursively(nextEffect->parent());
   DCHECK_EQ(nextEffect->parent(), currentEffectNode());
 
 #if DCHECK_IS_ON()
   DCHECK(!m_effectNodesConverted.contains(nextEffect))
       << "Malformed paint artifact. Paint chunks under the same effect should "
          "be contiguous.";
   m_effectNodesConverted.add(nextEffect);
 #endif
 
   // An effect node can't omit render surface if it has child with exotic
   // blending mode. See comments below for more detail.
   // TODO(crbug.com/504464): Remove premature optimization here.
   if (nextEffect->blendMode() != SkBlendMode::kSrcOver) {
-    effectTree().Node(compositorIdForCurrentEffectNode())->has_render_surface =
-        true;
+    effectTree()
+        .Node(getCurrentCompositorEffectNodeIndex())
+        ->has_render_surface = true;
   }
 
   // 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());
+  int outputClipId = ensureCompositorClipNode(nextEffect->outputClip());
 
   cc::EffectNode& effectNode = *effectTree().Node(effectTree().Insert(
-      cc::EffectNode(), compositorIdForCurrentEffectNode()));
+      cc::EffectNode(), getCurrentCompositorEffectNodeIndex()));
   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
@@ skipping 161 matching lines @@
   collectPendingLayers(paintArtifact, pendingLayers, geometryMapper);
 
   Vector<std::unique_ptr<ContentLayerClientImpl>> newContentLayerClients;
   newContentLayerClients.reserveCapacity(paintArtifact.paintChunks().size());
   for (const PendingLayer& pendingLayer : pendingLayers) {
     gfx::Vector2dF layerOffset;
     scoped_refptr<cc::Layer> layer = compositedLayerForPendingLayer(
         paintArtifact, pendingLayer, layerOffset, newContentLayerClients,
         rasterChunkInvalidations, storeDebugInfo, geometryMapper);
 
-    int transformId = propertyTreeManager.compositorIdForTransformNode(
+    int transformId = propertyTreeManager.ensureCompositorTransformNode(
         pendingLayer.propertyTreeState.transform());
-    int scrollId = propertyTreeManager.compositorIdForScrollNode(
+    int scrollId = propertyTreeManager.ensureCompositorScrollNode(
         pendingLayer.propertyTreeState.scroll());
-    int clipId = propertyTreeManager.compositorIdForClipNode(
+    int clipId = propertyTreeManager.ensureCompositorClipNode(
         pendingLayer.propertyTreeState.clip());
     int effectId = propertyTreeManager.switchToEffectNode(
         *pendingLayer.propertyTreeState.effect());
 
     propertyTreeManager.updateScrollOffset(layer->id(), scrollId);
 
     layer->set_offset_to_transform_parent(layerOffset);
 
     m_rootLayer->AddChild(layer);
     layer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
@@ skipping 19 matching lines @@
 #ifndef NDEBUG
 void PaintArtifactCompositor::showDebugData() {
   LOG(ERROR) << layersAsJSON(LayerTreeIncludesDebugInfo)
                     ->toPrettyJSONString()
                     .utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink