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

cc/trees/property_tree_builder.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 "cc/trees/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 195 matching lines @@
 }
 
 static size_t NumUnclippedDescendants(Layer* layer) {
   return layer->num_unclipped_descendants();
 }
 
 static size_t NumUnclippedDescendants(LayerImpl* layer) {
   return layer->test_properties()->num_unclipped_descendants;
 }
 
+static Layer* MaskLayer(Layer* layer) {
+  return layer->mask_layer();
+}
+
+static LayerImpl* MaskLayer(LayerImpl* layer) {
+  return layer->test_properties()->mask_layer;
+}
+
+static Layer* ReplicaLayer(Layer* layer) {
+  return layer->replica_layer();
+}
+
+static LayerImpl* ReplicaLayer(LayerImpl* layer) {
+  return layer->test_properties()->replica_layer;
+}
+
 template <typename LayerType>
 static LayerType* GetTransformParent(const DataForRecursion<LayerType>& data,
                                      LayerType* layer) {
   return PositionConstraint(layer).is_fixed_position()
              ? data.transform_fixed_parent
              : data.transform_tree_parent;
 }
 
 template <typename LayerType>
 static ClipNode* GetClipParent(const DataForRecursion<LayerType>& data,
                                LayerType* layer) {
   const bool inherits_clip = !ClipParent(layer);
   const int id = inherits_clip ? data.clip_tree_parent
                                : ClipParent(layer)->clip_tree_index();
   return data.property_trees->clip_tree.Node(id);
 }
 
 template <typename LayerType>
 static bool LayerClipsSubtree(LayerType* layer) {
-  return layer->masks_to_bounds() || layer->mask_layer();
+  return layer->masks_to_bounds() || MaskLayer(layer);
 }
 
 template <typename LayerType>
 static int GetScrollParentId(const DataForRecursion<LayerType>& data,
                              LayerType* layer) {
   const bool inherits_scroll = !ScrollParent(layer);
   const int id = inherits_scroll ? data.scroll_tree_parent
                                  : ScrollParent(layer)->scroll_tree_index();
   return id;
 }
@@ skipping 477 matching lines @@
                                bool axis_aligned) {
   const bool preserves_2d_axis_alignment =
       (current_transform * layer->transform()).Preserves2dAxisAlignment() &&
       axis_aligned && layer->AnimationsPreserveAxisAlignment();
   const bool is_root = !layer->parent();
   if (is_root)
     return true;
 
   // If the layer uses a mask and the layer is not a replica layer.
   // TODO(weiliangc): After slimming paint there won't be replica layers.
-  if (layer->mask_layer() && layer->parent()->replica_layer() != layer) {
+  if (MaskLayer(layer) && ReplicaLayer(layer->parent()) != layer) {
     return true;
   }
 
   // If the layer has a reflection.
-  if (layer->replica_layer()) {
+  if (ReplicaLayer(layer)) {
     return true;
   }
 
   // If the layer uses a CSS filter.
   if (!layer->filters().IsEmpty() || !layer->background_filters().IsEmpty()) {
     return true;
   }
 
   // If the layer will use a CSS filter.  In this case, the animation
   // will start and add a filter to this layer, so it needs a surface.
@@ skipping 126 matching lines @@
 
   node.data.opacity = Opacity(layer);
   node.data.has_render_surface = should_create_render_surface;
   node.data.has_copy_request = HasCopyRequest(layer);
   node.data.has_background_filters = !layer->background_filters().IsEmpty();
   node.data.has_potential_opacity_animation = has_potential_opacity_animation;
   node.data.double_sided = DoubleSided(layer);
   node.data.subtree_hidden = HideLayerAndSubtree(layer);
   node.data.is_currently_animating_opacity = layer->OpacityIsAnimating();
 
+  EffectTree& effect_tree = data_for_children->property_trees->effect_tree;
+  if (MaskLayer(layer)) {
+    node.data.mask_layer_id = MaskLayer(layer)->id();
+    effect_tree.AddMaskOrReplicaLayerId(node.data.mask_layer_id);
+  }
+  if (ReplicaLayer(layer)) {
+    node.data.replica_layer_id = ReplicaLayer(layer)->id();
+    effect_tree.AddMaskOrReplicaLayerId(node.data.replica_layer_id);
+    if (MaskLayer(ReplicaLayer(layer))) {
+      node.data.replica_mask_layer_id = MaskLayer(ReplicaLayer(layer))->id();
+      effect_tree.AddMaskOrReplicaLayerId(node.data.replica_mask_layer_id);
+    }
+  }
+
   if (!is_root) {
     // The effect node's transform id is used only when we create a render
     // surface. So, we can leave the default value when we don't create a render
     // surface.
     if (should_create_render_surface) {
       // In this case, we will create a transform node, so it's safe to use the
       // next available id from the transform tree as this effect node's
       // transform id.
       node.data.transform_id =
           data_from_ancestor.property_trees->transform_tree.next_available_id();
       node.data.has_unclipped_descendants =
           (NumUnclippedDescendants(layer) != 0);
     }
     node.data.clip_id = data_from_ancestor.clip_tree_parent;
   } else {
     // Root render surface acts the unbounded and untransformed to draw content
     // into. Transform node created from root layer (includes device scale
     // factor) and clip node created from root layer (include viewports) applies
     // to root render surface's content, but not root render surface itself.
     node.data.transform_id = kRootPropertyTreeNodeId;
     node.data.clip_id = kViewportClipTreeNodeId;
   }
-  data_for_children->effect_tree_parent =
-      data_for_children->property_trees->effect_tree.Insert(node, parent_id);
+  data_for_children->effect_tree_parent = effect_tree.Insert(node, parent_id);
   int node_id = data_for_children->effect_tree_parent;
   layer->SetEffectTreeIndex(node_id);
   data_for_children->property_trees->effect_id_to_index_map[layer->id()] =
       data_for_children->effect_tree_parent;
 
   std::vector<std::unique_ptr<CopyOutputRequest>> layer_copy_requests;
   TakeCopyRequests(layer, &layer_copy_requests);
   for (auto& it : layer_copy_requests) {
-    data_for_children->property_trees->effect_tree.AddCopyRequest(
-        node_id, std::move(it));
+    effect_tree.AddCopyRequest(node_id, std::move(it));
   }
   layer_copy_requests.clear();
 
   if (should_create_render_surface) {
     data_for_children->compound_transform_since_render_target =
         gfx::Transform();
     data_for_children->axis_align_since_render_target = true;
   }
   return should_create_render_surface;
 }
@@ skipping 192 matching lines @@
       data_for_children.effect_tree_parent =
           scroll_child->parent()->effect_tree_index();
       data_for_children.render_target =
           scroll_child->parent()->effect_tree_index();
       BuildPropertyTreesInternal(scroll_child, data_for_children,
                                  &data_from_child);
       data_to_parent->Merge(data_from_child);
     }
   }
 
-  if (layer->has_replica()) {
+  if (ReplicaLayer(layer)) {
     DataForRecursionFromChild<LayerType> data_from_child;
-    BuildPropertyTreesInternal(layer->replica_layer(), data_for_children,
+    BuildPropertyTreesInternal(ReplicaLayer(layer), data_for_children,
                                &data_from_child);
     data_to_parent->Merge(data_from_child);
   }
 
-  if (layer->mask_layer()) {
-    layer->mask_layer()->set_property_tree_sequence_number(
+  if (MaskLayer(layer)) {
+    MaskLayer(layer)->set_property_tree_sequence_number(
         data_from_parent.property_trees->sequence_number);
-    layer->mask_layer()->set_offset_to_transform_parent(
+    MaskLayer(layer)->set_offset_to_transform_parent(
         layer->offset_to_transform_parent());
-    layer->mask_layer()->SetTransformTreeIndex(layer->transform_tree_index());
-    layer->mask_layer()->SetClipTreeIndex(layer->clip_tree_index());
-    layer->mask_layer()->SetEffectTreeIndex(layer->effect_tree_index());
-    layer->mask_layer()->SetScrollTreeIndex(layer->scroll_tree_index());
+    MaskLayer(layer)->SetTransformTreeIndex(layer->transform_tree_index());
+    MaskLayer(layer)->SetClipTreeIndex(layer->clip_tree_index());
+    MaskLayer(layer)->SetEffectTreeIndex(layer->effect_tree_index());
+    MaskLayer(layer)->SetScrollTreeIndex(layer->scroll_tree_index());
   }
 
   EffectNode* effect_node = data_for_children.property_trees->effect_tree.Node(
       data_for_children.effect_tree_parent);
 
   if (effect_node->owner_id == layer->id()) {
     if (effect_node->data.has_copy_request)
       data_to_parent->num_copy_requests_in_subtree++;
     effect_node->data.num_copy_requests_in_subtree =
         data_to_parent->num_copy_requests_in_subtree;
@@ skipping 189 matching lines @@
   if (SkColorGetA(color) != 255)
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
 }
 
 }  // namespace cc