Remove deprecated paths from image filter infrastructure.

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "GrBlurUtils.h"
@@ skipping 1141 matching lines @@
 
     if (kAlpha_8_SkColorType == bitmap.colorType() && paint.getShader()) {
         // We don't have local coords in this case and have previously set the transform
         // matrices directly on the texture processor.
         fDrawContext->drawRect(fClip, grPaint, viewMatrix, dstRect);
     } else {
         fDrawContext->fillRectToRect(fClip, grPaint, viewMatrix, dstRect, paintRect);
     }
 }
 
-bool SkGpuDevice::filterTexture(GrContext* context, GrTexture* texture,
-                                int width, int height,
-                                const SkImageFilter* filter,
-                                const SkImageFilter::Context& ctx,
-                                SkBitmap* result, SkIPoint* offset) {
-    ASSERT_SINGLE_OWNER
-    SkASSERT(filter);
-
-    SkImageFilter::DeviceProxy proxy(this);
-
-    if (filter->canFilterImageGPU()) {
-        SkBitmap bm;
-        GrWrapTextureInBitmap(texture, width, height, false, &bm);
-        return filter->filterImageGPUDeprecated(&proxy, bm, ctx, result, offset);
-    } else {
-        return false;
-    }
-}
-
 void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
                              int left, int top, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     // drawSprite is defined to be in device coords.
     CHECK_SHOULD_DRAW(draw);
 
     SkAutoLockPixels alp(bitmap, !bitmap.getTexture());
     if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
         return;
     }
 
     int offX = bitmap.pixelRefOrigin().fX;
     int offY = bitmap.pixelRefOrigin().fY;
     int w = bitmap.width();
     int h = bitmap.height();
 
     GrTexture* texture;
     // draw sprite neither filters nor tiles.
     AutoBitmapTexture abt(fContext, bitmap, GrTextureParams::ClampNoFilter(), &texture);
     if (!texture) {
         return;
     }
 
     bool alphaOnly = kAlpha_8_SkColorType == bitmap.colorType();
 
-    SkImageFilter* filter = paint.getImageFilter();
-    // This bitmap will own the filtered result as a texture.
-    SkBitmap filteredBitmap;
-
-    if (filter) {
-        SkIPoint offset = SkIPoint::Make(0, 0);
-        SkMatrix matrix(*draw.fMatrix);
-        matrix.postTranslate(SkIntToScalar(-left), SkIntToScalar(-top));
-        SkIRect clipBounds = draw.fClip->getBounds().makeOffset(-left, -top);
-        SkAutoTUnref<SkImageFilter::Cache> cache(getImageFilterCache());
-        // This cache is transient, and is freed (along with all its contained
-        // textures) when it goes out of scope.
-        SkImageFilter::Context ctx(matrix, clipBounds, cache);
-        if (this->filterTexture(fContext, texture, w, h, filter, ctx, &filteredBitmap,
-                                &offset)) {
-            texture = (GrTexture*) filteredBitmap.getTexture();
-            offX = filteredBitmap.pixelRefOrigin().fX;
-            offY = filteredBitmap.pixelRefOrigin().fY;
-            w = filteredBitmap.width();
-            h = filteredBitmap.height();
-            left += offset.x();
-            top += offset.y();
-        } else {
-            return;
-        }
-        SkASSERT(!GrPixelConfigIsAlphaOnly(texture->config()));
-        alphaOnly = false;
-    }
+    SkASSERT(!paint.getImageFilter());
 
     GrPaint grPaint;
     SkAutoTUnref<const GrFragmentProcessor> fp(
         GrSimpleTextureEffect::Create(texture, SkMatrix::I()));
     if (alphaOnly) {
         fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
     } else {
         fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
     }
     if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp,
@@ skipping 115 matching lines @@
     GrRenderTarget* devRT = dev->accessRenderTarget();
     GrTexture* devTex;
     if (nullptr == (devTex = devRT->asTexture())) {
         return;
     }
 
     const SkImageInfo ii = dev->imageInfo();
     int w = ii.width();
     int h = ii.height();
 
-    SkImageFilter* filter = paint.getImageFilter();
-    // This bitmap will own the filtered result as a texture.
-    SkBitmap filteredBitmap;
-
-    if (filter) {
-        SkIPoint offset = SkIPoint::Make(0, 0);
-        SkMatrix matrix(*draw.fMatrix);
-        matrix.postTranslate(SkIntToScalar(-x), SkIntToScalar(-y));
-        SkIRect clipBounds = draw.fClip->getBounds().makeOffset(-x, -y);
-        // This cache is transient, and is freed (along with all its contained
-        // textures) when it goes out of scope.
-        SkAutoTUnref<SkImageFilter::Cache> cache(getImageFilterCache());
-        SkImageFilter::Context ctx(matrix, clipBounds, cache);
-        if (this->filterTexture(fContext, devTex, device->width(), device->height(),
-                                filter, ctx, &filteredBitmap, &offset)) {
-            devTex = filteredBitmap.getTexture();
-            w = filteredBitmap.width();
-            h = filteredBitmap.height();
-            x += offset.fX;
-            y += offset.fY;
-        } else {
-            return;
-        }
-    }
+    SkASSERT(!paint.getImageFilter());
 
     GrPaint grPaint;
     SkAutoTUnref<const GrFragmentProcessor> fp(
         GrSimpleTextureEffect::Create(devTex, SkMatrix::I()));
     if (GrPixelConfigIsAlphaOnly(devTex->config())) {
         // Can this happen?
         fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
    } else {
         fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
     }
 
     if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp,
                                        this->surfaceProps().isGammaCorrect(), &grPaint)) {
         return;
     }
 
     SkRect dstRect = SkRect::MakeXYWH(SkIntToScalar(x),
                                       SkIntToScalar(y),
                                       SkIntToScalar(w),
                                       SkIntToScalar(h));
 
     // The device being drawn may not fill up its texture (e.g. saveLayer uses approximate
     // scratch texture).
     SkRect srcRect = SkRect::MakeWH(SK_Scalar1 * w / devTex->width(),
                                     SK_Scalar1 * h / devTex->height());
 
     fDrawContext->fillRectToRect(fClip, grPaint, SkMatrix::I(), dstRect, srcRect);
 }
 
-bool SkGpuDevice::canHandleImageFilter(const SkImageFilter* filter) {
-    ASSERT_SINGLE_OWNER
-    return filter->canFilterImageGPU();
-}
-
-bool SkGpuDevice::filterImage(const SkImageFilter* filter, const SkBitmap& src,
-                              const SkImageFilter::Context& ctx,
-                              SkBitmap* result, SkIPoint* offset) {
-    ASSERT_SINGLE_OWNER
-    // want explicitly our impl, so guard against a subclass of us overriding it
-    if (!this->SkGpuDevice::canHandleImageFilter(filter)) {
-        return false;
-    }
-
-    SkAutoLockPixels alp(src, !src.getTexture());
-    if (!src.getTexture() && !src.readyToDraw()) {
-        return false;
-    }
-
-    GrTexture* texture;
-    // We assume here that the filter will not attempt to tile the src. Otherwise, this cache lookup
-    // must be pushed upstack.
-    AutoBitmapTexture abt(fContext, src, GrTextureParams::ClampNoFilter(), &texture);
-    if (!texture) {
-        return false;
-    }
-
-    return this->filterTexture(fContext, texture, src.width(), src.height(),
-                               filter, ctx, result, offset);
-}
-
 void SkGpuDevice::drawImage(const SkDraw& draw, const SkImage* image, SkScalar x, SkScalar y,
                             const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     SkMatrix viewMatrix = *draw.fMatrix;
     viewMatrix.preTranslate(x, y);
     if (as_IB(image)->peekTexture()) {
         CHECK_SHOULD_DRAW(draw);
         GrImageTextureAdjuster adjuster(as_IB(image));
         this->drawTextureProducer(&adjuster, nullptr, nullptr, SkCanvas::kFast_SrcRectConstraint,
                                   viewMatrix, fClip, paint);
@@ skipping 466 matching lines @@
     GrLayerHoister::UnlockLayers(fContext, atlasedNeedRendering);
     GrLayerHoister::UnlockLayers(fContext, atlasedRecycled);
     GrLayerHoister::End(fContext);
 
     return true;
 #else
     return false;
 #endif
 }
 
-SkImageFilter::Cache* SkGpuDevice::NewImageFilterCache() {
-    return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
-}
-
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
-    return SkGpuDevice::NewImageFilterCache();
+    return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif