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 202 matching lines @@
             return nullptr;
         }
     }
 
     bool filterImage(const SkImageFilter*, const SkBitmap&, const SkImageFilter::Context&,
                      SkBitmap*, SkIPoint*) override {
         return false;
     }
 };
 
+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/14 21:41:43]

As discussed, please change this bool to a nullable SkIRect param, so I don't
have to change it later when implementing filter effects region.

-    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->canFilterImageGPU()) {
+            if (!filter->filterImageGPU(&proxy, src, ctx, &dst, offsetResult)) {

[Stephen White, 2015/10/14 21:41:43]

This is going to bypass the caching logic in filterImage(), causing repeated
re-processing of nodes in the graph with valence > 1.

My preference would be that we create an old-school Proxy for now, and use the
old code until we can switch all of it over to SkImage/SkSurface. You should
still get GPU processing via filterImage(), and in fact you could then refactor
a lot of this code with the CPU implementation, since it'll be much the same
calls.

If you really want to avoid creating a real device, we could try to put the
filteImageGPU() logic in SkGpuImageFilterProxy::filterImage() instead. Then at
least you'd get caching.

+                return nullptr;
+            }
+        } else {
+            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
     }
 
-    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()),
+                                    &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;
 }