Move application of filter effect boundaries to a helper

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 117 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 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;
+}
+
 FloatRect FilterEffect::determineFilterPrimitiveSubregion(DetermineSubregionFlags flags)
 {
     Filter* filter = this->filter();
     ASSERT(filter);
 
     // 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();
     }
 
     // After calling determineFilterPrimitiveSubregion on the target effect, reset the subregion again for <feTile>.
     if (filterEffectType() == FilterEffectTypeTile)
         subregion = filter->filterRegion();
 
     if (flags & MapRectForward) {
         // mapRect works on absolute rectangles.
         subregion = filter->mapAbsoluteRectToLocalRect(mapRect(
             filter->mapLocalRectToAbsoluteRect(subregion)));
     }
 
-    FloatRect boundaries = effectBoundaries();
-    if (hasX())
-        subregion.setX(boundaries.x());
-    if (hasY())
-        subregion.setY(boundaries.y());
-    if (hasWidth())
-        subregion.setWidth(boundaries.width());
-    if (hasHeight())
-        subregion.setHeight(boundaries.height());
+    subregion = applyEffectBoundaries(subregion);
 
     setFilterPrimitiveSubregion(subregion);
 
     FloatRect absoluteSubregion = filter->mapLocalRectToAbsoluteRect(subregion);
 
     // Clip every filter effect to the filter region.
     if (flags & ClipToFilterRegion) {
         absoluteSubregion.intersect(filter->absoluteFilterRegion());
     }
 
@@ skipping 28 matching lines @@
     return false;
 }
 
 SkImageFilter::CropRect FilterEffect::getCropRect(const FloatSize& cropOffset) const
 {
     FloatRect rect;
     uint32_t flags = 0;
     if (!hasConnectedInput() && !filter()->filterRegion().isEmpty()) {
         rect = filter()->filterRegion();
         flags = SkImageFilter::CropRect::kHasAll_CropEdge;
-        rect.move(cropOffset);
     }
-    FloatRect boundaries = effectBoundaries();
-    boundaries.move(cropOffset);
-    if (hasX()) {
-        rect.setX(boundaries.x());
-        flags |= SkImageFilter::CropRect::kHasLeft_CropEdge;
-    }
-    if (hasY()) {
-        rect.setY(boundaries.y());
-        flags |= SkImageFilter::CropRect::kHasTop_CropEdge;
-    }
-    if (hasWidth()) {
-        rect.setWidth(boundaries.width());
-        flags |= SkImageFilter::CropRect::kHasWidth_CropEdge;
-    }
-    if (hasHeight()) {
-        rect.setHeight(boundaries.height());
-        flags |= SkImageFilter::CropRect::kHasHeight_CropEdge;
-    }
+
+    rect = applyEffectBoundaries(rect);
+
+    rect.move(cropOffset);
     rect.scale(filter()->scale());
+
+    flags |= hasX() ? SkImageFilter::CropRect::kHasLeft_CropEdge : 0;
+    flags |= hasY() ? SkImageFilter::CropRect::kHasTop_CropEdge : 0;
+    flags |= hasWidth() ? SkImageFilter::CropRect::kHasWidth_CropEdge : 0;
+    flags |= hasHeight() ? SkImageFilter::CropRect::kHasHeight_CropEdge : 0;
+
     return SkImageFilter::CropRect(rect, flags);
 }
 
 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, PassRefPtr<SkImageFilter> imageFilter)
 {
     int index = getImageFilterIndex(colorSpace, requiresPMColorValidation);
     m_imageFilters[index] = imageFilter;
 }
 
 } // namespace blink