Return an infinite rect when calling RenderLayerClipper::parentClipRects on the root context layer

Source/core/rendering/RenderLayerClipper.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 53 matching lines @@
         tempContext.clipRectsType = TemporaryClipRects;
         ClipRects clipRects;
         calculateClipRects(tempContext, clipRects);
         ASSERT(clipRects == *m_clipRectsCache->getClipRects(clipRectsType, clipRectsContext.respectOverflowClip).get());
 #endif
         return; // We have the correct cached value.
     }
 
     // For transformed layers, the root layer was shifted to be us, so there is no need to
     // examine the parent. We want to cache clip rects with us as the root.
-    RenderLayer* parentLayer = clipRectsContext.rootLayer != m_renderer->layer() ? m_renderer->layer()->parent() : 0;
+    RenderLayer* parentLayer = !isClippingRootForContext(clipRectsContext) ? m_renderer->layer()->parent() : 0;
     if (parentLayer)
         parentLayer->clipper().updateClipRects(clipRectsContext);
 
     ClipRects clipRects;
     calculateClipRects(clipRectsContext, clipRects);
 
     if (!m_clipRectsCache)
         m_clipRectsCache = adoptPtr(new ClipRectsCache);
 
     if (parentLayer && parentLayer->clipper().clipRects(clipRectsContext) && clipRects == *parentLayer->clipper().clipRects(clipRectsContext))
@@ skipping 77 matching lines @@
     LayoutPoint clippingRootOffset;
     m_renderer->layer()->convertToLayerCoords(clippingRootLayer, clippingRootOffset);
     clipRect.moveBy(-clippingRootOffset);
 
     return clipRect;
 }
 
 void RenderLayerClipper::calculateRects(const ClipRectsContext& clipRectsContext, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
     ClipRect& backgroundRect, ClipRect& foregroundRect, ClipRect& outlineRect, const LayoutPoint* offsetFromRoot) const
 {
-    if (clipRectsContext.rootLayer != m_renderer->layer() && m_renderer->layer()->parent()) {
+    bool isClippingRoot = isClippingRootForContext(clipRectsContext);
+
+    if (!isClippingRoot && m_renderer->layer()->parent()) {
         backgroundRect = backgroundClipRect(clipRectsContext);
         backgroundRect.move(roundedIntSize(clipRectsContext.subPixelAccumulation));
         backgroundRect.intersect(paintDirtyRect);
     } else {
         backgroundRect = paintDirtyRect;
     }
 
     foregroundRect = backgroundRect;
     outlineRect = backgroundRect;
 
     LayoutPoint offset;
     if (offsetFromRoot)
         offset = *offsetFromRoot;
     else
         m_renderer->layer()->convertToLayerCoords(clipRectsContext.rootLayer, offset);
     layerBounds = LayoutRect(offset, m_renderer->layer()->size());
 
     // Update the clip rects that will be passed to child layers.
     if (m_renderer->hasOverflowClip()) {
         // This layer establishes a clip of some kind.
-        if (m_renderer->layer() != clipRectsContext.rootLayer || clipRectsContext.respectOverflowClip == RespectOverflowClip) {
+        if (!isClippingRoot || clipRectsContext.respectOverflowClip == RespectOverflowClip) {
             foregroundRect.intersect(toRenderBox(m_renderer)->overflowClipRect(offset, clipRectsContext.overlayScrollbarSizeRelevancy));
             if (m_renderer->style()->hasBorderRadius())
                 foregroundRect.setHasRadius(true);
         }
 
         // If we establish an overflow clip at all, then go ahead and make sure our background
         // rect is intersected with our layer's bounds including our visual overflow,
         // since any visual overflow like box-shadow or border-outset is not clipped by overflow:auto/hidden.
         if (toRenderBox(m_renderer)->hasVisualOverflow()) {
             // FIXME: Perhaps we should be propagating the borderbox as the clip rect for children, even though
             //        we may need to inflate our clip specifically for shadows or outsets.
             // FIXME: Does not do the right thing with CSS regions yet, since we don't yet factor in the
             // individual region boxes as overflow.
             LayoutRect layerBoundsWithVisualOverflow = toRenderBox(m_renderer)->visualOverflowRect();
             toRenderBox(m_renderer)->flipForWritingMode(layerBoundsWithVisualOverflow); // Layers are in physical coordinates, so the overflow has to be flipped.
             layerBoundsWithVisualOverflow.moveBy(offset);
-            if (m_renderer->layer() != clipRectsContext.rootLayer || clipRectsContext.respectOverflowClip == RespectOverflowClip)
+            if (!isClippingRoot || clipRectsContext.respectOverflowClip == RespectOverflowClip)
                 backgroundRect.intersect(layerBoundsWithVisualOverflow);
         } else {
             LayoutRect bounds = toRenderBox(m_renderer)->borderBoxRect();
             bounds.moveBy(offset);
-            if (m_renderer->layer() != clipRectsContext.rootLayer || clipRectsContext.respectOverflowClip == RespectOverflowClip)
+            if (!isClippingRoot || clipRectsContext.respectOverflowClip == RespectOverflowClip)
                 backgroundRect.intersect(bounds);
         }
     }
 
     // CSS clip (different than clipping due to overflow) can clip to any box, even if it falls outside of the border box.
     if (m_renderer->hasClip()) {
         // Clip applies to *us* as well, so go ahead and update the damageRect.
         LayoutRect newPosClip = toRenderBox(m_renderer)->clipRect(offset);
         backgroundRect.intersect(newPosClip);
         foregroundRect.intersect(newPosClip);
         outlineRect.intersect(newPosClip);
     }
 }
 
 void RenderLayerClipper::calculateClipRects(const ClipRectsContext& clipRectsContext, ClipRects& clipRects) const
 {
     if (!m_renderer->layer()->parent()) {
         // The root layer's clip rect is always infinite.
         clipRects.reset(PaintInfo::infiniteRect());
         return;
     }
 
     ClipRectsType clipRectsType = clipRectsContext.clipRectsType;
     bool useCached = clipRectsType != TemporaryClipRects;
 
+    bool isClippingRoot = isClippingRootForContext(clipRectsContext);
+
     // For transformed layers, the root layer was shifted to be us, so there is no need to
     // examine the parent. We want to cache clip rects with us as the root.
-    RenderLayer* parentLayer = clipRectsContext.rootLayer != m_renderer->layer() ? m_renderer->layer()->parent() : 0;
+    RenderLayer* parentLayer = !isClippingRoot ? m_renderer->layer()->parent() : 0;
 
     // Ensure that our parent's clip has been calculated so that we can examine the values.
     if (parentLayer) {
         if (useCached && parentLayer->clipper().clipRects(clipRectsContext)) {
             clipRects = *parentLayer->clipper().clipRects(clipRectsContext);
         } else {
             ClipRectsContext parentContext(clipRectsContext);
             parentContext.overlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize; // FIXME: why?
             parentLayer->clipper().calculateClipRects(parentContext, clipRects);
         }
     } else {
         clipRects.reset(PaintInfo::infiniteRect());
     }
 
     // A fixed object is essentially the root of its containing block hierarchy, so when
     // we encounter such an object, we reset our clip rects to the fixedClipRect.
     if (m_renderer->style()->position() == FixedPosition) {
         clipRects.setPosClipRect(clipRects.fixedClipRect());
         clipRects.setOverflowClipRect(clipRects.fixedClipRect());
         clipRects.setFixed(true);
     } else if (m_renderer->style()->hasInFlowPosition()) {
         clipRects.setPosClipRect(clipRects.overflowClipRect());
     } else if (m_renderer->style()->position() == AbsolutePosition) {
         clipRects.setOverflowClipRect(clipRects.posClipRect());
     }
 
     // Update the clip rects that will be passed to child layers.
-    if ((m_renderer->hasOverflowClip() && (clipRectsContext.respectOverflowClip == RespectOverflowClip || m_renderer->layer() != clipRectsContext.rootLayer)) || m_renderer->hasClip()) {
+    if ((m_renderer->hasOverflowClip() && (clipRectsContext.respectOverflowClip == RespectOverflowClip || !isClippingRoot)) || m_renderer->hasClip()) {
         // This layer establishes a clip of some kind.
 
         // This offset cannot use convertToLayerCoords, because sometimes our rootLayer may be across
         // some transformed layer boundary, for example, in the RenderLayerCompositor overlapMap, where
         // clipRects are needed in view space.
         LayoutPoint offset;
         offset = roundedLayoutPoint(m_renderer->localToContainerPoint(FloatPoint(), clipRectsContext.rootLayer->renderer()));
         RenderView* view = m_renderer->view();
         ASSERT(view);
         if (view && clipRects.fixed() && clipRectsContext.rootLayer->renderer() == view) {
@@ skipping 56 matching lines @@
     RenderView* view = m_renderer->view();
     ASSERT(view);
 
     // Note: infinite clipRects should not be scrolled here, otherwise they will accidentally no longer be considered infinite.
     if (parentRects.fixed() && clipRectsContext.rootLayer->renderer() == view && backgroundClipRect != PaintInfo::infiniteRect())
         backgroundClipRect.move(view->frameView()->scrollOffsetForFixedPosition());
 
     return backgroundClipRect;
 }
 
+bool RenderLayerClipper::isClippingRootForContext(const ClipRectsContext& clipRectsContext) const
+{
+    return clipRectsContext.rootLayer == m_renderer->layer();
+}
+
 void RenderLayerClipper::parentClipRects(const ClipRectsContext& clipRectsContext, ClipRects& clipRects) const
 {
+    // The root is not clipped.
+    if (isClippingRootForContext(clipRectsContext)) {
+        clipRects.reset(PaintInfo::infiniteRect());
+        return;
+    }
+
     ASSERT(m_renderer->layer()->parent());
 
     RenderLayerClipper& parentClipper = m_renderer->layer()->parent()->clipper();
     if (clipRectsContext.clipRectsType == TemporaryClipRects) {
         parentClipper.calculateClipRects(clipRectsContext, clipRects);
         return;
     }
 
     parentClipper.updateClipRects(clipRectsContext);
     clipRects = *parentClipper.clipRects(clipRectsContext);
@@ skipping 13 matching lines @@
         ASSERT(current);
         if (current->transform() || (current->compositingState() == PaintsIntoOwnBacking) || current->groupedMapping())
             return const_cast<RenderLayer*>(current);
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 } // namespace WebCore