Remove owning_id from EffectNode and replace it by an opaque stable_id

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 109 matching lines @@
 }
 
 void PropertyTreeManager::SetupRootEffectNode() {
   // cc is hardcoded to use effect node index 1 for root render surface.
   cc::EffectTree& effect_tree = property_trees_.effect_tree;
   effect_tree.clear();
   property_trees_.element_id_to_effect_node_index.clear();
   cc::EffectNode& effect_node =
       *effect_tree.Node(effect_tree.Insert(cc::EffectNode(), kInvalidNodeId));
   DCHECK_EQ(effect_node.id, kSecondaryRootNodeId);
-  effect_node.owning_layer_id = root_layer_->id();
+  effect_node.stable_id = root_layer_->id();
   effect_node.transform_id = kRealRootNodeId;
   effect_node.clip_id = kSecondaryRootNodeId;
   effect_node.has_render_surface = true;
-  effect_tree.SetOwningLayerIdForNode(&effect_node,
-                                      effect_node.owning_layer_id);
 
   effect_stack_.push_back(
       BlinkEffectAndCcIdPair{EffectPaintPropertyNode::Root(), effect_node.id});
   root_layer_->SetEffectTreeIndex(effect_node.id);
 }
 
 void PropertyTreeManager::SetupRootScrollNode() {
   cc::ScrollTree& scroll_tree = property_trees_.scroll_tree;
   scroll_tree.clear();
   property_trees_.element_id_to_scroll_node_index.clear();
@@ skipping 265 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> dummy_layer = next_effect->EnsureDummyLayer();
   root_layer_->AddChild(dummy_layer);
 
   int output_clip_id = EnsureCompositorClipNode(next_effect->OutputClip());
 
   cc::EffectNode& effect_node = *GetEffectTree().Node(GetEffectTree().Insert(
       cc::EffectNode(), GetCurrentCompositorEffectNodeIndex()));
-  effect_node.owning_layer_id = dummy_layer->id();
+  effect_node.stable_id = dummy_layer->id();
   effect_node.clip_id = output_clip_id;
   // 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 (!next_effect->Filter().IsEmpty() ||
       next_effect->BlendMode() != SkBlendMode::kSrcOver)
     effect_node.has_render_surface = true;
   effect_node.opacity = next_effect->Opacity();
   if (next_effect->GetColorFilter() != kColorFilterNone) {
     // Currently color filter is only used by SVG masks.
     // We are cutting corner here by support only specific configuration.
     DCHECK(next_effect->GetColorFilter() == kColorFilterLuminanceToAlpha);
     DCHECK(next_effect->BlendMode() == SkBlendMode::kDstIn);
     DCHECK(next_effect->Filter().IsEmpty());
     effect_node.filters.Append(cc::FilterOperation::CreateReferenceFilter(
         SkColorFilterImageFilter::Make(SkLumaColorFilter::Make(), nullptr)));
   } else {
     effect_node.filters = next_effect->Filter().AsCcFilterOperations();
   }
   effect_node.blend_mode = next_effect->BlendMode();
-  GetEffectTree().SetOwningLayerIdForNode(&effect_node,
-                                          effect_node.owning_layer_id);
   CompositorElementId compositor_element_id =
       next_effect->GetCompositorElementId();
   if (compositor_element_id) {
     property_trees_.element_id_to_effect_node_index[compositor_element_id] =
         effect_node.id;
   }
   effect_stack_.push_back(BlinkEffectAndCcIdPair{next_effect, effect_node.id});
 
   dummy_layer->set_property_tree_sequence_number(sequence_number_);
   dummy_layer->SetTransformTreeIndex(kSecondaryRootNodeId);
   dummy_layer->SetClipTreeIndex(output_clip_id);
   dummy_layer->SetEffectTreeIndex(effect_node.id);
   dummy_layer->SetScrollTreeIndex(kRealRootNodeId);
 }
 
 }  // namespace blink