Consolidate FilterOperation and FilterEffect mapRect implementations

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005 Rob Buis <buis@kde.org>
  * Copyright (C) 2005 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Igalia, S.L.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 13 matching lines @@
  */
 
 #include "platform/graphics/filters/FEGaussianBlur.h"
 
 #include "platform/graphics/filters/Filter.h"
 #include "platform/graphics/filters/SkiaImageFilterBuilder.h"
 #include "platform/text/TextStream.h"
 
 #include "SkBlurImageFilter.h"
 
-static inline float gaussianKernelFactor() {
-  return 3 / 4.f * sqrtf(twoPiFloat);
+namespace blink {
+
+namespace {
+
+inline unsigned approximateBoxWidth(float s) {
+  return static_cast<unsigned>(
+      floorf(s * (3 / 4.f * sqrtf(twoPiFloat)) + 0.5f));
 }
 
-namespace blink {
+IntSize calculateKernelSize(const FloatSize& std) {
+  DCHECK(std.width() >= 0 && std.height() >= 0);
+  IntSize kernelSize;
+  // Limit the kernel size to 1000. A bigger radius won't make a big difference
+  // for the result image but inflates the absolute paint rect too much. This is
+  // compatible with Firefox' behavior.

[Stephen Chennney, 2016/10/10 19:43:25]

Where do we do this limiting? It would be nice of the comment to say where the
code is (or else the comment is out of date and should be removed).

[fs, 2016/10/10 20:40:03]

It looks like this comment has outstayed its welcome. It appears to have been
added in 695f3cdf1bfd5c171556245d73d842d3bb5ba32c (back in 2010) together with a
gMaxKernelSize (set to 1000) which was clamped against.
https://codereview.chromium.org/793873002 the dropped the clamping but
supposedly forgot to remove the comment. I guess remove it then.

[fs, 2016/10/10 20:43:53]

Dropped.

+  if (std.width()) {
+    int size = std::max<unsigned>(2, approximateBoxWidth(std.width()));
+    kernelSize.setWidth(size);
+  }
+  if (std.height()) {
+    int size = std::max<unsigned>(2, approximateBoxWidth(std.height()));
+    kernelSize.setHeight(size);
+  }
+  return kernelSize;
+}
+
+}
 
 FEGaussianBlur::FEGaussianBlur(Filter* filter, float x, float y)
     : FilterEffect(filter), m_stdX(x), m_stdY(y) {}
 
 FEGaussianBlur* FEGaussianBlur::create(Filter* filter, float x, float y) {
   return new FEGaussianBlur(filter, x, y);
 }
 
-IntSize FEGaussianBlur::calculateUnscaledKernelSize(const FloatPoint& std) {
-  ASSERT(std.x() >= 0 && std.y() >= 0);
-
-  IntSize kernelSize;
-  // Limit the kernel size to 1000. A bigger radius won't make a big difference
-  // for the result image but inflates the absolute paint rect too much. This is
-  // compatible with Firefox' behavior.
-  if (std.x()) {
-    int size = std::max<unsigned>(
-        2,
-        static_cast<unsigned>(floorf(std.x() * gaussianKernelFactor() + 0.5f)));
-    kernelSize.setWidth(size);
-  }
-
-  if (std.y()) {
-    int size = std::max<unsigned>(
-        2,
-        static_cast<unsigned>(floorf(std.y() * gaussianKernelFactor() + 0.5f)));
-    kernelSize.setHeight(size);
-  }
-
-  return kernelSize;
-}
-
-IntSize FEGaussianBlur::calculateKernelSize(const Filter* filter,
-                                            const FloatPoint& std) {
-  FloatPoint stdError(filter->applyHorizontalScale(std.x()),
-                      filter->applyVerticalScale(std.y()));
-  return calculateUnscaledKernelSize(stdError);
-}
-
-FloatRect FEGaussianBlur::mapEffect(const FloatRect& rect) const {
-  IntSize kernelSize =
-      calculateKernelSize(getFilter(), FloatPoint(m_stdX, m_stdY));
-
+FloatRect FEGaussianBlur::mapEffect(const FloatSize& stdDeviation,
+                                    const FloatRect& rect) {
+  IntSize kernelSize = calculateKernelSize(stdDeviation);
   // We take the half kernel size and multiply it by three, because we run box
   // blur three times.
   FloatRect result = rect;
   result.inflateX(3.0f * kernelSize.width() * 0.5f);
   result.inflateY(3.0f * kernelSize.height() * 0.5f);
   return result;
 }
 
+FloatRect FEGaussianBlur::mapEffect(const FloatRect& rect) const {
+  FloatSize stdError(getFilter()->applyHorizontalScale(m_stdX),
+                     getFilter()->applyVerticalScale(m_stdY));
+  return mapEffect(stdError, rect);
+}
+
 sk_sp<SkImageFilter> FEGaussianBlur::createImageFilter() {
   sk_sp<SkImageFilter> input(
       SkiaImageFilterBuilder::build(inputEffect(0), operatingColorSpace()));
   float stdX = getFilter()->applyHorizontalScale(m_stdX);
   float stdY = getFilter()->applyVerticalScale(m_stdY);
   SkImageFilter::CropRect rect = getCropRect();
   return SkBlurImageFilter::Make(SkFloatToScalar(stdX), SkFloatToScalar(stdY),
                                  std::move(input), &rect);
 }
 
 TextStream& FEGaussianBlur::externalRepresentation(TextStream& ts,
                                                    int indent) const {
   writeIndent(ts, indent);
   ts << "[feGaussianBlur";
   FilterEffect::externalRepresentation(ts);
   ts << " stdDeviation=\"" << m_stdX << ", " << m_stdY << "\"]\n";
   inputEffect(0)->externalRepresentation(ts, indent + 1);
   return ts;
 }
 
 }  // namespace blink