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

cc/trees/layer_tree_host_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 629 matching lines @@
   // surface.
   size_t render_surface_layer_list_size = render_surface_layer_list.size();
   for (size_t i = 0; i < render_surface_layer_list_size; ++i) {
     size_t surface_index = render_surface_layer_list_size - 1 - i;
     LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
     RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
     DCHECK(render_surface);
     render_surface->damage_tracker()->UpdateDamageTrackingState(
         render_surface->layer_list(), render_surface,
         render_surface->SurfacePropertyChangedOnlyFromDescendant(),
-        render_surface->content_rect(), render_surface_layer->mask_layer(),
+        render_surface->content_rect(), render_surface->MaskLayer(),
         render_surface_layer->filters());
   }
 }
 
 void LayerTreeHostImpl::FrameData::AsValueInto(
     base::trace_event::TracedValue* value) const {
   value->SetBoolean("has_no_damage", has_no_damage);
 
   // Quad data can be quite large, so only dump render passes if we select
   // cc.debug.quads.
@@ skipping 29 matching lines @@
 static void AppendQuadsForRenderSurfaceLayer(
     RenderPass* target_render_pass,
     LayerImpl* layer,
     const RenderPass* contributing_render_pass,
     AppendQuadsData* append_quads_data) {
   RenderSurfaceImpl* surface = layer->render_surface();
   const gfx::Transform& draw_transform = surface->draw_transform();
   const Occlusion& occlusion = surface->occlusion_in_content_space();
   SkColor debug_border_color = surface->GetDebugBorderColor();
   float debug_border_width = surface->GetDebugBorderWidth();
-  LayerImpl* mask_layer = layer->mask_layer();
+  LayerImpl* mask_layer = surface->MaskLayer();
 
   surface->AppendQuads(target_render_pass, draw_transform, occlusion,
                        debug_border_color, debug_border_width, mask_layer,
                        append_quads_data, contributing_render_pass->id);
 
   // Add replica after the surface so that it appears below the surface.
-  if (layer->has_replica()) {
+  if (surface->HasReplica()) {
     const gfx::Transform& replica_draw_transform =
         surface->replica_draw_transform();
     Occlusion replica_occlusion = occlusion.GetOcclusionWithGivenDrawTransform(
         surface->replica_draw_transform());
     SkColor replica_debug_border_color = surface->GetReplicaDebugBorderColor();
     float replica_debug_border_width = surface->GetReplicaDebugBorderWidth();
     // TODO(danakj): By using the same RenderSurfaceImpl for both the
     // content and its reflection, it's currently not possible to apply a
     // separate mask to the reflection layer or correctly handle opacity in
     // reflections (opacity must be applied after drawing both the layer and its
     // reflection). The solution is to introduce yet another RenderSurfaceImpl
     // to draw the layer and its reflection in. For now we only apply a separate
     // reflection mask if the contents don't have a mask of their own.
     LayerImpl* replica_mask_layer =
-        mask_layer ? mask_layer : layer->replica_layer()->mask_layer();
+        surface->HasMask() ? surface->MaskLayer() : surface->ReplicaMaskLayer();
 
     surface->AppendQuads(target_render_pass, replica_draw_transform,
                          replica_occlusion, replica_debug_border_color,
                          replica_debug_border_width, replica_mask_layer,
                          append_quads_data, contributing_render_pass->id);
   }
 }
 
 static void AppendQuadsToFillScreen(const gfx::Rect& root_scroll_layer_rect,
                                     RenderPass* target_render_pass,
@@ skipping 3296 matching lines @@
     const {
   return fixed_raster_scale_attempted_scale_change_history_.count() >=
          kFixedRasterScaleAttemptedScaleChangeThreshold;
 }
 
 void LayerTreeHostImpl::SetFixedRasterScaleAttemptedToChangeScale() {
   fixed_raster_scale_attempted_scale_change_history_.set(0);
 }
 
 }  // namespace cc