Revert of Remove deprecated paths from image filter infrastructure.

src/core/SkImageFilter.cpp

 /*
  * Copyright 2012 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 "SkImageFilter.h"
 #include "SkImageFilterCacheKey.h"
 
@@ skipping 238 matching lines @@
     SkASSERT(result);
     SkASSERT(offset);
     uint32_t srcGenID = fUsesSrcInput ? src.getGenerationID() : 0;
     Cache::Key key(fUniqueID, context.ctm(), context.clipBounds(),
                    srcGenID, SkIRect::MakeWH(0, 0));
     if (context.cache()) {
         if (context.cache()->get(key, result, offset)) {
             return true;
         }
     }
-    if (this->onFilterImageDeprecated(proxy, src, context, result, offset)) {
+    /*
+     *  Give the proxy first shot at the filter. If it returns false, ask
+     *  the filter to do it.
+     */
+    if ((proxy && proxy->filterImage(this, src, context, result, offset)) ||
+        this->onFilterImageDeprecated(proxy, src, context, result, offset)) {
         if (context.cache()) {
             context.cache()->set(key, *result, *offset);
             SkAutoMutexAcquire mutex(fMutex);
             fCacheKeys.push_back(key);
         }
         return true;
     }
     return false;
 }
 
@@ skipping 146 matching lines @@
     SkIRect temp = this->onFilterNodeBounds(srcBounds, ctx.ctm(), kForward_MapDirection);
     fCropRect.applyTo(temp, ctx.ctm(), this->affectsTransparentBlack(), dstBounds);
     // Intersect against the clip bounds, in case the crop rect has
     // grown the bounds beyond the original clip. This can happen for
     // example in tiling, where the clip is much smaller than the filtered
     // primitive. If we didn't do this, we would be processing the filter
     // at the full crop rect size in every tile.
     return dstBounds->intersect(ctx.clipBounds());
 }
 
+bool SkImageFilter::applyCropRectDeprecated(const Context& ctx, Proxy* proxy, const SkBitmap& src,
+                                            SkIPoint* srcOffset, SkIRect* bounds,
+                                            SkBitmap* dst) const {
+    SkIRect srcBounds;
+    src.getBounds(&srcBounds);
+    srcBounds.offset(*srcOffset);
+    SkIRect dstBounds = this->onFilterNodeBounds(srcBounds, ctx.ctm(), kForward_MapDirection);
+    fCropRect.applyTo(dstBounds, ctx.ctm(), this->affectsTransparentBlack(), bounds);
+    if (!bounds->intersect(ctx.clipBounds())) {
+        return false;
+    }
+
+    if (srcBounds.contains(*bounds)) {
+        *dst = src;
+        return true;
+    } else {
+        SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds->width(), bounds->height()));
+        if (!device) {
+            return false;
+        }
+        SkCanvas canvas(device);
+        canvas.clear(0x00000000);
+        canvas.drawBitmap(src, srcOffset->x() - bounds->x(), srcOffset->y() - bounds->y());
+        *srcOffset = SkIPoint::Make(bounds->x(), bounds->y());
+        *dst = device->accessBitmap(false);
+        return true;
+    }
+}
+
 // Return a larger (newWidth x newHeight) copy of 'src' with black padding
 // around it.
 static sk_sp<SkSpecialImage> pad_image(SkSpecialImage* src,
                                        int newWidth, int newHeight, int offX, int offY) {
 
     SkImageInfo info = SkImageInfo::MakeN32Premul(newWidth, newHeight);
     sk_sp<SkSpecialSurface> surf(src->makeSurface(info));
     if (!surf) {
         return nullptr;
     }
@@ skipping 87 matching lines @@
         return sk_sp<SkSpecialImage>(SkRef(src));
     }
 
     sk_sp<SkSpecialImage> result(input->filterImage(src, this->mapContext(ctx), offset));
 
     SkASSERT(!result || src->isTextureBacked() == result->isTextureBacked());
 
     return result;
 }
 
+#if SK_SUPPORT_GPU
+
+bool SkImageFilter::filterInputGPUDeprecated(int index, SkImageFilter::Proxy* proxy,
+                                             const SkBitmap& src, const Context& ctx,
+                                             SkBitmap* result, SkIPoint* offset) const {
+    SkImageFilter* input = this->getInput(index);
+    if (!input) {
+        return true;
+    }
+
+    // SRGBTODO: Don't handle sRGB here, in anticipation of this code path being deleted.
+    sk_sp<SkSpecialImage> specialSrc(SkSpecialImage::internal_fromBM(proxy, src, nullptr));
+    if (!specialSrc) {
+        return false;
+    }
+
+    sk_sp<SkSpecialImage> tmp(input->onFilterImage(specialSrc.get(),
+                                                   this->mapContext(ctx),
+                                                   offset));
+    if (!tmp) {
+        return false;
+    }
+
+    if (!tmp->internal_getBM(result)) {
+        return false;
+    }
+
+    if (!result->getTexture()) {
+        GrContext* context = src.getTexture()->getContext();
+
+        const SkImageInfo info = result->info();
+        if (kUnknown_SkColorType == info.colorType()) {
+            return false;
+        }
+        SkAutoTUnref<GrTexture> resultTex(
+            GrRefCachedBitmapTexture(context, *result, GrTextureParams::ClampNoFilter()));
+        if (!resultTex) {
+            return false;
+        }
+        result->setPixelRef(new SkGrPixelRef(info, resultTex))->unref();
+    }
+
+    return true;
+}
+#endif
+
 namespace {
 
 class CacheImpl : public SkImageFilter::Cache {
 public:
     CacheImpl(size_t maxBytes) : fMaxBytes(maxBytes), fCurrentBytes(0) { }
     ~CacheImpl() override {
         SkTDynamicHash<Value, Key>::Iter iter(&fLookup);
 
         while (!iter.done()) {
             Value* v = &*iter;
@@ skipping 147 matching lines @@
                                    false,   /* preserveLCDText */
                                    true /*forImageFilter*/);
     SkBaseDevice* dev = fDevice->onCreateDevice(cinfo, nullptr);
     if (nullptr == dev) {
         const SkSurfaceProps surfaceProps(fDevice->fSurfaceProps.flags(),
                                           kUnknown_SkPixelGeometry);
         dev = SkBitmapDevice::Create(cinfo.fInfo, surfaceProps);
     }
     return dev;
 }
+
+bool SkImageFilter::DeviceProxy::filterImage(const SkImageFilter* filter, const SkBitmap& src,
+                                       const SkImageFilter::Context& ctx,
+                                       SkBitmap* result, SkIPoint* offset) {
+    return fDevice->filterImage(filter, src, ctx, result, offset);
+}