cc: Remove WebCore rect use from the compositor, except within Region.

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 "config.h"
 
 #include "cc/occlusion_tracker.h"
 
 #include <algorithm>
 
-#include "FloatRect.h"
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
 #include "cc/math_util.h"
 #include "cc/overdraw_metrics.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
@@ skipping 102 matching lines @@
     // apply |transform| to each rect within |region| in order to transform the entire Region.
 
     bool clipped;
     gfx::QuadF transformedBoundsQuad = MathUtil::mapQuad(transform, gfx::QuadF(region.bounds()), clipped);
     // FIXME: Find a rect interior to each transformed quad.
     if (clipped || !transformedBoundsQuad.IsRectilinear())
         return Region();
 
     Region transformedRegion;
 
-    Vector<WebCore::IntRect> rects = region.rects();
-    for (size_t i = 0; i < rects.size(); ++i) {
+    for (Region::Iterator rects(region); rects.has_rect(); rects.next()) {
         // We've already checked for clipping in the mapQuad call above, these calls should not clip anything further.
-        gfx::Rect transformedRect = gfx::ToEnclosedRect(MathUtil::mapClippedRect(transform, cc::FloatRect(rects[i])));
+        gfx::Rect transformedRect = gfx::ToEnclosedRect(MathUtil::mapClippedRect(transform, gfx::RectF(rects.rect())));
         if (!surface->clipRect().IsEmpty())
             transformedRect.Intersect(surface->clipRect());
         transformedRegion.Union(transformedRect);
     }
     return transformedRegion;
 }
 
 static inline void reduceOcclusion(const gfx::Rect& affectedArea, const gfx::Rect& expandedPixel, Region& occlusion)
 {
     if (affectedArea.IsEmpty())
         return;
 
     Region affectedOcclusion = intersect(occlusion, affectedArea);
-    Vector<WebCore::IntRect> affectedOcclusionRects = affectedOcclusion.rects();
+    Region::Iterator affectedOcclusionRects(affectedOcclusion);
 
     occlusion.Subtract(affectedArea);
-    for (size_t j = 0; j < affectedOcclusionRects.size(); ++j) {
-        WebCore::IntRect& occlusionRect = affectedOcclusionRects[j];
+    for (; affectedOcclusionRects.has_rect(); affectedOcclusionRects.next()) {
+        gfx::Rect occlusionRect = affectedOcclusionRects.rect();
 
         // Shrink the rect by expanding the non-opaque pixels outside the rect.
 
         // The expandedPixel is the Rect for a single pixel after being
         // expanded by filters on the layer. The original pixel would be
         // Rect(0, 0, 1, 1), and the expanded pixel is the rect, relative
         // to this original rect, that the original pixel can influence after
         // being filtered.
         // To convert the expandedPixel Rect back to filter outsets:
         // x = -leftOutset
         // width = leftOutset + rightOutset
         // right = x + width = -leftOutset + leftOutset + rightOutset = rightOutset
 
         // The leftOutset of the filters moves pixels on the right side of
         // the occlusionRect into it, shrinking its right edge.
         int shrinkLeft = occlusionRect.x() == affectedArea.x() ? 0 : expandedPixel.right();
         int shrinkTop = occlusionRect.y() == affectedArea.y() ? 0 : expandedPixel.bottom();
-        int shrinkRight = occlusionRect.maxX() == affectedArea.right() ? 0 : -expandedPixel.x();
-        int shrinkBottom = occlusionRect.maxY() == affectedArea.bottom() ? 0 : -expandedPixel.y();
+        int shrinkRight = occlusionRect.right() == affectedArea.right() ? 0 : -expandedPixel.x();
+        int shrinkBottom = occlusionRect.bottom() == affectedArea.bottom() ? 0 : -expandedPixel.y();
 
-        occlusionRect.move(shrinkLeft, shrinkTop);
-        occlusionRect.contract(shrinkLeft + shrinkRight, shrinkTop + shrinkBottom);
+        occlusionRect.Inset(shrinkLeft, shrinkTop, shrinkRight, shrinkBottom);
 
         occlusion.Union(occlusionRect);
     }
 }
 
 template<typename LayerType>
 static void reduceOcclusionBelowSurface(LayerType* contributingLayer, const gfx::Rect& surfaceRect, const WebTransformationMatrix& surfaceTransform, LayerType* renderTarget, Region& occlusionInTarget, Region& occlusionInScreen)
 {
     if (surfaceRect.IsEmpty())
         return;
@@ skipping 63 matching lines @@
 static inline void addOcclusionBehindLayer(Region& region, const LayerType* layer, const WebTransformationMatrix& transform, const Region& opaqueContents, const gfx::Rect& clipRectInTarget, const gfx::Size& minimumTrackingSize, std::vector<gfx::Rect>* occludingScreenSpaceRects)
 {
     DCHECK(layer->visibleContentRect().Contains(opaqueContents.bounds()));
 
     bool clipped;
     gfx::QuadF visibleTransformedQuad = MathUtil::mapQuad(transform, gfx::QuadF(layer->visibleContentRect()), clipped);
     // FIXME: Find a rect interior to each transformed quad.
     if (clipped || !visibleTransformedQuad.IsRectilinear())
         return;
 
-    Vector<WebCore::IntRect> contentRects = opaqueContents.rects();
-    for (size_t i = 0; i < contentRects.size(); ++i) {
+    for (Region::Iterator opaqueContentRects(opaqueContents); opaqueContentRects.has_rect(); opaqueContentRects.next()) {
         // We've already checked for clipping in the mapQuad call above, these calls should not clip anything further.
-        gfx::Rect transformedRect = gfx::ToEnclosedRect(MathUtil::mapClippedRect(transform, cc::FloatRect(contentRects[i])));
+        gfx::Rect transformedRect = gfx::ToEnclosedRect(MathUtil::mapClippedRect(transform, gfx::RectF(opaqueContentRects.rect())));
         transformedRect.Intersect(clipRectInTarget);
         if (transformedRect.width() >= minimumTrackingSize.width() || transformedRect.height() >= minimumTrackingSize.height()) {
             if (occludingScreenSpaceRects)
                 occludingScreenSpaceRects->push_back(transformedRect);
             region.Union(transformedRect);
         }
     }
 }
 
 template<typename LayerType, typename RenderSurfaceType>
@@ skipping 204 matching lines @@
 template void OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>::finishedRenderTarget(const LayerImpl* finishedTarget);
 template void OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>::leaveToRenderTarget(const LayerImpl* newTarget);
 template void OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>::markOccludedBehindLayer(const LayerImpl*);
 template bool OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>::occluded(const LayerImpl*, const gfx::Rect& contentRect, const WebKit::WebTransformationMatrix& drawTransform, bool implDrawTransformIsUnknown, const gfx::Rect& clippedRectInTarget, bool* hasOcclusionFromOutsideTargetSurface) const;
 template gfx::Rect OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>::unoccludedContentRect(const LayerImpl*, const gfx::Rect& contentRect, const WebKit::WebTransformationMatrix& drawTransform, bool implDrawTransformIsUnknown, const gfx::Rect& clippedRectInTarget, bool* hasOcclusionFromOutsideTargetSurface) const;
 template gfx::Rect OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>::unoccludedContributingSurfaceContentRect(const LayerImpl*, bool forReplica, const gfx::Rect& contentRect, bool* hasOcclusionFromOutsideTargetSurface) const;
 template gfx::Rect OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>::layerClipRectInTarget(const LayerImpl*) const;
 
 
 }  // namespace cc