Turn FilterEffectBuilder into a stack-allocated helper

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 2362 matching lines @@
 }
 
 void PaintLayer::ensureCompositedLayerMapping()
 {
     if (m_rareData && m_rareData->compositedLayerMapping)
         return;
 
     ensureRareData().compositedLayerMapping = wrapUnique(new CompositedLayerMapping(*this));
     m_rareData->compositedLayerMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
 
-    updateOrRemoveFilterEffectBuilder();
+    updateOrRemoveFilterEffect();
 }
 
 void PaintLayer::clearCompositedLayerMapping(bool layerBeingDestroyed)
 {
     if (!layerBeingDestroyed) {
         // We need to make sure our decendants get a geometry update. In principle,
         // we could call setNeedsGraphicsLayerUpdate on our children, but that would
         // require walking the z-order lists to find them. Instead, we over-invalidate
         // by marking our parent as needing a geometry update.
         if (PaintLayer* compositingParent = enclosingLayerWithCompositedLayerMapping(ExcludeSelf))
             compositingParent->compositedLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
     }
 
     if (m_rareData)
         m_rareData->compositedLayerMapping.reset();
 
     if (!layerBeingDestroyed)
-        updateOrRemoveFilterEffectBuilder();
+        updateOrRemoveFilterEffect();
 }
 
 void PaintLayer::setGroupedMapping(CompositedLayerMapping* groupedMapping, SetGroupMappingOptions options)
 {
     CompositedLayerMapping* oldGroupedMapping = this->groupedMapping();
     if (groupedMapping == oldGroupedMapping)
         return;
 
     if (options == InvalidateLayerAndRemoveFromMapping && oldGroupedMapping) {
         oldGroupedMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
@@ skipping 163 matching lines @@
 
     return hasBoxDecorationsOrBackground() || hasOverflowControls();
 }
 
 void PaintLayer::updateFilters(const ComputedStyle* oldStyle, const ComputedStyle& newStyle)
 {
     if (!newStyle.hasFilterInducingProperty() && (!oldStyle || !oldStyle->hasFilterInducingProperty()))
         return;
 
     updateOrRemoveFilterClients();
-    updateOrRemoveFilterEffectBuilder();
+    updateOrRemoveFilterEffect();
 }
 
 bool PaintLayer::attemptDirectCompositingUpdate(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     CompositingReasons oldPotentialCompositingReasonsFromStyle = potentialCompositingReasonsFromStyle();
     compositor()->updatePotentialCompositingReasonsFromStyle(this);
 
     // This function implements an optimization for transforms and opacity.
     // A common pattern is for a touchmove handler to update the transform
     // and/or an opacity of an element every frame while the user moves their
@@ skipping 88 matching lines @@
 bool PaintLayer::scrollsOverflow() const
 {
     if (PaintLayerScrollableArea* scrollableArea = this->getScrollableArea())
         return scrollableArea->scrollsOverflow();
 
     return false;
 }
 
 namespace {
 
-FilterOperations resolveReferenceFilters(
-    const FilterOperations& filters, float effectiveZoom, Element& element, const FloatRect& zoomedReferenceBox)
+FilterOperations resolveReferenceFilters(const FilterEffectBuilder& builder, const FilterOperations& filters)
 {
     DCHECK(filters.hasReferenceFilter());
 
     for (FilterOperation* filterOperation : filters.operations()) {
         if (filterOperation->type() != FilterOperation::REFERENCE)
             continue;
         ReferenceFilterOperation& referenceOperation = toReferenceFilterOperation(*filterOperation);
         // TODO(fs): Cache the Filter if it didn't change.
-        Filter* referenceFilter = FilterEffectBuilder::buildReferenceFilter(referenceOperation, zoomedReferenceBox, nullptr, nullptr, element, nullptr, effectiveZoom);
-        referenceOperation.setFilter(referenceFilter);
+        referenceOperation.setFilter(builder.buildReferenceFilter(referenceOperation));
     }
     return filters;
 }
 
 } // unnamed namespace
 
 FilterOperations PaintLayer::addReflectionToFilterOperations(const ComputedStyle& style) const
 {
     FilterOperations filterOperations = style.filter();
     if (RuntimeEnabledFeatures::cssBoxReflectFilterEnabled() && layoutObject()->hasReflection() && layoutObject()->isBox()) {
         BoxReflection reflection = boxReflectionForPaintLayer(*this, style);
         filterOperations.operations().append(BoxReflectFilterOperation::create(reflection));
     }
     return filterOperations;
 }
 
 CompositorFilterOperations PaintLayer::createCompositorFilterOperationsForFilter(const ComputedStyle& style)
 {
     FilterOperations filterOperations = addReflectionToFilterOperations(style);
-    if (filterOperations.hasReferenceFilter())
-        filterOperations = resolveReferenceFilters(filterOperations, style.effectiveZoom(), toElement(*enclosingNode()), boxForFilter());
+    if (filterOperations.hasReferenceFilter()) {
+        FilterEffectBuilder builder(toElement(enclosingNode()), boxForFilter(), style.effectiveZoom());
+        filterOperations = resolveReferenceFilters(builder, filterOperations);
+    }
     return SkiaImageFilterBuilder::buildFilterOperations(filterOperations);
 }
 
 CompositorFilterOperations PaintLayer::createCompositorFilterOperationsForBackdropFilter(const ComputedStyle& style)
 {
     FilterOperations operations = style.backdropFilter();
-    if (operations.hasReferenceFilter())
-        operations = resolveReferenceFilters(operations, style.effectiveZoom(), toElement(*enclosingNode()), boxForFilter());
+    if (operations.hasReferenceFilter()) {
+        FilterEffectBuilder builder(toElement(enclosingNode()), boxForFilter(), style.effectiveZoom());
+        operations = resolveReferenceFilters(builder, operations);
+    }
     return SkiaImageFilterBuilder::buildFilterOperations(operations);
 }
 
 PaintLayerFilterInfo& PaintLayer::ensureFilterInfo()
 {
     PaintLayerRareData& rareData = ensureRareData();
     if (!rareData.filterInfo)
         rareData.filterInfo = new PaintLayerFilterInfo(this);
     return *rareData.filterInfo;
 }
@@ skipping 21 matching lines @@
     if (filter.isEmpty() && m_rareData && m_rareData->filterInfo) {
         m_rareData->filterInfo->clearLayer();
         m_rareData->filterInfo = nullptr;
     } else if (filter.hasReferenceFilter()) {
         ensureFilterInfo().updateReferenceFilterClients(filter);
     } else if (filterInfo()) {
         filterInfo()->clearFilterReferences();
     }
 }
 
-FilterEffectBuilder* PaintLayer::updateFilterEffectBuilder() const
+FilterEffect* PaintLayer::updateFilterEffect() 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().
+    // Should have been added by updateOrRemoveFilterEffect().
     ASSERT(filterInfo);
 
-    if (filterInfo->builder())
-        return filterInfo->builder();
-
-    filterInfo->setBuilder(FilterEffectBuilder::create());
+    if (filterInfo->lastEffect())
+        return filterInfo->lastEffect();
 
     const ComputedStyle& style = layoutObject()->styleRef();
-    Element* element = toElement(enclosingNode());
+    const bool hasReferenceFilter = style.filter().hasReferenceFilter();
+    FloatRect zoomedReferenceBox;
+    if (hasReferenceFilter)
+        zoomedReferenceBox = boxForFilter();
+
     FilterOperations operations = addReflectionToFilterOperations(style);
-    FloatRect zoomedReferenceBox;
-    if (style.filter().hasReferenceFilter()) {
-        zoomedReferenceBox = boxForFilter();
-        operations = resolveReferenceFilters(operations, style.effectiveZoom(), *element, zoomedReferenceBox);
-    }
-    if (!filterInfo->builder()->build(element, operations, style.effectiveZoom(), zoomedReferenceBox))
-        filterInfo->setBuilder(nullptr);
+    FilterEffectBuilder builder(toElement(enclosingNode()), zoomedReferenceBox, style.effectiveZoom());
+    if (hasReferenceFilter)
+        operations = resolveReferenceFilters(builder, operations);
 
-    return filterInfo->builder();
+    filterInfo->setLastEffect(builder.buildFilterEffect(operations));
+    return filterInfo->lastEffect();
 }
 
 FilterEffect* PaintLayer::lastFilterEffect() const
 {
-    FilterEffectBuilder* builder = updateFilterEffectBuilder();
-    if (!builder)
-        return nullptr;
-    return builder->lastEffect();
+    return updateFilterEffect();
 }
 
 FloatRect PaintLayer::mapRectForFilter(const FloatRect& rect) const
 {
     if (!hasFilterThatMovesPixels())
         return rect;
 
     // Ensure the filter-chain is refreshed wrt reference filters.
-    updateFilterEffectBuilder();
+    updateFilterEffect();
 
     FilterOperations filterOperations = addReflectionToFilterOperations(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().hasFilterThatMovesPixels())
         return true;
     if (RuntimeEnabledFeatures::cssBoxReflectFilterEnabled() && style.hasBoxReflect())
         return true;
     return false;
 }
 
-void PaintLayer::updateOrRemoveFilterEffectBuilder()
+void PaintLayer::updateOrRemoveFilterEffect()
 {
     // FilterEffectBuilder is only used to render the filters in software mode,
-    // so we always need to run updateOrRemoveFilterEffectBuilder after the composited
+    // so we always need to run updateOrRemoveFilterEffect 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);
-
+            filterInfo->setLastEffect(nullptr);
         return;
     }
 
-    ensureFilterInfo().setBuilder(nullptr);
+    ensureFilterInfo().setLastEffect(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 right before performing layout but
         // after style recalc.
         //
@@ skipping 136 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif