cc: Chromify Layer and LayerImpl classes.

cc/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/occlusion_tracker.h"
 
 #include <algorithm>
 
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
@@ skipping 81 matching lines @@
         gfx::ToEnclosedRect(transformed_quad.BoundingBox());
     DCHECK(!clipped);  // We only map if the transform preserves axis alignment.
     if (have_clip_rect)
       transformed_rect.Intersect(clip_rect_in_new_target);
     transformed_region.Union(transformed_rect);
   }
   return transformed_region;
 }
 
 static inline bool LayerOpacityKnown(const Layer* layer) {
-  return !layer->drawOpacityIsAnimating();
+  return !layer->draw_opacity_is_animating();
 }
 static inline bool LayerOpacityKnown(const LayerImpl* layer) {
   return true;
 }
 static inline bool LayerTransformsToTargetKnown(const Layer* layer) {
-  return !layer->drawTransformIsAnimating();
+  return !layer->draw_transform_is_animating();
 }
 static inline bool LayerTransformsToTargetKnown(const LayerImpl* layer) {
   return true;
 }
 
 static inline bool SurfaceOpacityKnown(const RenderSurface* rs) {
   return !rs->draw_opacity_is_animating();
 }
 static inline bool SurfaceOpacityKnown(const RenderSurfaceImpl* rs) {
   return true;
 }
 static inline bool SurfaceTransformsToTargetKnown(const RenderSurface* rs) {
   return !rs->target_surface_transforms_are_animating();
 }
 static inline bool SurfaceTransformsToTargetKnown(const RenderSurfaceImpl* rs) {
   return true;
 }
 static inline bool SurfaceTransformsToScreenKnown(const RenderSurface* rs) {
   return !rs->screen_space_transforms_are_animating();
 }
 static inline bool SurfaceTransformsToScreenKnown(const RenderSurfaceImpl* rs) {
   return true;
 }
 
 static inline bool LayerIsInUnsorted3dRenderingContext(const Layer* layer) {
-  return layer->parent() && layer->parent()->preserves3D();
+  return layer->parent() && layer->parent()->preserves_3d();
 }
 static inline bool LayerIsInUnsorted3dRenderingContext(const LayerImpl* layer) {
   return false;
 }
 
 template <typename LayerType, typename RenderSurfaceType>
 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::EnterRenderTarget(
     const LayerType* new_target) {
   if (!stack_.empty() && stack_.back().target == new_target)
     return;
 
   const LayerType* old_target = NULL;
   const RenderSurfaceType* old_ancestor_that_moves_pixels = NULL;
   if (!stack_.empty()) {
     old_target = stack_.back().target;
     old_ancestor_that_moves_pixels =
-        old_target->renderSurface()->nearest_ancestor_that_moves_pixels();
+        old_target->render_surface()->nearest_ancestor_that_moves_pixels();
   }
   const RenderSurfaceType* new_ancestor_that_moves_pixels =
-      new_target->renderSurface()->nearest_ancestor_that_moves_pixels();
+      new_target->render_surface()->nearest_ancestor_that_moves_pixels();
 
   stack_.push_back(StackObject(new_target));
 
   // We copy the screen occlusion into the new RenderSurface subtree, but we
   // never copy in the occlusion from inside the target, since we are looking
   // at a new RenderSurface target.
 
   // If we are entering a subtree that is going to move pixels around, then the
   // occlusion we've computed so far won't apply to the pixels we're drawing
   // here in the same way. We discard the occlusion thus far to be safe, and
   // ensure we don't cull any pixels that are moved such that they become
   //  visible.
   bool entering_subtree_that_moves_pixels =
       new_ancestor_that_moves_pixels &&
       new_ancestor_that_moves_pixels != old_ancestor_that_moves_pixels;
 
   bool have_transform_from_screen_to_new_target = false;
   gfx::Transform inverse_new_target_screen_space_transform(
       // Note carefully, not used if screen space transform is uninvertible.
       gfx::Transform::kSkipInitialization);
-  if (SurfaceTransformsToScreenKnown(new_target->renderSurface())) {
+  if (SurfaceTransformsToScreenKnown(new_target->render_surface())) {
     have_transform_from_screen_to_new_target =
-        new_target->renderSurface()->screen_space_transform().GetInverse(
+        new_target->render_surface()->screen_space_transform().GetInverse(
             &inverse_new_target_screen_space_transform);
   }
 
   bool entering_root_target = new_target->parent() == NULL;
 
   bool copy_outside_occlusion_forward =
       stack_.size() > 1 &&
       !entering_subtree_that_moves_pixels &&
       have_transform_from_screen_to_new_target &&
       !entering_root_target;
   if (!copy_outside_occlusion_forward)
     return;
 
   int last_index = stack_.size() - 1;
   gfx::Transform old_target_to_new_target_transform(
       inverse_new_target_screen_space_transform,
-      old_target->renderSurface()->screen_space_transform());
+      old_target->render_surface()->screen_space_transform());
   stack_[last_index].occlusion_from_outside_target =
       TransformSurfaceOpaqueRegion<RenderSurfaceType>(
           stack_[last_index - 1].occlusion_from_outside_target,
           false,
           gfx::Rect(),
           old_target_to_new_target_transform);
   stack_[last_index].occlusion_from_outside_target.Union(
       TransformSurfaceOpaqueRegion<RenderSurfaceType>(
           stack_[last_index - 1].occlusion_from_inside_target,
           false,
           gfx::Rect(),
           old_target_to_new_target_transform));
 }
 
 template <typename LayerType, typename RenderSurfaceType>
 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::FinishedRenderTarget(
     const LayerType* finished_target) {
   // Make sure we know about the target surface.
   EnterRenderTarget(finished_target);
 
-  RenderSurfaceType* surface = finished_target->renderSurface();
+  RenderSurfaceType* surface = finished_target->render_surface();
 
   // 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.
   // TODO(senorblanco):  Make this smarter for SkImageFilter case:  once
   // SkImageFilters can report affectsOpacity(), call that.
-  if (finished_target->maskLayer() ||
+  if (finished_target->mask_layer() ||
       !SurfaceOpacityKnown(surface) ||
       surface->draw_opacity() < 1 ||
       finished_target->filters().hasFilterThatAffectsOpacity() ||
       finished_target->filter()) {
     stack_.back().occlusion_from_outside_target.Clear();
     stack_.back().occlusion_from_inside_target.Clear();
   } else if (!SurfaceTransformsToTargetKnown(surface)) {
     stack_.back().occlusion_from_inside_target.Clear();
     stack_.back().occlusion_from_outside_target.Clear();
   }
 }
 
 template <typename LayerType>
 static void ReduceOcclusionBelowSurface(LayerType* contributing_layer,
                                         gfx::Rect surface_rect,
                                         const gfx::Transform& surface_transform,
                                         LayerType* render_target,
                                         Region* occlusion_from_inside_target) {
   if (surface_rect.IsEmpty())
     return;
 
   gfx::Rect affected_area_in_target = gfx::ToEnclosingRect(
       MathUtil::mapClippedRect(surface_transform, gfx::RectF(surface_rect)));
-  if (contributing_layer->renderSurface()->is_clipped()) {
+  if (contributing_layer->render_surface()->is_clipped()) {
     affected_area_in_target.Intersect(
-        contributing_layer->renderSurface()->clip_rect());
+        contributing_layer->render_surface()->clip_rect());
   }
   if (affected_area_in_target.IsEmpty())
     return;
 
   int outset_top, outset_right, outset_bottom, outset_left;
-  contributing_layer->backgroundFilters().getOutsets(
+  contributing_layer->background_filters().getOutsets(
       outset_top, outset_right, outset_bottom, outset_left);
 
   // The filter can move pixels from outside of the clip, so allow affectedArea
   // to expand outside the clip.
   affected_area_in_target.Inset(
       -outset_left, -outset_top, -outset_right, -outset_bottom);
 
   gfx::Rect FilterOutsetsInTarget(-outset_left,
                                   -outset_top,
                                   outset_left + outset_right,
@@ skipping 33 matching lines @@
     const LayerType* new_target) {
   int last_index = stack_.size() - 1;
   bool surface_will_be_at_top_after_pop =
       stack_.size() > 1 && stack_[last_index - 1].target == new_target;
 
   // We merge the screen occlusion from the current RenderSurfaceImpl subtree
   // out to its parent target RenderSurfaceImpl. The target occlusion can be
   // merged out as well but needs to be transformed to the new target.
 
   const LayerType* old_target = stack_[last_index].target;
-  const RenderSurfaceType* old_surface = old_target->renderSurface();
+  const RenderSurfaceType* old_surface = old_target->render_surface();
 
   Region old_occlusion_from_inside_target_in_new_target =
       TransformSurfaceOpaqueRegion<RenderSurfaceType>(
           stack_[last_index].occlusion_from_inside_target,
           old_surface->is_clipped(),
           old_surface->clip_rect(),
           old_surface->draw_transform());
-  if (old_target->hasReplica() && !old_target->replicaHasMask()) {
+  if (old_target->has_replica() && !old_target->replica_has_mask()) {
     old_occlusion_from_inside_target_in_new_target.Union(
         TransformSurfaceOpaqueRegion<RenderSurfaceType>(
             stack_[last_index].occlusion_from_inside_target,
             old_surface->is_clipped(),
             old_surface->clip_rect(),
             old_surface->replica_draw_transform()));
   }
 
   Region old_occlusion_from_outside_target_in_new_target =
       TransformSurfaceOpaqueRegion<RenderSurfaceType>(
           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->backgroundFilters().hasFilterThatMovesPixels()) {
+  if (old_target->background_filters().hasFilterThatMovesPixels()) {
     unoccluded_surface_rect = UnoccludedContributingSurfaceContentRect(
         old_target, false, old_surface->content_rect(), NULL);
-    if (old_target->hasReplica()) {
+    if (old_target->has_replica()) {
       unoccluded_replica_rect = UnoccludedContributingSurfaceContentRect(
           old_target, true, old_surface->content_rect(), NULL);
     }
   }
 
   if (surface_will_be_at_top_after_pop) {
     // Merge the top of the stack down.
     stack_[last_index - 1].occlusion_from_inside_target.Union(
         old_occlusion_from_inside_target_in_new_target);
     // TODO(danakj): Strictly this should subtract the inside target occlusion
     // before union.
     if (new_target->parent()) {
       stack_[last_index - 1].occlusion_from_outside_target.Union(
           old_occlusion_from_outside_target_in_new_target);
     }
     stack_.pop_back();
   } else {
     // Replace the top of the stack with the new pushed surface.
     stack_.back().target = new_target;
     stack_.back().occlusion_from_inside_target =
         old_occlusion_from_inside_target_in_new_target;
     if (new_target->parent()) {
       stack_.back().occlusion_from_outside_target =
           old_occlusion_from_outside_target_in_new_target;
     } else {
       stack_.back().occlusion_from_outside_target.Clear();
     }
   }
 
-  if (!old_target->backgroundFilters().hasFilterThatMovesPixels())
+  if (!old_target->background_filters().hasFilterThatMovesPixels())
     return;
 
   ReduceOcclusionBelowSurface(old_target,
                               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->hasReplica())
+  if (!old_target->has_replica())
     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,
                               &stack_.back().occlusion_from_outside_target);
 }
 
 template <typename LayerType, typename RenderSurfaceType>
 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::
     MarkOccludedBehindLayer(const LayerType* layer) {
   DCHECK(!stack_.empty());
-  DCHECK_EQ(layer->renderTarget(), stack_.back().target);
+  DCHECK_EQ(layer->render_target(), stack_.back().target);
   if (stack_.empty())
     return;
 
-  if (!LayerOpacityKnown(layer) || layer->drawOpacity() < 1)
+  if (!LayerOpacityKnown(layer) || layer->draw_opacity() < 1)
     return;
 
   if (LayerIsInUnsorted3dRenderingContext(layer))
     return;
 
   if (!LayerTransformsToTargetKnown(layer))
     return;
 
-  Region opaque_contents = layer->visibleContentOpaqueRegion();
+  Region opaque_contents = layer->VisibleContentOpaqueRegion();
   if (opaque_contents.IsEmpty())
     return;
 
-  DCHECK(layer->visibleContentRect().Contains(opaque_contents.bounds()));
+  DCHECK(layer->visible_content_rect().Contains(opaque_contents.bounds()));
 
   bool clipped;
   gfx::QuadF visible_transformed_quad = MathUtil::mapQuad(
-      layer->drawTransform(), gfx::QuadF(opaque_contents.bounds()), clipped);
+      layer->draw_transform(), gfx::QuadF(opaque_contents.bounds()), clipped);
   // FIXME: Find a rect interior to each transformed quad.
   if (clipped || !visible_transformed_quad.IsRectilinear())
     return;
 
   gfx::Rect clip_rect_in_target = gfx::IntersectRects(
-      layer->renderTarget()->renderSurface()->content_rect(),
+      layer->render_target()->render_surface()->content_rect(),
       ScreenSpaceClipRectInTargetSurface(
-          layer->renderTarget()->renderSurface(), screen_space_clip_rect_));
+          layer->render_target()->render_surface(), screen_space_clip_rect_));
 
   for (Region::Iterator opaqueContentRects(opaque_contents);
        opaqueContentRects.has_rect();
        opaqueContentRects.next()) {
     gfx::QuadF transformed_quad = MathUtil::mapQuad(
-        layer->drawTransform(),
+        layer->draw_transform(),
         gfx::QuadF(opaqueContentRects.rect()),
         clipped);
     gfx::Rect transformed_rect =
         gfx::ToEnclosedRect(transformed_quad.BoundingBox());
     DCHECK(!clipped);  // We only map if the transform preserves axis alignment.
     transformed_rect.Intersect(clip_rect_in_target);
     if (transformed_rect.width() < minimum_tracking_size_.width() &&
         transformed_rect.height() < minimum_tracking_size_.height())
       continue;
     stack_.back().occlusion_from_inside_target.Union(transformed_rect);
 
     if (!occluding_screen_space_rects_)
       continue;
 
     // Save the occluding area in screen space for debug visualization.
     gfx::QuadF screen_space_quad = MathUtil::mapQuad(
-        layer->renderTarget()->renderSurface()->screen_space_transform(),
+        layer->render_target()->render_surface()->screen_space_transform(),
         gfx::QuadF(transformed_rect), clipped);
     // TODO(danakj): Store the quad in the debug info instead of the bounding
     // box.
     gfx::Rect screen_space_rect =
         gfx::ToEnclosedRect(screen_space_quad.BoundingBox());
     occluding_screen_space_rects_->push_back(screen_space_rect);
   }
 
   if (!non_occluding_screen_space_rects_)
     return;
 
   Region non_opaque_contents =
-      SubtractRegions(gfx::Rect(layer->contentBounds()), opaque_contents);
+      SubtractRegions(gfx::Rect(layer->content_bounds()), opaque_contents);
   for (Region::Iterator nonOpaqueContentRects(non_opaque_contents);
        nonOpaqueContentRects.has_rect();
        nonOpaqueContentRects.next()) {
     // We've already checked for clipping in the mapQuad call above, these calls
     // should not clip anything further.
     gfx::Rect transformed_rect = gfx::ToEnclosedRect(
-        MathUtil::mapClippedRect(layer->drawTransform(),
+        MathUtil::mapClippedRect(layer->draw_transform(),
                                  gfx::RectF(nonOpaqueContentRects.rect())));
     transformed_rect.Intersect(clip_rect_in_target);
     if (transformed_rect.IsEmpty())
       continue;
 
     gfx::QuadF screen_space_quad = MathUtil::mapQuad(
-        layer->renderTarget()->renderSurface()->screen_space_transform(),
+        layer->render_target()->render_surface()->screen_space_transform(),
         gfx::QuadF(transformed_rect),
         clipped);
     // TODO(danakj): Store the quad in the debug info instead of the bounding
     // box.
     gfx::Rect screen_space_rect =
         gfx::ToEnclosedRect(screen_space_quad.BoundingBox());
     non_occluding_screen_space_rects_->push_back(screen_space_rect);
   }
 }
 
@@ skipping 14 matching lines @@
     return false;
   if (content_rect.IsEmpty())
     return true;
   if (impl_draw_transform_is_unknown)
     return false;
 
   // For tests with no render target.
   if (!render_target)
     return false;
 
-  DCHECK_EQ(render_target->renderTarget(), render_target);
-  DCHECK(render_target->renderSurface());
+  DCHECK_EQ(render_target->render_target(), render_target);
+  DCHECK(render_target->render_surface());
   DCHECK_EQ(render_target, stack_.back().target);
 
   gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
   if (!draw_transform.GetInverse(&inverse_draw_transform))
     return false;
 
   // Take the ToEnclosingRect at each step, as we want to contain any unoccluded
   // partial pixels in the resulting Rect.
   Region unoccluded_region_in_target_surface = gfx::ToEnclosingRect(
       MathUtil::mapClippedRect(draw_transform, gfx::RectF(content_rect)));
   // Layers can't clip across surfaces, so count this as internal occlusion.
   if (is_clipped)
     unoccluded_region_in_target_surface.Intersect(clip_rect_in_target);
   unoccluded_region_in_target_surface.Subtract(
       stack_.back().occlusion_from_inside_target);
   gfx::RectF unoccluded_rect_in_target_surface_without_outside_occlusion =
       unoccluded_region_in_target_surface.bounds();
   unoccluded_region_in_target_surface.Subtract(
       stack_.back().occlusion_from_outside_target);
 
   // Treat other clipping as occlusion from outside the surface.
   // TODO(danakj): Clip to visibleContentRect?
   unoccluded_region_in_target_surface.Intersect(
-      render_target->renderSurface()->content_rect());
+      render_target->render_surface()->content_rect());
   unoccluded_region_in_target_surface.Intersect(
-      ScreenSpaceClipRectInTargetSurface(render_target->renderSurface(),
+      ScreenSpaceClipRectInTargetSurface(render_target->render_surface(),
                                          screen_space_clip_rect_));
 
   gfx::RectF unoccluded_rect_in_target_surface =
       unoccluded_region_in_target_surface.bounds();
 
   if (has_occlusion_from_outside_target_surface) {
     // Check if the unoccluded rect shrank when applying outside occlusion.
     *has_occlusion_from_outside_target_surface = !gfx::SubtractRects(
         unoccluded_rect_in_target_surface_without_outside_occlusion,
         unoccluded_rect_in_target_surface).IsEmpty();
@@ skipping 20 matching lines @@
     return content_rect;
   if (content_rect.IsEmpty())
     return content_rect;
   if (impl_draw_transform_is_unknown)
     return content_rect;
 
   // For tests with no render target.
   if (!render_target)
     return content_rect;
 
-  DCHECK_EQ(render_target->renderTarget(), render_target);
-  DCHECK(render_target->renderSurface());
+  DCHECK_EQ(render_target->render_target(), render_target);
+  DCHECK(render_target->render_surface());
   DCHECK_EQ(render_target, stack_.back().target);
 
   gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
   if (!draw_transform.GetInverse(&inverse_draw_transform))
     return content_rect;
 
   // Take the ToEnclosingRect at each step, as we want to contain any unoccluded
   // partial pixels in the resulting Rect.
   Region unoccluded_region_in_target_surface = gfx::ToEnclosingRect(
       MathUtil::mapClippedRect(draw_transform, gfx::RectF(content_rect)));
   // Layers can't clip across surfaces, so count this as internal occlusion.
   if (is_clipped)
     unoccluded_region_in_target_surface.Intersect(clip_rect_in_target);
   unoccluded_region_in_target_surface.Subtract(
       stack_.back().occlusion_from_inside_target);
   gfx::RectF unoccluded_rect_in_target_surface_without_outside_occlusion =
       unoccluded_region_in_target_surface.bounds();
   unoccluded_region_in_target_surface.Subtract(
       stack_.back().occlusion_from_outside_target);
 
   // Treat other clipping as occlusion from outside the surface.
   // TODO(danakj): Clip to visibleContentRect?
   unoccluded_region_in_target_surface.Intersect(
-      render_target->renderSurface()->content_rect());
+      render_target->render_surface()->content_rect());
   unoccluded_region_in_target_surface.Intersect(
-      ScreenSpaceClipRectInTargetSurface(render_target->renderSurface(),
+      ScreenSpaceClipRectInTargetSurface(render_target->render_surface(),
                                          screen_space_clip_rect_));
 
   gfx::RectF unoccluded_rect_in_target_surface =
       unoccluded_region_in_target_surface.bounds();
   gfx::Rect unoccluded_rect = gfx::ToEnclosingRect(
       MathUtil::projectClippedRect(inverse_draw_transform,
                                    unoccluded_rect_in_target_surface));
   unoccluded_rect.Intersect(content_rect);
 
   if (has_occlusion_from_outside_target_surface) {
     // Check if the unoccluded rect shrank when applying outside occlusion.
     *has_occlusion_from_outside_target_surface = !gfx::SubtractRects(
         unoccluded_rect_in_target_surface_without_outside_occlusion,
         unoccluded_rect_in_target_surface).IsEmpty();
   }
 
   return unoccluded_rect;
 }
 
 template <typename LayerType, typename RenderSurfaceType>
 gfx::Rect OcclusionTrackerBase<LayerType, RenderSurfaceType>::
     UnoccludedContributingSurfaceContentRect(
         const LayerType* layer,
         bool for_replica,
         gfx::Rect content_rect,
         bool* has_occlusion_from_outside_target_surface) const {
   DCHECK(!stack_.empty());
   // The layer is a contributing render_target so it should have a surface.
-  DCHECK(layer->renderSurface());
+  DCHECK(layer->render_surface());
   // The layer is a contributing render_target so its target should be itself.
-  DCHECK_EQ(layer->renderTarget(), layer);
+  DCHECK_EQ(layer->render_target(), layer);
   // The layer should not be the root, else what is is contributing to?
   DCHECK(layer->parent());
   // This should be called while the layer is still considered the current
   // target in the occlusion tracker.
   DCHECK_EQ(layer, stack_.back().target);
 
   if (has_occlusion_from_outside_target_surface)
     *has_occlusion_from_outside_target_surface = false;
 
   if (content_rect.IsEmpty())
     return content_rect;
 
-  const RenderSurfaceType* surface = layer->renderSurface();
+  const RenderSurfaceType* surface = layer->render_surface();
   const LayerType* contributing_surface_render_target =
-      layer->parent()->renderTarget();
+      layer->parent()->render_target();
 
   if (!SurfaceTransformsToTargetKnown(surface))
     return content_rect;
 
   gfx::Transform draw_transform =
       for_replica ? surface->replica_draw_transform() : surface->draw_transform();
   gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
   if (!draw_transform.GetInverse(&inverse_draw_transform))
     return content_rect;
 
@@ skipping 17 matching lines @@
   gfx::RectF unoccluded_rect_in_target_surface_without_outside_occlusion =
       unoccluded_region_in_target_surface.bounds();
   if (has_occlusion) {
     const StackObject& second_last = stack_[stack_.size() - 2];
     unoccluded_region_in_target_surface.Subtract(
         second_last.occlusion_from_outside_target);
   }
 
   // Treat other clipping as occlusion from outside the target surface.
   unoccluded_region_in_target_surface.Intersect(
-      contributing_surface_render_target->renderSurface()->content_rect());
+      contributing_surface_render_target->render_surface()->content_rect());
   unoccluded_region_in_target_surface.Intersect(
       ScreenSpaceClipRectInTargetSurface(
-          contributing_surface_render_target->renderSurface(),
+          contributing_surface_render_target->render_surface(),
           screen_space_clip_rect_));
 
   gfx::RectF unoccluded_rect_in_target_surface =
       unoccluded_region_in_target_surface.bounds();
   gfx::Rect unoccluded_rect = gfx::ToEnclosingRect(
       MathUtil::projectClippedRect(inverse_draw_transform,
                                    unoccluded_rect_in_target_surface));
   unoccluded_rect.Intersect(content_rect);
 
   if (has_occlusion_from_outside_target_surface) {
     // Check if the unoccluded rect shrank when applying outside occlusion.
     *has_occlusion_from_outside_target_surface = !gfx::SubtractRects(
         unoccluded_rect_in_target_surface_without_outside_occlusion,
         unoccluded_rect_in_target_surface).IsEmpty();
   }
 
   return unoccluded_rect;
 }
 
 // Instantiate (and export) templates here for the linker.
 template class OcclusionTrackerBase<Layer, RenderSurface>;
 template class OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>;
 
 }  // namespace cc