cc: Add mask and replica layer ids to the effect tree

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 17 matching lines @@
 namespace proto {
 class ClipNodeData;
 class EffectNodeData;
 class PropertyTree;
 class PropertyTrees;
 class ScrollNodeData;
 class TransformNodeData;
 class TransformCachedNodeData;
 class TransformTreeData;
 class TreeNode;
-}
+}  // namespace proto
 
 class CopyOutputRequest;
 class LayerTreeImpl;
 class RenderSurfaceImpl;
 class ScrollState;
 struct ScrollAndScaleSet;
 
 // ------------------------------*IMPORTANT*---------------------------------
 // Each class declared here has a corresponding proto defined in
 // cc/proto/property_tree.proto. When making any changes to a class structure
@@ skipping 252 matching lines @@
   bool is_currently_animating_opacity;
   // We need to track changes to effects on the compositor to compute damage
   // rect.
   bool effect_changed;
   int num_copy_requests_in_subtree;
   bool has_unclipped_descendants;
   int transform_id;
   int clip_id;
   // Effect node id of which this effect contributes to.
   int target_id;
+  int mask_layer_id;
+  int replica_layer_id;
+  int replica_mask_layer_id;
 
   bool operator==(const EffectNodeData& other) const;
 
   void ToProtobuf(proto::TreeNode* proto) const;
   void FromProtobuf(const proto::TreeNode& proto);
   void AsValueInto(base::trace_event::TracedValue* value) const;
 };
 
 typedef TreeNode<EffectNodeData> EffectNode;
 
@@ skipping 284 matching lines @@
 };
 
 class CC_EXPORT EffectTree final : public PropertyTree<EffectNode> {
  public:
   EffectTree();
   ~EffectTree();
 
   EffectTree& operator=(const EffectTree& from);
   bool operator==(const EffectTree& other) const;
 
+  void clear();
+
   float EffectiveOpacity(const EffectNode* node) const;
 
   void UpdateEffects(int id);
 
   void UpdateEffectChanged(EffectNode* node, EffectNode* parent_node);
 
   void AddCopyRequest(int node_id, std::unique_ptr<CopyOutputRequest> request);
   void PushCopyRequestsTo(EffectTree* other_tree);
   void TakeCopyRequestsAndTransformToSurface(
       int node_id,
       std::vector<std::unique_ptr<CopyOutputRequest>>* requests);
   bool HasCopyRequests() const;
   void ClearCopyRequests();
 
+  void AddMaskOrReplicaLayerId(int id);
+  const std::vector<int>& mask_replica_layer_ids() const {
+    return mask_replica_layer_ids_;
+  }
+
   bool ContributesToDrawnSurface(int id);
 
   void ResetChangeTracking();
 
   void ToProtobuf(proto::PropertyTree* proto) const;
   void FromProtobuf(const proto::PropertyTree& proto,
                     std::unordered_map<int, int>* node_id_to_index_map);
 
  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, replica, and replica mask layer ids that
+  // effect nodes refer to.
+  std::vector<int> mask_replica_layer_ids_;
 };
 
 class CC_EXPORT ScrollTree final : public PropertyTree<ScrollNode> {
  public:
   ScrollTree();
   ~ScrollTree();
 
   ScrollTree& operator=(const ScrollTree& from);
   bool operator==(const ScrollTree& other) const;
 
@@ skipping 119 matching lines @@
 
  private:
   gfx::Vector2dF inner_viewport_container_bounds_delta_;
   gfx::Vector2dF outer_viewport_container_bounds_delta_;
   gfx::Vector2dF inner_viewport_scroll_bounds_delta_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_