Fix the reference box computation for CSS filter effects.

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 1043 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(layer);
         expandClipRectForDescendantsAndReflection(clipRect, layer, layer, transparencyBehavior, subPixelAccumulation, globalPaintFlags);
-        clipRect.expand(layer->layoutObject()->style()->filterOutsets());
+        clipRect.expand(layer->filterOutsets());
         LayoutRect result = transform.mapRect(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->layoutObject()->style()->filterOutsets());
+    clipRect.expand(layer->filterOutsets());
     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 1094 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);
         else
             expandRectForReflectionAndStackingChildren(this, result);
 
         // FIXME: We can optimize the size of the composited layers, by not enlarging
         // filtered areas with the outsets if we know that the filter is going to render in hardware.
         // https://bugs.webkit.org/show_bug.cgi?id=81239
-        result.expand(m_layoutObject->style()->filterOutsets());
+        result.expand(filterOutsets());
     }
 
     if (transform() && paintsWithTransform(GlobalPaintNormalPhase) && (this != ancestorLayer || options == MaybeIncludeTransformForAncestorLayer))
         result = transform()->mapRect(result);
 
     if (enclosingPaginationLayer()) {
         convertFromFlowThreadToVisualBoundingBoxInAncestor(this, ancestorLayer, result);
         return result;
     }
     LayoutPoint delta;
@@ skipping 357 matching lines @@
             RefPtrWillBeRawPtr<Filter> referenceFilter = ReferenceFilterBuilder::build(effectiveZoom, toElement(enclosingElement), nullptr, referenceOperation);
             referenceOperation.setFilter(referenceFilter.release());
         }
     }
 
     return filters;
 }
 
 } // unnamed namespace
 
-FilterOperations PaintLayer::computeFilterOperations(const ComputedStyle& style)
+FilterOperations PaintLayer::computeFilterOperations(const ComputedStyle& style) const
 {
     return computeFilterOperationsHandleReferenceFilters(style.filter(), style.effectiveZoom(), enclosingElement());
 }
 
-FilterOperations PaintLayer::computeBackdropFilterOperations(const ComputedStyle& style)
+FilterOperations PaintLayer::computeBackdropFilterOperations(const ComputedStyle& style) const
 {
     return computeFilterOperationsHandleReferenceFilters(style.backdropFilter(), style.effectiveZoom(), enclosingElement());
 }
 
 void PaintLayer::updateOrRemoveFilterClients()
 {
     if (!hasFilter()) {
         removeFilterInfoIfNeeded();
         return;
     }
 
     if (layoutObject()->style()->filter().hasReferenceFilter())
         ensureFilterInfo()->updateReferenceFilterClients(layoutObject()->style()->filter());
     else if (hasFilterInfo())
         filterInfo()->removeReferenceFilterClients();
 }
 
+FilterEffectBuilder* PaintLayer::updateFilterEffectBuilder() const
+{
+    // TODO(chrishtr): ensure (and assert) that compositing is clean here.
+
+    if (!paintsWithFilters())
+        return nullptr;
+
+    PaintLayerFilterInfo* filterInfo = this->filterInfo();
+
+    // Should have been added by updateOrRemoveFilterEffectBuilder().
+    ASSERT(filterInfo);
+
+    if (filterInfo->builder())
+        return filterInfo->builder();
+
+    filterInfo->setBuilder(FilterEffectBuilder::create());
+
+    float zoom = layoutObject()->style() ? layoutObject()->style()->effectiveZoom() : 1.0f;
+    if (!filterInfo->builder()->build(toElement(enclosingElement()), computeFilterOperations(layoutObject()->styleRef()), zoom))
+        filterInfo->setBuilder(nullptr);
+
+    return filterInfo->builder();
+}
+
+FilterEffect* PaintLayer::lastFilterEffect() const
+{
+    FilterEffectBuilder* builder = updateFilterEffectBuilder();
+    if (!builder)
+        return nullptr;
+    return builder->lastEffect().get();
+}
+
+FilterOutsets PaintLayer::filterOutsets() const
+{
+    if (!layoutObject()->hasFilter())
+        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);
 
         return;
     }
 
-    PaintLayerFilterInfo* filterInfo = ensureFilterInfo();
-    if (!filterInfo->builder())
-        filterInfo->setBuilder(FilterEffectBuilder::create());
-
-    // If the filter fails to build, remove it from the layer. It will still attempt to
-    // go through regular processing (e.g. compositing), but never apply anything.
-    float zoom = layoutObject()->style() ? layoutObject()->style()->effectiveZoom() : 1.0f;
-    if (!filterInfo->builder()->build(toElement(enclosingElement()), computeFilterOperations(layoutObject()->styleRef()), zoom))
-        filterInfo->setBuilder(nullptr);
+    ensureFilterInfo()->setBuilder(nullptr);
 }
 
 void PaintLayer::filterNeedsPaintInvalidation()
 {
     {
         DeprecatedScheduleStyleRecalcDuringLayout marker(layoutObject()->document().lifecycle());
         // It's possible for scheduleSVGFilterLayerUpdateHack to schedule a style recalc, which
         // is a problem because this function can be called while performing layout.
         // Presumably this represents an illegal data flow of layout or compositing
         // information into the style system.
@@ skipping 106 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif