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

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 168 matching lines @@
   for (int i = 0; i < proto.scrolls_size(); ++i) {
     scrolls.push_back(LayerTreeHostCommon::ScrollUpdateInfo());
     scrolls[i].FromProtobuf(proto.scrolls(i));
   }
   page_scale_delta = proto.page_scale_delta();
   elastic_overscroll_delta = ProtoToVector2dF(proto.elastic_overscroll_delta());
   top_controls_delta = proto.top_controls_delta();
 }
 
 static inline void SetMaskLayersAreDrawnRenderSurfaceLayerListMembers(
-    LayerImpl* layer,
+    RenderSurfaceImpl* surface,
     PropertyTrees* property_trees) {
-  if (layer->mask_layer()) {
-    layer->mask_layer()->set_is_drawn_render_surface_layer_list_member(true);
-    draw_property_utils::ComputeMaskDrawProperties(layer->mask_layer(),
+  LayerImpl* mask_layer = surface->MaskLayer();
+  LayerImpl* replica_mask_layer = surface->ReplicaMaskLayer();
+  if (mask_layer) {
+    mask_layer->set_is_drawn_render_surface_layer_list_member(true);
+    draw_property_utils::ComputeMaskDrawProperties(mask_layer, property_trees);
+  }
+  if (replica_mask_layer) {
+    replica_mask_layer->set_is_drawn_render_surface_layer_list_member(true);
+    draw_property_utils::ComputeMaskDrawProperties(replica_mask_layer,
                                                    property_trees);
   }
-  if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
-    layer->replica_layer()
-        ->mask_layer()
-        ->set_is_drawn_render_surface_layer_list_member(true);
-    draw_property_utils::ComputeMaskDrawProperties(
-        layer->replica_layer()->mask_layer(), property_trees);
-  }
 }
 
-static inline void ClearLayerIsDrawnRenderSurfaceLayerListMember(
-    LayerImpl* layer) {
-  layer->set_is_drawn_render_surface_layer_list_member(false);
-  if (layer->mask_layer())
-    layer->mask_layer()->set_is_drawn_render_surface_layer_list_member(false);
-  if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
-    layer->replica_layer()
-        ->mask_layer()
-        ->set_is_drawn_render_surface_layer_list_member(false);
-  }
+static inline void ClearMaskLayersAreDrawnRenderSurfaceLayerListMembers(
+    RenderSurfaceImpl* surface) {
+  LayerImpl* mask_layer = surface->MaskLayer();
+  LayerImpl* replica_mask_layer = surface->ReplicaMaskLayer();
+  if (mask_layer)
+    mask_layer->set_is_drawn_render_surface_layer_list_member(false);
+  if (replica_mask_layer)
+    replica_mask_layer->set_is_drawn_render_surface_layer_list_member(false);
 }
 
 static inline void ClearIsDrawnRenderSurfaceLayerListMember(
     LayerImplList* layer_list,
     ScrollTree* scroll_tree) {
   for (LayerImpl* layer : *layer_list) {
     if (layer->is_drawn_render_surface_layer_list_member()) {
       DCHECK_GT(scroll_tree->Node(layer->scroll_tree_index())
                     ->data.num_drawn_descendants,
                 0);
       scroll_tree->Node(layer->scroll_tree_index())
           ->data.num_drawn_descendants--;
     }
-    ClearLayerIsDrawnRenderSurfaceLayerListMember(layer);
+    layer->set_is_drawn_render_surface_layer_list_member(false);
   }
 }
 
 static bool CdpPerfTracingEnabled() {
   bool tracing_enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED("cdp.perf", &tracing_enabled);
   return tracing_enabled;
 }
 
 static float TranslationFromActiveTreeLayerScreenSpaceTransform(
@@ skipping 84 matching lines @@
     LayerImplList* render_surface_layer_list,
     bool can_render_to_separate_surface) {
   ScrollTree* scroll_tree = &property_trees->scroll_tree;
   for (int i = 0; i < static_cast<int>(scroll_tree->size()); ++i)
     scroll_tree->Node(i)->data.num_drawn_descendants = 0;
 
   // Add all non-skipped surfaces to the initial render surface layer list. Add
   // all non-skipped layers to the layer list of their target surface, and
   // add their content rect to their target surface's accumulated content rect.
   for (LayerImpl* layer : *layer_tree_impl) {
-    if (layer->render_surface())
+    if (layer->render_surface()) {
       layer->ClearRenderSurfaceLayerList();
-    ClearLayerIsDrawnRenderSurfaceLayerListMember(layer);
+      ClearMaskLayersAreDrawnRenderSurfaceLayerListMembers(
+          layer->render_surface());
+    }
+    layer->set_is_drawn_render_surface_layer_list_member(false);
 
     bool layer_is_drawn =
         property_trees->effect_tree.Node(layer->effect_tree_index())
             ->data.is_drawn;
     bool is_root = layer_tree_impl->IsRootLayer(layer);
     bool skip_layer =
         !is_root && draw_property_utils::LayerShouldBeSkipped(
                         layer, layer_is_drawn, property_trees->transform_tree,
                         property_trees->effect_tree);
     if (skip_layer)
@@ skipping 25 matching lines @@
                                                         surface);
 
       // Ignore occlusion from outside the surface when surface contents need to
       // be fully drawn. Layers with copy-request need to be complete.  We could
       // be smarter about layers with replica and exclude regions where both
       // layer and the replica are occluded, but this seems like overkill. The
       // same is true for layers with filters that move pixels.
       // TODO(senorblanco): make this smarter for the SkImageFilter case (check
       // for pixel-moving filters)
       bool is_occlusion_immune = surface->HasCopyRequest() ||
-                                 layer->has_replica() ||
+                                 surface->HasReplica() ||
                                  layer->filters().HasReferenceFilter() ||
                                  layer->filters().HasFilterThatMovesPixels();
       if (is_occlusion_immune) {
         surface->SetNearestOcclusionImmuneAncestor(surface);
       } else if (is_root) {
         surface->SetNearestOcclusionImmuneAncestor(nullptr);
       } else {
         surface->SetNearestOcclusionImmuneAncestor(
             surface->render_target()->nearest_occlusion_immune_ancestor());
       }
@@ skipping 65 matching lines @@
           // root surface.
           DCHECK(!target_surface->layer_list().empty() ||
                  target_surface->render_target() == target_surface);
         } else {
           // This layer was removed when the target itself was cleared.
           DCHECK(target_surface->layer_list().empty());
         }
       }
       continue;
     }
-    SetMaskLayersAreDrawnRenderSurfaceLayerListMembers(layer, property_trees);
+    SetMaskLayersAreDrawnRenderSurfaceLayerListMembers(surface, property_trees);
     final_surface_list->push_back(layer);
   }
 }
 
 static void CalculateRenderSurfaceLayerList(
     LayerTreeImpl* layer_tree_impl,
     PropertyTrees* property_trees,
     LayerImplList* render_surface_layer_list,
     const bool can_render_to_separate_surface,
     const int max_texture_size) {
@@ skipping 206 matching lines @@
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc