Fix border radius on composited children.

third_party/WebKit/Source/core/paint/PaintLayerPainter.cpp

 // Copyright 2014 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 "core/paint/PaintLayerPainter.h"
 
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
@@ skipping 246 matching lines @@
 
     if (paintingInfo.ancestorHasClipPathClipping && m_paintLayer.layoutObject()->isPositioned())
         UseCounter::count(m_paintLayer.layoutObject()->document(), UseCounter::ClipPathOfPositionedElement);
 
     // These helpers output clip and compositing operations using a RAII pattern. Stack-allocated-varibles are destructed in the reverse order of construction,
     // so they are nested properly.
     Optional<ClipPathClipper> clipPathClipper;
     // Clip-path, like border radius, must not be applied to the contents of a composited-scrolling container.
     // It must, however, still be applied to the mask layer, so that the compositor can properly mask the
     // scrolling contents and scrollbars.
-    if (m_paintLayer.layoutObject()->hasClipPath() && (!m_paintLayer.needsCompositedScrolling() || (paintFlags & PaintLayerPaintingChildClippingMaskPhase))) {
+    if (m_paintLayer.layoutObject()->hasClipPath() && (!m_paintLayer.needsCompositedScrolling() || (paintFlags & (PaintLayerPaintingChildClippingMaskPhase | PaintLayerPaintingAncestorClippingMaskPhase)))) {
         paintingInfo.ancestorHasClipPathClipping = true;
 
         LayoutRect referenceBox(m_paintLayer.boxForClipPath());
         // Note that this isn't going to work correctly if crossing a column boundary. The reference box should be
         // determined per-fragment, and hence this ought to be performed after fragmentation.
         if (m_paintLayer.enclosingPaginationLayer())
             m_paintLayer.convertFromFlowThreadToVisualBoundingBoxInAncestor(paintingInfo.rootLayer, referenceBox);
         else
             referenceBox.moveBy(offsetFromRoot);
         clipPathClipper.emplace(
@@ skipping 15 matching lines @@
 
     PaintLayerPaintingInfo localPaintingInfo(paintingInfo);
     localPaintingInfo.subPixelAccumulation = subpixelAccumulation;
 
     PaintLayerFragments layerFragments;
     if (shouldPaintContent || shouldPaintSelfOutline || isPaintingOverlayScrollbars) {
         // Collect the fragments. This will compute the clip rectangles and paint offsets for each layer fragment.
         ClipRectsCacheSlot cacheSlot = (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects : PaintingClipRects;
         // TODO(trchen): We haven't decided how to handle visual fragmentation with SPv2.
         // Related thread https://groups.google.com/a/chromium.org/forum/#!topic/graphics-dev/81XuWFf-mxM
-        if (fragmentPolicy == ForceSingleFragment || RuntimeEnabledFeatures::slimmingPaintV2Enabled())
-            m_paintLayer.appendSingleFragmentIgnoringPagination(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
-        else
-            m_paintLayer.collectFragments(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
+        if (fragmentPolicy == ForceSingleFragment || RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+            m_paintLayer.appendSingleFragmentIgnoringPagination(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect,
+                cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, paintFlags & PaintLayerPaintingAncestorClippingMaskPhase, &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
+        } else {
+            m_paintLayer.collectFragments(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect,
+                cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, paintFlags & PaintLayerPaintingAncestorClippingMaskPhase,
+                &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
+        }
 
         // TODO(trchen): Needs to adjust cull rect between transform spaces. https://crbug.com/593596
         // Disables layer culling for SPv2 for now because the space of the cull rect doesn't match
         // the space we paint in. Clipping will still be done by clip nodes, so this won't cause
         // rendering issues, only performance.
         if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
             layerFragments[0].backgroundRect = LayoutRect(LayoutRect::infiniteIntRect());
             layerFragments[0].foregroundRect = LayoutRect(LayoutRect::infiniteIntRect());
         }
 
@@ skipping 53 matching lines @@
         if (shouldPaintNormalFlowAndPosZOrderLists) {
             if (paintChildren(NormalFlowChildren | PositiveZOrderChildren, context, paintingInfo, paintFlags) == MayBeClippedByPaintDirtyRect)
                 result = MayBeClippedByPaintDirtyRect;
         }
 
         if (shouldPaintOverlayScrollbars)
             paintOverflowControlsForFragments(layerFragments, context, localPaintingInfo, paintFlags);
     } // FilterPainter block
 
     bool shouldPaintMask = (paintFlags & PaintLayerPaintingCompositingMaskPhase) && shouldPaintContent && m_paintLayer.layoutObject()->hasMask() && !selectionOnly;
-    bool shouldPaintClippingMask = (paintFlags & PaintLayerPaintingChildClippingMaskPhase) && shouldPaintContent && !selectionOnly;
+    bool shouldPaintClippingMask = (paintFlags & (PaintLayerPaintingChildClippingMaskPhase | PaintLayerPaintingAncestorClippingMaskPhase)) && shouldPaintContent && !selectionOnly;
 
     if (shouldPaintMask)
         paintMaskForFragments(layerFragments, context, localPaintingInfo, paintFlags);
     if (shouldPaintClippingMask) {
         // Paint the border radius mask for the fragments.
         paintChildClippingMaskForFragments(layerFragments, context, localPaintingInfo, paintFlags);
     }
 
     if (subsequenceRecorder)
         m_paintLayer.setPreviousPaintResult(result);
@@ skipping 75 matching lines @@
     } else if (paginationLayer) {
         // FIXME: This is a mess. Look closely at this code and the code in Layer and fix any
         // issues in it & refactor to make it obvious from code structure what it does and that it's
         // correct.
         ClipRectsCacheSlot cacheSlot = (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects : PaintingClipRects;
         ShouldRespectOverflowClipType respectOverflowClip = shouldRespectOverflowClip(paintFlags, m_paintLayer.layoutObject());
         // Calculate the transformed bounding box in the current coordinate space, to figure out
         // which fragmentainers (e.g. columns) we need to visit.
         LayoutRect transformedExtent = PaintLayer::transparencyClipBox(&m_paintLayer, paginationLayer, PaintLayer::PaintingTransparencyClipBox, PaintLayer::RootOfTransparencyClipBox, paintingInfo.subPixelAccumulation, paintingInfo.getGlobalPaintFlags());
         // FIXME: we don't check if paginationLayer is within paintingInfo.rootLayer here.
-        paginationLayer->collectFragments(fragments, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, 0, paintingInfo.subPixelAccumulation, &transformedExtent);
+        paginationLayer->collectFragments(fragments, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, false, 0, paintingInfo.subPixelAccumulation, &transformedExtent);
     } else {
         // We don't need to collect any fragments in the regular way here. We have already
         // calculated a clip rectangle for the ancestry if it was needed, and clipping this
         // layer is something that can be done further down the path, when the transform has
         // been applied.
         PaintLayerFragment fragment;
         fragment.backgroundRect = paintingInfo.paintDirtyRect;
         fragments.append(fragment);
     }
 
@@ skipping 153 matching lines @@
         switch (phase) {
         case PaintPhaseSelfBlockBackgroundOnly: // Background painting will handle clipping to self.
         case PaintPhaseSelfOutlineOnly:
         case PaintPhaseMask: // Mask painting will handle clipping to self.
             clippingRule = LayerClipRecorder::DoNotIncludeSelfForBorderRadius;
             break;
         default:
             clippingRule = LayerClipRecorder::IncludeSelfForBorderRadius;
             break;
         }
-
         clipRecorder.emplace(context, *m_paintLayer.layoutObject(), clipType, clipRect, &paintingInfo, fragment.paginationOffset, paintFlags, clippingRule);
     }
 
     LayoutRect newCullRect(clipRect.rect());
     Optional<ScrollRecorder> scrollRecorder;
     LayoutPoint paintOffset = -m_paintLayer.layoutBoxLocation();
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
         const ObjectPaintProperties* objectPaintProperties = m_paintLayer.layoutObject()->objectPaintProperties();
         ASSERT(objectPaintProperties && objectPaintProperties->localBorderBoxProperties());
         paintOffset += toSize(objectPaintProperties->localBorderBoxProperties()->paintOffset);
     } else {
         paintOffset += toSize(fragment.layerBounds.location());
         if (!paintingInfo.scrollOffsetAccumulation.isZero()) {
             // As a descendant of the root layer, m_paintLayer's painting is not controlled by the ScrollRecorders
             // created by BlockPainter of the ancestor layers up to the root layer, so we need to issue ScrollRecorder
             // for this layer seperately, with the scroll offset accumulated from the root layer to the parent of this
             // layer, to get the same result as ScrollRecorder in BlockPainter.
             paintOffset += paintingInfo.scrollOffsetAccumulation;
 
             newCullRect.move(paintingInfo.scrollOffsetAccumulation);
             scrollRecorder.emplace(context, *m_paintLayer.layoutObject(), phase, paintingInfo.scrollOffsetAccumulation);
         }
     }
     PaintInfo paintInfo(context, pixelSnappedIntRect(newCullRect), phase,
         paintingInfo.getGlobalPaintFlags(), paintFlags, paintingInfo.rootLayer->layoutObject());
 
+    // TODO(schenney): This is the wrong object for painting AncestorClippingMask.
     m_paintLayer.layoutObject()->paint(paintInfo, paintOffset);
 }
 
 void PaintLayerPainter::paintBackgroundForFragments(const PaintLayerFragments& layerFragments,
     GraphicsContext& context, const LayoutRect& transparencyPaintDirtyRect,
     const PaintLayerPaintingInfo& localPaintingInfo, PaintLayerFlags paintFlags)
 {
     Optional<DisplayItemCacheSkipper> cacheSkipper;
     if (layerFragments.size() > 1)
         cacheSkipper.emplace(context);
@@ skipping 107 matching lines @@
     if (!m_paintLayer.containsDirtyOverlayScrollbars())
         return;
 
     PaintLayerPaintingInfo paintingInfo(&m_paintLayer, LayoutRect(enclosingIntRect(damageRect)), paintFlags, LayoutSize());
     paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
     m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 } // namespace blink