Remove owning_id from EffectNode and replace it by an opaque stable_id

cc/trees/property_tree.h

 // 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.
 
 #ifndef CC_TREES_PROPERTY_TREE_H_
 #define CC_TREES_PROPERTY_TREE_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 86 matching lines @@
     property_trees_ = property_trees;
   }
   PropertyTrees* property_trees() const { return property_trees_; }
 
   void AsValueInto(base::trace_event::TracedValue* value) const;
 
   const T* FindNodeFromOwningLayerId(int id) const {
     return Node(FindNodeIndexFromOwningLayerId(id));
   }
   T* UpdateNodeFromOwningLayerId(int id) {
+#if DCHECK_IS_ON()
+    DCHECK(LookupByOnwningLayerIdAllowed());
+#endif
     int index = FindNodeIndexFromOwningLayerId(id);
     if (index == kInvalidNodeId) {
       DCHECK(property_trees()->is_main_thread);
       property_trees()->needs_rebuild = true;
     }
 
     return Node(index);
   }
 
   int FindNodeIndexFromOwningLayerId(int id) const {
+#if DCHECK_IS_ON()
+    DCHECK(LookupByOnwningLayerIdAllowed());
+#endif
     auto iter = owning_layer_id_to_node_index_.find(id);
     if (iter == owning_layer_id_to_node_index_.end())
       return kInvalidNodeId;
     else
       return iter->second;
   }
 
   void SetOwningLayerIdForNode(const T* node, int id) {
+#if DCHECK_IS_ON()
+    DCHECK(LookupByOnwningLayerIdAllowed());
+#endif
     if (!node) {
       owning_layer_id_to_node_index_[id] = kInvalidNodeId;
       return;
     }
 
     DCHECK(node == Node(node->id));
     owning_layer_id_to_node_index_[id] = node->id;
   }
 
+ protected:
+#if DCHECK_IS_ON()
+  virtual bool LookupByOnwningLayerIdAllowed() const { return true; }
+#endif
+
  private:
   std::vector<T> nodes_;
 
   // Maps from layer id to the property tree node index. This container is
   // typically very small and the memory overhead of unordered_map will
   // dominate so use a flat_map. See http://crbug.com/709243
   base::flat_map<int, int> owning_layer_id_to_node_index_;
 
   bool needs_update_;
   PropertyTrees* property_trees_;
@@ skipping 258 matching lines @@
 
   void TakeRenderSurfaces(
       std::vector<std::unique_ptr<RenderSurfaceImpl>>* render_surfaces);
 
   // Returns true if render surfaces changed (that is, if any render surfaces
   // were created or destroyed).
   bool CreateOrReuseRenderSurfaces(
       std::vector<std::unique_ptr<RenderSurfaceImpl>>* old_render_surfaces,
       LayerTreeImpl* layer_tree_impl);
 
+ protected:
+#if DCHECK_IS_ON()
+  bool LookupByOnwningLayerIdAllowed() const override;
+#endif
+
  private:
   void UpdateOpacities(EffectNode* node, EffectNode* parent_node);
   void UpdateIsDrawn(EffectNode* node, EffectNode* parent_node);
   void UpdateBackfaceVisibility(EffectNode* node, EffectNode* parent_node);
 
   // Stores copy requests, keyed by node id.
   std::unordered_multimap<int, std::unique_ptr<CopyOutputRequest>>
       copy_requests_;
 
   // Unsorted list of all mask layer ids that effect nodes refer to.
@@ skipping 218 matching lines @@
   // These maps allow mapping directly from a compositor element id to the
   // respective property node. This will eventually allow simplifying logic in
   // various places that today has to map from element id to layer id, and then
   // from layer id to the respective property node. Completing that work is
   // pending the launch of Slimming Paint v2 and reworking UI compositor logic
   // to produce cc property trees and these maps.
   base::flat_map<ElementId, int> element_id_to_effect_node_index;
   base::flat_map<ElementId, int> element_id_to_scroll_node_index;
   base::flat_map<ElementId, int> element_id_to_transform_node_index;
 
-  std::vector<int> always_use_active_tree_opacity_effect_ids;
+  std::vector<ElementId> always_use_active_tree_opacity_effect_ids;
   TransformTree transform_tree;
   EffectTree effect_tree;
   ClipTree clip_tree;
   ScrollTree scroll_tree;
   bool needs_rebuild;
   bool can_adjust_raster_scales;
   // Change tracking done on property trees needs to be preserved across commits
   // (when they are not rebuild). We cache a global bool which stores whether
   // we did any change tracking so that we can skip copying the change status
   // between property trees when this bool is false.
@@ skipping 63 matching lines @@
   DrawTransforms& GetDrawTransforms(int transform_id, int effect_id) const;
   DrawTransformData& FetchDrawTransformsDataFromCache(int transform_id,
                                                       int effect_id) const;
 
   PropertyTreesCachedData cached_data_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_