Moving SkBlurImageFilter into core

src/core/SkBlurImageFilter.cpp

 /*
  * Copyright 2011 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#include "SkBlurImageFilter.h"
-
 #include "SkAutoPixmapStorage.h"
 #include "SkColorPriv.h"
 #include "SkGpuBlurUtils.h"
 #include "SkOpts.h"
 #include "SkReadBuffer.h"
 #include "SkSpecialImage.h"
 #include "SkWriteBuffer.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "SkGr.h"
 #endif
 
-sk_sp<SkImageFilter> SkBlurImageFilter::Make(SkScalar sigmaX, SkScalar sigmaY, 
+class SkBlurImageFilterImpl : public SkImageFilter {
+public:
+    SkBlurImageFilterImpl(SkScalar sigmaX,
+                      SkScalar sigmaY,
+                      sk_sp<SkImageFilter> input,
+                      const CropRect* cropRect);
+
+    SkRect computeFastBounds(const SkRect&) const override;
+
+    SK_TO_STRING_OVERRIDE()
+    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurImageFilterImpl)
+
+#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
+    static SkImageFilter* Create(SkScalar sigmaX, SkScalar sigmaY, SkImageFilter* input = nullptr,
+                                 const CropRect* cropRect = nullptr) {
+        return SkImageFilter::MakeBlur(sigmaX, sigmaY, sk_ref_sp<SkImageFilter>(input),
+                                     cropRect).release();
+    }
+#endif
+
+protected:
+    void flatten(SkWriteBuffer&) const override;
+    sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
+                                        SkIPoint* offset) const override;
+    SkIRect onFilterNodeBounds(const SkIRect& src, const SkMatrix&, MapDirection) const override;
+
+private:
+    SkSize   fSigma;
+    typedef SkImageFilter INHERITED;
+
+    friend class SkImageFilter;
+};
+
+SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkImageFilter)
+    SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurImageFilterImpl)
+SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
+
+///////////////////////////////////////////////////////////////////////////////
+
+sk_sp<SkImageFilter> SkImageFilter::MakeBlur(SkScalar sigmaX, SkScalar sigmaY,
                                              sk_sp<SkImageFilter> input,
                                              const CropRect* cropRect) {
     if (0 == sigmaX && 0 == sigmaY && !cropRect) {
         return input;
     }
-    return sk_sp<SkImageFilter>(new SkBlurImageFilter(sigmaX, sigmaY, input, cropRect));
+    return sk_sp<SkImageFilter>(new SkBlurImageFilterImpl(sigmaX, sigmaY, input, cropRect));
 }
 
 // This rather arbitrary-looking value results in a maximum box blur kernel size
 // of 1000 pixels on the raster path, which matches the WebKit and Firefox
 // implementations. Since the GPU path does not compute a box blur, putting
 // the limit on sigma ensures consistent behaviour between the GPU and
 // raster paths.
 #define MAX_SIGMA SkIntToScalar(532)
 
 static SkVector map_sigma(const SkSize& localSigma, const SkMatrix& ctm) {
     SkVector sigma = SkVector::Make(localSigma.width(), localSigma.height());
     ctm.mapVectors(&sigma, 1);
     sigma.fX = SkMinScalar(SkScalarAbs(sigma.fX), MAX_SIGMA);
     sigma.fY = SkMinScalar(SkScalarAbs(sigma.fY), MAX_SIGMA);
     return sigma;
 }
 
-SkBlurImageFilter::SkBlurImageFilter(SkScalar sigmaX,
+SkBlurImageFilterImpl::SkBlurImageFilterImpl(SkScalar sigmaX,
                                      SkScalar sigmaY,
                                      sk_sp<SkImageFilter> input,
                                      const CropRect* cropRect)
     : INHERITED(&input, 1, cropRect)
     , fSigma(SkSize::Make(sigmaX, sigmaY)) {
 }
 
-sk_sp<SkFlattenable> SkBlurImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkBlurImageFilterImpl::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkScalar sigmaX = buffer.readScalar();
     SkScalar sigmaY = buffer.readScalar();
-    return Make(sigmaX, sigmaY, common.getInput(0), &common.cropRect());
+    return SkImageFilter::MakeBlur(sigmaX, sigmaY, common.getInput(0), &common.cropRect());
 }
 
-void SkBlurImageFilter::flatten(SkWriteBuffer& buffer) const {
+void SkBlurImageFilterImpl::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeScalar(fSigma.fWidth);
     buffer.writeScalar(fSigma.fHeight);
 }
 
 static void get_box3_params(SkScalar s, int *kernelSize, int* kernelSize3, int *lowOffset,
                             int *highOffset) {
     float pi = SkScalarToFloat(SK_ScalarPI);
     int d = static_cast<int>(floorf(SkScalarToFloat(s) * 3.0f * sqrtf(2.0f * pi) / 4.0f + 0.5f));
     *kernelSize = d;
     if (d % 2 == 1) {
         *lowOffset = *highOffset = (d - 1) / 2;
         *kernelSize3 = d;
     } else {
         *highOffset = d / 2;
         *lowOffset = *highOffset - 1;
         *kernelSize3 = d + 1;
     }
 }
 
-sk_sp<SkSpecialImage> SkBlurImageFilter::onFilterImage(SkSpecialImage* source,
+sk_sp<SkSpecialImage> SkBlurImageFilterImpl::onFilterImage(SkSpecialImage* source,
                                                        const Context& ctx,
                                                        SkIPoint* offset) const {
     SkIPoint inputOffset = SkIPoint::Make(0, 0);
 
     sk_sp<SkSpecialImage> input(this->filterInput(0, source, ctx, &inputOffset));
     if (!input) {
         return nullptr;
     }
 
     SkIRect inputBounds = SkIRect::MakeXYWH(inputOffset.fX, inputOffset.fY,
@@ skipping 130 matching lines @@
         SkOpts::box_blur_xx(d,  h,  dstBoundsT,   t, kernelSizeY,  highOffsetY, lowOffsetY,  h, w);
         SkOpts::box_blur_xy(t,  h,  dstBoundsT,   d, kernelSizeY3, highOffsetY, highOffsetY, h, w);
     }
 
     return SkSpecialImage::MakeFromRaster(SkIRect::MakeWH(dstBounds.width(),
                                                           dstBounds.height()),
                                           dst, &source->props());
 }
 
 
-SkRect SkBlurImageFilter::computeFastBounds(const SkRect& src) const {
+SkRect SkBlurImageFilterImpl::computeFastBounds(const SkRect& src) const {
     SkRect bounds = this->getInput(0) ? this->getInput(0)->computeFastBounds(src) : src;
     bounds.outset(SkScalarMul(fSigma.width(), SkIntToScalar(3)),
                   SkScalarMul(fSigma.height(), SkIntToScalar(3)));
     return bounds;
 }
 
-SkIRect SkBlurImageFilter::onFilterNodeBounds(const SkIRect& src, const SkMatrix& ctm,
+SkIRect SkBlurImageFilterImpl::onFilterNodeBounds(const SkIRect& src, const SkMatrix& ctm,
                                               MapDirection) const {
     SkVector sigma = map_sigma(fSigma, ctm);
     return src.makeOutset(SkScalarCeilToInt(SkScalarMul(sigma.x(), SkIntToScalar(3))),
                           SkScalarCeilToInt(SkScalarMul(sigma.y(), SkIntToScalar(3))));
 }
 
 #ifndef SK_IGNORE_TO_STRING
-void SkBlurImageFilter::toString(SkString* str) const {
-    str->appendf("SkBlurImageFilter: (");
+void SkBlurImageFilterImpl::toString(SkString* str) const {
+    str->appendf("SkBlurImageFilterImpl: (");
     str->appendf("sigma: (%f, %f) input (", fSigma.fWidth, fSigma.fHeight);
 
     if (this->getInput(0)) {
         this->getInput(0)->toString(str);
     }
 
     str->append("))");
 }
 #endif