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"
 #include "core/paint/LayerClipRecorder.h"
+#include "core/paint/LayoutObjectDrawingRecorder.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/ScrollRecorder.h"
 #include "core/paint/ScrollableAreaPainter.h"
 #include "core/paint/Transform3DRecorder.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/geometry/FloatPoint3D.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/CompositingRecorder.h"
@@ skipping 332 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 30 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(
+      paintLayerForFragments->appendSingleFragmentIgnoringPagination(
           layerFragments, localPaintingInfo.rootLayer,
           localPaintingInfo.paintDirtyRect, cacheSlot,
           IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot,
           localPaintingInfo.subPixelAccumulation);
     } else if (isFixedPositionObjectInPagedMedia()) {
       PaintLayerFragments singleFragment;
-      m_paintLayer.appendSingleFragmentIgnoringPagination(
+      paintLayerForFragments->appendSingleFragmentIgnoringPagination(
           singleFragment, localPaintingInfo.rootLayer,
           localPaintingInfo.paintDirtyRect, cacheSlot,
           IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot,
           localPaintingInfo.subPixelAccumulation);
       repeatFixedPositionObjectInPages(singleFragment[0], paintingInfo,
                                        layerFragments);
     } else {
-      m_paintLayer.collectFragments(layerFragments, localPaintingInfo.rootLayer,
-                                    localPaintingInfo.paintDirtyRect, cacheSlot,
-                                    IgnoreOverlayScrollbarSize,
-                                    respectOverflowClip, &offsetFromRoot,
-                                    localPaintingInfo.subPixelAccumulation);
+      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 80 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 164 matching lines @@
       // A fixed-position object is repeated on every page instead of paginated,
       // so we should apply the original ancestor clip rect.
       if (!isFixedPositionObjectInPagedMedia)
         clipRectForFragment.moveBy(fragment.paginationOffset);
       clipRectForFragment.intersect(fragment.backgroundRect);
       if (clipRectForFragment.isEmpty())
         continue;
       if (needsToClip(paintingInfo, clipRectForFragment)) {
         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);
+  }
+
+  // If we are painting a mask for any reason and we have already processed the
+  // clips, there is no need to go through the remaining painting pipeline.
+  // We know that the mask just needs the area bounded by the clip rects to be
+  // filled with black.
+  if (clipRecorder && phase == PaintPhaseClippingMask) {
+    fillMaskingFragment(context, clipRect);

[Stephen Chennney, 2017/01/04 19:22:46]

This avoids all sorts of problems with coordinate systems and the necessary
paint area. We know we want a mask that allows anything inside the clip. If we
use the child's area we fail to render siblings that are also inside the clip.
If we try to use the clipper's area we have problems with border-related offsets
in computing the paint area, with no easy way to resolve them. Just filling all
of the clip is the fastest approach.

+    return;
   }
 
   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 125 matching lines @@
     return;
 
   PaintLayerPaintingInfo paintingInfo(&m_paintLayer,
                                       LayoutRect(enclosingIntRect(damageRect)),
                                       paintFlags, LayoutSize());
   paint(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
   m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
+void PaintLayerPainter::fillMaskingFragment(GraphicsContext& context,
+                                            const ClipRect& clipRect) {
+  const LayoutBox* layoutBox = toLayoutBox(m_paintLayer.layoutObject());
+  if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(
+          context, *layoutBox, PaintPhaseClippingMask))
+    return;
+
+  IntRect snappedClipRect = pixelSnappedIntRect(clipRect.rect());
+  LayoutObjectDrawingRecorder drawingRecorder(
+      context, *layoutBox, PaintPhaseClippingMask, snappedClipRect);
+  context.fillRect(snappedClipRect, Color::black);
+}
+
 }  // namespace blink