cc: Remove more references to owning_layer_ from RenderSurfaceImpl

cc/layers/render_surface_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/layers/render_surface_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 15 matching lines @@
 #include "cc/trees/occlusion.h"
 #include "cc/trees/transform_node.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 RenderSurfaceImpl::RenderSurfaceImpl(LayerImpl* owning_layer)
     : owning_layer_(owning_layer),
+      layer_tree_impl_(owning_layer->layer_tree_impl()),
+      stable_effect_id_(owning_layer->id()),
       surface_property_changed_(false),
       ancestor_property_changed_(false),
       contributes_to_drawn_surface_(false),
       nearest_occlusion_immune_ancestor_(nullptr),
       target_render_surface_layer_index_history_(0),
       current_layer_index_history_(0) {
   damage_tracker_ = DamageTracker::Create();
 }
 
 RenderSurfaceImpl::~RenderSurfaceImpl() {}
 
 RenderSurfaceImpl* RenderSurfaceImpl::render_target() {
-  EffectTree& effect_tree =
-      owning_layer_->layer_tree_impl()->property_trees()->effect_tree;
+  EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(EffectTreeIndex());
   EffectNode* target_node = effect_tree.Node(node->target_id);
   if (target_node->id != 0)
     return target_node->render_surface;
   else
     return this;
 }
 
 const RenderSurfaceImpl* RenderSurfaceImpl::render_target() const {
   const EffectTree& effect_tree =
-      owning_layer_->layer_tree_impl()->property_trees()->effect_tree;
+      layer_tree_impl_->property_trees()->effect_tree;
   const EffectNode* node = effect_tree.Node(EffectTreeIndex());
   const EffectNode* target_node = effect_tree.Node(node->target_id);
   if (target_node->id != 0)
     return target_node->render_surface;
   else
     return this;
 }
 
 RenderSurfaceImpl::DrawProperties::DrawProperties() {
   draw_opacity = 1.f;
@@ skipping 39 matching lines @@
 
 bool RenderSurfaceImpl::UsesDefaultBlendMode() const {
   return BlendMode() == SkXfermode::kSrcOver_Mode;
 }
 
 SkColor RenderSurfaceImpl::GetDebugBorderColor() const {
   return DebugColors::SurfaceBorderColor();
 }
 
 float RenderSurfaceImpl::GetDebugBorderWidth() const {
-  return DebugColors::SurfaceBorderWidth(owning_layer_->layer_tree_impl());
-}
-
-int RenderSurfaceImpl::OwningLayerId() const {
-  return owning_layer_ ? owning_layer_->id() : 0;
+  return DebugColors::SurfaceBorderWidth(layer_tree_impl_);
 }
 
 LayerImpl* RenderSurfaceImpl::MaskLayer() {
   int mask_layer_id = OwningEffectNode()->mask_layer_id;
-  return owning_layer_->layer_tree_impl()->LayerById(mask_layer_id);
+  return layer_tree_impl_->LayerById(mask_layer_id);
 }
 
 bool RenderSurfaceImpl::HasMask() const {
   return OwningEffectNode()->mask_layer_id != EffectTree::kInvalidNodeId;
 }
 
 const FilterOperations& RenderSurfaceImpl::Filters() const {
   return OwningEffectNode()->filters;
 }
 
@@ skipping 15 matching lines @@
 
 int RenderSurfaceImpl::TransformTreeIndex() const {
   return owning_layer_->transform_tree_index();
 }
 
 int RenderSurfaceImpl::ClipTreeIndex() const {
   return owning_layer_->clip_tree_index();
 }
 
 int RenderSurfaceImpl::EffectTreeIndex() const {
-  return owning_layer_->effect_tree_index();
+  return layer_tree_impl_->property_trees()
+      ->effect_id_to_index_map[stable_effect_id_];
 }
 
 const EffectNode* RenderSurfaceImpl::OwningEffectNode() const {
-  return owning_layer_->layer_tree_impl()->property_trees()->effect_tree.Node(
+  return layer_tree_impl_->property_trees()->effect_tree.Node(
       EffectTreeIndex());
 }
 
 void RenderSurfaceImpl::SetClipRect(const gfx::Rect& clip_rect) {
   if (clip_rect == draw_properties_.clip_rect)
     return;
 
   surface_property_changed_ = true;
   draw_properties_.clip_rect = clip_rect;
 }
@@ skipping 65 matching lines @@
       std::min(surface_content_rect.width(), max_texture_size));
   surface_content_rect.set_height(
       std::min(surface_content_rect.height(), max_texture_size));
 
   SetContentRect(surface_content_rect);
 }
 
 void RenderSurfaceImpl::SetContentRectToViewport() {
   // Only root render surface use viewport as content rect.
   DCHECK_EQ(render_target(), this);
-  gfx::Rect viewport = gfx::ToEnclosingRect(owning_layer_->layer_tree_impl()
-                                                ->property_trees()
-                                                ->clip_tree.ViewportClip());
+  gfx::Rect viewport = gfx::ToEnclosingRect(
+      layer_tree_impl_->property_trees()->clip_tree.ViewportClip());
   SetContentRect(viewport);
 }
 
 void RenderSurfaceImpl::ClearAccumulatedContentRect() {
   accumulated_content_rect_ = gfx::Rect();
 }
 
 void RenderSurfaceImpl::AccumulateContentRectFromContributingLayer(
     LayerImpl* layer) {
   DCHECK(layer->DrawsContent());
@@ skipping 36 matching lines @@
   //
   DCHECK(owning_layer_);
   return surface_property_changed_ || AncestorPropertyChanged();
 }
 
 bool RenderSurfaceImpl::SurfacePropertyChangedOnlyFromDescendant() const {
   return surface_property_changed_ && !AncestorPropertyChanged();
 }
 
 bool RenderSurfaceImpl::AncestorPropertyChanged() const {
-  const PropertyTrees* property_trees =
-      owning_layer_->layer_tree_impl()->property_trees();
+  const PropertyTrees* property_trees = layer_tree_impl_->property_trees();
   return ancestor_property_changed_ || property_trees->full_tree_damaged ||
          property_trees->transform_tree.Node(TransformTreeIndex())
              ->transform_changed ||
          property_trees->effect_tree.Node(EffectTreeIndex())->effect_changed;
 }
 
 void RenderSurfaceImpl::NoteAncestorPropertyChanged() {
   ancestor_property_changed_ = true;
 }
 
@@ skipping 28 matching lines @@
                                     SkColor debug_border_color,
                                     float debug_border_width,
                                     LayerImpl* mask_layer,
                                     AppendQuadsData* append_quads_data,
                                     RenderPassId render_pass_id) {
   gfx::Rect visible_layer_rect =
       occlusion_in_content_space.GetUnoccludedContentRect(content_rect());
   if (visible_layer_rect.IsEmpty())
     return;
 
-  const PropertyTrees* property_trees =
-      owning_layer_->layer_tree_impl()->property_trees();
+  const PropertyTrees* property_trees = layer_tree_impl_->property_trees();
   int sorting_context_id =
       property_trees->transform_tree.Node(TransformTreeIndex())
           ->sorting_context_id;
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
   shared_quad_state->SetAll(
       draw_transform, content_rect().size(), content_rect(),
       draw_properties_.clip_rect, draw_properties_.is_clipped,
       draw_properties_.draw_opacity, BlendMode(), sorting_context_id);
 
-  if (owning_layer_->ShowDebugBorders()) {
+  if (layer_tree_impl_->debug_state().show_debug_borders) {
     DebugBorderDrawQuad* debug_border_quad =
         render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
     debug_border_quad->SetNew(shared_quad_state, content_rect(),
                               visible_layer_rect, debug_border_color,
                               debug_border_width);
   }
 
   ResourceId mask_resource_id = 0;
   gfx::Size mask_texture_size;
   gfx::Vector2dF mask_uv_scale;
@@ skipping 17 matching lines @@
 
   RenderPassDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_quad_state, content_rect(), visible_layer_rect,
                render_pass_id, mask_resource_id, mask_uv_scale,
                mask_texture_size, Filters(), owning_layer_to_target_scale,
                FiltersOrigin(), BackgroundFilters());
 }
 
 }  // namespace cc