Swap over to using SkImageFilter::filterImage instead of filterImageDeprecated

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 254 matching lines @@
     return false;
 }
 
 bool SkImageFilter::filterInputDeprecated(int index, Proxy* proxy, const SkBitmap& src,
                                           const Context& ctx,
                                           SkBitmap* result, SkIPoint* offset) const {
     SkImageFilter* input = this->getInput(index);
     if (!input) {
         return true;
     }
-    return input->filterImageDeprecated(proxy, src, this->mapContext(ctx), result, offset);
+
+    SkAutoTUnref<SkSpecialImage> specialSrc(SkSpecialImage::internal_fromBM(proxy, src));
+    if (!specialSrc) {
+        return false;
+    }
+
+    SkAutoTUnref<SkSpecialImage> tmp(input->onFilterImage(specialSrc,
+                                                          this->mapContext(ctx),
+                                                          offset));
+    if (!tmp) {
+        return false;
+    }
+
+    return tmp->internal_getBM(result);
 }
 
 bool SkImageFilter::filterBounds(const SkIRect& src, const SkMatrix& ctm, SkIRect* dst,
                                  MapDirection direction) const {
     SkASSERT(dst);
     SkIRect bounds;
     if (kReverse_MapDirection == direction) {
         this->onFilterNodeBounds(src, ctm, &bounds, direction);
         return this->onFilterBounds(bounds, ctm, dst, direction);
     } else {
@@ skipping 34 matching lines @@
         SkImageFilter* input = this->getInput(i);
         if (input && !input->canComputeFastBounds()) {
             return false;
         }
     }
     return true;
 }
 
 bool SkImageFilter::onFilterImageDeprecated(Proxy*, const SkBitmap&, const Context&,
                                             SkBitmap*, SkIPoint*) const {
+    // Only classes that now use the new SkSpecialImage-based path will not have
+    // onFilterImageDeprecated methods. For those classes we should never be
+    // calling this method.
+    SkASSERT(0);
     return false;
 }
 
+// SkImageFilter-derived classes that do not yet have their own onFilterImage
+// implementation convert back to calling the deprecated filterImage method
 SkSpecialImage* SkImageFilter::onFilterImage(SkSpecialImage* src, const Context& ctx,
                                              SkIPoint* offset) const {
     SkBitmap srcBM, resultBM;
 
     if (!src->internal_getBM(&srcBM)) {
         return nullptr;
     }
 
+    // This is the only valid call to the old filterImage path
     if (!this->filterImageDeprecated(src->internal_getProxy(), srcBM, ctx, &resultBM, offset)) {
         return nullptr;
     }
 
     return SkSpecialImage::internal_fromBM(src->internal_getProxy(), resultBM);
 }
 
 bool SkImageFilter::canFilterImageGPU() const {
     return this->asFragmentProcessor(nullptr, nullptr, SkMatrix::I(), SkIRect());
 }
@@ skipping 225 matching lines @@
 
 #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;
     }
-    // Ensure that GrContext calls under filterImage and filterImageGPU below will see an identity
-    // matrix with no clip and that the matrix, clip, and render target set before this function was
-    // called are restored before we return to the caller.
-    GrContext* context = src.getTexture()->getContext();
-    if (input->filterImageDeprecated(proxy, src, this->mapContext(ctx), result, offset)) {
-        if (!result->getTexture()) {
-            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;
-    } else {
+
+    SkAutoTUnref<SkSpecialImage> specialSrc(SkSpecialImage::internal_fromBM(proxy, src));
+    if (!specialSrc) {
         return false;
     }
+
+    SkAutoTUnref<SkSpecialImage> tmp(input->onFilterImage(specialSrc,
+                                                          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);
@@ skipping 157 matching lines @@
     }
     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);
 }