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

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 513 matching lines @@
       double_sided(false),
       is_drawn(true),
       subtree_hidden(false),
       has_potential_opacity_animation(false),
       is_currently_animating_opacity(false),
       effect_changed(false),
       num_copy_requests_in_subtree(0),
       has_unclipped_descendants(false),
       transform_id(0),
       clip_id(0),
-      target_id(0) {}
+      target_id(0),
+      mask_layer_id(-1),
+      replica_layer_id(-1),
+      replica_mask_layer_id(-1) {}
 
 EffectNodeData::EffectNodeData(const EffectNodeData& other) = default;
 
 bool EffectNodeData::operator==(const EffectNodeData& other) const {
   return opacity == other.opacity &&
          screen_space_opacity == other.screen_space_opacity &&
          has_render_surface == other.has_render_surface &&
          has_copy_request == other.has_copy_request &&
          has_background_filters == other.has_background_filters &&
          hidden_by_backface_visibility == other.hidden_by_backface_visibility &&
          double_sided == other.double_sided && is_drawn == other.is_drawn &&
          subtree_hidden == other.subtree_hidden &&
          has_potential_opacity_animation ==
              other.has_potential_opacity_animation &&
          is_currently_animating_opacity ==
              other.is_currently_animating_opacity &&
          effect_changed == other.effect_changed &&
          num_copy_requests_in_subtree == other.num_copy_requests_in_subtree &&
          transform_id == other.transform_id && clip_id == other.clip_id &&
-         target_id == other.target_id;
+         target_id == other.target_id && mask_layer_id == other.mask_layer_id &&
+         replica_layer_id == other.replica_layer_id &&
+         replica_mask_layer_id == other.replica_mask_layer_id;
 }
 
 void EffectNodeData::ToProtobuf(proto::TreeNode* proto) const {
   DCHECK(!proto->has_effect_node_data());
   proto::EffectNodeData* data = proto->mutable_effect_node_data();
   data->set_opacity(opacity);
   data->set_screen_space_opacity(screen_space_opacity);
   data->set_has_render_surface(has_render_surface);
   data->set_has_copy_request(has_copy_request);
   data->set_has_background_filters(has_background_filters);
   data->set_hidden_by_backface_visibility(hidden_by_backface_visibility);
   data->set_double_sided(double_sided);
   data->set_is_drawn(is_drawn);
   data->set_subtree_hidden(subtree_hidden);
   data->set_has_potential_opacity_animation(has_potential_opacity_animation);
   data->set_is_currently_animating_opacity(is_currently_animating_opacity);
   data->set_effect_changed(effect_changed);
   data->set_num_copy_requests_in_subtree(num_copy_requests_in_subtree);
   data->set_transform_id(transform_id);
   data->set_clip_id(clip_id);
   data->set_target_id(target_id);
+  data->set_mask_layer_id(mask_layer_id);
+  data->set_replica_layer_id(replica_layer_id);
+  data->set_replica_mask_layer_id(replica_mask_layer_id);
 }
 
 void EffectNodeData::FromProtobuf(const proto::TreeNode& proto) {
   DCHECK(proto.has_effect_node_data());
   const proto::EffectNodeData& data = proto.effect_node_data();
 
   opacity = data.opacity();
   screen_space_opacity = data.screen_space_opacity();
   has_render_surface = data.has_render_surface();
   has_copy_request = data.has_copy_request();
   has_background_filters = data.has_background_filters();
   hidden_by_backface_visibility = data.hidden_by_backface_visibility();
   double_sided = data.double_sided();
   is_drawn = data.is_drawn();
   subtree_hidden = data.subtree_hidden();
   has_potential_opacity_animation = data.has_potential_opacity_animation();
   is_currently_animating_opacity = data.is_currently_animating_opacity();
   effect_changed = data.effect_changed();
   num_copy_requests_in_subtree = data.num_copy_requests_in_subtree();
   transform_id = data.transform_id();
   clip_id = data.clip_id();
   target_id = data.target_id();
+  mask_layer_id = data.mask_layer_id();
+  replica_layer_id = data.replica_layer_id();
+  replica_mask_layer_id = data.replica_mask_layer_id();
 }
 
 void EffectNodeData::AsValueInto(base::trace_event::TracedValue* value) const {
   value->SetDouble("opacity", opacity);
   value->SetBoolean("has_render_surface", has_render_surface);
   value->SetBoolean("has_copy_request", has_copy_request);
   value->SetBoolean("has_background_filters", has_background_filters);
   value->SetBoolean("double_sided", double_sided);
   value->SetBoolean("is_drawn", is_drawn);
   value->SetBoolean("has_potential_opacity_animation",
                     has_potential_opacity_animation);
   value->SetBoolean("effect_changed", effect_changed);
   value->SetInteger("num_copy_requests_in_subtree",
                     num_copy_requests_in_subtree);
   value->SetInteger("transform_id", transform_id);
   value->SetInteger("clip_id", clip_id);
   value->SetInteger("target_id", target_id);
+  value->SetInteger("mask_layer_id", mask_layer_id);
+  value->SetInteger("replica_layer_id", replica_layer_id);
+  value->SetInteger("replica_mask_layer_id", replica_mask_layer_id);
 }
 
 ScrollNodeData::ScrollNodeData()
     : scrollable(false),
       main_thread_scrolling_reasons(
           MainThreadScrollingReason::kNotScrollingOnMain),
       contains_non_fast_scrollable_region(false),
       max_scroll_offset_affected_by_page_scale(false),
       is_inner_viewport_scroll_layer(false),
       is_outer_viewport_scroll_layer(false),
@@ skipping 800 matching lines @@
   for (int i = 1; i < data.cached_data_size(); ++i) {
     cached_data_.push_back(TransformCachedNodeData());
     cached_data_.back().FromProtobuf(data.cached_data(i));
   }
 }
 
 EffectTree::EffectTree() {}
 
 EffectTree::~EffectTree() {}
 
+void EffectTree::clear() {
+  PropertyTree<EffectNode>::clear();
+  mask_replica_layer_ids_.clear();
+}
+
 float EffectTree::EffectiveOpacity(const EffectNode* node) const {
   return node->data.subtree_hidden ? 0.f : node->data.opacity;
 }
 
 void EffectTree::UpdateOpacities(EffectNode* node, EffectNode* parent_node) {
   node->data.screen_space_opacity = EffectiveOpacity(node);
 
   if (parent_node)
     node->data.screen_space_opacity *= parent_node->data.screen_space_opacity;
 }
@@ skipping 154 matching lines @@
     node.data.num_copy_requests_in_subtree = 0;
     node.data.has_copy_request = false;
   }
 
   // Any copy requests that are still left will be aborted (sending an empty
   // result) on destruction.
   copy_requests_.clear();
   set_needs_update(true);
 }
 
+void EffectTree::AddMaskOrReplicaLayerId(int id) {
+  mask_replica_layer_ids_.push_back(id);
+}
+
 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
   // copy requests.
   EffectNode* node = Node(id);
   EffectNode* parent_node = parent(node);
   return node->data.is_drawn && (!parent_node || parent_node->data.is_drawn);
 }
 
 void EffectTree::ResetChangeTracking() {
@@ skipping 45 matching lines @@
     const proto::PropertyTree& proto,
     std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Clip);
 
   PropertyTree::FromProtobuf(proto, node_id_to_index_map);
 }
 
 EffectTree& EffectTree::operator=(const EffectTree& from) {
   PropertyTree::operator=(from);
+  mask_replica_layer_ids_ = from.mask_replica_layer_ids_;
   // copy_requests_ are omitted here, since these need to be moved rather
   // than copied or assigned.
   return *this;
 }
 
 bool EffectTree::operator==(const EffectTree& other) const {
-  return PropertyTree::operator==(other);
+  return PropertyTree::operator==(other) &&
+         mask_replica_layer_ids_ == other.mask_replica_layer_ids_;
 }
 
 void EffectTree::ToProtobuf(proto::PropertyTree* proto) const {
   DCHECK(!proto->has_property_type());
   proto->set_property_type(proto::PropertyTree::Effect);
 
   PropertyTree::ToProtobuf(proto);
+  proto::EffectTreeData* data = proto->mutable_effect_tree_data();
+
+  for (auto i : mask_replica_layer_ids_)
+    data->add_mask_replica_layer_ids(i);
 }
 
 void EffectTree::FromProtobuf(
     const proto::PropertyTree& proto,
     std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Effect);
 
   PropertyTree::FromProtobuf(proto, node_id_to_index_map);
+  const proto::EffectTreeData& data = proto.effect_tree_data();
+
+  DCHECK(mask_replica_layer_ids_.empty());
+  for (int i = 0; i < data.mask_replica_layer_ids_size(); ++i) {
+    mask_replica_layer_ids_.push_back(data.mask_replica_layer_ids(i));
+  }
 }
 
 ScrollTree::ScrollTree()
     : currently_scrolling_node_id_(-1),
       layer_id_to_scroll_offset_map_(ScrollTree::ScrollOffsetMap()) {}
 
 ScrollTree::~ScrollTree() {}
 
 ScrollTree& ScrollTree::operator=(const ScrollTree& from) {
   PropertyTree::operator=(from);
@@ skipping 633 matching lines @@
   value->EndDictionary();
 
   value->BeginDictionary("scroll_tree");
   scroll_tree.AsValueInto(value.get());
   value->EndDictionary();
 
   return value;
 }
 
 }  // namespace cc