cc: Move Layer Id to Node Map to Individual Property Tree Private

third_party/WebKit/Source/platform/graphics/compositing/PropertyTreeManager.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/PropertyTreeManager.h"
 
 #include "cc/layers/layer.h"
 #include "cc/trees/clip_node.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host.h"
@@ skipping 81 matching lines @@
   transformTree.set_needs_update(true);
 
   m_transformNodeMap.set(TransformPaintPropertyNode::root(), transformNode.id);
   m_rootLayer->SetTransformTreeIndex(transformNode.id);
 }
 
 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.layer_id_to_clip_node_index.clear();
   cc::ClipNode& clipNode =
       *clipTree.Node(clipTree.Insert(cc::ClipNode(), kRealRootNodeId));
   DCHECK_EQ(clipNode.id, kSecondaryRootNodeId);
 
   clipNode.resets_clip = true;
   clipNode.owning_layer_id = m_rootLayer->id();
   clipNode.clip_type = cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP;
   clipNode.clip = gfx::RectF(
       gfx::SizeF(m_rootLayer->layer_tree_host()->device_viewport_size()));
   clipNode.transform_id = kRealRootNodeId;
   clipNode.target_transform_id = kRealRootNodeId;
   clipNode.target_effect_id = kSecondaryRootNodeId;
-  m_propertyTrees.layer_id_to_clip_node_index[clipNode.owning_layer_id] =
-      clipNode.id;
+  clipTree.SetOwningLayerIdForNode(&clipNode, clipNode.owning_layer_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.layer_id_to_effect_node_index.clear();
   m_propertyTrees.element_id_to_effect_node_index.clear();
   cc::EffectNode& effectNode =
       *effectTree.Node(effectTree.Insert(cc::EffectNode(), kInvalidNodeId));
   DCHECK_EQ(effectNode.id, kSecondaryRootNodeId);
   effectNode.owning_layer_id = m_rootLayer->id();
   effectNode.transform_id = kRealRootNodeId;
   effectNode.clip_id = kSecondaryRootNodeId;
   effectNode.has_render_surface = true;
-  m_propertyTrees.layer_id_to_effect_node_index[effectNode.owning_layer_id] =
-      effectNode.id;
+  effectTree.SetOwningLayerIdForNode(&effectNode, effectNode.owning_layer_id);
 
   m_effectStack.push_back(
       BlinkEffectAndCcIdPair{EffectPaintPropertyNode::root(), effectNode.id});
   m_rootLayer->SetEffectTreeIndex(effectNode.id);
 }
 
 void PropertyTreeManager::setupRootScrollNode() {
   cc::ScrollTree& scrollTree = m_propertyTrees.scroll_tree;
   scrollTree.clear();
-  m_propertyTrees.layer_id_to_scroll_node_index.clear();
   m_propertyTrees.element_id_to_scroll_node_index.clear();
   cc::ScrollNode& scrollNode =
       *scrollTree.Node(scrollTree.Insert(cc::ScrollNode(), kRealRootNodeId));
   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;
+  scrollTree.SetOwningLayerIdForNode(&scrollNode, scrollNode.owning_layer_id);
 
   m_scrollNodeMap.set(ScrollPaintPropertyNode::root(), scrollNode.id);
   m_rootLayer->SetScrollTreeIndex(scrollNode.id);
 }
 
 int PropertyTreeManager::ensureCompositorTransformNode(
     const TransformPaintPropertyNode* transformNode) {
   DCHECK(transformNode);
   // TODO(crbug.com/645615): Remove the failsafe here.
   if (!transformNode)
@@ skipping 57 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 = 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;
+  clipTree().SetOwningLayerIdForNode(&compositorNode,
+                                     compositorNode.owning_layer_id);
 
   // TODO(jbroman): Don't discard rounded corners.
   compositorNode.clip = clipNode->clipRect().rect();
   compositorNode.transform_id =
       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;
@@ skipping 80 matching lines @@
   // set in updateLayerScrollMapping but that should occur here.
 }
 
 void PropertyTreeManager::updateLayerScrollMapping(
     cc::Layer* layer,
     const TransformPaintPropertyNode* transform) {
   auto* enclosingScrollNode = transform->findEnclosingScrollNode();
   int scrollNodeId = ensureCompositorScrollNode(enclosingScrollNode);
   layer->SetScrollTreeIndex(scrollNodeId);
   int layerId = layer->id();
-  m_propertyTrees.layer_id_to_scroll_node_index[layerId] = scrollNodeId;
+  auto& compositorScrollNode = *scrollTree().Node(scrollNodeId);
+
+  scrollTree().SetOwningLayerIdForNode(&compositorScrollNode, layerId);
 
   if (!transform->isScrollTranslation())
     return;
 
-  auto& compositorScrollNode = *scrollTree().Node(scrollNodeId);
-
   // TODO(pdr): Remove the scroll node's owning_layer_id. This approach of
   // setting owning_layer_id only when it is not set lets us maintain a 1:1
   // mapping from layer to scroll node.
   if (compositorScrollNode.owning_layer_id == cc::Layer::INVALID_ID) {
     compositorScrollNode.owning_layer_id = layerId;
     auto& compositorTransformNode =
         *transformTree().Node(compositorScrollNode.transform_id);
     // TODO(pdr): Set this in updateScrollAndScrollTranslationNodes once the
     // layer id is no longer needed.
     scrollTree().SetScrollOffset(layerId,
@@ skipping 89 matching lines @@
     // We are cutting corner here by support only specific configuration.
     DCHECK(nextEffect->colorFilter() == ColorFilterLuminanceToAlpha);
     DCHECK(nextEffect->blendMode() == SkBlendMode::kDstIn);
     DCHECK(nextEffect->filter().isEmpty());
     effectNode.filters.Append(cc::FilterOperation::CreateReferenceFilter(
         SkColorFilterImageFilter::Make(SkLumaColorFilter::Make(), nullptr)));
   } else {
     effectNode.filters = nextEffect->filter().asCcFilterOperations();
   }
   effectNode.blend_mode = nextEffect->blendMode();
-  m_propertyTrees.layer_id_to_effect_node_index[effectNode.owning_layer_id] =
-      effectNode.id;
+  effectTree().SetOwningLayerIdForNode(&effectNode, effectNode.owning_layer_id);
   CompositorElementId compositorElementId = nextEffect->compositorElementId();
   if (compositorElementId) {
     m_propertyTrees.element_id_to_effect_node_index[compositorElementId] =
         effectNode.id;
   }
   m_effectStack.push_back(BlinkEffectAndCcIdPair{nextEffect, effectNode.id});
 
   dummyLayer->set_property_tree_sequence_number(m_sequenceNumber);
   dummyLayer->SetTransformTreeIndex(kSecondaryRootNodeId);
   dummyLayer->SetClipTreeIndex(outputClipId);
   dummyLayer->SetEffectTreeIndex(effectNode.id);
   dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
 }
 
 }  // namespace blink