cc: Create a Region class that wraps SkRegion, to replace use of WebCore::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>
 
@@ skipping 40 matching lines @@
 
     if (layerIterator.representsItself)
         markOccludedBehindLayer(layerIterator.currentLayer);
     else if (layerIterator.representsContributingRenderSurface)
         leaveToRenderTarget(renderTarget);
 }
 
 template<typename LayerType, typename RenderSurfaceType>
 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::enterRenderTarget(const LayerType* newTarget)
 {
-    if (!m_stack.isEmpty() && m_stack.last().target == newTarget)
+    if (!m_stack.empty() && m_stack.back().target == newTarget)
         return;
 
-    const LayerType* oldTarget = m_stack.isEmpty() ? 0 : m_stack.last().target;
+    const LayerType* oldTarget = m_stack.empty() ? 0 : m_stack.back().target;
     const RenderSurfaceType* oldAncestorThatMovesPixels = !oldTarget ? 0 : oldTarget->renderSurface()->nearestAncestorThatMovesPixels();
     const RenderSurfaceType* newAncestorThatMovesPixels = newTarget->renderSurface()->nearestAncestorThatMovesPixels();
 
-    m_stack.append(StackObject(newTarget));
+    m_stack.push_back(StackObject(newTarget));
 
     // We copy the screen occlusion into the new RenderSurfaceImpl subtree, but we never copy in the
     // target occlusion, since we are looking at a new RenderSurfaceImpl 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 enteringSubtreeThatMovesPixels = newAncestorThatMovesPixels && newAncestorThatMovesPixels != oldAncestorThatMovesPixels;
 
     bool copyScreenOcclusionForward = m_stack.size() > 1 && !enteringSubtreeThatMovesPixels;
@@ skipping 25 matching lines @@
 {
     // Make sure we know about the target surface.
     enterRenderTarget(finishedTarget);
 
     RenderSurfaceType* surface = finishedTarget->renderSurface();
 
     // 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 (finishedTarget->maskLayer() || !surfaceOpacityKnown(surface) || surface->drawOpacity() < 1 || finishedTarget->filters().hasFilterThatAffectsOpacity() || finishedTarget->filter()) {
-        m_stack.last().occlusionInScreen = Region();
-        m_stack.last().occlusionInTarget = Region();
+        m_stack.back().occlusionInScreen = Region();
+        m_stack.back().occlusionInTarget = Region();
     } else {
         if (!surfaceTransformsToTargetKnown(surface))
-            m_stack.last().occlusionInTarget = Region();
+            m_stack.back().occlusionInTarget = Region();
         if (!surfaceTransformsToScreenKnown(surface))
-            m_stack.last().occlusionInScreen = Region();
+            m_stack.back().occlusionInScreen = Region();
     }
 }
 
 template<typename RenderSurfaceType>
 static inline Region transformSurfaceOpaqueRegion(const RenderSurfaceType* surface, const Region& region, const WebTransformationMatrix& transform)
 {
     // Verify that rects within the |surface| will remain rects in its target surface after applying |transform|. If this is true, then
     // apply |transform| to each rect within |region| in order to transform the entire Region.
 
     bool clipped;
@@ skipping 12 matching lines @@
         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);
+    Region affectedOcclusion = IntersectRegions(occlusion, affectedArea);
     Region::Iterator affectedOcclusionRects(affectedOcclusion);
 
     occlusion.Subtract(affectedArea);
     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
@@ skipping 63 matching lines @@
     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.Union(m_stack[lastIndex].occlusionInScreen);
         m_stack[lastIndex - 1].occlusionInTarget.Union(oldTargetOcclusionInNewTarget);
-        m_stack.removeLast();
+        m_stack.pop_back();
     } 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;
+        m_stack.back().target = newTarget;
+        m_stack.back().occlusionInTarget = oldTargetOcclusionInNewTarget;
     }
 
     if (oldTarget->backgroundFilters().hasFilterThatMovesPixels()) {
-        reduceOcclusionBelowSurface(oldTarget, unoccludedSurfaceRect, oldSurface->drawTransform(), newTarget, m_stack.last().occlusionInTarget, m_stack.last().occlusionInScreen);
+        reduceOcclusionBelowSurface(oldTarget, unoccludedSurfaceRect, oldSurface->drawTransform(), newTarget, m_stack.back().occlusionInTarget, m_stack.back().occlusionInScreen);
         if (oldTarget->hasReplica())
-            reduceOcclusionBelowSurface(oldTarget, unoccludedReplicaRect, oldSurface->replicaDrawTransform(), newTarget, m_stack.last().occlusionInTarget, m_stack.last().occlusionInScreen);
+            reduceOcclusionBelowSurface(oldTarget, unoccludedReplicaRect, oldSurface->replicaDrawTransform(), newTarget, m_stack.back().occlusionInTarget, m_stack.back().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(opaqueContents.bounds()));
 
     bool clipped;
@@ skipping 10 matching lines @@
             if (occludingScreenSpaceRects)
                 occludingScreenSpaceRects->push_back(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())
+    DCHECK(!m_stack.empty());
+    DCHECK(layer->renderTarget() == m_stack.back().target);
+    if (m_stack.empty())
         return;
 
     if (!layerOpacityKnown(layer) || layer->drawOpacity() < 1)
         return;
 
     if (layerIsInUnsorted3dRenderingContext(layer))
         return;
 
     Region opaqueContents = layer->visibleContentOpaqueRegion();
     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);
+        addOcclusionBehindLayer<LayerType>(m_stack.back().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();
+        WebTransformationMatrix targetToScreenTransform = m_stack.back().target->renderSurface()->screenSpaceTransform();
         bool clipped;
         gfx::QuadF clipQuadInScreen = MathUtil::mapQuad(targetToScreenTransform, gfx::QuadF(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);
+        addOcclusionBehindLayer<LayerType>(m_stack.back().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(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())
+    DCHECK(!m_stack.empty());
+    if (m_stack.empty())
         return false;
     if (contentRect.IsEmpty())
         return true;
 
-    DCHECK(renderTarget == m_stack.last().target);
+    DCHECK(renderTarget == m_stack.back().target);
 
-    if (!implDrawTransformIsUnknown && testContentRectOccluded(contentRect, drawTransform, clippedRectInTarget, m_stack.last().occlusionInTarget))
+    if (!implDrawTransformIsUnknown && testContentRectOccluded(contentRect, drawTransform, clippedRectInTarget, m_stack.back().occlusionInTarget))
         return true;
 
     // renderTarget can be NULL in some tests.
     bool transformToScreenKnown = renderTarget && !implDrawTransformIsUnknown && layerTransformsToScreenKnown(renderTarget);
-    if (transformToScreenKnown && testContentRectOccluded(contentRect, renderTarget->renderSurface()->screenSpaceTransform() * drawTransform, m_rootTargetRect, m_stack.last().occlusionInScreen)) {
+    if (transformToScreenKnown && testContentRectOccluded(contentRect, renderTarget->renderSurface()->screenSpaceTransform() * drawTransform, m_rootTargetRect, m_stack.back().occlusionInScreen)) {
         if (hasOcclusionFromOutsideTargetSurface)
             *hasOcclusionFromOutsideTargetSurface = true;
         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.
@@ skipping 13 matching lines @@
     gfx::RectF transformedRect = MathUtil::mapClippedRect(contentSpaceTransform, gfx::RectF(contentRect));
     gfx::Rect shrunkRect = rectSubtractRegion(gfx::IntersectRects(gfx::ToEnclosingRect(transformedRect), clipRectInTarget), occlusion);
     gfx::Rect unoccludedRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(contentSpaceTransform.inverse(), gfx::RectF(shrunkRect)));
     // The rect back in content space is a bounding box and may extend outside of the original contentRect, so clamp it to the contentRectBounds.
     return gfx::IntersectRects(unoccludedRect, contentRect);
 }
 
 template<typename LayerType, typename RenderSurfaceType>
 gfx::Rect OcclusionTrackerBase<LayerType, RenderSurfaceType>::unoccludedContentRect(const LayerType* renderTarget, const gfx::Rect& contentRect, const WebKit::WebTransformationMatrix& drawTransform, bool implDrawTransformIsUnknown, const gfx::Rect& clippedRectInTarget, bool* hasOcclusionFromOutsideTargetSurface) const
 {
-    DCHECK(!m_stack.isEmpty());
-    if (m_stack.isEmpty())
+    DCHECK(!m_stack.empty());
+    if (m_stack.empty())
         return contentRect;
     if (contentRect.IsEmpty())
         return contentRect;
 
     DCHECK(renderTarget->renderTarget() == renderTarget);
     DCHECK(renderTarget->renderSurface());
-    DCHECK(renderTarget == m_stack.last().target);
+    DCHECK(renderTarget == m_stack.back().target);
 
     // We want to return a rect that contains all the visible parts of |contentRect| in both screen space and in the target surface.
     // So we find the visible parts of |contentRect| in each space, and take the intersection.
 
     gfx::Rect unoccludedInScreen = contentRect;
     if (layerTransformsToScreenKnown(renderTarget) && !implDrawTransformIsUnknown)
-        unoccludedInScreen = computeUnoccludedContentRect(contentRect, renderTarget->renderSurface()->screenSpaceTransform() * drawTransform, m_rootTargetRect, m_stack.last().occlusionInScreen);
+        unoccludedInScreen = computeUnoccludedContentRect(contentRect, renderTarget->renderSurface()->screenSpaceTransform() * drawTransform, m_rootTargetRect, m_stack.back().occlusionInScreen);
 
     gfx::Rect unoccludedInTarget = contentRect;
     if (!implDrawTransformIsUnknown)
-        unoccludedInTarget = computeUnoccludedContentRect(contentRect, drawTransform, clippedRectInTarget, m_stack.last().occlusionInTarget);
+        unoccludedInTarget = computeUnoccludedContentRect(contentRect, drawTransform, clippedRectInTarget, m_stack.back().occlusionInTarget);
 
     if (hasOcclusionFromOutsideTargetSurface)
         *hasOcclusionFromOutsideTargetSurface = (gfx::IntersectRects(unoccludedInScreen, unoccludedInTarget) != unoccludedInTarget);
 
     return gfx::IntersectRects(unoccludedInScreen, unoccludedInTarget);
 }
 
 template<typename LayerType, typename RenderSurfaceType>
 gfx::Rect OcclusionTrackerBase<LayerType, RenderSurfaceType>::unoccludedContributingSurfaceContentRect(const LayerType* layer, bool forReplica, const gfx::Rect& contentRect, bool* hasOcclusionFromOutsideTargetSurface) const
 {
-    DCHECK(!m_stack.isEmpty());
+    DCHECK(!m_stack.empty());
     // The layer is a contributing renderTarget so it should have a surface.
     DCHECK(layer->renderSurface());
     // The layer is a contributing renderTarget so its target should be itself.
     DCHECK(layer->renderTarget() == 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(layer == m_stack.last().target);
+    DCHECK(layer == m_stack.back().target);
 
     if (contentRect.IsEmpty())
         return contentRect;
 
     RenderSurfaceType* surface = layer->renderSurface();
 
     gfx::Rect surfaceClipRect = surface->clipRect();
     if (surfaceClipRect.IsEmpty()) {
         LayerType* contributingSurfaceRenderTarget = layer->parent()->renderTarget();
         surfaceClipRect = gfx::IntersectRects(contributingSurfaceRenderTarget->renderSurface()->contentRect(), gfx::ToEnclosingRect(surface->drawableContentRect()));
@@ skipping 36 matching lines @@
     // FIXME: we could remove this helper function, but unit tests currently override this
     //        function, and they need to be verified/adjusted before this can be removed.
     return layer->drawableContentRect();
 }
 
 // Instantiate (and export) templates here for the linker.
 template class OcclusionTrackerBase<Layer, RenderSurface>;
 template class OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>;
 
 }  // namespace cc