cc: Rename visible_content_rect and content stuff on quads.

cc/trees/occlusion_tracker_unittest.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 "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 17 matching lines @@
 namespace cc {
 namespace {
 
 class TestContentLayerImpl : public LayerImpl {
  public:
   TestContentLayerImpl(LayerTreeImpl* tree_impl, int id)
       : LayerImpl(tree_impl, id), override_opaque_contents_rect_(false) {
     SetDrawsContent(true);
   }
 
-  SimpleEnclosedRegion VisibleContentOpaqueRegion() const override {
+  SimpleEnclosedRegion VisibleOpaqueRegion() const override {
     if (override_opaque_contents_rect_) {
       return SimpleEnclosedRegion(
-          gfx::IntersectRects(opaque_contents_rect_, visible_content_rect()));
+          gfx::IntersectRects(opaque_contents_rect_, visible_layer_rect()));
     }
-    return LayerImpl::VisibleContentOpaqueRegion();
+    return LayerImpl::VisibleOpaqueRegion();
   }
   void SetOpaqueContentsRect(const gfx::Rect& opaque_contents_rect) {
     override_opaque_contents_rect_ = true;
     opaque_contents_rect_ = opaque_contents_rect;
   }
 
  private:
   bool override_opaque_contents_rect_;
   gfx::Rect opaque_contents_rect_;
 };
 
 class TestOcclusionTrackerWithClip : public TestOcclusionTracker {
  public:
   explicit TestOcclusionTrackerWithClip(const gfx::Rect& viewport_rect)
       : TestOcclusionTracker(viewport_rect) {}
 
   bool OccludedLayer(const LayerImpl* layer,
                      const gfx::Rect& content_rect) const {
-    DCHECK(layer->visible_content_rect().Contains(content_rect));
+    DCHECK(layer->visible_layer_rect().Contains(content_rect));
     return this->GetCurrentOcclusionForLayer(layer->draw_transform())
         .IsOccluded(content_rect);
   }
 
   // Gives an unoccluded sub-rect of |content_rect| in the content space of the
   // layer. Simple wrapper around GetUnoccludedContentRect.
   gfx::Rect UnoccludedLayerContentRect(const LayerImpl* layer,
                                        const gfx::Rect& content_rect) const {
-    DCHECK(layer->visible_content_rect().Contains(content_rect));
+    DCHECK(layer->visible_layer_rect().Contains(content_rect));
     return this->GetCurrentOcclusionForLayer(layer->draw_transform())
         .GetUnoccludedContentRect(content_rect);
   }
 
   gfx::Rect UnoccludedSurfaceContentRect(const LayerImpl* layer,
                                          const gfx::Rect& content_rect) const {
     RenderSurfaceImpl* surface = layer->render_surface();
     return this->GetCurrentOcclusionForContributingSurface(
                      surface->draw_transform())
         .GetUnoccludedContentRect(content_rect);
@@ skipping 555 matching lines @@
         root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
     LayerImpl* child = this->CreateSurface(
         parent, child_transform, gfx::PointF(30.f, 30.f), gfx::Size(500, 500));
     TestContentLayerImpl* layer = this->CreateDrawingLayer(
         child, layer_transform, gfx::PointF(), gfx::Size(500, 500), true);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip occlusion(gfx::Rect(0, 0, 1000, 1000));
 
     gfx::Rect clipped_layer_in_child = MathUtil::MapEnclosingClippedRect(
-        layer_transform, layer->visible_content_rect());
+        layer_transform, layer->visible_layer_rect());
 
     this->VisitLayer(layer, &occlusion);
     this->EnterContributingSurface(child, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(clipped_layer_in_child.ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     this->LeaveContributingSurface(child, &occlusion);
@@ skipping 1852 matching lines @@
     EXPECT_EQ(gfx::Rect(),
               occlusion.UnoccludedSurfaceContentRect(
                   surface, gfx::Rect(80, 70, 50, 50)));
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestUnoccludedSurfaceQuery)
 
 }  // namespace
 }  // namespace cc