Revert of 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::determineMaximumEffectRect(DetermineMaxEffectRectFlags flags)
+FloatRect FilterEffect::applyEffectBoundaries(const FloatRect& rect) const
 {
-    DCHECK(getFilter());
-    Filter* filter = getFilter();
+    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;
+}
 
-    // Compute the union of the inputs. Always do this because it has
-    // side-effects. (It computes the maximum effect rect of the input.)
-    FloatRect absoluteInputUnion;
-    for (auto& effect : m_inputEffects)
-        absoluteInputUnion.unite(effect->determineMaximumEffectRect(flags));
+FloatRect FilterEffect::determineFilterPrimitiveSubregion(DetermineSubregionFlags flags)
+{
+    Filter* filter = this->getFilter();
+    ASSERT(filter);
 
-    FloatRect absoluteSubregion;
-    switch (getFilterEffectType()) {
-    default:
-        if (m_inputEffects.size()) {
-            absoluteSubregion = absoluteInputUnion;
-            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;
+    // 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();
     }
 
-    if (flags & MapRectForward)
-        absoluteSubregion = mapRect(absoluteSubregion);
+    // 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);
 
     // Clip every filter effect to the filter region.
-    if (flags & ClipToFilterRegion)
+    if (flags & ClipToFilterRegion) {
         absoluteSubregion.intersect(filter->absoluteFilterRegion());
+    }
 
-    m_maxEffectRect = absoluteSubregion;
-    return absoluteSubregion;
+    setMaxEffectRect(absoluteSubregion);
+    return subregion;
 }
 
 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 = getFilter()->mapLocalRectToAbsoluteRect(filterPrimitiveSubregion());
+        FloatRect rect = filterPrimitiveSubregion();
+        rect.scale(getFilter()->scale());
         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