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 309 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 36 matching lines @@
       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())
+        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);
+          IgnoreOverlayScrollbarSize, respectOverflowClip,
+          paintFlags & PaintLayerPaintingAncestorClippingMaskPhase,
+          &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
+    } else {
+      m_paintLayer.collectFragments(
+          layerFragments, localPaintingInfo.rootLayer,
+          localPaintingInfo.paintDirtyRect, cacheSlot,
+          IgnoreOverlayScrollbarSize, respectOverflowClip,
+          paintFlags & PaintLayerPaintingAncestorClippingMaskPhase,
+          &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
+    }
 
     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 76 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 58 matching lines @@
   // its parent.
   PaintLayer* parentLayer = m_paintLayer.parent();
 
   LayoutObject* object = m_paintLayer.layoutObject();
   LayoutView* view = object->view();
   bool isFixedPosObjectInPagedMedia =
       object->style()->position() == FixedPosition &&
       object->container() == view && view->pageLogicalHeight();
   PaintLayer* paginationLayer = m_paintLayer.enclosingPaginationLayer();
   PaintLayerFragments fragments;
+
   // TODO(crbug.com/619094): Figure out the correct behaviour for fixed position
   // objects in paged media with vertical writing modes.
   if (isFixedPosObjectInPagedMedia && view->isHorizontalWritingMode()) {
     // "For paged media, boxes with fixed positions are repeated on every page."
     // https://www.w3.org/TR/2011/REC-CSS2-20110607/visuren.html#fixed-positioning
     unsigned pages =
         ceilf(view->documentRect().height() / view->pageLogicalHeight());
     LayoutPoint paginationOffset;
 
     // The fixed position object is offset from the top of the page, so remove
@@ skipping 21 matching lines @@
     // 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,
+        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 195 matching lines @@
 
     // We pass IntPoint() as the paint offset here, because
     // ScrollableArea::paintOverflowControls just ignores it and uses the
     // offset found in a previous pass.
     CullRect snappedCullRect(pixelSnappedIntRect(cullRect));
     ScrollableAreaPainter(*scrollableArea)
         .paintOverflowControls(context, IntPoint(), snappedCullRect, true);
   }
 }
 
+LayoutPoint PaintLayerPainter::fragmentOffsetForAncestorClipMask(
+    const LayoutPoint& originalFragmentOffset) {
+  // The clipping container that will be used to define the clip and the
+  // child layer with respect to which the fragment offset is defined share
+  // a layer root. When the clip is recorded we will be using the clipping
+  // container's layer's offset to the root to position the clip. Hence we
+  // must convert the fragment offset into a corresponding offset in the
+  // clipping container's layer coordinates. To do that, we find the
+  // originalFragmentOffset's coordinate in the root layer, fragmentDelta.
+  // We also find the offset of the clipping container's origin in the root
+  // layer's coordinates, clippingDelta. clippingDelta - fragmentDelta gives
+  // the fragment's position in the root layer. But we need the position in
+  // the clipping layer coords, and we subtract clippingDelta to get that. The
+  // resulting offset is -fragmentDelta.
+  DCHECK_EQ(m_paintLayer.root(),
+            m_paintLayer.clippingContainer()->enclosingLayer()->root());
+  LayoutPoint fragmentDelta(originalFragmentOffset);
+  m_paintLayer.convertToLayerCoords(m_paintLayer.root(), fragmentDelta);
+  return LayoutPoint(-fragmentDelta.x(), -fragmentDelta.y());
+}
+
 void PaintLayerPainter::paintFragmentWithPhase(
     PaintPhase phase,
     const PaintLayerFragment& fragment,
     GraphicsContext& context,
     const ClipRect& clipRect,
     const PaintLayerPaintingInfo& paintingInfo,
     PaintLayerFlags paintFlags,
     ClipState clipState) {
   DCHECK(m_paintLayer.isSelfPaintingLayer());
 
   Optional<LayerClipRecorder> clipRecorder;
   if (clipState != HasClipped && paintingInfo.clipToDirtyRect &&
       needsToClip(paintingInfo, clipRect)) {
     DisplayItem::Type clipType =
         DisplayItem::paintPhaseToClipLayerFragmentType(phase);
     LayerClipRecorder::BorderRadiusClippingRule clippingRule;
     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);
+    // When painting the clipping mask for a composited child, we pass
+    // the clipping container object as the layoutObject to provide the clip.
+    // The recorder assumes the fragment is positioned in that objects's
+    // layer coordinates, so we also convert that.
+    if (paintFlags & PaintLayerPaintingAncestorClippingMaskPhase) {
+      clipRecorder.emplace(
+          context, *(toLayoutBoxModelObject(m_paintLayer.clippingContainer())),
+          clipType, clipRect, &paintingInfo,
+          fragmentOffsetForAncestorClipMask(fragment.paginationOffset),
+          paintFlags, clippingRule);
+    } else {
+      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 auto* objectPaintProperties =
         m_paintLayer.layoutObject()->paintProperties();
     DCHECK(objectPaintProperties &&
            objectPaintProperties->localBorderBoxProperties());
@@ skipping 13 matching lines @@
 
       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.

[Stephen Chennney, 2016/11/08 21:42:52]

No it's not. It's the wrong object for all the clipping code, not the painting
code. Remove this comment.

   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;
@@ skipping 165 matching lines @@
 
   PaintLayerPaintingInfo paintingInfo(&m_paintLayer,
                                       LayoutRect(enclosingIntRect(damageRect)),
                                       paintFlags, LayoutSize());
   paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
   m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 }  // namespace blink