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

cc/trees/occlusion_tracker.cc

 // Copyright 2012 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/occlusion_tracker.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 163 matching lines @@
 
   RenderSurfaceImpl* surface = finished_target->render_surface();
 
   // Readbacks always happen on render targets so we only need to check
   // for readbacks here.
   bool target_is_only_for_copy_request =
       surface->HasCopyRequest() && finished_target->IsHidden();
 
   // If the occlusion within the surface can not be applied to things outside of
   // the surface's subtree, then clear the occlusion here so it won't be used.
-  if (finished_target->mask_layer() || surface->draw_opacity() < 1 ||
+  if (surface->MaskLayer() || surface->draw_opacity() < 1 ||
       !finished_target->uses_default_blend_mode() ||
       target_is_only_for_copy_request ||
       finished_target->filters().HasFilterThatAffectsOpacity()) {
     stack_.back().occlusion_from_outside_target.Clear();
     stack_.back().occlusion_from_inside_target.Clear();
   }
 }
 
 static void ReduceOcclusionBelowSurface(
     const LayerImpl* contributing_layer,
@@ skipping 63 matching lines @@
 
   const RenderSurfaceImpl* old_surface = stack_[last_index].target;
   const LayerImpl* old_target =
       new_target->layer_tree_impl()->LayerById(old_surface->OwningLayerId());
 
   SimpleEnclosedRegion old_occlusion_from_inside_target_in_new_target =
       TransformSurfaceOpaqueRegion(
           stack_[last_index].occlusion_from_inside_target,
           old_surface->is_clipped(), old_surface->clip_rect(),
           old_surface->draw_transform());
-  if (old_target->has_replica() && !old_target->replica_has_mask()) {
+  if (old_surface->HasReplica() && !old_surface->HasReplicaMask()) {
     old_occlusion_from_inside_target_in_new_target.Union(
         TransformSurfaceOpaqueRegion(
             stack_[last_index].occlusion_from_inside_target,
             old_surface->is_clipped(), old_surface->clip_rect(),
             old_surface->replica_draw_transform()));
   }
 
   SimpleEnclosedRegion old_occlusion_from_outside_target_in_new_target =
       TransformSurfaceOpaqueRegion(
           stack_[last_index].occlusion_from_outside_target, false, gfx::Rect(),
           old_surface->draw_transform());
 
   gfx::Rect unoccluded_surface_rect;
   gfx::Rect unoccluded_replica_rect;
   if (old_target->background_filters().HasFilterThatMovesPixels()) {
     Occlusion surface_occlusion = GetCurrentOcclusionForContributingSurface(
         old_surface->draw_transform());
     unoccluded_surface_rect =
         surface_occlusion.GetUnoccludedContentRect(old_surface->content_rect());
-    if (old_target->has_replica()) {
+    if (old_surface->HasReplica()) {
       Occlusion replica_occlusion = GetCurrentOcclusionForContributingSurface(
           old_surface->replica_draw_transform());
       unoccluded_replica_rect = replica_occlusion.GetUnoccludedContentRect(
           old_surface->content_rect());
     }
   }
 
   if (surface_will_be_at_top_after_pop) {
     // Merge the top of the stack down.
     stack_[last_index - 1].occlusion_from_inside_target.Union(
@@ skipping 25 matching lines @@
                               unoccluded_surface_rect,
                               old_surface->draw_transform(),
                               new_target,
                               &stack_.back().occlusion_from_inside_target);
   ReduceOcclusionBelowSurface(old_target,
                               unoccluded_surface_rect,
                               old_surface->draw_transform(),
                               new_target,
                               &stack_.back().occlusion_from_outside_target);
 
-  if (!old_target->has_replica())
+  if (!old_surface->HasReplica())
     return;
   ReduceOcclusionBelowSurface(old_target,
                               unoccluded_replica_rect,
                               old_surface->replica_draw_transform(),
                               new_target,
                               &stack_.back().occlusion_from_inside_target);
   ReduceOcclusionBelowSurface(old_target,
                               unoccluded_replica_rect,
                               old_surface->replica_draw_transform(),
                               new_target,
@@ skipping 49 matching lines @@
   DCHECK(layer_tree->root_layer()->render_surface() == stack_.back().target);
   const SimpleEnclosedRegion& occluded =
       stack_.back().occlusion_from_inside_target;
   Region visible_region(screen_space_clip_rect_);
   for (size_t i = 0; i < occluded.GetRegionComplexity(); ++i)
     visible_region.Subtract(occluded.GetRect(i));
   return visible_region;
 }
 
 }  // namespace cc