Remove most remaining references to IntRect and FloatRect.

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>
 
@@ skipping 117 matching lines @@
         return Region();
 
     Region transformedRegion;
 
     Vector<WebCore::IntRect> rects = region.rects();
     for (size_t i = 0; i < rects.size(); ++i) {
         // 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])));
         if (!surface->clipRect().IsEmpty())
             transformedRect.Intersect(surface->clipRect());
-        transformedRegion.unite(cc::IntRect(transformedRect));
+        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, cc::IntRect(affectedArea));
+    Region affectedOcclusion = intersect(occlusion, affectedArea);
     Vector<WebCore::IntRect> affectedOcclusionRects = affectedOcclusion.rects();
 
-    occlusion.subtract(cc::IntRect(affectedArea));
+    occlusion.Subtract(affectedArea);
     for (size_t j = 0; j < affectedOcclusionRects.size(); ++j) {
         WebCore::IntRect& occlusionRect = affectedOcclusionRects[j];
 
         // 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();
 
         occlusionRect.move(shrinkLeft, shrinkTop);
         occlusionRect.contract(shrinkLeft + shrinkRight, shrinkTop + shrinkBottom);
 
-        occlusion.unite(occlusionRect);
+        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;
 
-    gfx::Rect boundsInTarget = gfx::ToEnclosingRect(MathUtil::mapClippedRect(surfaceTransform, cc::FloatRect(surfaceRect)));
+    gfx::Rect boundsInTarget = gfx::ToEnclosingRect(MathUtil::mapClippedRect(surfaceTransform, gfx::RectF(surfaceRect)));
     if (!contributingLayer->renderSurface()->clipRect().IsEmpty())
         boundsInTarget.Intersect(contributingLayer->renderSurface()->clipRect());
 
     int outsetTop, outsetRight, outsetBottom, outsetLeft;
     contributingLayer->backgroundFilters().getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft);
 
     // The filter can move pixels from outside of the clip, so allow affectedArea to expand outside the clip.
     boundsInTarget.Inset(-outsetLeft, -outsetTop, -outsetRight, -outsetBottom);
 
-    gfx::Rect boundsInScreen = gfx::ToEnclosingRect(MathUtil::mapClippedRect(renderTarget->renderSurface()->screenSpaceTransform(), cc::FloatRect(boundsInTarget)));
+    gfx::Rect boundsInScreen = gfx::ToEnclosingRect(MathUtil::mapClippedRect(renderTarget->renderSurface()->screenSpaceTransform(), gfx::RectF(boundsInTarget)));
 
     gfx::Rect filterOutsetsInTarget(-outsetLeft, -outsetTop, outsetLeft + outsetRight, outsetTop + outsetBottom);
-    gfx::Rect filterOutsetsInScreen = gfx::ToEnclosingRect(MathUtil::mapClippedRect(renderTarget->renderSurface()->screenSpaceTransform(), cc::FloatRect(filterOutsetsInTarget)));
+    gfx::Rect filterOutsetsInScreen = gfx::ToEnclosingRect(MathUtil::mapClippedRect(renderTarget->renderSurface()->screenSpaceTransform(), gfx::RectF(filterOutsetsInTarget)));
 
     reduceOcclusion(boundsInTarget, filterOutsetsInTarget, occlusionInTarget);
     reduceOcclusion(boundsInScreen, filterOutsetsInScreen, occlusionInScreen);
 }
 
 template<typename LayerType, typename RenderSurfaceType>
 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::leaveToRenderTarget(const LayerType* newTarget)
 {
     int lastIndex = m_stack.size() - 1;
     bool surfaceWillBeAtTopAfterPop = m_stack.size() > 1 && m_stack[lastIndex - 1].target == newTarget;
 
     // 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* oldTarget = m_stack[lastIndex].target;
     const RenderSurfaceType* oldSurface = oldTarget->renderSurface();
     Region oldTargetOcclusionInNewTarget = transformSurfaceOpaqueRegion<RenderSurfaceType>(oldSurface, m_stack[lastIndex].occlusionInTarget, oldSurface->drawTransform());
     if (oldTarget->hasReplica() && !oldTarget->replicaHasMask())
-        oldTargetOcclusionInNewTarget.unite(transformSurfaceOpaqueRegion<RenderSurfaceType>(oldSurface, m_stack[lastIndex].occlusionInTarget, oldSurface->replicaDrawTransform()));
+        oldTargetOcclusionInNewTarget.Union(transformSurfaceOpaqueRegion<RenderSurfaceType>(oldSurface, m_stack[lastIndex].occlusionInTarget, oldSurface->replicaDrawTransform()));
 
     gfx::Rect unoccludedSurfaceRect;
     gfx::Rect unoccludedReplicaRect;
     if (oldTarget->backgroundFilters().hasFilterThatMovesPixels()) {
         unoccludedSurfaceRect = unoccludedContributingSurfaceContentRect(oldTarget, false, oldSurface->contentRect());
         if (oldTarget->hasReplica())
             unoccludedReplicaRect = unoccludedContributingSurfaceContentRect(oldTarget, true, oldSurface->contentRect());
     }
 
     if (surfaceWillBeAtTopAfterPop) {
         // Merge the top of the stack down.
-        m_stack[lastIndex - 1].occlusionInScreen.unite(m_stack[lastIndex].occlusionInScreen);
-        m_stack[lastIndex - 1].occlusionInTarget.unite(oldTargetOcclusionInNewTarget);
+        m_stack[lastIndex - 1].occlusionInScreen.Union(m_stack[lastIndex].occlusionInScreen);
+        m_stack[lastIndex - 1].occlusionInTarget.Union(oldTargetOcclusionInNewTarget);
         m_stack.removeLast();
     } else {
         // Replace the top of the stack with the new pushed surface. Copy the occluded screen region to the top.
         m_stack.last().target = newTarget;
         m_stack.last().occlusionInTarget = oldTargetOcclusionInNewTarget;
     }
 
     if (oldTarget->backgroundFilters().hasFilterThatMovesPixels()) {
         reduceOcclusionBelowSurface(oldTarget, unoccludedSurfaceRect, oldSurface->drawTransform(), newTarget, m_stack.last().occlusionInTarget, m_stack.last().occlusionInScreen);
         if (oldTarget->hasReplica())
             reduceOcclusionBelowSurface(oldTarget, unoccludedReplicaRect, oldSurface->replicaDrawTransform(), newTarget, m_stack.last().occlusionInTarget, m_stack.last().occlusionInScreen);
     }
 }
 
 // FIXME: Remove usePaintTracking when paint tracking is on for paint culling.
 template<typename LayerType>
 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(cc::IntRect(opaqueContents.bounds())));
+    DCHECK(layer->visibleContentRect().Contains(opaqueContents.bounds()));
 
     bool clipped;
     FloatQuad visibleTransformedQuad = MathUtil::mapQuad(transform, FloatQuad(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) {
         // 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])));
         transformedRect.Intersect(clipRectInTarget);
         if (transformedRect.width() >= minimumTrackingSize.width() || transformedRect.height() >= minimumTrackingSize.height()) {
             if (occludingScreenSpaceRects)
                 occludingScreenSpaceRects->push_back(transformedRect);
-            region.unite(cc::IntRect(transformedRect));
+            region.Union(transformedRect);
         }
     }
 }
 
 template<typename LayerType, typename RenderSurfaceType>
 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::markOccludedBehindLayer(const LayerType* layer)
 {
     DCHECK(!m_stack.isEmpty());
     DCHECK(layer->renderTarget() == m_stack.last().target);
     if (m_stack.isEmpty())
         return;
 
     if (!layerOpacityKnown(layer) || layer->drawOpacity() < 1)
         return;
 
     if (layerIsInUnsorted3dRenderingContext(layer))
         return;
 
     Region opaqueContents = layer->visibleContentOpaqueRegion();
-    if (opaqueContents.isEmpty())
+    if (opaqueContents.IsEmpty())
         return;
 
     gfx::Rect clipRectInTarget = layerClipRectInTarget(layer);
     if (layerTransformsToTargetKnown(layer))
         addOcclusionBehindLayer<LayerType>(m_stack.last().occlusionInTarget, layer, layer->drawTransform(), opaqueContents, clipRectInTarget, m_minimumTrackingSize, 0);
 
     // We must clip the occlusion within the layer's clipRectInTarget within screen space as well. If the clip rect can't be moved to screen space and
     // remain rectilinear, then we don't add any occlusion in screen space.
 
     if (layerTransformsToScreenKnown(layer)) {
         WebTransformationMatrix targetToScreenTransform = m_stack.last().target->renderSurface()->screenSpaceTransform();
         bool clipped;
-        FloatQuad clipQuadInScreen = MathUtil::mapQuad(targetToScreenTransform, FloatQuad(FloatRect(clipRectInTarget)), clipped);
+        FloatQuad clipQuadInScreen = MathUtil::mapQuad(targetToScreenTransform, FloatQuad(clipRectInTarget), clipped);
         // FIXME: Find a rect interior to the transformed clip quad.
         if (clipped || !clipQuadInScreen.isRectilinear())
             return;
         gfx::Rect clipRectInScreen = gfx::IntersectRects(m_rootTargetRect, gfx::ToEnclosedRect(clipQuadInScreen.boundingBox()));
         addOcclusionBehindLayer<LayerType>(m_stack.last().occlusionInScreen, layer, layer->screenSpaceTransform(), opaqueContents, clipRectInScreen, m_minimumTrackingSize, m_occludingScreenSpaceRects);
     }
 }
 
 static inline bool testContentRectOccluded(const gfx::Rect& contentRect, const WebTransformationMatrix& contentSpaceTransform, const gfx::Rect& clipRectInTarget, const Region& occlusion)
 {
     gfx::RectF transformedRect = MathUtil::mapClippedRect(contentSpaceTransform, gfx::RectF(contentRect));
     // Take the gfx::ToEnclosingRect, as we want to include partial pixels in the test.
     gfx::Rect targetRect = gfx::IntersectRects(gfx::ToEnclosingRect(transformedRect), clipRectInTarget);
-    return targetRect.IsEmpty() || occlusion.contains(cc::IntRect(targetRect));
+    return targetRect.IsEmpty() || occlusion.Contains(targetRect);
 }
 
 template<typename LayerType, typename RenderSurfaceType>
 bool OcclusionTrackerBase<LayerType, RenderSurfaceType>::occluded(const LayerType* renderTarget, const gfx::Rect& contentRect, const WebKit::WebTransformationMatrix& drawTransform, bool implDrawTransformIsUnknown, const gfx::Rect& clippedRectInTarget, bool* hasOcclusionFromOutsideTargetSurface) const
 {
     if (hasOcclusionFromOutsideTargetSurface)
         *hasOcclusionFromOutsideTargetSurface = false;
 
     DCHECK(!m_stack.isEmpty());
     if (m_stack.isEmpty())
@@ skipping 14 matching lines @@
         return true;
     }
 
     return false;
 }
 
 // Determines what portion of rect, if any, is unoccluded (not occluded by region). If
 // the resulting unoccluded region is not rectangular, we return a rect containing it.
 static inline gfx::Rect rectSubtractRegion(const gfx::Rect& rect, const Region& region)
 {
-    cc::IntRect intRect(rect);
-    Region rectRegion(intRect);
-    rectRegion.subtract(region);
-    return cc::IntRect(rectRegion.bounds());
+    Region rectRegion(rect);
+    rectRegion.Subtract(region);
+    return rectRegion.bounds();
 }
 
 static inline gfx::Rect computeUnoccludedContentRect(const gfx::Rect& contentRect, const WebTransformationMatrix& contentSpaceTransform, const gfx::Rect& clipRectInTarget, const Region& occlusion)
 {
     if (!contentSpaceTransform.isInvertible())
         return contentRect;
 
     // Take the ToEnclosingRect at each step, as we want to contain any unoccluded partial pixels in the resulting Rect.
     gfx::RectF transformedRect = MathUtil::mapClippedRect(contentSpaceTransform, gfx::RectF(contentRect));
     gfx::Rect shrunkRect = rectSubtractRegion(gfx::IntersectRects(gfx::ToEnclosingRect(transformedRect), clipRectInTarget), occlusion);
@@ skipping 115 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