Fix propagation of clip-path and border-radius clipping to child layers

Source/core/rendering/RenderLayer.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 92 matching lines @@
 
 using namespace HTMLNames;
 
 RenderLayer::RenderLayer(RenderLayerModelObject* renderer)
     : m_hasSelfPaintingLayerDescendant(false)
     , m_hasSelfPaintingLayerDescendantDirty(false)
     , m_hasOutOfFlowPositionedDescendant(false)
     , m_hasOutOfFlowPositionedDescendantDirty(true)
     , m_hasUnclippedDescendant(false)
     , m_isUnclippedDescendant(false)
+    , m_hasComplexClippedAncestor(false)
     , m_isRootLayer(renderer->isRenderView())
     , m_usedTransparency(false)
     , m_childLayerHasBlendMode(false)
     , m_childLayerHasBlendModeStatusDirty(false)
     , m_visibleContentStatusDirty(true)
     , m_hasVisibleContent(false)
     , m_visibleDescendantStatusDirty(false)
     , m_hasVisibleDescendant(false)
     , m_hasVisibleNonLayerContent(false)
     , m_isPaginated(false)
@@ skipping 1268 matching lines @@
     if (child->stackingNode()->isNormalFlowOnly())
         m_stackingNode->dirtyNormalFlowList();
 
     if (!child->stackingNode()->isNormalFlowOnly() || child->firstChild()) {
         // Dirty the z-order list in which we are contained. The ancestorStackingContainerNode() can be null in the
         // case where we're building up generated content layers. This is ok, since the lists will start
         // off dirty in that case anyway.
         child->stackingNode()->dirtyStackingContainerZOrderLists();
     }
 
+    child->updateHasComplexClippedAncestor();
     child->updateDescendantDependentFlags();
     if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)
         setAncestorChainHasVisibleDescendant();
 
     if (child->isSelfPaintingLayer() || child->hasSelfPaintingLayerDescendant())
         setAncestorChainHasSelfPaintingLayerDescendant();
 
     if (child->paintsWithBlendMode() || child->childLayerHasBlendMode())
         setAncestorChainBlendedDescendant();
 
@@ skipping 596 matching lines @@
     // Ensure our lists are up-to-date.
     m_stackingNode->updateLayerListsIfNeeded();
 
     LayoutPoint offsetFromRoot;
     convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot);
 
     IntRect rootRelativeBounds;
     bool rootRelativeBoundsComputed = false;
 
     // Apply clip-path to context.
-    bool hasClipPath = false;
-    RenderStyle* style = renderer()->style();
-    RenderSVGResourceClipper* resourceClipper = 0;
+    bool needsContextRestore = false;
+    Vector<RenderSVGResourceClipper*> resourceClippers;
     ClipperContext clipperContext;
-    if (renderer()->hasClipPath() && !context->paintingDisabled() && style) {
-        ASSERT(style->clipPath());
-        if (style->clipPath()->type() == ClipPathOperation::SHAPE) {
-            hasClipPath = true;
-            context->save();
-            ShapeClipPathOperation* clipPath = toShapeClipPathOperation(style->clipPath());
-
-            if (!rootRelativeBoundsComputed) {
-                rootRelativeBounds = calculateLayerBounds(paintingInfo.rootLayer, &offsetFromRoot, 0);
-                rootRelativeBoundsComputed = true;
-            }
-
-            context->clipPath(clipPath->path(rootRelativeBounds), clipPath->windRule());
-        } else if (style->clipPath()->type() == ClipPathOperation::REFERENCE) {
-            ReferenceClipPathOperation* referenceClipPathOperation = toReferenceClipPathOperation(style->clipPath());
-            Document& document = renderer()->document();
-            // FIXME: It doesn't work with forward or external SVG references (https://bugs.webkit.org/show_bug.cgi?id=90405)
-            Element* element = document.getElementById(referenceClipPathOperation->fragment());
-            if (element && element->hasTagName(SVGNames::clipPathTag) && element->renderer()) {
-                if (!rootRelativeBoundsComputed) {
-                    rootRelativeBounds = calculateLayerBounds(paintingInfo.rootLayer, &offsetFromRoot, 0);
-                    rootRelativeBoundsComputed = true;
-                }
-
-                resourceClipper = toRenderSVGResourceClipper(toRenderSVGResourceContainer(element->renderer()));
-                if (!resourceClipper->applyClippingToContext(renderer(), rootRelativeBounds,
-                    paintingInfo.paintDirtyRect, context, clipperContext)) {
-                    // No need to post-apply the clipper if this failed.
-                    resourceClipper = 0;
-                }
-            }
-        }
-    }
+    if (!context->paintingDisabled())
+        applyComplexClip(context, this, &clipperContext, paintingInfo, offsetFromRoot, &needsContextRestore, &rootRelativeBoundsComputed, &rootRelativeBounds, &resourceClippers);
 
     // Blending operations must be performed only with the nearest ancestor stacking context.
     // Note that there is no need to create a transparency layer if we're painting the root.
     bool createTransparencyLayerForBlendMode = !renderer()->isRoot() && m_stackingNode->isStackingContext() && m_childLayerHasBlendMode;
 
     if (createTransparencyLayerForBlendMode)
         beginTransparencyLayers(context, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.paintBehavior);
 
     LayerPaintingInfo localPaintingInfo(paintingInfo);
     FilterEffectRendererHelper filterPainter(filterRenderer() && paintsWithFilters());
@@ skipping 114 matching lines @@
         paintChildClippingMaskForFragments(layerFragments, context, localPaintingInfo, paintingRootForRenderer);
     }
 
     // End our transparency layer
     if ((haveTransparency || paintsWithBlendMode() || createTransparencyLayerForBlendMode) && m_usedTransparency && !(m_reflectionInfo && m_reflectionInfo->isPaintingInsideReflection())) {
         context->endLayer();
         context->restore();
         m_usedTransparency = false;
     }
 
-    if (resourceClipper)
-        resourceClipper->postApplyStatefulResource(renderer(), context, clipperContext);
+    while (resourceClippers.size()) {
+        resourceClippers.last()->postApplyStatefulResource(renderer(), context, clipperContext);
+        resourceClippers.removeLast();
+    }
 
-    if (hasClipPath)
+    if (needsContextRestore)
         context->restore();
 }
 
+void RenderLayer::applyComplexClip(GraphicsContext* context, RenderLayer* currentLayer, ClipperContext* clipperContext, const LayerPaintingInfo& paintingInfo, const LayoutPoint& offsetFromRoot, bool* needsContextRestore, bool* rootRelativeBoundsComputed, IntRect* rootRelativeBounds, Vector<RenderSVGResourceClipper*>* resourceClippers)
+{
+    bool isRecursing = currentLayer != this;
+    if (parent() && parent()->hasComplexClippedAncestor() && (hasCompositedLayerMapping() || isRecursing)) {
+        bool parentRelativeBoundsComputed = false;
+        IntRect parentRootRelativeBounds;
+        LayoutPoint delta;
+        convertToLayerCoords(parent(), delta);
+        LayoutPoint parentOffsetFromRoot = toPoint(offsetFromRoot - delta);
+        AffineTransform savedCTM;
+        if (hasTransform()) {
+            // Apply inverse transform to bring parent layer's clip into currentLayer's frame of reference.
+            // Can't use save/restore because clip must be preserved.
+            savedCTM = context->getCTM();
+            // FIXME: Flattening to an affine transform at each recursion level does not handle cascading
+            // 3D transforms correctly when preserves3D() == true.
+            context->concatCTM(transform()->inverse().toAffineTransform());
+        }
+        parent()->applyComplexClip(context, currentLayer, clipperContext, paintingInfo, parentOffsetFromRoot, needsContextRestore, &parentRelativeBoundsComputed, &parentRootRelativeBounds, resourceClippers);
+        if (hasTransform())
+            context->setCTM(savedCTM);
+    }
+
+    RenderStyle* style = renderer()->style();
+    if (style && inContainingBlockChain(currentLayer, this)) {
+        if (renderer()->hasClipPath()) {
+            ASSERT(style->clipPath());
+            if (style->clipPath()->type() == ClipPathOperation::SHAPE) {
+                if (!*needsContextRestore) {
+                    // we have not yet saved the context in the current applyClipPath recursion chain
+                    *needsContextRestore = true;
+                    context->save();
+                }
+                ShapeClipPathOperation* clipPath = static_cast<ShapeClipPathOperation*>(style->clipPath());
+                if (!*rootRelativeBoundsComputed) {
+                    *rootRelativeBounds = calculateLayerBounds(paintingInfo.rootLayer, &offsetFromRoot, 0);
+                    *rootRelativeBoundsComputed = true;
+                }
+                context->clipPath(clipPath->path(*rootRelativeBounds), clipPath->windRule());
+            } else if (style->clipPath()->type() == ClipPathOperation::REFERENCE) {
+                ReferenceClipPathOperation* referenceClipPathOperation = static_cast<ReferenceClipPathOperation*>(style->clipPath());
+                Document& document = renderer()->document();
+                // FIXME: It doesn't work with forward or external SVG references (https://bugs.webkit.org/show_bug.cgi?id=90405)
+                Element* element = document.getElementById(referenceClipPathOperation->fragment());
+                if (element && element->hasTagName(SVGNames::clipPathTag) && element->renderer()) {
+                    if (!*rootRelativeBoundsComputed) {
+                        *rootRelativeBounds = calculateLayerBounds(paintingInfo.rootLayer, &offsetFromRoot, 0);
+                        *rootRelativeBoundsComputed = true;
+                    }
+                    RenderSVGResourceClipper* resourceClipper = toRenderSVGResourceClipper(toRenderSVGResourceContainer(element->renderer()));
+                    if (resourceClipper->applyClippingToContext(renderer(), *rootRelativeBounds, paintingInfo.paintDirtyRect, context, *clipperContext))
+                        resourceClippers->append(resourceClipper);
+                }
+            }
+        }
+        if (isRecursing && renderer()->hasOverflowClip() && style->hasBorderRadius()) {
+            // Propagate border radius clipping from ancestors.
+            // The border radius of currentLayer is skipped because it is already taken care of by clipToRect
+            context->clipRoundedRect(style->getRoundedInnerBorderFor(LayoutRect(offsetFromRoot, size())));
+        }
+    }
+}
+
 void RenderLayer::paintLayerByApplyingTransform(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutPoint& translationOffset)
 {
     // This involves subtracting out the position of the layer in our current coordinate space, but preserving
     // the accumulated error for sub-pixel layout.
     LayoutPoint delta;
     convertToLayerCoords(paintingInfo.rootLayer, delta);
     delta.moveBy(translationOffset);
     TransformationMatrix transform(renderableTransform(paintingInfo.paintBehavior));
     IntPoint roundedDelta = roundedIntPoint(delta);
     transform.translateRight(roundedDelta.x(), roundedDelta.y());
@@ skipping 1504 matching lines @@
     // FIXME: Handle simple transforms.
     if (paintsWithTransform(PaintBehaviorNormal))
         return false;
 
     // FIXME: Remove this check.
     // This function should not be called when layer-lists are dirty.
     // It is somehow getting triggered during style update.
     if (m_stackingNode->zOrderListsDirty() || m_stackingNode->normalFlowListDirty())
         return false;
 
+    if (hasComplexClippedAncestor())
+        return false;
+
     // FIXME: We currently only check the immediate renderer,
     // which will miss many cases.
     if (renderer()->backgroundIsKnownToBeOpaqueInRect(localRect))
         return true;
 
     // We can't consult child layers if we clip, since they might cover
     // parts of the rect that are clipped out.
     if (renderer()->hasOverflowClip())
         return false;
 
@@ skipping 160 matching lines @@
         // We need to reset the isUnclippedDescendant bit here because normally
         // the "unclipped-ness" property is only updated in
         // RenderLayerCompositor::updateCompositingRequirementsState(). However,
         // it is only updated for layers which are known to be out of flow.
         // Since this is no longer out of flow, we have to explicitly ensure
         // that it doesn't think it is unclipped.
         setIsUnclippedDescendant(false);
     }
 }
 
+void RenderLayer::updateHasComplexClippedAncestor()
+{
+    bool hasComplexClip = renderer()->hasClipPath()
+        || (renderer()->hasOverflowClip() && renderer()->style()->hasBorderRadius())
+        || (parent() && parent()->hasComplexClippedAncestor());
+
+    if (hasComplexClip == hasComplexClippedAncestor())
+        return;
+
+    setHasComplexClippedAncestor(hasComplexClip);
+
+    for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
+        child->updateHasComplexClippedAncestor();
+    }
+}
+
 static bool hasOrHadFilters(const RenderStyle* oldStyle, const RenderStyle* newStyle)
 {
     ASSERT(newStyle);
     return (oldStyle && oldStyle->hasFilter()) || newStyle->hasFilter();
 }
 
 inline bool RenderLayer::needsCompositingLayersRebuiltForClip(const RenderStyle* oldStyle, const RenderStyle* newStyle) const
 {
     ASSERT(newStyle);
     return oldStyle && (oldStyle->clip() != newStyle->clip() || oldStyle->hasClip() != newStyle->hasClip());
@@ skipping 68 matching lines @@
     updateReflectionInfo(oldStyle);
 
     if (RuntimeEnabledFeatures::cssCompositingEnabled())
         updateBlendMode();
 
     updateDescendantDependentFlags();
     updateTransform();
 
     bool didPaintWithFilters = false;
 
+    updateHasComplexClippedAncestor();
+
     if (paintsWithFilters())
         didPaintWithFilters = true;
     updateFilters(oldStyle, renderer()->style());
 
     const RenderStyle* newStyle = renderer()->style();
     if (compositor()->updateLayerCompositingState(this)
         || needsCompositingLayersRebuiltForClip(oldStyle, newStyle)
         || needsCompositingLayersRebuiltForOverflow(oldStyle, newStyle)
         || needsCompositingLayersRebuiltForFilters(oldStyle, newStyle, didPaintWithFilters))
         compositor()->setCompositingLayersNeedRebuild();
@@ skipping 168 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif