cc: Rename visible_content_rect and content stuff on quads.

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 <algorithm>
 
 #include "cc/base/math_util.h"
 #include "cc/base/region.h"
@@ skipping 340 matching lines @@
 
   if (layer->draw_opacity() < 1)
     return;
 
   if (!layer->uses_default_blend_mode())
     return;
 
   if (layer->Is3dSorted())
     return;
 
-  SimpleEnclosedRegion opaque_contents = layer->VisibleContentOpaqueRegion();
-  if (opaque_contents.IsEmpty())
+  SimpleEnclosedRegion opaque_layer_region = layer->VisibleOpaqueRegion();
+  if (opaque_layer_region.IsEmpty())
     return;
 
-  DCHECK(layer->visible_content_rect().Contains(opaque_contents.bounds()));
+  DCHECK(layer->visible_layer_rect().Contains(opaque_layer_region.bounds()));
 
   // TODO(danakj): Find a rect interior to each transformed quad.
   if (!layer->draw_transform().Preserves2dAxisAlignment())
     return;
 
   gfx::Rect clip_rect_in_target = ScreenSpaceClipRectInTargetSurface(
       layer->render_target()->render_surface(), screen_space_clip_rect_);
   if (layer->is_clipped()) {
     clip_rect_in_target.Intersect(layer->clip_rect());
   } else {
     clip_rect_in_target.Intersect(
         layer->render_target()->render_surface()->content_rect());
   }
 
-  for (size_t i = 0; i < opaque_contents.GetRegionComplexity(); ++i) {
+  for (size_t i = 0; i < opaque_layer_region.GetRegionComplexity(); ++i) {
     gfx::Rect transformed_rect =
         MathUtil::MapEnclosedRectWith2dAxisAlignedTransform(
-            layer->draw_transform(), opaque_contents.GetRect(i));
+            layer->draw_transform(), opaque_layer_region.GetRect(i));
     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);
   }
 }
 
 Region OcclusionTracker::ComputeVisibleRegionInScreen() const {
   DCHECK(!stack_.back().target->parent());
   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