Include filter-generated content bounds in visual rects

third_party/WebKit/Source/core/paint/PaintLayer.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>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 1088 matching lines @@
         IntPoint pixelSnappedDelta = roundedIntPoint(delta);
         TransformationMatrix transform;
         transform.translate(pixelSnappedDelta.x(), pixelSnappedDelta.y());
         if (layer->transform())
             transform = transform * *layer->transform();
 
         // We don't use fragment boxes when collecting a transformed layer's bounding box, since it always
         // paints unfragmented.
         LayoutRect clipRect = layer->physicalBoundingBox(LayoutPoint());
         expandClipRectForDescendantsAndReflection(clipRect, layer, layer, transparencyBehavior, subPixelAccumulation, globalPaintFlags);
-        LayoutRect result = enclosingLayoutRect(transform.mapRect(layer->mapRectForFilter(FloatRect(clipRect))));
+        LayoutRect result = enclosingLayoutRect(transform.mapRect(layer->mapRectToAffectedFilterRegion(FloatRect(clipRect))));
         if (!paginationLayer)
             return result;
 
         // We have to break up the transformed extent across our columns.
         // Split our box up into the actual fragment boxes that layout in the columns/pages and unite those together to
         // get our true bounding box.
         LayoutFlowThread* enclosingFlowThread = toLayoutFlowThread(paginationLayer->layoutObject());
         result = enclosingFlowThread->fragmentsBoundingBox(result);
 
         LayoutPoint rootLayerDelta;
         paginationLayer->convertToLayerCoords(rootLayer, rootLayerDelta);
         result.moveBy(rootLayerDelta);
         return result;
     }
 
     LayoutRect clipRect = layer->shouldFragmentCompositedBounds(rootLayer) ? layer->fragmentsBoundingBox(rootLayer) : layer->physicalBoundingBox(rootLayer);
     expandClipRectForDescendantsAndReflection(clipRect, layer, rootLayer, transparencyBehavior, subPixelAccumulation, globalPaintFlags);
-    clipRect = layer->mapLayoutRectForFilter(clipRect);
+    clipRect = layer->mapLayoutRectToAffectedFilterRegion(clipRect);
     clipRect.move(subPixelAccumulation);
     return clipRect;
 }
 
 LayoutRect PaintLayer::paintingExtent(const PaintLayer* rootLayer, const LayoutSize& subPixelAccumulation, GlobalPaintFlags globalPaintFlags)
 {
     return transparencyClipBox(this, rootLayer, PaintingTransparencyClipBox, RootOfTransparencyClipBox, subPixelAccumulation, globalPaintFlags);
 }
 
 void* PaintLayer::operator new(size_t sz)
@@ skipping 1105 matching lines @@
         // children of the parent, that need to be included in reflected composited bounds.
         // Fix this by including composited bounds of stacking children of the reflected Layer.
         if (hasCompositedLayerMapping() && parent() && parent()->reflectionInfo() && parent()->reflectionInfo()->reflectionLayer() == this)
             expandRectForReflectionAndStackingChildren(parent(), result, options);
         else
             expandRectForReflectionAndStackingChildren(this, result, options);
 
         // Only enlarge by the filter outsets if we know the filter is going to be rendered in software.
         // Accelerated filters will handle their own outsets.
         if (paintsWithFilters())
-            result = mapLayoutRectForFilter(result);
+            result = mapLayoutRectToAffectedFilterRegion(result);
     }
 
     if (transform() && (options == IncludeTransformsAndCompositedChildLayers || ((paintsWithTransform(GlobalPaintNormalPhase) && (this != ancestorLayer || options == MaybeIncludeTransformForAncestorLayer)))))
         result = transform()->mapRect(result);
 
     if (shouldFragmentCompositedBounds(ancestorLayer)) {
         convertFromFlowThreadToVisualBoundingBoxInAncestor(ancestorLayer, result);
         return result;
     }
     LayoutPoint delta;
@@ skipping 470 matching lines @@
 }
 
 FilterEffect* PaintLayer::lastFilterEffect() const
 {
     FilterEffectBuilder* builder = updateFilterEffectBuilder();
     if (!builder)
         return nullptr;
     return builder->lastEffect();
 }
 
-FloatRect PaintLayer::mapRectForFilter(const FloatRect& rect) const
+FloatRect PaintLayer::mapRectToAffectedFilterRegion(const FloatRect& rect) const
 {
     if (!hasFilterThatMovesPixels())
         return rect;
     // Ensure the filter-chain is refreshed wrt reference filters.
     updateFilterEffectBuilder();
 
     FilterOperations filterOperations = computeFilterOperations(layoutObject()->styleRef());
-    return filterOperations.mapRect(rect);
+    FloatRect filteredRect = filterOperations.mapRect(rect);
+
+    // Some reference filters (e.g., FETurbulence, FETile) have effect bounds
+    // determined by the filter itself instead of the source rect.
+    if (filterOperations.hasReferenceFilter()) {
+        if (FilterEffect* lastEffect = lastFilterEffect())
+            filteredRect.unite(lastEffect->determineFilterPrimitiveSubregion(MapRectForward));

[Stephen White, 2016/08/25 15:03:14]

I think this is papering over the problem. I think the real problem is that we
need to expose a flavour of FilterOperations::mapRect() which calls
FilterEffect::mapPaintRect().

See the comment here, which explicitly calls out tile and displacement map:

https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/graph...

OTOH, it would be nice if we could unite FilterEffect::mapRect() and
FilterEffect::mapPaintRect(). The latter was added by someone other than me, and
we should figure out what the differences really are for the paint case and why
they don't apply to the other cases. That's not clear to me.

Also, jbroman@ should probably take a look at this.

[pdr., 2016/08/29 17:51:12]

I've filed https://crbug.com/642035 as a brain-dump of my findings in this
patch. We do need to combine mapRect and mapPaintRect and use the result in
PaintLayer::mapRectForFilter, but this is a large project.

+    }
+
+    return filteredRect;
 }
 
-LayoutRect PaintLayer::mapLayoutRectForFilter(const LayoutRect& rect) const
+LayoutRect PaintLayer::mapLayoutRectToAffectedFilterRegion(const LayoutRect& rect) const
 {
     if (!hasFilterThatMovesPixels())
         return rect;
-    return enclosingLayoutRect(mapRectForFilter(FloatRect(rect)));
+    return enclosingLayoutRect(mapRectToAffectedFilterRegion(FloatRect(rect)));
 }
 
 bool PaintLayer::hasFilterThatMovesPixels() const
 {
     if (!hasFilterInducingProperty())
         return false;
     const ComputedStyle& style = layoutObject()->styleRef();
     if (style.hasFilter() && style.filter().hasFilterThatMovesPixels())
         return true;
     if (RuntimeEnabledFeatures::cssBoxReflectFilterEnabled() && style.hasBoxReflect())
@@ skipping 165 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif