Revamp filter primitive region calculations for Filter Effects

third_party/WebKit/Source/platform/graphics/filters/FilterEffect.cpp

 /*
  * Copyright (C) 2008 Alex Mathews <possessedpenguinbob@gmail.com>
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  * Copyright (C) 2012 University of Szeged
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 15 matching lines @@
 #include "platform/graphics/filters/Filter.h"
 #include "platform/graphics/filters/SkiaImageFilterBuilder.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h"
 #include "third_party/skia/include/effects/SkPictureImageFilter.h"
 
 namespace blink {
 
 FilterEffect::FilterEffect(Filter* filter)
     : m_filter(filter)
-    , m_hasX(false)
-    , m_hasY(false)
-    , m_hasWidth(false)
-    , m_hasHeight(false)
     , m_clipsToBounds(true)
     , m_originTainted(false)
     , m_operatingColorSpace(ColorSpaceLinearRGB)
 {
     ASSERT(m_filter);
 }
 
 FilterEffect::~FilterEffect()
 {
 }
@@ skipping 76 matching lines @@
     return ColorSpaceUtilities::convertColor(deviceColor, operatingColorSpace());
 }
 
 TextStream& FilterEffect::externalRepresentation(TextStream& ts, int) const
 {
     // FIXME: We should dump the subRegions of the filter primitives here later. This isn't
     // possible at the moment, because we need more detailed informations from the target object.
     return ts;
 }
 
-FloatRect FilterEffect::applyEffectBoundaries(const FloatRect& rect) const
+FloatRect FilterEffect::determineMaximumEffectRect(DetermineMaxEffectRectFlags flags)
 {
-    FloatRect clippedRect = rect;
-    if (hasX())
-        clippedRect.setX(effectBoundaries().x());
-    if (hasY())
-        clippedRect.setY(effectBoundaries().y());
-    if (hasWidth())
-        clippedRect.setWidth(effectBoundaries().width());
-    if (hasHeight())
-        clippedRect.setHeight(effectBoundaries().height());
-    return clippedRect;
-}
+    DCHECK(getFilter());
+    Filter* filter = getFilter();
 
-FloatRect FilterEffect::determineFilterPrimitiveSubregion(DetermineSubregionFlags flags)
-{
-    Filter* filter = this->getFilter();
-    ASSERT(filter);
+    // Compute the union of the inputs. Always do this because it has
+    // side-effects. (It computes the maximum effect rect of the input.)
+    FloatRect inputUnion;

[pdr., 2016/09/03 04:50:03]

Nit: absoluteInputUnion?

[fs, 2016/09/04 09:34:24]

Done.

+    for (auto& effect : m_inputEffects)
+        inputUnion.unite(effect->determineMaximumEffectRect(flags));
 
-    // FETile, FETurbulence, FEFlood don't have input effects, take the filter region as unite rect.
-    FloatRect subregion;
-    if (unsigned numberOfInputEffects = inputEffects().size()) {
-        subregion = inputEffect(0)->determineFilterPrimitiveSubregion(flags);
-        for (unsigned i = 1; i < numberOfInputEffects; ++i)
-            subregion.unite(inputEffect(i)->determineFilterPrimitiveSubregion(flags));
-    } else {
-        subregion = filter->filterRegion();
+    FloatRect absoluteSubregion;
+    switch (getFilterEffectType()) {
+    default:
+        if (m_inputEffects.size()) {
+            absoluteSubregion = inputUnion;
+            if (clipsToBounds())
+                absoluteSubregion.intersect(filter->mapLocalRectToAbsoluteRect(filterPrimitiveSubregion()));
+            break;
+        }
+        // Else fall-through and use the primitive region. (FETurbulence/FEFlood/FEImage)
+    case FilterEffectTypeTile:
+        absoluteSubregion = filter->mapLocalRectToAbsoluteRect(filterPrimitiveSubregion());
+        break;
+    case FilterEffectTypeSourceInput:
+        absoluteSubregion = filter->absoluteFilterRegion();
+        break;
     }
 
-    // After calling determineFilterPrimitiveSubregion on the target effect, reset the subregion again for <feTile>.
-    if (getFilterEffectType() == FilterEffectTypeTile)
-        subregion = filter->filterRegion();
-
-    if (flags & MapRectForward) {
-        // mapRect works on absolute rectangles.
-        subregion = filter->mapAbsoluteRectToLocalRect(mapRect(
-            filter->mapLocalRectToAbsoluteRect(subregion)));
-    }
-
-    subregion = applyEffectBoundaries(subregion);
-
-    setFilterPrimitiveSubregion(subregion);
-
-    FloatRect absoluteSubregion = filter->mapLocalRectToAbsoluteRect(subregion);
+    if (flags & MapRectForward)
+        absoluteSubregion = mapRect(absoluteSubregion);
 
     // Clip every filter effect to the filter region.
-    if (flags & ClipToFilterRegion) {
+    if (flags & ClipToFilterRegion)
         absoluteSubregion.intersect(filter->absoluteFilterRegion());
-    }
 
-    setMaxEffectRect(absoluteSubregion);
-    return subregion;
+    m_maxEffectRect = absoluteSubregion;

[pdr., 2016/09/03 04:50:03]

(Not for this patch, possibly one of the pessimizations :)
It seems brittle that we rely on determineMaximumEffectRect being called before
maxEffectRect is used, and that the determined max effect rect type (forward,
clip, etc) happens to be what the maxEffectRect caller wants. And... yeah.

[fs, 2016/09/04 09:34:24]

Yeah...

+    return absoluteSubregion;
 }
 
 sk_sp<SkImageFilter> FilterEffect::createImageFilter()
 {
     return nullptr;
 }
 
 sk_sp<SkImageFilter> FilterEffect::createImageFilterWithoutValidation()
 {
     return createImageFilter();
@@ skipping 11 matching lines @@
 sk_sp<SkImageFilter> FilterEffect::createTransparentBlack() const
 {
     SkImageFilter::CropRect rect = getCropRect();
     sk_sp<SkColorFilter> colorFilter = SkColorFilter::MakeModeFilter(0, SkXfermode::kClear_Mode);
     return SkColorFilterImageFilter::Make(std::move(colorFilter), nullptr, &rect);
 }
 
 SkImageFilter::CropRect FilterEffect::getCropRect() const
 {
     if (!filterPrimitiveSubregion().isEmpty()) {
-        FloatRect rect = filterPrimitiveSubregion();
-        rect.scale(getFilter()->scale());
+        FloatRect rect = getFilter()->mapLocalRectToAbsoluteRect(filterPrimitiveSubregion());
         return SkImageFilter::CropRect(rect);
     } else {
         return SkImageFilter::CropRect(SkRect::MakeEmpty(), 0);
     }
 }
 
 static int getImageFilterIndex(ColorSpace colorSpace, bool requiresPMColorValidation)
 {
     // Map the (colorspace, bool) tuple to an integer index as follows:
     // 0 == linear colorspace, no PM validation
     // 1 == device colorspace, no PM validation
     // 2 == linear colorspace, PM validation
     // 3 == device colorspace, PM validation
     return (colorSpace == ColorSpaceLinearRGB ? 0x1 : 0x0) | (requiresPMColorValidation ? 0x2 : 0x0);
 }
 
 SkImageFilter* FilterEffect::getImageFilter(ColorSpace colorSpace, bool requiresPMColorValidation) const
 {
     int index = getImageFilterIndex(colorSpace, requiresPMColorValidation);
     return m_imageFilters[index].get();
 }
 
 void FilterEffect::setImageFilter(ColorSpace colorSpace, bool requiresPMColorValidation, sk_sp<SkImageFilter> imageFilter)
 {
     int index = getImageFilterIndex(colorSpace, requiresPMColorValidation);
     m_imageFilters[index] = std::move(imageFilter);
 }
 
 } // namespace blink