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 "sk_tool_utils.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);
 static bool return_large = false;
 static bool return_undef = false;
@@ skipping 213 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(SkPaint::kSlight_Hinting);
+        paint.setAntiAlias(true);
+        paint.setDither(true);
+        paint.setLinearText(true);
+        paint.setSubpixelText(false);
+        paint.setLCDRenderText(false);
+        paint.setEmbeddedBitmapText(true);
+        paint.setAutohinted(false);
+        paint.setVerticalText(true);
+        paint.setUnderlineText(false);
+        paint.setStrikeThruText(true);
+        paint.setFakeBoldText(true);
+        paint.setDevKernText(false);
+        paint.setFilterQuality(kLow_SkFilterQuality);
+        paint.setStyle(SkPaint::kStroke_Style);
+        paint.setColor(SK_ColorRED);
+        paint.setStrokeWidth(SkIntToScalar(3));
+        paint.setStrokeMiter(SkIntToScalar(1));
+        paint.setStrokeCap(SkPaint::kRound_Cap);
+        paint.setStrokeJoin(SkPaint::kBevel_Join);
+        SkAutoTUnref<SkColorFilter> colorFilter(
+            SkColorFilter::CreateLightingFilter(make_color(), make_color()));
+        paint.setColorFilter(colorFilter);
+        paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
+        SkAutoTUnref<SkPathEffect> pathEffect(SkCornerPathEffect::Create(SkIntToScalar(3)));
+        paint.setPathEffect(pathEffect);
+        SkAutoTUnref<SkMaskFilter> maskFilter(
+            SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
+                                     SkIntToScalar(25),
+                                     SkBlurMaskFilter::kHighQuality_BlurFlag));
+        paint.setMaskFilter(maskFilter);
+        SkAutoTUnref<SkTypeface> typeface(
+            sk_tool_utils::create_portable_typeface("serif", SkTypeface::kBold));
+        paint.setTypeface(typeface);
+        SkLayerRasterizer::Builder rasterizerBuilder;
+        SkPaint paintForRasterizer;
+        rasterizerBuilder.addLayer(paintForRasterizer);
+        SkAutoTUnref<SkRasterizer> rasterizer(rasterizerBuilder.detachRasterizer());
+        paint.setRasterizer(rasterizer);
+        SkAutoTUnref<SkImageFilter> imageFilter(
+            SkBlurImageFilter::Create(SkIntToScalar(2), SkIntToScalar(2)));
+        paint.setImageFilter(imageFilter);
+        SkAutoDataUnref data(SkData::NewWithCString("This is an annotation."));
+        SkAutoTUnref<SkAnnotation> annotation(
+            SkAnnotation::Create(SkAnnotationKeys::Define_Named_Dest_Key(), data));
+        paint.setAnnotation(annotation);
+        paint.setTextAlign(SkPaint::kCenter_Align);
+        paint.setTextSize(SkIntToScalar(8));
+        paint.setTextScaleX(SkFloatToScalar(0.75));
+        paint.setTextSkewX(SkFloatToScalar(-0.25));
+        paint.setTextEncoding(SkPaint::kUTF16_TextEncoding);
+        SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
+                                                     SkIntToScalar(kBitmapSize)));

[ajuma, 2016/01/04 22:39:46]

Is it worthwhile also adding test cases that use some subset of these calls, or
will the fuzzer handle that automatically? Also, is the fuzzer continuously
being run by a bot (like ClusterFuzz) or do we need to do something to trigger
it?

[sugoi1, 2016/01/05 15:59:55]

You could choose to use each of these functions randomly, which would be nice
(as in 'if(random value) paint.function();'). You should also use make_scalar()
for scalars instead of hardcoded values. Same thing with bools, where you could
use '(R(2) == 1)' instead (you can create a make_bool() function if you find
that too tedious). Enums can also be randomized using the R() function and
casting to result to the appropriate enum. Try to randomize as many values as
possible.

[ajuma, 2016/01/06 20:53:39]

Thanks for the tips! (And also thanks for all the info about fuzzing.) I've made
the test more randomized now.

+        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);