Account for filter bounds for backgroundRect during PaintLayer painting

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 183 matching lines @@
          layer = layer->nextSibling())
       layers.push(layer);
   }
 }
 
 LayoutRect PaintLayerClipper::localClipRect(
     const PaintLayer& clippingRootLayer) const {
   ClipRectsContext context(&clippingRootLayer, PaintingClipRects);
   if (m_geometryMapper) {
     ClipRect clipRect;
-    calculateClipRectWithGeometryMapper(context, false, clipRect);
-    applyOverflowClipToBackgroundRectWithGeometryMapper(context, clipRect);
+    calculateBackgroundClipRectWithGeometryMapper(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();
@@ skipping 34 matching lines @@
         (expected.isEmpty() && actual.isEmpty()) || expected == actual; \
     if (!matches) {                                                     \
       LOG(ERROR) << "Rects don't match for m_layer="                    \
                  << m_layer.layoutObject()->debugName()                 \
                  << " expected=" << expected.toString()                 \
                  << " actual=" << actual.toString();                    \
     }                                                                   \
   } while (false);
 #endif
 
-void PaintLayerClipper::mapLocalToRootWithGeometryMapper(
-    const ClipRectsContext& context,
-    LayoutRect& rectToMap) const {
-  DCHECK(m_geometryMapper);
-
-  const auto* layerTransform = m_layer.layoutObject()
-                                   .paintProperties()
-                                   ->localBorderBoxProperties()
-                                   ->transform();
-  const auto* rootTransform = context.rootLayer->layoutObject()
-                                  .paintProperties()
-                                  ->localBorderBoxProperties()
-                                  ->transform();
-
-  FloatRect floatRect(rectToMap);
-  floatRect.moveBy(FloatPoint(m_layer.layoutObject().paintOffset()));
-  m_geometryMapper->sourceToDestinationRect(layerTransform, rootTransform,
-                                            floatRect);
-  rectToMap = LayoutRect(floatRect);
-  rectToMap.moveBy(-context.rootLayer->layoutObject().paintOffset());
-  rectToMap.move(context.subPixelAccumulation);
-}
-
 void PaintLayerClipper::calculateRectsWithGeometryMapper(
     const ClipRectsContext& context,
     const LayoutRect& paintDirtyRect,
     LayoutRect& layerBounds,
     ClipRect& backgroundRect,
     ClipRect& foregroundRect,
     const LayoutPoint* offsetFromRoot) const {
   const auto* properties = m_layer.layoutObject().paintProperties();
   // TODO(chrishtr): fix the underlying bug that causes this situation.
   if (!properties) {
     backgroundRect = ClipRect(LayoutRect(LayoutRect::infiniteIntRect()));
     foregroundRect = ClipRect(LayoutRect(LayoutRect::infiniteIntRect()));
   } else {
-    calculateClipRectWithGeometryMapper(context, false, backgroundRect);
-
+    calculateBackgroundClipRectWithGeometryMapper(context, backgroundRect);
     backgroundRect.move(context.subPixelAccumulation);
     backgroundRect.intersect(paintDirtyRect);
 
-    applyOverflowClipToBackgroundRectWithGeometryMapper(context,
-                                                        backgroundRect);
-
-    calculateClipRectWithGeometryMapper(context, true, foregroundRect);
+    calculateForegroundClipRectWithGeometryMapper(context, foregroundRect);
     foregroundRect.move(context.subPixelAccumulation);
     foregroundRect.intersect(paintDirtyRect);
   }
   LayoutPoint offset;
   if (offsetFromRoot)
     offset = *offsetFromRoot;
   else
     m_layer.convertToLayerCoords(context.rootLayer, offset);
   layerBounds = LayoutRect(offset, LayoutSize(m_layer.size()));
 
@@ skipping 48 matching lines @@
     LayoutRect overflowAndClipRect =
         toLayoutBox(layoutObject)
             .overflowClipRect(offset, context.overlayScrollbarClipBehavior);
     foregroundRect.intersect(overflowAndClipRect);
     if (layoutObject.styleRef().hasBorderRadius())
       foregroundRect.setHasRadius(true);
 
     // FIXME: Does not do the right thing with columns yet, since we don't yet
     // factor in the individual column boxes as overflow.
 
-    // The LayoutView is special since its overflow clipping rect may be larger
-    // than its box rect (crbug.com/492871).
-    LayoutRect layerBoundsWithVisualOverflow =
-        layoutObject.isLayoutView()
-            ? toLayoutView(layoutObject).viewRect()
-            : toLayoutBox(layoutObject).visualOverflowRect();
-    // PaintLayer are in physical coordinates, so the overflow has to be
-    // flipped.
-    toLayoutBox(layoutObject).flipForWritingMode(layerBoundsWithVisualOverflow);
+    LayoutRect layerBoundsWithVisualOverflow = localVisualRect();
     layerBoundsWithVisualOverflow.moveBy(offset);
     backgroundRect.intersect(layerBoundsWithVisualOverflow);
   }
 
   // CSS clip (different than clipping due to overflow) can clip to any box,
   // even if it falls outside of the border box.
   if (layoutObject.hasClip()) {
     // Clip applies to *us* as well, so go ahead and update the damageRect.
     LayoutRect newPosClip = toLayoutBox(layoutObject).clipRect(offset);
     backgroundRect.intersect(newPosClip);
@@ skipping 44 matching lines @@
                                               EPosition position) {
   if (position == EPosition::kFixed)
     return parentRects.fixedClipRect();
 
   if (position == EPosition::kAbsolute)
     return parentRects.posClipRect();
 
   return parentRects.overflowClipRect();
 }
 
-void PaintLayerClipper::calculateClipRectWithGeometryMapper(
+void PaintLayerClipper::calculateBackgroundClipRectWithGeometryMapper(
     const ClipRectsContext& context,
-    bool isForeground,
     ClipRect& output) const {
   DCHECK(m_geometryMapper);
+  PropertyTreeState sourcePropertyTreeState(nullptr, nullptr, nullptr);
+  PropertyTreeState destinationPropertyTreeState(nullptr, nullptr, nullptr);
+  initializeCommonClipRectState(context, sourcePropertyTreeState,
+                                destinationPropertyTreeState);
+  const auto* ancestorProperties =
+      context.rootLayer->layoutObject().paintProperties();
+
+  if (&m_layer != context.rootLayer) {
+    // Set the clip of |destinationPropertyTreeState| to be inside the
+    // ancestor's overflow clip, so that that clip is not applied.
+    if (context.respectOverflowClip == IgnoreOverflowClip &&
+        ancestorProperties->overflowClip())
+      destinationPropertyTreeState.setClip(ancestorProperties->overflowClip());
+  }
+
+  // The background rect applies all clips *above* m_layer, but not the overflow
+  // clip of m_layer. It also applies a clip to the total painting bounds
+  // of m_layer, because nothing in m_layer or its children within the clip can
+  // paint outside of those bounds.
+  // The total painting bounds includes any visual overflow (such as shadow) and
+  // filter bounds.
+  if (shouldClipOverflow(context)) {
+    FloatRect clipRect(localVisualRect());
+    clipRect.moveBy(FloatPoint(m_layer.layoutObject().paintOffset()));
+    m_geometryMapper->sourceToDestinationVisualRect(
+        sourcePropertyTreeState, destinationPropertyTreeState, clipRect);
+    output.setRect(FloatClipRect(clipRect));
+  } else {
+    const FloatClipRect& clippedRectInRootLayerSpace =
+        m_geometryMapper->sourceToDestinationClipRect(
+            sourcePropertyTreeState, destinationPropertyTreeState);
+    output.setRect(clippedRectInRootLayerSpace);
+  }
+
+  output.moveBy(-context.rootLayer->layoutObject().paintOffset());
+}
+
+void PaintLayerClipper::initializeCommonClipRectState(
+    const ClipRectsContext& context,
+    PropertyTreeState& sourcePropertyTreeState,
+    PropertyTreeState& destinationPropertyTreeState) const {
+  DCHECK(m_geometryMapper);
   const auto* properties = m_layer.layoutObject().paintProperties();
   DCHECK(properties && properties->localBorderBoxProperties());
 
-  PropertyTreeState propertyTreeState = *properties->localBorderBoxProperties();
+  sourcePropertyTreeState = *properties->localBorderBoxProperties();
   const auto* ancestorProperties =
       context.rootLayer->layoutObject().paintProperties();
   DCHECK(ancestorProperties && ancestorProperties->localBorderBoxProperties());
-  PropertyTreeState destinationPropertyTreeState =
+  destinationPropertyTreeState =
       *ancestorProperties->localBorderBoxProperties();
   // CSS clip of the root is always applied.
   if (ancestorProperties->cssClip()) {
     DCHECK(destinationPropertyTreeState.clip() ==
            ancestorProperties->cssClip());
     destinationPropertyTreeState.setClip(
         ancestorProperties->cssClip()->parent());
   }
+}
+
+void PaintLayerClipper::calculateForegroundClipRectWithGeometryMapper(
+    const ClipRectsContext& context,
+    ClipRect& output) const {
+  DCHECK(m_geometryMapper);
+  PropertyTreeState sourcePropertyTreeState(nullptr, nullptr, nullptr);
+  PropertyTreeState destinationPropertyTreeState(nullptr, nullptr, nullptr);
+  initializeCommonClipRectState(context, sourcePropertyTreeState,
+                                destinationPropertyTreeState);
+  const auto* properties = m_layer.layoutObject().paintProperties();
+  const auto* ancestorProperties =
+      context.rootLayer->layoutObject().paintProperties();
 
   if (&m_layer == context.rootLayer) {
-    // Set the overflow clip for |propertyTreeState| so that it differs from
-    // |destinationPropertyTreeState| in its clip.
-    if (isForeground && context.respectOverflowClip == RespectOverflowClip &&
+    // Set the overflow clip for |sourcePropertyTreeState| so that it differs
+    // from |destinationPropertyTreeState| in its clip.
+    if (context.respectOverflowClip == RespectOverflowClip &&
         properties->overflowClip())
-      propertyTreeState.setClip(properties->overflowClip());
+      sourcePropertyTreeState.setClip(properties->overflowClip());
   } else {
     // Set the clip of |destinationPropertyTreeState| to be inside the
     // ancestor's overflow clip, so that that clip is not applied.
     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());
+    // Set the overflow clip for |sourcePropertyTreeState| so that it differs
+    // from destinationPropertyTreeState| in its clip.
+    if (properties->overflowClip())
+      sourcePropertyTreeState.setClip(properties->overflowClip());
   }
 
   const FloatClipRect& clippedRectInRootLayerSpace =
       m_geometryMapper->sourceToDestinationClipRect(
-          propertyTreeState, destinationPropertyTreeState);
+          sourcePropertyTreeState, destinationPropertyTreeState);
   output.setRect(clippedRectInRootLayerSpace);
 
   output.moveBy(-context.rootLayer->layoutObject().paintOffset());
 }
 
-void PaintLayerClipper::applyOverflowClipToBackgroundRectWithGeometryMapper(
-    const ClipRectsContext& context,
-    ClipRect& clip) const {
+LayoutRect PaintLayerClipper::localVisualRect() const {
   const LayoutObject& layoutObject = m_layer.layoutObject();
-  if (!shouldClipOverflow(context))
-    return;
+  // The LayoutView is special since its overflow clipping rect may be larger
+  // than its box rect (crbug.com/492871).
   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);
+  if (m_layer.paintsWithFilters()) {
+    layerBoundsWithVisualOverflow =
+        m_layer.mapLayoutRectForFilter(layerBoundsWithVisualOverflow);
+  }
+  return layerBoundsWithVisualOverflow;
 }
 
 void PaintLayerClipper::calculateBackgroundClipRect(
     const ClipRectsContext& context,
     ClipRect& output) const {
   if (m_geometryMapper) {
     // TODO(chrishtr): fix the underlying bug that causes this situation.
     if (!m_layer.layoutObject().paintProperties()) {
       output.setRect(FloatClipRect());
       return;
     }
 
-    calculateClipRectWithGeometryMapper(context, false, output);
+    calculateBackgroundClipRectWithGeometryMapper(context, output);
 #ifdef CHECK_CLIP_RECTS
     ClipRect testBackgroundClipRect =
         PaintLayerClipper(m_layer, nullptr).backgroundClipRect(context);
     CHECK_RECTS_EQ(testBackgroundClipRect, output);
 #endif
     return;
   }
   DCHECK(m_layer.parent());
   LayoutView* layoutView = m_layer.layoutObject().view();
   DCHECK(layoutView);
@@ skipping 61 matching lines @@
   DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnorePlatformOverlayScrollbarSize,
                            subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink