Remove owning_id from EffectNode and replace it by an opaque stable_id

cc/trees/property_tree.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 742 matching lines @@
   }
   return &sticky_position_data_[node->sticky_position_constraint_id];
 }
 
 EffectTree::EffectTree() {
   render_surfaces_.push_back(nullptr);
 }
 
 EffectTree::~EffectTree() {}
 
+#if DCHECK_IS_ON()
+bool EffectTree::LookupByOnwningLayerIdAllowed() const {
+  return false;
+}
+#endif
+
 int EffectTree::Insert(const EffectNode& tree_node, int parent_id) {
   int node_id = PropertyTree<EffectNode>::Insert(tree_node, parent_id);
   DCHECK_EQ(node_id, static_cast<int>(render_surfaces_.size()));
 
   render_surfaces_.push_back(nullptr);
   return node_id;
 }
 
 void EffectTree::clear() {
   PropertyTree<EffectNode>::clear();
@@ skipping 234 matching lines @@
 void EffectTree::UpdateRenderSurfaces(LayerTreeImpl* layer_tree_impl) {
   for (int id = kContentsRootNodeId; id < static_cast<int>(size()); ++id) {
     EffectNode* effect_node = Node(id);
     bool needs_render_surface =
         id == kContentsRootNodeId || effect_node->has_render_surface;
     if (needs_render_surface == !!render_surfaces_[id])
       continue;
 
     if (needs_render_surface) {
       render_surfaces_[id] = base::MakeUnique<RenderSurfaceImpl>(
-          layer_tree_impl, effect_node->owning_layer_id);
+          layer_tree_impl, effect_node->stable_id);
       render_surfaces_[id]->set_effect_tree_index(id);
     } else {
       render_surfaces_[id].reset();
     }
   }
 }
 
 bool EffectTree::ContributesToDrawnSurface(int id) {
   // All drawn nodes contribute to drawn surface.
   // Exception : Nodes that are hidden and are drawn only for the sake of
@@ skipping 24 matching lines @@
 bool EffectTree::CreateOrReuseRenderSurfaces(
     std::vector<std::unique_ptr<RenderSurfaceImpl>>* old_render_surfaces,
     LayerTreeImpl* layer_tree_impl) {
   // Make a list of {stable id, node id} pairs for nodes that are supposed to
   // have surfaces.
   std::vector<std::pair<int, int>> stable_id_node_id_list;
   for (int id = kContentsRootNodeId; id < static_cast<int>(size()); ++id) {
     EffectNode* node = Node(id);
     if (node->has_render_surface) {
       stable_id_node_id_list.push_back(
-          std::make_pair(node->owning_layer_id, node->id));
+          std::make_pair(node->stable_id, node->id));
     }
   }
 
   // Sort by stable id so that we can process the two lists cosequentially.
   std::sort(stable_id_node_id_list.begin(), stable_id_node_id_list.end());
   std::sort(old_render_surfaces->begin(), old_render_surfaces->end(),
             [](const std::unique_ptr<RenderSurfaceImpl>& a,
                const std::unique_ptr<RenderSurfaceImpl>& b) {
               return a->id() < b->id();
             });
@@ skipping 638 matching lines @@
   outer_viewport_container_bounds_delta_ = bounds_delta;
   transform_tree.UpdateOuterViewportContainerBoundsDelta();
 }
 
 void PropertyTrees::SetInnerViewportScrollBoundsDelta(
     gfx::Vector2dF bounds_delta) {
   inner_viewport_scroll_bounds_delta_ = bounds_delta;
 }
 
 void PropertyTrees::PushOpacityIfNeeded(PropertyTrees* target_tree) {
-  for (int id : target_tree->always_use_active_tree_opacity_effect_ids) {
+  for (const ElementId& element_id :
+       target_tree->always_use_active_tree_opacity_effect_ids) {
     if (const EffectNode* source_effect_node =
-            effect_tree.FindNodeFromOwningLayerId(id)) {
+            effect_tree.FindNodeFromElementId(element_id)) {
       EffectNode* target_effect_node =
-          target_tree->effect_tree.UpdateNodeFromOwningLayerId(id);
+          target_tree->effect_tree.FindNodeFromElementId(element_id);
       float source_opacity = source_effect_node->opacity;
       float target_opacity = target_effect_node->opacity;
       if (source_opacity == target_opacity)
         continue;
       target_effect_node->opacity = source_opacity;
       target_tree->effect_tree.set_needs_update(true);
     }
   }
 }
 
 void PropertyTrees::RemoveIdFromIdToIndexMaps(int id) {
   transform_tree.SetOwningLayerIdForNode(nullptr, id);
   clip_tree.SetOwningLayerIdForNode(nullptr, id);
   scroll_tree.SetOwningLayerIdForNode(nullptr, id);
-  effect_tree.SetOwningLayerIdForNode(nullptr, id);
 }
 
 void PropertyTrees::UpdateChangeTracking() {
   for (int id = EffectTree::kContentsRootNodeId;
        id < static_cast<int>(effect_tree.size()); ++id) {
     EffectNode* node = effect_tree.Node(id);
     EffectNode* parent_node = effect_tree.parent(node);
     effect_tree.UpdateEffectChanged(node, parent_node);
   }
   for (int i = TransformTree::kContentsRootNodeId;
@@ skipping 369 matching lines @@
   const EffectNode* effect_node = effect_tree.Node(effect_id);
 
   if (effect_node->surface_contents_scale.x() != 0.0 &&
       effect_node->surface_contents_scale.y() != 0.0)
     screen_space_transform.Scale(1.0 / effect_node->surface_contents_scale.x(),
                                  1.0 / effect_node->surface_contents_scale.y());
   return screen_space_transform;
 }
 
 }  // namespace cc