Replace filter outsets with bounds mapping in Blink.

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 1042 matching lines @@
 {
     if (m_shouldIsolateCompositedDescendants == static_cast<unsigned>(shouldIsolateCompositedDescendants))
         return;
 
     m_shouldIsolateCompositedDescendants = shouldIsolateCompositedDescendants;
 
     if (hasCompositedLayerMapping())
         compositedLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateLocal);
 }
 
-bool PaintLayer::hasAncestorWithFilterOutsets() const
+bool PaintLayer::hasAncestorWithFilterThatMovesPixels() const
 {
     for (const PaintLayer* curr = this; curr; curr = curr->parent()) {
-        if (curr->hasFilterOutsets())
+        if (curr->hasFilterThatMovesPixels())
             return true;
     }
     return false;
 }
 
 static void expandClipRectForDescendantsAndReflection(LayoutRect& clipRect, const PaintLayer* layer, const PaintLayer* rootLayer,
     PaintLayer::TransparencyClipBoxBehavior transparencyBehavior, const LayoutSize& subPixelAccumulation, GlobalPaintFlags globalPaintFlags)
 {
     // If we have a mask, then the clip is limited to the border box area (and there is
     // no need to examine child layers).
@@ skipping 37 matching lines @@
 
         delta.move(subPixelAccumulation);
         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(layer);
+        LayoutRect clipRect = layer->physicalBoundingBox(LayoutPoint());
         expandClipRectForDescendantsAndReflection(clipRect, layer, layer, transparencyBehavior, subPixelAccumulation, globalPaintFlags);
-        clipRect.expand(layer->filterOutsets());
-        LayoutRect result = transform.mapRect(clipRect);
+        LayoutRect result = enclosingLayoutRect(transform.mapRect(layer->mapRectForFilter(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->fragmentsBoundingBox(rootLayer);
     expandClipRectForDescendantsAndReflection(clipRect, layer, rootLayer, transparencyBehavior, subPixelAccumulation, globalPaintFlags);
-    clipRect.expand(layer->filterOutsets());
+    clipRect = layer->mapLayoutRectForFilter(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 1057 matching lines @@
         // a recursive computation of stacking children yields no results. This breaks cases when there are stacking
         // 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);
         else
             expandRectForReflectionAndStackingChildren(this, result);
 
         // 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.expand(filterOutsets());
-        }
+        if (paintsWithFilters())
+            result = mapLayoutRectForFilter(result);
     }
 
     if (transform() && paintsWithTransform(GlobalPaintNormalPhase) && (this != ancestorLayer || options == MaybeIncludeTransformForAncestorLayer))
         result = transform()->mapRect(result);
 
     if (enclosingPaginationLayer()) {
         convertFromFlowThreadToVisualBoundingBoxInAncestor(ancestorLayer, result);
         return result;
     }
     LayoutPoint delta;
@@ skipping 465 matching lines @@
 }
 
 FilterEffect* PaintLayer::lastFilterEffect() const
 {
     FilterEffectBuilder* builder = updateFilterEffectBuilder();
     if (!builder)
         return nullptr;
     return builder->lastEffect();
 }
 
-bool PaintLayer::hasFilterOutsets() const
+FloatRect PaintLayer::mapRectForFilter(const FloatRect& rect) const
 {
-    if (!layoutObject()->hasFilterInducingProperty())
+    if (!hasFilterThatMovesPixels())
+        return rect;
+    // Ensure the filter-chain is refreshed wrt reference filters.
+    updateFilterEffectBuilder();
+
+    FilterOperations filterOperations = computeFilterOperations(layoutObject()->styleRef());
+    return filterOperations.mapRect(rect);
+}
+
+LayoutRect PaintLayer::mapLayoutRectForFilter(const LayoutRect& rect) const
+{
+    if (!hasFilterThatMovesPixels())
+        return rect;
+    return enclosingLayoutRect(mapRectForFilter(FloatRect(rect)));
+}
+
+bool PaintLayer::hasFilterThatMovesPixels() const
+{
+    if (!hasFilterInducingProperty())
         return false;
     const ComputedStyle& style = layoutObject()->styleRef();
-    if (style.hasFilter() && style.filter().hasOutsets())
+    if (style.hasFilter() && style.filter().hasFilterThatMovesPixels())
         return true;
     if (RuntimeEnabledFeatures::cssBoxReflectFilterEnabled() && style.hasBoxReflect())
         return true;
     return false;
 }
 
-FilterOutsets PaintLayer::filterOutsets() const
-{
-    if (!layoutObject()->hasFilterInducingProperty())
-        return FilterOutsets();
-
-    // Ensure the filter-chain is refreshed wrt reference filters.
-    updateFilterEffectBuilder();
-
-    return layoutObject()->style()->filter().outsets();
-}
-
 void PaintLayer::updateOrRemoveFilterEffectBuilder()
 {
     // FilterEffectBuilder is only used to render the filters in software mode,
     // so we always need to run updateOrRemoveFilterEffectBuilder after the composited
     // mode might have changed for this layer.
     if (!paintsWithFilters()) {
         // Don't delete the whole filter info here, because we might use it
         // for loading CSS shader files.
         if (PaintLayerFilterInfo* filterInfo = this->filterInfo())
             filterInfo->setBuilder(nullptr);
@@ skipping 134 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif