Remove asFragmentProcessor gpu-specific ImageFilter code path

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 375 matching lines @@
     }
 
     // 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, &src->props());
 }
 
-bool SkImageFilter::canFilterImageGPU() const {
-    return this->asFragmentProcessor(nullptr, nullptr, SkMatrix::I(), SkIRect());
-}
-
-bool SkImageFilter::filterImageGPUDeprecated(Proxy* proxy, const SkBitmap& src, const Context& ctx,
-                                             SkBitmap* result, SkIPoint* offset) const {
-#if SK_SUPPORT_GPU
-    SkBitmap input = src;
-    SkASSERT(fInputCount == 1);
-    SkIPoint srcOffset = SkIPoint::Make(0, 0);
-    if (!this->filterInputGPUDeprecated(0, proxy, src, ctx, &input, &srcOffset)) {
-        return false;
-    }
-    GrTexture* srcTexture = input.getTexture();
-    SkIRect bounds;
-    if (!this->applyCropRectDeprecated(ctx, proxy, input, &srcOffset, &bounds, &input)) {
-        return false;
-    }
-    GrContext* context = srcTexture->getContext();
-
-    GrSurfaceDesc desc;
-    desc.fFlags = kRenderTarget_GrSurfaceFlag;
-    desc.fWidth = bounds.width();
-    desc.fHeight = bounds.height();
-    desc.fConfig = kRGBA_8888_GrPixelConfig;
-
-    SkAutoTUnref<GrTexture> dst(context->textureProvider()->createApproxTexture(desc));
-    if (!dst) {
-        return false;
-    }
-
-    GrFragmentProcessor* fp;
-    offset->fX = bounds.left();
-    offset->fY = bounds.top();
-    bounds.offset(-srcOffset);
-    SkMatrix matrix(ctx.ctm());
-    matrix.postTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
-    GrPaint paint;
-    // SRGBTODO: Don't handle sRGB here, in anticipation of this code path being deleted.
-    if (this->asFragmentProcessor(&fp, srcTexture, matrix, bounds)) {
-        SkASSERT(fp);
-        paint.addColorFragmentProcessor(fp)->unref();
-        paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
-
-        SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(dst->asRenderTarget()));
-        if (drawContext) {
-            SkRect srcRect = SkRect::Make(bounds);
-            SkRect dstRect = SkRect::MakeWH(srcRect.width(), srcRect.height());
-            GrClip clip(dstRect);
-            drawContext->fillRectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect);
-
-            GrWrapTextureInBitmap(dst, bounds.width(), bounds.height(), false, result);
-            return true;
-        }
-    }
-#endif
-    return false;
-}
-
 #if SK_SUPPORT_GPU
 sk_sp<SkSpecialImage> SkImageFilter::DrawWithFP(GrContext* context,
                                                 sk_sp<GrFragmentProcessor> fp,
                                                 const SkIRect& bounds,
                                                 SkImageFilter::Proxy* proxy) {
     GrPaint paint;
     paint.addColorFragmentProcessor(fp.get());
     paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
 
     GrSurfaceDesc desc;
@@ skipping 148 matching lines @@
     return src;
 }
 
 
 SkImageFilter::Context SkImageFilter::mapContext(const Context& ctx) const {
     SkIRect clipBounds = this->onFilterNodeBounds(ctx.clipBounds(), ctx.ctm(),
                                                   MapDirection::kReverse_MapDirection);
     return Context(ctx.ctm(), clipBounds, ctx.cache());
 }
 
-bool SkImageFilter::asFragmentProcessor(GrFragmentProcessor**, GrTexture*,
-                                        const SkMatrix&, const SkIRect&) const {
-    return false;
-}
-
 sk_sp<SkImageFilter> SkImageFilter::MakeMatrixFilter(const SkMatrix& matrix,
                                                      SkFilterQuality filterQuality,
                                                      sk_sp<SkImageFilter> input) {
     return SkMatrixImageFilter::Make(matrix, filterQuality, std::move(input));
 }
 
 sk_sp<SkImageFilter> SkImageFilter::makeWithLocalMatrix(const SkMatrix& matrix) const {
     // SkLocalMatrixImageFilter takes SkImage* in its factory, but logically that parameter
     // is *always* treated as a const ptr. Hence the const-cast here.
     //
@@ skipping 229 matching lines @@
         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);
 }