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/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
 #include "core/paint/FilterPainter.h"
@@ skipping 353 matching lines @@
   // 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))) {
+       (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
@@ skipping 35 matching lines @@
                             isSelfPaintingLayer && !isPaintingOverlayScrollbars;
 
   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;
+    LayoutPoint offsetToClipper;
+    PaintLayer* paintLayerForFragments = &m_paintLayer;
+    if (paintFlags & PaintLayerPaintingAncestorClippingMaskPhase) {
+      // Compute fragments and their clips with respect to the clipping
+      // container. The paint rect is in this layer's space, so convert it
+      // to the clipper's layer's space. The rootLayer is also changed to
+      // the clipper's layer to simplify coordinate system adjustments.
+      // The change to rootLayer must persist to correctly record the clips.
+      paintLayerForFragments =
+          m_paintLayer.clippingContainer()->enclosingLayer();
+      localPaintingInfo.rootLayer = paintLayerForFragments;
+      m_paintLayer.convertToLayerCoords(localPaintingInfo.rootLayer,
+                                        offsetToClipper);
+      localPaintingInfo.paintDirtyRect.moveBy(offsetToClipper);
+    }
+
     // 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(
+        RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+      paintLayerForFragments->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);
+    } else {
+      paintLayerForFragments->collectFragments(
+          layerFragments, localPaintingInfo.rootLayer,
+          localPaintingInfo.paintDirtyRect, cacheSlot,
+          IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot,
+          localPaintingInfo.subPixelAccumulation);
+    }
+
+    if (paintFlags & PaintLayerPaintingAncestorClippingMaskPhase) {
+      // Fragment offsets have been computed in the clipping container's
+      // layer's coordinate system, but for the rest of painting we need
+      // them in the layer coordinate. So move them and the foreground rect
+      // that is also in the clipper's space.
+      LayoutSize negativeOffset(-offsetToClipper.x(), -offsetToClipper.y());
+      for (auto& fragment : layerFragments) {
+        fragment.foregroundRect.move(negativeOffset);
+        fragment.paginationOffset.move(negativeOffset);
+      }
+    }
 
     if (shouldPaintContent) {
       // TODO(wangxianzhu): This is for old slow scrolling. Implement similar
       // optimization for slimming paint v2.
       shouldPaintContent = atLeastOneFragmentIntersectsDamageRect(
           layerFragments, localPaintingInfo, paintFlags, offsetFromRoot);
       if (!shouldPaintContent)
         result = MayBeClippedByPaintDirtyRect;
     }
   }
@@ skipping 83 matching lines @@
     if (shouldPaintOverlayScrollbars)
       paintOverflowControlsForFragments(layerFragments, context,
                                         localPaintingInfo, paintFlags);
   }  // FilterPainter block
 
   bool shouldPaintMask =
       (paintFlags & PaintLayerPaintingCompositingMaskPhase) &&
       shouldPaintContent && m_paintLayer.layoutObject()->hasMask() &&
       !selectionOnly;
   bool shouldPaintClippingMask =
-      (paintFlags & PaintLayerPaintingChildClippingMaskPhase) &&
+      (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);
   }
@@ skipping 154 matching lines @@
       if (needsToClip(paintingInfo, clipRectForFragment)) {
         if (m_paintLayer.layoutObject()->isPositioned() &&
             clipRectForFragment.isClippedByClipCss())
           UseCounter::count(m_paintLayer.layoutObject()->document(),
                             UseCounter::ClipCssOfPositionedElement);
         if (m_paintLayer.layoutObject()->isFixedPositioned())
           UseCounter::count(m_paintLayer.layoutObject()->document(),
                             UseCounter::ClipCssOfFixedPositionElement);
         clipRecorder.emplace(context, *parentLayer->layoutObject(),
                              DisplayItem::kClipLayerParent, clipRectForFragment,
-                             &paintingInfo, fragment.paginationOffset,
+                             paintingInfo.rootLayer, fragment.paginationOffset,
                              paintFlags);
       }
     }
     if (paintFragmentByApplyingTransform(context, paintingInfo, paintFlags,
                                          fragment.paginationOffset) ==
         MayBeClippedByPaintDirtyRect)
       result = MayBeClippedByPaintDirtyRect;
   }
   return result;
 }
@@ skipping 117 matching lines @@
 
   for (auto& fragment : layerFragments) {
     // We need to apply the same clips and transforms that
     // paintFragmentWithPhase would have.
     LayoutRect cullRect = fragment.backgroundRect.rect();
 
     Optional<LayerClipRecorder> clipRecorder;
     if (needsToClip(localPaintingInfo, fragment.backgroundRect)) {
       clipRecorder.emplace(context, *m_paintLayer.layoutObject(),
                            DisplayItem::kClipLayerOverflowControls,
-                           fragment.backgroundRect, &localPaintingInfo,
+                           fragment.backgroundRect, localPaintingInfo.rootLayer,
                            fragment.paginationOffset, paintFlags);
     }
 
     Optional<ScrollRecorder> scrollRecorder;
     if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
         !localPaintingInfo.scrollOffsetAccumulation.isZero()) {
       cullRect.move(localPaintingInfo.scrollOffsetAccumulation);
       scrollRecorder.emplace(context, *m_paintLayer.layoutObject(),
                              DisplayItem::kScrollOverflowControls,
                              localPaintingInfo.scrollOffsetAccumulation);
@@ skipping 29 matching lines @@
                                                // handle clipping to self.
       case PaintPhaseSelfOutlineOnly:
       case PaintPhaseMask:  // Mask painting will handle clipping to self.
         clippingRule = LayerClipRecorder::DoNotIncludeSelfForBorderRadius;
         break;
       default:
         clippingRule = LayerClipRecorder::IncludeSelfForBorderRadius;
         break;
     }
 
+    // TODO(schenney): Nested border-radius clips are not applied to composited
+    // children, probably due to an incorrect clipRoot.
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=672561
     clipRecorder.emplace(context, *m_paintLayer.layoutObject(), clipType,
-                         clipRect, &paintingInfo, fragment.paginationOffset,
-                         paintFlags, clippingRule);
+                         clipRect, paintingInfo.rootLayer,
+                         fragment.paginationOffset, paintFlags, clippingRule);
   }
 
   LayoutRect newCullRect(clipRect.rect());
   Optional<ScrollRecorder> scrollRecorder;
   LayoutPoint paintOffset = -m_paintLayer.layoutBoxLocation();
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     const auto* objectPaintProperties =
         m_paintLayer.layoutObject()->paintProperties();
     DCHECK(objectPaintProperties &&
            objectPaintProperties->localBorderBoxProperties());
@@ skipping 51 matching lines @@
   // Optimize clipping for the single fragment case.
   bool shouldClip = localPaintingInfo.clipToDirtyRect &&
                     layerFragments.size() == 1 &&
                     !layerFragments[0].foregroundRect.isEmpty();
   ClipState clipState = HasNotClipped;
   Optional<LayerClipRecorder> clipRecorder;
   if (shouldClip &&
       needsToClip(localPaintingInfo, layerFragments[0].foregroundRect)) {
     clipRecorder.emplace(context, *m_paintLayer.layoutObject(),
                          DisplayItem::kClipLayerForeground,
-                         layerFragments[0].foregroundRect, &localPaintingInfo,
+                         layerFragments[0].foregroundRect,
+                         localPaintingInfo.rootLayer,
                          layerFragments[0].paginationOffset, paintFlags);
     clipState = HasClipped;
   }
 
   // We have to loop through every fragment multiple times, since we have to
   // issue paint invalidations in each specific phase in order for interleaving
   // of the fragments to work properly.
   if (selectionOnly) {
     paintForegroundForFragmentsWithPhase(PaintPhaseSelection, layerFragments,
                                          context, localPaintingInfo, paintFlags,
@@ skipping 126 matching lines @@
 
   PaintLayerPaintingInfo paintingInfo(&m_paintLayer,
                                       LayoutRect(enclosingIntRect(damageRect)),
                                       paintFlags, LayoutSize());
   paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
   m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 }  // namespace blink