Image filters: implement SkImage::makeWithFilter().

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 "SkBlurImageFilter.h"
 #include "SkCanvas.h"
@@ skipping 359 matching lines @@
                                                   kSkia8888_GrPixelConfig);
     } else
 #endif
     {
         const SkImageInfo info = SkImageInfo::MakeN32(widthHeight, widthHeight,
                                                       kOpaque_SkAlphaType);
         return SkSpecialSurface::MakeRaster(info);
     }
 }
 
+static sk_sp<SkSurface> create_surface(GrContext* context, int width, int height) {
+    const SkImageInfo info = SkImageInfo::MakeN32(width, height, kOpaque_SkAlphaType);
+#if SK_SUPPORT_GPU
+    if (context) {
+        return SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info);
+    } else
+#endif
+    {
+        return SkSurface::MakeRaster(info);
+    }
+}
+
 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);
 
@@ skipping 1272 matching lines @@
 
     // This should not crash (http://crbug.com/570479).
     canvas->drawRect(SkRect::MakeIWH(largeW, largeH), paint);
 }
 
 DEF_TEST(ImageFilterBlurLargeImage, reporter) {
     auto surface(SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
 
+static void test_make_with_filter(skiatest::Reporter* reporter, GrContext* context) {
+    sk_sp<SkSurface> surface(create_surface(context, 100, 100));
+    surface->getCanvas()->clear(SK_ColorRED);
+    SkPaint bluePaint;
+    bluePaint.setColor(SK_ColorBLUE);
+    SkIRect subset = SkIRect::MakeXYWH(25, 20, 50, 50);
+    surface->getCanvas()->drawRect(SkRect::Make(subset), bluePaint);
+    sk_sp<SkImage> sourceImage = surface->makeImageSnapshot();
+
+    sk_sp<SkImageFilter> filter = make_grayscale(nullptr, nullptr);
+    SkIRect clipBounds = SkIRect::MakeXYWH(30, 35, 100, 100);
+    SkIRect outSubset;
+    SkIPoint offset;
+    sk_sp<SkImage> result;
+
+    result = sourceImage->makeWithFilter(nullptr, subset, clipBounds, &outSubset, &offset);
+    REPORTER_ASSERT(reporter, !result);
+
+    result = sourceImage->makeWithFilter(filter.get(), subset, clipBounds, nullptr, &offset);
+    REPORTER_ASSERT(reporter, !result);
+
+    result = sourceImage->makeWithFilter(filter.get(), subset, clipBounds, &outSubset, nullptr);
+    REPORTER_ASSERT(reporter, !result);
+
+    SkIRect bigSubset = SkIRect::MakeXYWH(-10000, -10000, 20000, 20000);
+    result = sourceImage->makeWithFilter(filter.get(), bigSubset, clipBounds, &outSubset, &offset);
+    REPORTER_ASSERT(reporter, !result);
+
+    SkIRect empty = SkIRect::MakeEmpty();
+    result = sourceImage->makeWithFilter(filter.get(), empty, clipBounds, &outSubset, &offset);
+    REPORTER_ASSERT(reporter, !result);
+
+    result = sourceImage->makeWithFilter(filter.get(), subset, empty, &outSubset, &offset);
+    REPORTER_ASSERT(reporter, !result);
+
+    SkIRect leftField = SkIRect::MakeXYWH(-1000, 0, 100, 100);
+    result = sourceImage->makeWithFilter(filter.get(), subset, leftField, &outSubset, &offset);
+    REPORTER_ASSERT(reporter, !result);
+
+    result = sourceImage->makeWithFilter(filter.get(), subset, clipBounds, &outSubset, &offset);
+
+    REPORTER_ASSERT(reporter, result);
+    REPORTER_ASSERT(reporter, result->bounds().contains(outSubset));
+    SkIRect destRect = SkIRect::MakeXYWH(offset.x(), offset.y(),
+                                          outSubset.width(), outSubset.height());
+    REPORTER_ASSERT(reporter, clipBounds.contains(destRect));
+}
+
+DEF_TEST(ImageFilterMakeWithFilter, reporter) {
+    test_make_with_filter(reporter, nullptr);
+}
+
+#if SK_SUPPORT_GPU
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterMakeWithFilter_Gpu, reporter, ctxInfo) {
+    test_make_with_filter(reporter, ctxInfo.grContext());
+}
+#endif
+
 #if SK_SUPPORT_GPU
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterHugeBlur_Gpu, reporter, ctxInfo) {
 
     sk_sp<SkSurface> surf(SkSurface::MakeRenderTarget(ctxInfo.grContext(),
                                                       SkBudgeted::kNo,
                                                       SkImageInfo::MakeN32Premul(100, 100)));
 
 
     SkCanvas* canvas = surf->getCanvas();
@@ skipping 44 matching lines @@
         { SkColorFilterImageFilter::Make(cf, blif), false },
         { SkMergeImageFilter::Make(cfif, blif),     false },
         { SkComposeImageFilter::Make(blif, cfif),   false },
     };
     
     for (const auto& rec : recs) {
         const bool canHandle = rec.fFilter->canHandleComplexCTM();
         REPORTER_ASSERT(reporter, canHandle == rec.fExpectCanHandle);
     }
 }