Plumb border radius through when computing clip visual rects.

third_party/WebKit/Source/core/paint/PaintLayerClipper.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>
@@ skipping 188 matching lines @@
     for (const PaintLayer* layer = currentLayer->firstChild(); layer;
          layer = layer->nextSibling())
       layers.push(layer);
   }
 }
 
 LayoutRect PaintLayerClipper::localClipRect(
     const PaintLayer& clippingRootLayer) const {
   ClipRectsContext context(&clippingRootLayer, PaintingClipRects);
   if (m_geometryMapper) {
-    LayoutRect premappedRect =
-        applyOverflowClipToBackgroundRectWithGeometryMapper(
-            context, clipRectWithGeometryMapper(context, false))
-            .rect();
+    ClipRect clipRect = clipRectWithGeometryMapper(context, false);
+    applyOverflowClipToBackgroundRectWithGeometryMapper(context, clipRect);
+    LayoutRect premappedRect = clipRect.rect();
 
     // The rect now needs to be transformed to the local space of this
     // PaintLayer.
     premappedRect.moveBy(context.rootLayer->layoutObject()->paintOffset());
 
     const auto* clipRootLayerTransform = clippingRootLayer.layoutObject()
                                              ->paintProperties()
                                              ->localBorderBoxProperties()
                                              ->transform();
     const auto* layerTransform = m_layer.layoutObject()
@@ skipping 53 matching lines @@
   rectToMap.moveBy(-context.rootLayer->layoutObject()->paintOffset());
 }
 
 void PaintLayerClipper::calculateRectsWithGeometryMapper(
     const ClipRectsContext& context,
     const LayoutRect& paintDirtyRect,
     LayoutRect& layerBounds,
     ClipRect& backgroundRect,
     ClipRect& foregroundRect,
     const LayoutPoint* offsetFromRoot) const {
-  backgroundRect = applyOverflowClipToBackgroundRectWithGeometryMapper(
-      context, clipRectWithGeometryMapper(context, false));
+  backgroundRect = clipRectWithGeometryMapper(context, false);
+  applyOverflowClipToBackgroundRectWithGeometryMapper(context, backgroundRect);
+
   backgroundRect.move(
       context.subPixelAccumulation);  // TODO(chrishtr): is this needed?
   backgroundRect.intersect(paintDirtyRect);
 
   foregroundRect.move(
       context.subPixelAccumulation);  // TODO(chrishtr): is this needed?
   foregroundRect = clipRectWithGeometryMapper(context, true);
   foregroundRect.intersect(paintDirtyRect);
   LayoutPoint offset;
   if (offsetFromRoot)
@@ skipping 161 matching lines @@
     if (context.respectOverflowClip == IgnoreOverflowClip &&
         ancestorProperties->overflowClip())
       destinationPropertyTreeState.setClip(ancestorProperties->overflowClip());
 
     // Set the overflow clip for |propertyTreeState| so that it differs from
     // destinationPropertyTreeState| in its clip.
     if (isForeground && properties->overflowClip())
       propertyTreeState.setClip(properties->overflowClip());
   }
 
-  FloatRect clippedRectInRootLayerSpace =
+  FloatClipRect clippedRectInRootLayerSpace =
       m_geometryMapper->sourceToDestinationVisualRect(
           FloatRect(source), propertyTreeState, destinationPropertyTreeState);
-  clippedRectInRootLayerSpace.moveBy(
-      -FloatPoint(context.rootLayer->layoutObject()->paintOffset()));
-  return ClipRect(LayoutRect(clippedRectInRootLayerSpace));
+  ClipRect clipRect(LayoutRect(clippedRectInRootLayerSpace.rect()));
+  if (clippedRectInRootLayerSpace.hasRadius())
+    clipRect.setHasRadius(true);
+
+  clipRect.moveBy(-context.rootLayer->layoutObject()->paintOffset());
+  return clipRect;
 }
 
-ClipRect PaintLayerClipper::applyOverflowClipToBackgroundRectWithGeometryMapper(
+void PaintLayerClipper::applyOverflowClipToBackgroundRectWithGeometryMapper(
     const ClipRectsContext& context,
-    const ClipRect& clip) const {
+    ClipRect& clip) const {
   const LayoutObject& layoutObject = *m_layer.layoutObject();
-  FloatRect clipRect(clip.rect());
-  if (shouldClipOverflow(context)) {
-    LayoutRect layerBoundsWithVisualOverflow =
-        layoutObject.isLayoutView()
-            ? toLayoutView(layoutObject).viewRect()
-            : toLayoutBox(layoutObject).visualOverflowRect();
-    toLayoutBox(layoutObject)
-        .flipForWritingMode(
-            // PaintLayer are in physical coordinates, so the overflow has to be
-            // flipped.
-            layerBoundsWithVisualOverflow);
-    mapLocalToRootWithGeometryMapper(context, layerBoundsWithVisualOverflow);
-    clipRect.intersect(FloatRect(layerBoundsWithVisualOverflow));
-  }
-
-  return ClipRect(LayoutRect(clipRect));
+  if (!shouldClipOverflow(context))
+    return;
+  LayoutRect layerBoundsWithVisualOverflow =
+      layoutObject.isLayoutView()
+          ? toLayoutView(layoutObject).viewRect()
+          : toLayoutBox(layoutObject).visualOverflowRect();
+  toLayoutBox(layoutObject)
+      .flipForWritingMode(
+          // PaintLayer are in physical coordinates, so the overflow has to be
+          // flipped.
+          layerBoundsWithVisualOverflow);
+  mapLocalToRootWithGeometryMapper(context, layerBoundsWithVisualOverflow);
+  clip.intersect(layerBoundsWithVisualOverflow);
 }
 
 ClipRect PaintLayerClipper::backgroundClipRect(
     const ClipRectsContext& context) const {
   if (m_geometryMapper) {
     ClipRect backgroundClipRect = clipRectWithGeometryMapper(context, false);
 #ifdef CHECK_CLIP_RECTS
     ClipRect testBackgroundClipRect =
         PaintLayerClipper(m_layer, false).backgroundClipRect(context);
     CHECK_RECTS_EQ(testBackgroundClipRect, backgroundClipRect);
@@ skipping 65 matching lines @@
     const LayoutSize& subpixelAccumulation) const {
   DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnoreOverlayScrollbarSize, subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink