Implement an SkPaint-based image filter

samplecode/SampleFilterFuzz.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 "SampleCode.h"
 #include "SkAlphaThresholdFilter.h"
+#include "SkAnnotation.h"
 #include "SkBlurImageFilter.h"
+#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkColorCubeFilter.h"
 #include "SkColorFilter.h"
 #include "SkColorFilterImageFilter.h"
 #include "SkComposeImageFilter.h"
+#include "SkCornerPathEffect.h"
 #include "SkData.h"
 #include "SkDisplacementMapEffect.h"
 #include "SkDropShadowImageFilter.h"
 #include "SkFlattenableSerialization.h"
 #include "SkImageSource.h"
+#include "SkLayerRasterizer.h"
 #include "SkLightingImageFilter.h"
 #include "SkMagnifierImageFilter.h"
 #include "SkMatrixConvolutionImageFilter.h"
 #include "SkMergeImageFilter.h"
 #include "SkMorphologyImageFilter.h"
 #include "SkOffsetImageFilter.h"
+#include "SkPaintImageFilter.h"
 #include "SkPerlinNoiseShader.h"
 #include "SkPictureImageFilter.h"
 #include "SkPictureRecorder.h"
 #include "SkPoint3.h"
 #include "SkRandom.h"
-#include "SkRectShaderImageFilter.h"
 #include "SkTestImageFilters.h"
 #include "SkTileImageFilter.h"
+#include "SkTypeface.h"
 #include "SkView.h"
 #include "SkXfermodeImageFilter.h"
 #include <stdio.h>
 #include <time.h>
 
 //#define SK_ADD_RANDOM_BIT_FLIPS
 //#define SK_FUZZER_IS_VERBOSE
 
 static const uint32_t kSeed = (uint32_t)(time(nullptr));
 static SkRandom gRand(kSeed);
@@ skipping 43 matching lines @@
     }
 
     if (!positiveOnly && (R(4) == 1)) v = -v;
     return v;
 }
 
 static SkScalar make_scalar(bool positiveOnly = false) {
     return make_number(positiveOnly);
 }
 
+static SkString make_string() {
+    int length = R(1000);
+    SkString str(length);
+    for (int i = 0; i < length; ++i) {
+        str[i] = static_cast<char>(R(256));
+    }
+    return str;
+}
+
+static const char* make_font_name() {
+    int sel = R(8);
+
+    switch(sel) {
+        case 0: return "Courier New";
+        case 1: return "Helvetica";
+        case 3: return "monospace";
+        case 4: return "sans-serif";
+        case 5: return "serif";
+        case 6: return "Times";
+        case 7:
+        default:
+            return "Times New Roman";

[sugoi1, 2016/01/07 16:06:20]

Nit: Maybe add an option to get a garbage string.

[ajuma, 2016/01/08 17:44:28]

Done.

+    }
+}
+
+static bool make_bool() {
+    return R(2) == 1;
+}
+
 static SkRect make_rect() {
     return SkRect::MakeWH(SkIntToScalar(R(static_cast<float>(kBitmapSize))),
                           SkIntToScalar(R(static_cast<float>(kBitmapSize))));
 }
 
 static SkRegion make_region() {
     SkIRect iRegion = SkIRect::MakeXYWH(R(static_cast<float>(kBitmapSize)),
                                         R(static_cast<float>(kBitmapSize)),
                                         R(static_cast<float>(kBitmapSize)),
                                         R(static_cast<float>(kBitmapSize)));
     return SkRegion(iRegion);
 }
 
 static SkMatrix make_matrix() {
     SkMatrix m;
     for (int i = 0; i < 9; ++i) {
         m[i] = make_scalar();
     }
     return m;
 }
 
 static SkXfermode::Mode make_xfermode() {
     return static_cast<SkXfermode::Mode>(R(SkXfermode::kLastMode+1));
 }
 
+static SkPaint::Align make_paint_align() {
+    return static_cast<SkPaint::Align>(R(SkPaint::kRight_Align+1));
+}
+
+static SkPaint::Hinting make_paint_hinting() {
+    return static_cast<SkPaint::Hinting>(R(SkPaint::kFull_Hinting+1));
+}
+
+static SkPaint::Style make_paint_style() {
+    return static_cast<SkPaint::Style>(R(SkPaint::kStrokeAndFill_Style+1));
+}
+
+static SkPaint::Cap make_paint_cap() {
+    return static_cast<SkPaint::Cap>(R(SkPaint::kDefault_Cap+1));
+}
+
+static SkPaint::Join make_paint_join() {
+    return static_cast<SkPaint::Join>(R(SkPaint::kDefault_Join+1));
+}
+
+static SkPaint::TextEncoding make_paint_text_encoding() {
+    return static_cast<SkPaint::TextEncoding>(R(SkPaint::kGlyphID_TextEncoding+1));
+}
+
+static SkBlurStyle make_blur_style() {
+    return static_cast<SkBlurStyle>(R(kLastEnum_SkBlurStyle+1));
+}
+
+static SkBlurMaskFilter::BlurFlags make_blur_mask_filter_flag() {
+    return static_cast<SkBlurMaskFilter::BlurFlags>(R(SkBlurMaskFilter::kAll_BlurFlag+1));
+}
+
+static SkFilterQuality make_filter_quality() {
+    return static_cast<SkFilterQuality>(R(kHigh_SkFilterQuality+1));
+}
+
+static SkTypeface::Style make_typeface_style() {
+    return static_cast<SkTypeface::Style>(R(SkTypeface::kBoldItalic+1));
+}
+
 static SkColor make_color() {
     return (R(2) == 1) ? 0xFFC0F0A0 : 0xFF000090;
 }
 
 static SkDropShadowImageFilter::ShadowMode make_shadow_mode() {
     return (R(2) == 1) ? SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode :
                          SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode;
 }
 
 static SkPoint3 make_point() {
@@ skipping 127 matching lines @@
 
 static SkImageFilter* make_image_filter(bool canBeNull = true) {
     SkImageFilter* filter = 0;
 
     // Add a 1 in 3 chance to get a nullptr input
     if (canBeNull && (R(3) == 1)) { return filter; }
 
     enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
            DOWN_SAMPLE, XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
            DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
-           MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, NUM_FILTERS };
+           MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS };
 
     switch (R(NUM_FILTERS)) {
     case ALPHA_THRESHOLD:
         filter = SkAlphaThresholdFilter::Create(make_region(), make_scalar(), make_scalar());
         break;
     case MERGE:
         filter = SkMergeImageFilter::Create(make_image_filter(), make_image_filter(), make_xfermode());
         break;
     case COLOR:
     {
@@ skipping 85 matching lines @@
                  make_point(), make_scalar(), make_scalar(), make_color(),
                  make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_filter());
         break;
     case NOISE:
     {
         SkAutoTUnref<SkShader> shader((R(2) == 1) ?
             SkPerlinNoiseShader::CreateFractalNoise(
                 make_scalar(true), make_scalar(true), R(10.0f), make_scalar()) :
             SkPerlinNoiseShader::CreateTurbulence(
                 make_scalar(true), make_scalar(true), R(10.0f), make_scalar()));
+        SkPaint paint;
+        paint.setShader(shader);
         SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
                                                      SkIntToScalar(kBitmapSize)));
-        filter = SkRectShaderImageFilter::Create(shader, &cropR);
+        filter = SkPaintImageFilter::Create(paint, &cropR);
     }
         break;
     case DROP_SHADOW:
         filter = SkDropShadowImageFilter::Create(make_scalar(), make_scalar(), make_scalar(true),
                     make_scalar(true), make_color(), make_shadow_mode(), make_image_filter(),
                     nullptr);
         break;
     case MORPHOLOGY:
         if (R(2) == 1) {
             filter = SkDilateImageFilter::Create(R(static_cast<float>(kBitmapSize)),
@@ skipping 26 matching lines @@
         SkRTreeFactory factory;
         SkPictureRecorder recorder;
         SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize), 
                                                             SkIntToScalar(kBitmapSize), 
                                                             &factory, 0);
         drawSomething(recordingCanvas);
         SkAutoTUnref<SkPicture> pict(recorder.endRecording());
         filter = SkPictureImageFilter::Create(pict.get(), make_rect());
     }
         break;
+    case PAINT:
+    {
+        SkPaint paint;
+        paint.setHinting(make_paint_hinting());
+        paint.setAntiAlias(make_bool());
+        paint.setDither(make_bool());
+        paint.setLinearText(make_bool());
+        paint.setSubpixelText(make_bool());
+        paint.setLCDRenderText(make_bool());
+        paint.setEmbeddedBitmapText(make_bool());
+        paint.setAutohinted(make_bool());
+        paint.setVerticalText(make_bool());
+        paint.setUnderlineText(make_bool());
+        paint.setStrikeThruText(make_bool());
+        paint.setFakeBoldText(make_bool());
+        paint.setDevKernText(make_bool());
+        paint.setFilterQuality(make_filter_quality());
+        paint.setStyle(make_paint_style());
+        paint.setColor(make_color());
+        paint.setStrokeWidth(make_scalar());
+        paint.setStrokeMiter(make_scalar());
+        paint.setStrokeCap(make_paint_cap());
+        paint.setStrokeJoin(make_paint_join());
+        SkAutoTUnref<SkColorFilter> colorFilter(
+            SkColorFilter::CreateLightingFilter(make_color(), make_color()));

[Stephen White, 2016/01/07 16:17:33]

Not new to this CL, but when it comes to SkColorFilters, it looks
like we're only testing the lighting and mode filters. We should be 
exercising all of the ones exposed to serialization, including
SkColorMatrixFilter, SkLumaColorFilter, SkTableColorFilter.

I'd make a helper that randomly creates one of those (or null).

[ajuma, 2016/01/08 17:44:28]

Done.

+        paint.setColorFilter(colorFilter);
+        paint.setXfermodeMode(make_xfermode());
+        SkAutoTUnref<SkPathEffect> pathEffect(SkCornerPathEffect::Create(make_scalar()));

[Stephen White, 2016/01/07 16:17:33]

We should be exercising all the serializable path effects: SkArcToPathEffect,
SkComposePathEffect, SkDashPathEffect, SkDiscretePathEffect, SkPath1DPathEffect,
SkLine2DPathEffect, SkPath2DPathEffect, SkSumPathEffect.

Unlike the color filters above, this *is* new to this CL.

[ajuma, 2016/01/08 17:44:28]

Done.

+        paint.setPathEffect(pathEffect);
+        SkAutoTUnref<SkMaskFilter> maskFilter(
+            SkBlurMaskFilter::Create(make_blur_style(),

[Stephen White, 2016/01/07 16:17:33]

Also SkEmbossMaskFilter.

[ajuma, 2016/01/08 17:44:28]

Done.

+                                     make_scalar(),
+                                     make_blur_mask_filter_flag()));
+        paint.setMaskFilter(maskFilter);
+        SkAutoTUnref<SkTypeface> typeface(
+            SkTypeface::CreateFromName(make_font_name(), make_typeface_style()));
+        paint.setTypeface(typeface);
+        SkLayerRasterizer::Builder rasterizerBuilder;
+        SkPaint paintForRasterizer;
+        rasterizerBuilder.addLayer(paintForRasterizer);
+        SkAutoTUnref<SkRasterizer> rasterizer(rasterizerBuilder.detachRasterizer());
+        paint.setRasterizer(rasterizer);
+        paint.setImageFilter(make_image_filter());
+        SkAutoDataUnref data(make_3Dlut(nullptr, make_bool(), make_bool(), make_bool()));
+        SkAutoTUnref<SkAnnotation> annotation(
+            SkAnnotation::Create(make_string().c_str(), data));
+        paint.setAnnotation(annotation);
+        paint.setTextAlign(make_paint_align());
+        paint.setTextSize(make_scalar());
+        paint.setTextScaleX(make_scalar());
+        paint.setTextSkewX(make_scalar());
+        paint.setTextEncoding(make_paint_text_encoding());
+        SkImageFilter::CropRect cropR(make_rect());
+        filter = SkPaintImageFilter::Create(paint, &cropR);
+    }
     default:
         break;
     }
     return (filter || canBeNull) ? filter : make_image_filter(canBeNull);
 }
 
 static SkImageFilter* make_serialized_image_filter() {
     SkAutoTUnref<SkImageFilter> filter(make_image_filter(false));
     SkAutoTUnref<SkData> data(SkValidatingSerializeFlattenable(filter));
     const unsigned char* ptr = static_cast<const unsigned char*>(data->data());
@@ skipping 83 matching lines @@
     }
 
 private:
     typedef SkView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* MyFactory() { return new ImageFilterFuzzView; }
 static SkViewRegister reg(MyFactory);