Begin removing deprecated (and now, unused) ImageFilter code paths

tests/ImageFilterTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
-#include "SkBitmapDevice.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
 #include "SkColorFilterImageFilter.h"
 #include "SkColorMatrixFilter.h"
 #include "SkComposeImageFilter.h"
 #include "SkDisplacementMapEffect.h"
 #include "SkDropShadowImageFilter.h"
 #include "SkFlattenableSerialization.h"
 #include "SkGradientShader.h"
 #include "SkImage.h"
@@ skipping 11 matching lines @@
 #include "SkPoint3.h"
 #include "SkReadBuffer.h"
 #include "SkRect.h"
 #include "SkSpecialImage.h"
 #include "SkSpecialSurface.h"
 #include "SkSurface.h"
 #include "SkTableColorFilter.h"
 #include "SkTileImageFilter.h"
 #include "SkXfermodeImageFilter.h"
 #include "Test.h"
-#include "TestingSpecialImageAccess.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
-#include "SkGpuDevice.h"
 #endif
 
 static const int kBitmapSize = 4;
 
 namespace {
 
 class MatrixTestImageFilter : public SkImageFilter {
 public:
     static sk_sp<SkImageFilter> Make(skiatest::Reporter* reporter,
                                      const SkMatrix& expectedMatrix) {
@@ skipping 307 matching lines @@
     return SkColorFilterImageFilter::Make(std::move(filter), std::move(input), cropRect);
 }
 
 static sk_sp<SkImageFilter> make_blue(sk_sp<SkImageFilter> input,
                                       const SkImageFilter::CropRect* cropRect) {
     sk_sp<SkColorFilter> filter(SkColorFilter::MakeModeFilter(SK_ColorBLUE,
                                                               SkXfermode::kSrcIn_Mode));
     return SkColorFilterImageFilter::Make(std::move(filter), std::move(input), cropRect);
 }
 
-static sk_sp<SkSpecialSurface> create_empty_special_surface(GrContext* context,
-                                                            SkImageFilter::Proxy* proxy,
-                                                            int widthHeight) {
+static sk_sp<SkSpecialSurface> create_empty_special_surface(GrContext* context, int widthHeight) {
     if (context) {
         GrSurfaceDesc desc;
         desc.fConfig = kSkia8888_GrPixelConfig;
         desc.fFlags  = kRenderTarget_GrSurfaceFlag;
         desc.fWidth  = widthHeight;
         desc.fHeight = widthHeight;
-        return SkSpecialSurface::MakeRenderTarget(proxy, context, desc);
+        return SkSpecialSurface::MakeRenderTarget(context, desc);
     } else {
         const SkImageInfo info = SkImageInfo::MakeN32(widthHeight, widthHeight,
                                                       kOpaque_SkAlphaType);
-        return SkSpecialSurface::MakeRaster(proxy, info);
+        return SkSpecialSurface::MakeRaster(info);
     }
 }
 
-static sk_sp<SkSpecialImage> create_empty_special_image(GrContext* context,
-                                                        SkImageFilter::Proxy* proxy,
-                                                        int widthHeight) {
-    sk_sp<SkSpecialSurface> surf(create_empty_special_surface(context, proxy, widthHeight));
+static sk_sp<SkSpecialImage> create_empty_special_image(GrContext* context, int widthHeight) {
+    sk_sp<SkSpecialSurface> surf(create_empty_special_surface(context, widthHeight));
 
     SkASSERT(surf);
 
     SkCanvas* canvas = surf->getCanvas();
     SkASSERT(canvas);
 
     canvas->clear(0x0);
 
     return surf->makeImageSnapshot();
 }
@@ skipping 110 matching lines @@
                     0xFFFFFFFF, SK_Scalar1, SK_Scalar1, SK_Scalar1,
                     std::move(bmSrc)));
             SkCanvas canvas(result);
             SkRect r = SkRect::MakeWH(SkIntToScalar(kBitmapSize),
                                       SkIntToScalar(kBitmapSize));
             canvas.drawRect(r, paint);
         }
     }
 }
 
-static void test_crop_rects(SkImageFilter::Proxy* proxy,
-                            skiatest::Reporter* reporter,
+static void test_crop_rects(skiatest::Reporter* reporter,
                             GrContext* context) {
     // Check that all filters offset to their absolute crop rect,
     // unaffected by the input crop rect.
     // Tests pass by not asserting.
-    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 100));
+    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, 100));
     SkASSERT(srcImg);
 
     SkImageFilter::CropRect inputCropRect(SkRect::MakeXYWH(8, 13, 80, 80));
     SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(20, 30, 60, 60));
     sk_sp<SkImageFilter> input(make_grayscale(nullptr, &inputCropRect));
 
     FilterList filters(input, &cropRect);
 
     for (int i = 0; i < filters.count(); ++i) {
         SkImageFilter* filter = filters.getFilter(i);
         SkIPoint offset;
         SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(100, 100), nullptr);
         sk_sp<SkSpecialImage> resultImg(filter->filterImage(srcImg.get(), ctx, &offset));
         REPORTER_ASSERT_MESSAGE(reporter, resultImg, filters.getName(i));
         REPORTER_ASSERT_MESSAGE(reporter, offset.fX == 20 && offset.fY == 30, filters.getName(i));
     }
 }
 
-static void test_negative_blur_sigma(SkImageFilter::Proxy* proxy,
-                                     skiatest::Reporter* reporter,
+static void test_negative_blur_sigma(skiatest::Reporter* reporter,
                                      GrContext* context) {
     // Check that SkBlurImageFilter will accept a negative sigma, either in
     // the given arguments or after CTM application.
     const int width = 32, height = 32;
     const SkScalar five = SkIntToScalar(5);
 
     sk_sp<SkImageFilter> positiveFilter(SkBlurImageFilter::Make(five, five, nullptr));
     sk_sp<SkImageFilter> negativeFilter(SkBlurImageFilter::Make(-five, five, nullptr));
 
     SkBitmap gradient = make_gradient_circle(width, height);
-    sk_sp<SkSpecialImage> imgSrc(SkSpecialImage::MakeFromRaster(proxy,
-                                                                SkIRect::MakeWH(width, height),
+    sk_sp<SkSpecialImage> imgSrc(SkSpecialImage::MakeFromRaster(SkIRect::MakeWH(width, height),
                                                                 gradient));
 
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(32, 32), nullptr);
 
     sk_sp<SkSpecialImage> positiveResult1(positiveFilter->filterImage(imgSrc.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, positiveResult1);
 
     sk_sp<SkSpecialImage> negativeResult1(negativeFilter->filterImage(imgSrc.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, negativeResult1);
@@ skipping 43 matching lines @@
         diffs = memcmp(positiveResultBM1.getAddr32(0, y),
                        positiveResultBM2.getAddr32(0, y),
                        positiveResultBM1.rowBytes());
         REPORTER_ASSERT(reporter, !diffs);
         if (diffs) {
             break;
         }
     }
 }
 
-typedef void (*PFTest)(SkImageFilter::Proxy* proxy,
-                       skiatest::Reporter* reporter,
-                       GrContext* context);
-
-static void run_raster_test(skiatest::Reporter* reporter,
-                            int widthHeight,
-                            PFTest test) {
-    const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
-
-    const SkImageInfo info = SkImageInfo::MakeN32Premul(widthHeight, widthHeight);
-
-    sk_sp<SkBaseDevice> device(SkBitmapDevice::Create(info, props));
-    SkImageFilter::DeviceProxy proxy(device.get());
-
-    (*test)(&proxy, reporter, nullptr);
-}
-
-#if SK_SUPPORT_GPU
-static void run_gpu_test(skiatest::Reporter* reporter,
-                         GrContext* context,
-                         int widthHeight,
-                         PFTest test) {
-    const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
-
-    sk_sp<SkGpuDevice> device(SkGpuDevice::Create(context,
-                                                  SkBudgeted::kNo,
-                                                  SkImageInfo::MakeN32Premul(widthHeight,
-                                                                             widthHeight),
-                                                  0,
-                                                  &props,
-                                                  SkGpuDevice::kUninit_InitContents));
-    SkImageFilter::DeviceProxy proxy(device.get());
-
-    (*test)(&proxy, reporter, context);
-}
-#endif
-
 DEF_TEST(ImageFilterNegativeBlurSigma, reporter) {
-    run_raster_test(reporter, 100, test_negative_blur_sigma);
+    test_negative_blur_sigma(reporter, nullptr);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterNegativeBlurSigma_Gpu, reporter, ctxInfo) {
-    run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_negative_blur_sigma);
+    test_negative_blur_sigma(reporter, ctxInfo.fGrContext);
 }
 #endif
 
-static void test_zero_blur_sigma(SkImageFilter::Proxy* proxy,
-                                 skiatest::Reporter* reporter,
-                                 GrContext* context) {
+static void test_zero_blur_sigma(skiatest::Reporter* reporter, GrContext* context) {
     // Check that SkBlurImageFilter with a zero sigma and a non-zero srcOffset works correctly.
     SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(5, 0, 5, 10)));
     sk_sp<SkImageFilter> input(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
     sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(0, 0, std::move(input), &cropRect));
 
-    sk_sp<SkSpecialSurface> surf(create_empty_special_surface(context, proxy, 10));
+    sk_sp<SkSpecialSurface> surf(create_empty_special_surface(context, 10));
     surf->getCanvas()->clear(SK_ColorGREEN);
     sk_sp<SkSpecialImage> image(surf->makeImageSnapshot());
 
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(32, 32), nullptr);
 
     sk_sp<SkSpecialImage> result(filter->filterImage(image.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, offset.fX == 5 && offset.fY == 0);
     REPORTER_ASSERT(reporter, result);
     REPORTER_ASSERT(reporter, result->width() == 5 && result->height() == 10);
 
     SkBitmap resultBM;
 
     REPORTER_ASSERT(reporter, result->getROPixels(&resultBM));
 
     SkAutoLockPixels lock(resultBM);
     for (int y = 0; y < resultBM.height(); y++) {
         for (int x = 0; x < resultBM.width(); x++) {
             bool diff = *resultBM.getAddr32(x, y) != SK_ColorGREEN;
             REPORTER_ASSERT(reporter, !diff);
             if (diff) {
                 break;
             }
         }
     }
 }
 
 DEF_TEST(ImageFilterZeroBlurSigma, reporter) {
-    run_raster_test(reporter, 100, test_zero_blur_sigma);
+    test_zero_blur_sigma(reporter, nullptr);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterZeroBlurSigma_Gpu, reporter, ctxInfo) {
-    run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_zero_blur_sigma);
+    test_zero_blur_sigma(reporter, ctxInfo.fGrContext);
 }
 #endif
 
 
 // Tests that, even when an upstream filter has returned null (due to failure or clipping), a
 // downstream filter that affects transparent black still does so even with a nullptr input.
-static void test_fail_affects_transparent_black(SkImageFilter::Proxy* proxy,
-                                                skiatest::Reporter* reporter,
-                                                GrContext* context) {
+static void test_fail_affects_transparent_black(skiatest::Reporter* reporter, GrContext* context) {
     sk_sp<FailImageFilter> failFilter(new FailImageFilter());
-    sk_sp<SkSpecialImage> source(create_empty_special_image(context, proxy, 5));
+    sk_sp<SkSpecialImage> source(create_empty_special_image(context, 5));
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeXYWH(0, 0, 1, 1), nullptr);
     sk_sp<SkColorFilter> green(SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkXfermode::kSrc_Mode));
     SkASSERT(green->affectsTransparentBlack());
     sk_sp<SkImageFilter> greenFilter(SkColorFilterImageFilter::Make(std::move(green),
                                                                     std::move(failFilter)));
     SkIPoint offset;
     sk_sp<SkSpecialImage> result(greenFilter->filterImage(source.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, nullptr != result.get());
     if (result.get()) {
         SkBitmap resultBM;
         REPORTER_ASSERT(reporter, result->getROPixels(&resultBM));
         SkAutoLockPixels lock(resultBM);
         REPORTER_ASSERT(reporter, *resultBM.getAddr32(0, 0) == SK_ColorGREEN);
     }
 }
 
 DEF_TEST(ImageFilterFailAffectsTransparentBlack, reporter) {
-    run_raster_test(reporter, 100, test_fail_affects_transparent_black);
+    test_fail_affects_transparent_black(reporter, nullptr);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterFailAffectsTransparentBlack_Gpu, reporter, ctxInfo) {
-    run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_fail_affects_transparent_black);
+    test_fail_affects_transparent_black(reporter, ctxInfo.fGrContext);
 }
 #endif
 
 DEF_TEST(ImageFilterDrawTiled, reporter) {
     // Check that all filters when drawn tiled (with subsequent clip rects) exactly
     // match the same filters drawn with a single full-canvas bitmap draw.
     // Tests pass by not asserting.
 
     FilterList filters(nullptr);
 
@@ skipping 168 matching lines @@
     {
         sk_sp<SkImageFilter> composite(SkXfermodeImageFilter::Make(nullptr, nullptr,
                                                                    offset, nullptr));
         SkRect bounds = SkRect::MakeWH(100, 100);
         // Intentionally aliasing here, as that's what the real callers do.
         bounds = composite->computeFastBounds(bounds);
         REPORTER_ASSERT(reporter, bounds == SkRect::MakeWH(150, 100));
     }
 }
 
-static void test_imagefilter_merge_result_size(SkImageFilter::Proxy* proxy,
-                                               skiatest::Reporter* reporter,
-                                               GrContext* context) {
+static void test_imagefilter_merge_result_size(skiatest::Reporter* reporter, GrContext* context) {
     SkBitmap greenBM;
     greenBM.allocN32Pixels(20, 20);
     greenBM.eraseColor(SK_ColorGREEN);
     sk_sp<SkImage> greenImage(SkImage::MakeFromBitmap(greenBM));
     sk_sp<SkImageFilter> source(SkImageSource::Make(std::move(greenImage)));
     sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(source, source));
 
-    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 1));
+    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, 1));
 
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeXYWH(0, 0, 100, 100), nullptr);
     SkIPoint offset;
 
     sk_sp<SkSpecialImage> resultImg(merge->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, resultImg);
 
     REPORTER_ASSERT(reporter, resultImg->width() == 20 && resultImg->height() == 20);
 }
 
 DEF_TEST(ImageFilterMergeResultSize, reporter) {
-    run_raster_test(reporter, 100, test_imagefilter_merge_result_size);
+    test_imagefilter_merge_result_size(reporter, nullptr);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ImageFilterMergeResultSize_Gpu, reporter, ctxInfo) {
-    run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_imagefilter_merge_result_size);
+    test_imagefilter_merge_result_size(reporter, ctxInfo.fGrContext);
 }
 #endif
 
 static void draw_blurred_rect(SkCanvas* canvas) {
     SkPaint filterPaint;
     filterPaint.setColor(SK_ColorWHITE);
     filterPaint.setImageFilter(SkBlurImageFilter::Make(SkIntToScalar(8), 0, nullptr));
     canvas->saveLayer(nullptr, &filterPaint);
     SkPaint whitePaint;
     whitePaint.setColor(SK_ColorWHITE);
@@ skipping 109 matching lines @@
     SkPaint filterPaint;
     filterPaint.setImageFilter(std::move(filter));
     SkRect bounds = SkRect::MakeWH(1, 10);
     SkRect rect = SkRect::Make(SkIRect::MakeWH(width, height));
     SkPaint rectPaint;
     canvas.saveLayer(&bounds, &filterPaint);
     canvas.drawRect(rect, rectPaint);
     canvas.restore();
 }
 
-static void test_big_kernel(SkImageFilter::Proxy* proxy,
-                            skiatest::Reporter* reporter,
-                            GrContext* context) {
+static void test_big_kernel(skiatest::Reporter* reporter, GrContext* context) {
     // Check that a kernel that is too big for the GPU still works
     SkScalar identityKernel[49] = {
         0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 1, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0
     };
     SkISize kernelSize = SkISize::Make(7, 7);
     SkScalar gain = SK_Scalar1, bias = 0;
     SkIPoint kernelOffset = SkIPoint::Make(0, 0);
 
     sk_sp<SkImageFilter> filter(SkMatrixConvolutionImageFilter::Make(
                                         kernelSize, identityKernel, gain, bias, kernelOffset,
                                         SkMatrixConvolutionImageFilter::kClamp_TileMode,
                                         true, nullptr));
 
-    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 100));
+    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, 100));
     SkASSERT(srcImg);
 
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(100, 100), nullptr);
     sk_sp<SkSpecialImage> resultImg(filter->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, resultImg);
     REPORTER_ASSERT(reporter, SkToBool(context) == resultImg->isTextureBacked());
     REPORTER_ASSERT(reporter, resultImg->width() == 100 && resultImg->height() == 100);
     REPORTER_ASSERT(reporter, offset.fX == 0 && offset.fY == 0);
 }
 
 DEF_TEST(ImageFilterMatrixConvolutionBigKernel, reporter) {
-    run_raster_test(reporter, 100, test_big_kernel);
+    test_big_kernel(reporter, nullptr);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ImageFilterMatrixConvolutionBigKernel_Gpu,
                                       reporter, ctxInfo) {
-    run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_big_kernel);
+    test_big_kernel(reporter, ctxInfo.fGrContext);
 }
 #endif
 
 DEF_TEST(ImageFilterCropRect, reporter) {
-    run_raster_test(reporter, 100, test_crop_rects);
+    test_crop_rects(reporter, nullptr);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCropRect_Gpu, reporter, ctxInfo) {
-    run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_crop_rects);
+    test_crop_rects(reporter, ctxInfo.fGrContext);
 }
 #endif
 
 DEF_TEST(ImageFilterMatrix, reporter) {
     SkBitmap temp;
     temp.allocN32Pixels(100, 100);
     SkCanvas canvas(temp);
     canvas.scale(SkIntToScalar(2), SkIntToScalar(2));
 
     SkMatrix expectedMatrix = canvas.getTotalMatrix();
@@ skipping 68 matching lines @@
 
     canvas.clear(0x0);
     canvas.drawPicture(crossProcessPicture);
     pixel = *bitmap.getAddr32(0, 0);
     // If the security precautions are enabled, the result here should not be green, since the
     // filter draws nothing.
     REPORTER_ASSERT(reporter, SkPicture::PictureIOSecurityPrecautionsEnabled()
         ? pixel != SK_ColorGREEN : pixel == SK_ColorGREEN);
 }
 
-static void test_clipped_picture_imagefilter(SkImageFilter::Proxy* proxy,
-                                             skiatest::Reporter* reporter,
-                                             GrContext* context) {
+static void test_clipped_picture_imagefilter(skiatest::Reporter* reporter, GrContext* context) {
     sk_sp<SkPicture> picture;
 
     {
         SkRTreeFactory factory;
         SkPictureRecorder recorder;
         SkCanvas* recordingCanvas = recorder.beginRecording(1, 1, &factory, 0);
 
         // Create an SkPicture which simply draws a green 1x1 rectangle.
         SkPaint greenPaint;
         greenPaint.setColor(SK_ColorGREEN);
         recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(1, 1)), greenPaint);
         picture = recorder.finishRecordingAsPicture();
     }
 
-    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 2));
+    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, 2));
 
     sk_sp<SkImageFilter> imageFilter(SkPictureImageFilter::Make(picture));
 
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeXYWH(1, 1, 1, 1), nullptr);
 
     sk_sp<SkSpecialImage> resultImage(imageFilter->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, !resultImage);
 }
 
 DEF_TEST(ImageFilterClippedPictureImageFilter, reporter) {
-    run_raster_test(reporter, 2, test_clipped_picture_imagefilter);
+    test_clipped_picture_imagefilter(reporter, nullptr);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterClippedPictureImageFilter_Gpu, reporter, ctxInfo) {
-    run_gpu_test(reporter, ctxInfo.fGrContext, 2, test_clipped_picture_imagefilter);
+    test_clipped_picture_imagefilter(reporter, ctxInfo.fGrContext);
 }
 #endif
 
 DEF_TEST(ImageFilterEmptySaveLayer, reporter) {
     // Even when there's an empty saveLayer()/restore(), ensure that an image
     // filter or color filter which affects transparent black still draws.
 
     SkBitmap bitmap;
     bitmap.allocN32Pixels(10, 10);
     SkCanvas canvas(bitmap);
@@ skipping 213 matching lines @@
     REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
 }
 
 DEF_TEST(XfermodeImageFilterCroppedInput, reporter) {
     SkBitmap temp;
     temp.allocN32Pixels(100, 100);
     SkCanvas canvas(temp);
     test_xfermode_cropped_input(&canvas, reporter);
 }
 
-static void test_composed_imagefilter_offset(SkImageFilter::Proxy* proxy,
-                                             skiatest::Reporter* reporter,
-                                             GrContext* context) {
-    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 100));
+static void test_composed_imagefilter_offset(skiatest::Reporter* reporter, GrContext* context) {
+    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, 100));
 
     SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(1, 0, 20, 20));
     sk_sp<SkImageFilter> offsetFilter(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
     sk_sp<SkImageFilter> blurFilter(SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1,
                                                             nullptr, &cropRect));
     sk_sp<SkImageFilter> composedFilter(SkComposeImageFilter::Make(std::move(blurFilter),
                                                                    std::move(offsetFilter)));
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(100, 100), nullptr);
 
     sk_sp<SkSpecialImage> resultImg(composedFilter->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, resultImg);
     REPORTER_ASSERT(reporter, offset.fX == 1 && offset.fY == 0);
 }
 
 DEF_TEST(ComposedImageFilterOffset, reporter) {
-    run_raster_test(reporter, 100, test_composed_imagefilter_offset);
+    test_composed_imagefilter_offset(reporter, nullptr);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ComposedImageFilterOffset_Gpu, reporter, ctxInfo) {
-    run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_composed_imagefilter_offset);
+    test_composed_imagefilter_offset(reporter, ctxInfo.fGrContext);
 }
 #endif
 
-static void test_composed_imagefilter_bounds(SkImageFilter::Proxy* proxy,
-                                             skiatest::Reporter* reporter,
-                                             GrContext* context) {
+static void test_composed_imagefilter_bounds(skiatest::Reporter* reporter, GrContext* context) {
     // The bounds passed to the inner filter must be filtered by the outer
     // filter, so that the inner filter produces the pixels that the outer
     // filter requires as input. This matters if the outer filter moves pixels.
     // Here, accounting for the outer offset is necessary so that the green
     // pixels of the picture are not clipped.
 
     SkPictureRecorder recorder;
     SkCanvas* recordingCanvas = recorder.beginRecording(SkRect::MakeWH(200, 100));
     recordingCanvas->clipRect(SkRect::MakeXYWH(100, 0, 100, 100));
     recordingCanvas->clear(SK_ColorGREEN);
     sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     sk_sp<SkImageFilter> pictureFilter(SkPictureImageFilter::Make(picture));
     SkImageFilter::CropRect cropRect(SkRect::MakeWH(100, 100));
     sk_sp<SkImageFilter> offsetFilter(SkOffsetImageFilter::Make(-100, 0, nullptr, &cropRect));
     sk_sp<SkImageFilter> composedFilter(SkComposeImageFilter::Make(std::move(offsetFilter),
                                                                    std::move(pictureFilter)));
 
-    sk_sp<SkSpecialImage> sourceImage(create_empty_special_image(context, proxy, 100));
+    sk_sp<SkSpecialImage> sourceImage(create_empty_special_image(context, 100));
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(100, 100), nullptr);
     SkIPoint offset;
     sk_sp<SkSpecialImage> result(composedFilter->filterImage(sourceImage.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, offset.isZero());
     REPORTER_ASSERT(reporter, result);
     REPORTER_ASSERT(reporter, result->subset().size() == SkISize::Make(100, 100));
 
     SkBitmap resultBM;
     REPORTER_ASSERT(reporter, result->getROPixels(&resultBM));
     SkAutoLockPixels lock(resultBM);
     REPORTER_ASSERT(reporter, resultBM.getColor(50, 50) == SK_ColorGREEN);
 }
 
 DEF_TEST(ComposedImageFilterBounds, reporter) {
-    run_raster_test(reporter, 100, test_composed_imagefilter_bounds);
+    test_composed_imagefilter_bounds(reporter, nullptr);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ComposedImageFilterBounds_Gpu, reporter, ctxInfo) {
-    run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_composed_imagefilter_bounds);
+    test_composed_imagefilter_bounds(reporter, ctxInfo.fGrContext);
 }
 #endif
 
-static void test_partial_crop_rect(SkImageFilter::Proxy* proxy,
-                                   skiatest::Reporter* reporter,
-                                   GrContext* context) {
-    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 100));
+static void test_partial_crop_rect(skiatest::Reporter* reporter, GrContext* context) {
+    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, 100));
 
     SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(100, 0, 20, 30),
         SkImageFilter::CropRect::kHasWidth_CropEdge | SkImageFilter::CropRect::kHasHeight_CropEdge);
     sk_sp<SkImageFilter> filter(make_grayscale(nullptr, &cropRect));
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(100, 100), nullptr);
 
     sk_sp<SkSpecialImage> resultImg(filter->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, resultImg);
 
     REPORTER_ASSERT(reporter, offset.fX == 0);
     REPORTER_ASSERT(reporter, offset.fY == 0);
     REPORTER_ASSERT(reporter, resultImg->width() == 20);
     REPORTER_ASSERT(reporter, resultImg->height() == 30);
 }
 
 DEF_TEST(ImageFilterPartialCropRect, reporter) {
-    run_raster_test(reporter, 100, test_partial_crop_rect);
+    test_partial_crop_rect(reporter, nullptr);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterPartialCropRect_Gpu, reporter, ctxInfo) {
-    run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_partial_crop_rect);
+    test_partial_crop_rect(reporter, ctxInfo.fGrContext);
 }
 #endif
 
 DEF_TEST(ImageFilterCanComputeFastBounds, reporter) {
 
     {
         SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
         sk_sp<SkImageFilter> lighting(SkLightingImageFilter::MakePointLitDiffuse(location,
                                                                                  SK_ColorGREEN,
                                                                                  0, 0, nullptr));
@@ skipping 120 matching lines @@
 }
 
 DEF_TEST(ImageFilterBlurLargeImage, reporter) {
     auto surface(SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
 
 #if SK_SUPPORT_GPU
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterHugeBlur_Gpu, reporter, ctxInfo) {
-    const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
 
-    sk_sp<SkGpuDevice> device(SkGpuDevice::Create(ctxInfo.fGrContext,
-                                                  SkBudgeted::kNo,
-                                                  SkImageInfo::MakeN32Premul(100, 100),
-                                                  0,
-                                                  &props,
-                                                  SkGpuDevice::kUninit_InitContents));
-    SkCanvas canvas(device.get());
+    sk_sp<SkSurface> surf(SkSurface::MakeRenderTarget(ctxInfo.fGrContext,
+                                                      SkBudgeted::kNo,
+                                                      SkImageInfo::MakeN32Premul(100, 100)));
 
-    test_huge_blur(&canvas, reporter);
+
+    SkCanvas* canvas = surf->getCanvas();
+
+    test_huge_blur(canvas, reporter);
 }
 
 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(XfermodeImageFilterCroppedInput_Gpu, reporter, ctxInfo) {
-    const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
 
-    sk_sp<SkGpuDevice> device(SkGpuDevice::Create(ctxInfo.fGrContext,
-                                                  SkBudgeted::kNo,
-                                                  SkImageInfo::MakeN32Premul(1, 1),
-                                                  0,
-                                                  &props,
-                                                  SkGpuDevice::kUninit_InitContents));
-    SkCanvas canvas(device.get());
+    sk_sp<SkSurface> surf(SkSurface::MakeRenderTarget(ctxInfo.fGrContext,
+                                                      SkBudgeted::kNo,
+                                                      SkImageInfo::MakeN32Premul(1, 1)));
 
-    test_xfermode_cropped_input(&canvas, reporter);
+
+    SkCanvas* canvas = surf->getCanvas();
+
+    test_xfermode_cropped_input(canvas, reporter);
 }
 
 DEF_GPUTEST_FOR_ALL_GL_CONTEXTS(ImageFilterBlurLargeImage_Gpu, reporter, ctxInfo) {
     auto surface(SkSurface::MakeRenderTarget(ctxInfo.fGrContext, SkBudgeted::kYes,
                                              SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
 #endif