change SkImage_Gpu to handle all filters (w/ and w/o gpu support

src/image/SkImage_Gpu.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapCache.h"
 #include "SkImage_Gpu.h"
 #include "GrCaps.h"
@@ skipping 196 matching lines @@
 
         if (texture) {
             SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
             return SkGpuDevice::Create(texture->asRenderTarget(), width, height, &props,
                                        SkGpuDevice::kClear_InitContents);
         } else {
             return nullptr;
         }
     }
 
-    bool filterImage(const SkImageFilter*, const SkBitmap&, const SkImageFilter::Context&,
-                     SkBitmap*, SkIPoint*) override {
-        return false;
+    bool filterImage(const SkImageFilter* filter, const SkBitmap& src,
+                     const SkImageFilter::Context& ctx, SkBitmap* dst, SkIPoint* offset) override {
+        return filter->canFilterImageGPU() &&
+               filter->filterImageGPU(this, src, ctx, dst, offset);

[Stephen White, 2015/10/16 20:14:05]

This part looks good, I think.

     }
 };
 
+static SkIRect compute_fast_ibounds(SkImageFilter* filter, const SkIRect& srcBounds) {
+    SkRect fastBounds;
+    fastBounds.set(srcBounds);
+    filter->computeFastBounds(fastBounds, &fastBounds);
+    return fastBounds.roundOut();
+}
+
 SkImage* SkImage_Gpu::onApplyFilter(SkImageFilter* filter, SkIPoint* offsetResult,
                                     bool forceResultToOriginalSize) const {

[Stephen White, 2015/10/16 20:14:05]

I'd really appreciate if this could be turned into an optional SkIRect, and we
pass NULL for now (meaning force to original size). Even if the non-NULL path
doesn't work for now, it'll save me having to do a 3-sided patch later.

[reed1, 2015/10/16 20:41:52]

Adding a variant of the public API that takes a rect is just 1 CL in skia
(making the intersting change), and 1 CL in chrome to pass in different
information. (the public API is not virtual, and there are no subclass in
chrome/blink, so this is not a multi-stage change I think). Until we have a
tested impl somewhere, I would rather not extend our public API speculatively.

[Stephen White, 2015/10/16 21:12:04]

BTW, if we also added an SkMatrix param here, and just passed that instead of
SkMatrix::I() below, I don't think we would need SkLocalMatrixImageFilter at
all. Just sayin'.

[Stephen White, 2015/10/16 21:12:04]

It just seems like it would be very easy:

SkImage_Gpu::onApplyFilter(SkImageFilter* filter, SkIPoint* offsetResult,
SkIRect* destBounds = NULL) const {
...

SkIRect srcBounds = destBounds ? *destBounds : SkIRect::MakeWH(this->width(),
this->height));

...

-    if (!forceResultToOriginalSize || !filter->canFilterImageGPU()) {
-        return this->INHERITED::onApplyFilter(filter, offsetResult, forceResultToOriginalSize);
+    const SkIRect srcBounds = SkIRect::MakeWH(this->width(), this->height());
+
+    if (forceResultToOriginalSize) {
+        SkBitmap src;
+        GrWrapTextureInBitmap(fTexture, this->width(), this->height(), this->isOpaque(), &src);
+
+        const SkIRect clipBounds = srcBounds;
+        SkGpuImageFilterProxy proxy(fTexture->getContext());
+        SkImageFilter::Context ctx(SkMatrix::I(), clipBounds, SkImageFilter::Cache::Get());
+
+        SkBitmap dst;
+        if (!filter->filterImage(&proxy, src, ctx, &dst, offsetResult)) {
+            return nullptr;
+        }
+        if (dst.getTexture()) {
+            return new SkImage_Gpu(dst.width(), dst.height(), kNeedNewImageUniqueID, dst.alphaType(),
+                                   dst.getTexture(), SkSurface::kNo_Budgeted);
+        }
+
+        // fall-through to the drawing case
+        SkDebugf("------ got raster result from gpu-src using filter %s\n",

[Stephen White, 2015/10/16 20:14:05]

This shouldn't happen. Is it?

[reed1, 2015/10/16 20:41:52]

Done.

+                 filter->getTypeName());
     }
 
-    SkBitmap src;
-    GrWrapTextureInBitmap(fTexture, this->width(), this->height(), this->isOpaque(), &src);
+    const SkIRect dstR = forceResultToOriginalSize ?
+                            srcBounds : compute_fast_ibounds(filter, srcBounds);
 
-    GrContext* context = fTexture->getContext();
-    SkGpuImageFilterProxy proxy(context);
-    SkImageFilter::Context ctx(SkMatrix::I(),
-                               SkIRect::MakeWH(this->width(), this->height()),
-                               SkImageFilter::Cache::Get());
+    SkImageInfo info = SkImageInfo::MakeN32Premul(dstR.width(), dstR.height());
+    SkAutoTUnref<SkSurface> surface(this->onNewSurface(info));
 
-    SkBitmap dst;
-    if (filter->filterImageGPU(&proxy, src, ctx, &dst, offsetResult)) {
-        return new SkImage_Gpu(dst.width(), dst.height(), kNeedNewImageUniqueID, dst.alphaType(),
-                               dst.getTexture(), SkSurface::kNo_Budgeted);
-    }
-    return nullptr;
+    SkPaint paint;
+    paint.setImageFilter(filter);
+    surface->getCanvas()->drawImage(this, SkIntToScalar(-dstR.x()), SkIntToScalar(-dstR.y()),

[Stephen White, 2015/10/16 20:14:05]

It looks like if we fall-through here (when fForceToOriginalSize is true, but we
get a raster result), we'll filter it again and draw it again?

[reed1, 2015/10/16 20:41:52]

Ah, good point. However, I think your previous point is correct that we
shouldn't need the fall-through, so I'll clean up both parts.

+                                    &paint);
+
+    offsetResult->set(dstR.x(), dstR.y());
+    return surface->newImageSnapshot();
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static SkImage* new_wrapped_texture_common(GrContext* ctx, const GrBackendTextureDesc& desc,
                                            SkAlphaType at, GrWrapOwnership ownership,
                                            SkImage::TextureReleaseProc releaseProc,
                                            SkImage::ReleaseContext releaseCtx) {
     if (desc.fWidth <= 0 || desc.fHeight <= 0) {
         return nullptr;
@@ skipping 131 matching lines @@
     if (!dst) {
         return nullptr;
     }
     
     const SkIRect srcR = SkIRect::MakeWH(desc.fWidth, desc.fHeight);
     const SkIPoint dstP = SkIPoint::Make(0, 0);
     ctx->copySurface(dst, src, srcR, dstP, GrContext::kFlushWrites_PixelOp);
     return dst;
 }