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(

[trchen, 2017/03/30 18:46:40]

This look a lot similar to calculateForegroundClipRectWithGeometryMapper()
below.
Is it possible to extract some common logic to helper functions? Like functions
to map PaintLayer --> PaintPropertyTreeState for different stage, e.g.
pre-overflow-clip, pre-effect, post-effect states.

Doesn't have to be in this CL though. We can land then polish.

[chrishtr, 2017/03/30 23:50:14]

I went ahead and factored out some common code, since it was easy enough.

     const ClipRectsContext& context,
-    bool isForeground,
     ClipRect& output) const {
   DCHECK(m_geometryMapper);
   const auto* properties = m_layer.layoutObject().paintProperties();
+  DCHECK(properties && properties->localBorderBoxProperties());
+
+  PropertyTreeState propertyTreeState = *properties->localBorderBoxProperties();
+  const auto* ancestorProperties =
+      context.rootLayer->layoutObject().paintProperties();
+  DCHECK(ancestorProperties && ancestorProperties->localBorderBoxProperties());
+  PropertyTreeState destinationPropertyTreeState =
+      *ancestorProperties->localBorderBoxProperties();
+  // CSS clip of the root is always applied.
+  if (ancestorProperties->cssClip()) {
+    DCHECK(destinationPropertyTreeState.clip() ==
+           ancestorProperties->cssClip());
+    destinationPropertyTreeState.setClip(
+        ancestorProperties->cssClip()->parent());
+  }
+
+  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());
+  }
+
+  if (shouldClipOverflow(context)) {
+    FloatRect clipRect(localVisualRect());

[trchen, 2017/03/30 18:46:40]

This part still puzzles me. It seems to me the function is supposed to return a
clip rect that is suitable for clipping the stacking context's background phase.
Why should the visual overflow (which is supposed to be clipped by this rect)
take part in computation of this rect? A comment would help the reader to
understand.

[chrishtr, 2017/03/30 23:50:14]

The background phase also paints the visual overflow, including in this CL's
example, software filters. The backgroundRect is clipped to the bounds
of all of these effects, as far as I can tell as a performance optimization.

+    clipRect.moveBy(FloatPoint(m_layer.layoutObject().paintOffset()));
+    m_geometryMapper->sourceToDestinationVisualRect(
+        propertyTreeState, destinationPropertyTreeState, clipRect);
+    output.setRect(FloatClipRect(clipRect));
+  } else {
+    const FloatClipRect& clippedRectInRootLayerSpace =
+        m_geometryMapper->sourceToDestinationClipRect(
+            propertyTreeState, destinationPropertyTreeState);
+    output.setRect(clippedRectInRootLayerSpace);
+  }
+
+  output.moveBy(-context.rootLayer->layoutObject().paintOffset());
+}
+
+void PaintLayerClipper::calculateForegroundClipRectWithGeometryMapper(
+    const ClipRectsContext& context,
+    ClipRect& output) const {
+  DCHECK(m_geometryMapper);
+  const auto* properties = m_layer.layoutObject().paintProperties();
   DCHECK(properties && properties->localBorderBoxProperties());
 
   PropertyTreeState propertyTreeState = *properties->localBorderBoxProperties();
   const auto* ancestorProperties =
       context.rootLayer->layoutObject().paintProperties();
   DCHECK(ancestorProperties && ancestorProperties->localBorderBoxProperties());
   PropertyTreeState destinationPropertyTreeState =
       *ancestorProperties->localBorderBoxProperties();
   // CSS clip of the root is always applied.
   if (ancestorProperties->cssClip()) {
     DCHECK(destinationPropertyTreeState.clip() ==
            ancestorProperties->cssClip());
     destinationPropertyTreeState.setClip(
         ancestorProperties->cssClip()->parent());
   }
 
   if (&m_layer == context.rootLayer) {

[trchen, 2017/03/30 18:46:40]

Not related to this CL. Just taking note to remind myself this juggling looks
puzzling and I can make it cleaner.

[chrishtr, 2017/03/30 23:50:14]

ack

     // Set the overflow clip for |propertyTreeState| so that it differs from
     // |destinationPropertyTreeState| in its clip.
-    if (isForeground && context.respectOverflowClip == RespectOverflowClip &&
+    if (context.respectOverflowClip == RespectOverflowClip &&
         properties->overflowClip())
       propertyTreeState.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())
+    if (properties->overflowClip())
       propertyTreeState.setClip(properties->overflowClip());
   }
 
   const FloatClipRect& clippedRectInRootLayerSpace =
       m_geometryMapper->sourceToDestinationClipRect(
           propertyTreeState, 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