Switch SkBlurImageFilter over to new onFilterImage interface

src/effects/SkBlurImageFilter.cpp

Index: src/effects/SkBlurImageFilter.cpp
diff --git a/src/effects/SkBlurImageFilter.cpp b/src/effects/SkBlurImageFilter.cpp
index 249e69779deec6ff2490f2be5bbad3ed967f2bf6..aa5c35142078e1c070e5336e651176ca9e87d178 100644
--- a/src/effects/SkBlurImageFilter.cpp
+++ b/src/effects/SkBlurImageFilter.cpp
@@ -5,14 +5,16 @@
  * found in the LICENSE file.
  */
 
-#include "SkBitmap.h"
 #include "SkBlurImageFilter.h"
+
+#include "SkAutoPixmapStorage.h"
 #include "SkColorPriv.h"
-#include "SkDevice.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"
@@ -53,8 +55,8 @@ void SkBlurImageFilter::flatten(SkWriteBuffer& buffer) const {
     buffer.writeScalar(fSigma.fHeight);
 }
 
-static void getBox3Params(SkScalar s, int *kernelSize, int* kernelSize3, int *lowOffset,
-                          int *highOffset)
+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));
@@ -69,77 +71,108 @@ static void getBox3Params(SkScalar s, int *kernelSize, int* kernelSize3, int *lo
     }
 }
 
-bool SkBlurImageFilter::onFilterImageDeprecated(Proxy* proxy,
-                                                const SkBitmap& source, const Context& ctx,
-                                                SkBitmap* dst, SkIPoint* offset) const {
-    SkBitmap src = source;
-    SkIPoint srcOffset = SkIPoint::Make(0, 0);
-    if (!this->filterInputDeprecated(0, proxy, source, ctx, &src, &srcOffset)) {
-        return false;
-    }
+SkSpecialImage* SkBlurImageFilter::onFilterImage(SkSpecialImage* source, const Context& ctx,
+                                                 SkIPoint* offset) const {
+    SkIPoint inputOffset = SkIPoint::Make(0, 0);
 
-    if (src.colorType() != kN32_SkColorType) {
-        return false;
+    SkAutoTUnref<SkSpecialImage> input(this->filterInput(0, source, ctx, &inputOffset));
+    if (!input) {
+        return nullptr;
     }
 
-    SkIRect srcBounds = src.bounds();
-    srcBounds.offset(srcOffset);
+    SkIRect inputBounds = SkIRect::MakeXYWH(inputOffset.fX, inputOffset.fY,
+                                            input->width(), input->height());
+
     SkIRect dstBounds;
-    if (!this->applyCropRect(this->mapContext(ctx), srcBounds, &dstBounds)) {
-        return false;
+    if (!this->applyCropRect(this->mapContext(ctx), inputBounds, &dstBounds)) {
+        return nullptr;
     }
-    if (!srcBounds.intersect(dstBounds)) {
-        return false;
+    if (!inputBounds.intersect(dstBounds)) {
+        return nullptr;
     }
 
-    SkVector sigma = map_sigma(fSigma, ctx.ctm());
+    const SkVector sigma = map_sigma(fSigma, ctx.ctm());
+
+#if SK_SUPPORT_GPU
+    if (input->peekTexture()) {
+        if (0 == sigma.x() && 0 == sigma.y()) {
+            offset->fX = inputBounds.x();
+            offset->fY = inputBounds.y();
+            return input->makeSubset(inputBounds.makeOffset(-inputOffset.x(),
+                                                            -inputOffset.y())).release();
+        }
+
+        GrTexture* inputTexture = input->peekTexture();
+
+        offset->fX = dstBounds.fLeft;
+        offset->fY = dstBounds.fTop;
+        inputBounds.offset(-inputOffset);
+        dstBounds.offset(-inputOffset);
+        SkRect inputBoundsF(SkRect::Make(inputBounds));
+        SkAutoTUnref<GrTexture> tex(SkGpuBlurUtils::GaussianBlur(inputTexture->getContext(),
+                                                                 inputTexture,
+                                                                 false,
+                                                                 SkRect::Make(dstBounds),
+                                                                 &inputBoundsF,
+                                                                 sigma.x(),
+                                                                 sigma.y()));
+        if (!tex) {
+            return nullptr;
+        }
+
+        return SkSpecialImage::MakeFromGpu(source->internal_getProxy(),
+                                           SkIRect::MakeWH(dstBounds.width(), dstBounds.height()),
+                                           kNeedNewImageUniqueID_SpecialImage,
+                                           tex).release();
+    }
+#endif
 
     int kernelSizeX, kernelSizeX3, lowOffsetX, highOffsetX;
     int kernelSizeY, kernelSizeY3, lowOffsetY, highOffsetY;
-    getBox3Params(sigma.x(), &kernelSizeX, &kernelSizeX3, &lowOffsetX, &highOffsetX);
-    getBox3Params(sigma.y(), &kernelSizeY, &kernelSizeY3, &lowOffsetY, &highOffsetY);
+    get_box3_params(sigma.x(), &kernelSizeX, &kernelSizeX3, &lowOffsetX, &highOffsetX);
+    get_box3_params(sigma.y(), &kernelSizeY, &kernelSizeY3, &lowOffsetY, &highOffsetY);
 
     if (kernelSizeX < 0 || kernelSizeY < 0) {
-        return false;
+        return nullptr;
     }
 
     if (kernelSizeX == 0 && kernelSizeY == 0) {
-        src.extractSubset(dst, srcBounds.makeOffset(-srcOffset.x(), -srcOffset.y()));
-        offset->fX = srcBounds.x();
-        offset->fY = srcBounds.y();
-        return true;
+        offset->fX = inputBounds.x();
+        offset->fY = inputBounds.y();
+        return input->makeSubset(inputBounds.makeOffset(-inputOffset.x(),
+                                                        -inputOffset.y())).release();
     }
 
-    SkAutoLockPixels alp(src);
-    if (!src.getPixels()) {
-        return false;
-    }
+    SkPixmap inputPixmap;
 
-    SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(dstBounds.width(), dstBounds.height()));

[Stephen White, 2016/03/22 19:29:49]

BTW, there's actually a reason we were using createDevice() here. The idea was
that it would provide a central pinch-point for creating backing stores that
could come from discardable memory: https://codereview.chromium.org/1414843003

Anyway, that work hasn't been done yet; I just thought I'd mention it. We'll
have to circle back and revisit this code when we do. Maybe we can request
backing stores from the context's cache, rather than allocating them directly.

[robertphillips, 2016/03/22 19:40:50]

Acknowledged.

-    if (!device) {
-        return false;
+    if (!input->peekPixels(&inputPixmap)) {
+        return nullptr;
     }
-    *dst = device->accessBitmap(false);
-    SkAutoLockPixels alp_dst(*dst);
 
-    SkAutoTUnref<SkBaseDevice> tempDevice(proxy->createDevice(dst->width(), dst->height()));
-    if (!tempDevice) {
-        return false;
+    if (inputPixmap.colorType() != kN32_SkColorType) {
+        return nullptr;
     }
-    SkBitmap temp = tempDevice->accessBitmap(false);
-    SkAutoLockPixels alpTemp(temp);
+
+    SkImageInfo info = SkImageInfo::Make(dstBounds.width(), dstBounds.height(),
+                                         inputPixmap.colorType(), inputPixmap.alphaType());
+
+    SkBitmap tmp, dst;
+    tmp.allocPixels(info);

[Stephen White, 2016/03/22 19:29:49]

Shouldn't we be checking for allocation failure here?

[robertphillips, 2016/03/22 19:40:50]

It should throw on failure.

+    dst.allocPixels(info);
 
     offset->fX = dstBounds.fLeft;
     offset->fY = dstBounds.fTop;
-    SkPMColor* t = temp.getAddr32(0, 0);
-    SkPMColor* d = dst->getAddr32(0, 0);
+    SkPMColor* t = tmp.getAddr32(0, 0);
+    SkPMColor* d = dst.getAddr32(0, 0);
     int w = dstBounds.width(), h = dstBounds.height();
-    const SkPMColor* s = src.getAddr32(srcBounds.x() - srcOffset.x(), srcBounds.y() - srcOffset.y());
-    srcBounds.offset(-dstBounds.x(), -dstBounds.y());
+    const SkPMColor* s = inputPixmap.addr32(inputBounds.x() - inputOffset.x(),
+                                            inputBounds.y() - inputOffset.y());
+    inputBounds.offset(-dstBounds.x(), -dstBounds.y());
     dstBounds.offset(-dstBounds.x(), -dstBounds.y());
-    SkIRect srcBoundsT = SkIRect::MakeLTRB(srcBounds.top(), srcBounds.left(), srcBounds.bottom(), srcBounds.right());
+    SkIRect inputBoundsT = SkIRect::MakeLTRB(inputBounds.top(), inputBounds.left(),
+                                             inputBounds.bottom(), inputBounds.right());
     SkIRect dstBoundsT = SkIRect::MakeWH(dstBounds.height(), dstBounds.width());
-    int sw = src.rowBytesAsPixels();
+    int sw = inputPixmap.rowBytes() >> 2;
 
     /**
      *
@@ -160,22 +193,26 @@ bool SkBlurImageFilter::onFilterImageDeprecated(Proxy* proxy,
      * images, and all memory reads are contiguous.
      */
     if (kernelSizeX > 0 && kernelSizeY > 0) {
-        SkOpts::box_blur_xx(s, sw,  srcBounds,  t, kernelSizeX,  lowOffsetX,  highOffsetX, w, h);
-        SkOpts::box_blur_xx(t,  w,  dstBounds,  d, kernelSizeX,  highOffsetX, lowOffsetX,  w, h);
-        SkOpts::box_blur_xy(d,  w,  dstBounds,  t, kernelSizeX3, highOffsetX, highOffsetX, w, h);
-        SkOpts::box_blur_xx(t,  h,  dstBoundsT, d, kernelSizeY,  lowOffsetY,  highOffsetY, h, w);
-        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);
+        SkOpts::box_blur_xx(s, sw,  inputBounds,  t, kernelSizeX,  lowOffsetX,  highOffsetX, w, h);
+        SkOpts::box_blur_xx(t,  w,  dstBounds,    d, kernelSizeX,  highOffsetX, lowOffsetX,  w, h);
+        SkOpts::box_blur_xy(d,  w,  dstBounds,    t, kernelSizeX3, highOffsetX, highOffsetX, w, h);
+        SkOpts::box_blur_xx(t,  h,  dstBoundsT,   d, kernelSizeY,  lowOffsetY,  highOffsetY, h, w);
+        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);
     } else if (kernelSizeX > 0) {
-        SkOpts::box_blur_xx(s, sw,  srcBounds,  d, kernelSizeX,  lowOffsetX,  highOffsetX, w, h);
-        SkOpts::box_blur_xx(d,  w,  dstBounds,  t, kernelSizeX,  highOffsetX, lowOffsetX,  w, h);
-        SkOpts::box_blur_xx(t,  w,  dstBounds,  d, kernelSizeX3, highOffsetX, highOffsetX, w, h);
+        SkOpts::box_blur_xx(s, sw,  inputBounds,  d, kernelSizeX,  lowOffsetX,  highOffsetX, w, h);
+        SkOpts::box_blur_xx(d,  w,  dstBounds,    t, kernelSizeX,  highOffsetX, lowOffsetX,  w, h);
+        SkOpts::box_blur_xx(t,  w,  dstBounds,    d, kernelSizeX3, highOffsetX, highOffsetX, w, h);
     } else if (kernelSizeY > 0) {
-        SkOpts::box_blur_yx(s, sw,  srcBoundsT, d, kernelSizeY,  lowOffsetY,  highOffsetY, h, w);
-        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);
+        SkOpts::box_blur_yx(s, sw,  inputBoundsT, d, kernelSizeY,  lowOffsetY,  highOffsetY, h, w);
+        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 true;
+
+    return SkSpecialImage::MakeFromRaster(source->internal_getProxy(), 
+                                          SkIRect::MakeWH(dstBounds.width(),
+                                                          dstBounds.height()),
+                                          dst).release();
 }
 
 
@@ -198,55 +235,6 @@ void SkBlurImageFilter::onFilterNodeBounds(const SkIRect& src, const SkMatrix& c
                 SkScalarCeilToInt(SkScalarMul(sigma.y(), SkIntToScalar(3))));
 }
 
-bool SkBlurImageFilter::filterImageGPUDeprecated(Proxy* proxy, const SkBitmap& src,
-                                                 const Context& ctx,
-                                                 SkBitmap* result, SkIPoint* offset) const {
-#if SK_SUPPORT_GPU
-    SkBitmap input = src;
-    SkIPoint srcOffset = SkIPoint::Make(0, 0);
-    if (!this->filterInputGPUDeprecated(0, proxy, src, ctx, &input, &srcOffset)) {
-        return false;
-    }
-    SkIRect srcBounds = input.bounds();
-    srcBounds.offset(srcOffset);
-    SkIRect dstBounds;
-    if (!this->applyCropRect(this->mapContext(ctx), srcBounds, &dstBounds)) {
-        return false;
-    }
-    if (!srcBounds.intersect(dstBounds)) {
-        return false;
-    }
-    SkVector sigma = map_sigma(fSigma, ctx.ctm());
-    if (sigma.x() == 0 && sigma.y() == 0) {
-        input.extractSubset(result, srcBounds.makeOffset(-srcOffset.x(), -srcOffset.y()));
-        offset->fX = srcBounds.x();
-        offset->fY = srcBounds.y();
-        return true;
-    }
-    offset->fX = dstBounds.fLeft;
-    offset->fY = dstBounds.fTop;
-    srcBounds.offset(-srcOffset);
-    dstBounds.offset(-srcOffset);
-    SkRect srcBoundsF(SkRect::Make(srcBounds));
-    GrTexture* inputTexture = input.getTexture();
-    SkAutoTUnref<GrTexture> tex(SkGpuBlurUtils::GaussianBlur(inputTexture->getContext(),
-                                                             inputTexture,
-                                                             false,
-                                                             SkRect::Make(dstBounds),
-                                                             &srcBoundsF,
-                                                             sigma.x(),
-                                                             sigma.y()));
-    if (!tex) {
-        return false;
-    }
-    GrWrapTextureInBitmap(tex, dstBounds.width(), dstBounds.height(), false, result);
-    return true;
-#else
-    SkDEBUGFAIL("Should not call in GPU-less build");
-    return false;
-#endif
-}
-
 #ifndef SK_IGNORE_TO_STRING
 void SkBlurImageFilter::toString(SkString* str) const {
     str->appendf("SkBlurImageFilter: (");