Let clients of FilterEffectBuilder compute/provide the reference-box

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 2056 matching lines @@
             if (!result.hitTestRequest().listBased())
                 result = tempResult;
             if (!depthSortDescendants)
                 break;
         }
     }
 
     return resultLayer;
 }
 
+FloatRect PaintLayer::boxForFilter() const
+{
+    return FloatRect(physicalBoundingBoxIncludingReflectionAndStackingChildren(
+        LayoutPoint(), PaintLayer::CalculateBoundsOptions::IncludeTransformsAndCompositedChildLayers));
+}
+
 LayoutRect PaintLayer::boxForClipPath() const
 {
     if (!layoutObject()->isBox()) {
         SECURITY_DCHECK(layoutObject()->isLayoutInline());
         const LayoutInline& layoutInline = toLayoutInline(*layoutObject());
         // This somewhat convoluted computation matches what Gecko does.
         // See crbug.com/641907.
         LayoutRect inlineBBox = layoutInline.linesBoundingBox();
         const InlineFlowBox* flowBox = layoutInline.firstLineBox();
         inlineBBox.setHeight(flowBox ? flowBox->frameRect().height() : LayoutUnit(0));
@@ skipping 591 matching lines @@
 bool PaintLayer::scrollsOverflow() const
 {
     if (PaintLayerScrollableArea* scrollableArea = this->getScrollableArea())
         return scrollableArea->scrollsOverflow();
 
     return false;
 }
 
 namespace {
 
-FilterOperations resolveReferenceFilters(const FilterOperations& filters, float effectiveZoom, Node* enclosingNode)
+FilterOperations resolveReferenceFilters(
+    const FilterOperations& filters, float effectiveZoom, Element& element, const FloatRect& zoomedReferenceBox)
 {
-    if (filters.hasReferenceFilter()) {
-        for (size_t i = 0; i < filters.size(); ++i) {
-            FilterOperation* filterOperation = filters.operations().at(i).get();
-            if (filterOperation->type() != FilterOperation::REFERENCE)
-                continue;
-            ReferenceFilterOperation& referenceOperation = toReferenceFilterOperation(*filterOperation);
-            // FIXME: Cache the Filter if it didn't change.
-            Filter* referenceFilter = FilterEffectBuilder::buildReferenceFilter(referenceOperation, nullptr, nullptr, nullptr, *toElement(enclosingNode), nullptr, effectiveZoom);
-            referenceOperation.setFilter(referenceFilter);
-        }
+    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);
     }
     return filters;
 }
 
 } // unnamed namespace
 
-FilterOperations PaintLayer::computeFilterOperations(const ComputedStyle& style) const
+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 resolveReferenceFilters(filterOperations, style.effectiveZoom(), enclosingNode());
+    return filterOperations;
 }
 
 CompositorFilterOperations PaintLayer::createCompositorFilterOperationsForFilter(const ComputedStyle& style)
 {
-    return SkiaImageFilterBuilder::buildFilterOperations(computeFilterOperations(style));
+    FilterOperations filterOperations = addReflectionToFilterOperations(style);
+    if (filterOperations.hasReferenceFilter())
+        filterOperations = resolveReferenceFilters(filterOperations, style.effectiveZoom(), toElement(*enclosingNode()), boxForFilter());
+    return SkiaImageFilterBuilder::buildFilterOperations(filterOperations);
 }
 
 CompositorFilterOperations PaintLayer::createCompositorFilterOperationsForBackdropFilter(const ComputedStyle& style)
 {
-    FilterOperations operations = resolveReferenceFilters(style.backdropFilter(), style.effectiveZoom(), enclosingNode());
+    FilterOperations operations = style.backdropFilter();
+    if (operations.hasReferenceFilter())
+        operations = resolveReferenceFilters(operations, style.effectiveZoom(), toElement(*enclosingNode()), boxForFilter());
     return SkiaImageFilterBuilder::buildFilterOperations(operations);
 }
 
 PaintLayerFilterInfo& PaintLayer::ensureFilterInfo()
 {
     PaintLayerRareData& rareData = ensureRareData();
     if (!rareData.filterInfo)
         rareData.filterInfo = new PaintLayerFilterInfo(this);
     return *rareData.filterInfo;
 }
@@ skipping 39 matching lines @@
 
     // Should have been added by updateOrRemoveFilterEffectBuilder().
     ASSERT(filterInfo);
 
     if (filterInfo->builder())
         return filterInfo->builder();
 
     filterInfo->setBuilder(FilterEffectBuilder::create());
 
     const ComputedStyle& style = layoutObject()->styleRef();
-    if (!filterInfo->builder()->build(toElement(enclosingNode()), computeFilterOperations(style), style.effectiveZoom()))
+    Element* element = toElement(enclosingNode());
+    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);
 
     return filterInfo->builder();
 }
 
 FilterEffect* PaintLayer::lastFilterEffect() const
 {
     FilterEffectBuilder* builder = updateFilterEffectBuilder();
     if (!builder)
         return nullptr;
     return builder->lastEffect();
 }
 
 FloatRect PaintLayer::mapRectForFilter(const FloatRect& rect) const
 {
     if (!hasFilterThatMovesPixels())
         return rect;
+
     // Ensure the filter-chain is refreshed wrt reference filters.
     updateFilterEffectBuilder();
 
-    FilterOperations filterOperations = computeFilterOperations(layoutObject()->styleRef());
+    FilterOperations filterOperations = addReflectionToFilterOperations(layoutObject()->styleRef());

[Stephen White, 2016/09/16 19:14:23]

Isn't this already handled by the call to updateFilterEffectBuilder() call on
L2821? It now seems to call addReflectionToFilterOperations().

[Stephen White, 2016/09/16 19:16:54]

Oh, I see now that the computed filter operations aren't retained. Never mind.

[fs, 2016/09/16 19:20:37]

It isn't handled because there (in updateFilterEffectBuilder) we make a copy of
the Vector (FilterOperations) that we then build the FilterEffect chain from. So
because of that copy we have to start afresh here and re-add the reflection
filter. All very roundabout this, and I hope I'll be able to simplify it in
future CLs.

     return filterOperations.mapRect(rect);
 }
 
 LayoutRect PaintLayer::mapLayoutRectForFilter(const LayoutRect& rect) const
 {
     if (!hasFilterThatMovesPixels())
         return rect;
     return enclosingLayoutRect(mapRectForFilter(FloatRect(rect)));
 }
 
@@ skipping 173 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif