fuzz/FilterFuzz.cpp

   1 /*
   2  * Copyright 2013 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7 #include "Fuzz.h"
   8 #include "Sk1DPathEffect.h"
   9 #include "Sk2DPathEffect.h"
  10 #include "SkAlphaThresholdFilter.h"
  11 #include "SkArcToPathEffect.h"
  12 #include "SkBlurImageFilter.h"
  13 #include "SkBlurMaskFilter.h"
  14 #include "SkCanvas.h"
  15 #include "SkColorCubeFilter.h"
  16 #include "SkColorFilter.h"
  17 #include "SkColorFilterImageFilter.h"
  18 #include "SkColorMatrixFilter.h"
  19 #include "SkComposeImageFilter.h"
  20 #include "SkCornerPathEffect.h"
  21 #include "SkDashPathEffect.h"
  22 #include "SkData.h"
  23 #include "SkDiscretePathEffect.h"
  24 #include "SkDisplacementMapEffect.h"
  25 #include "SkDropShadowImageFilter.h"
  26 #include "SkEmbossMaskFilter.h"
  27 #include "SkFlattenableSerialization.h"
  28 #include "SkImageSource.h"
  29 #include "SkLayerRasterizer.h"
  30 #include "SkLightingImageFilter.h"
  31 #include "SkLumaColorFilter.h"
  32 #include "SkMagnifierImageFilter.h"
  33 #include "SkMatrixConvolutionImageFilter.h"
  34 #include "SkMergeImageFilter.h"
  35 #include "SkMorphologyImageFilter.h"
  36 #include "SkOffsetImageFilter.h"
  37 #include "SkPaintImageFilter.h"
  38 #include "SkPerlinNoiseShader.h"
  39 #include "SkPictureImageFilter.h"
  40 #include "SkPictureRecorder.h"
  41 #include "SkPoint3.h"
  42 #include "SkRandom.h"
  43 #include "SkTableColorFilter.h"
  44 #include "SkTileImageFilter.h"
  45 #include "SkTypeface.h"
  46 #include "SkXfermodeImageFilter.h"
  47 #include <stdio.h>
  48 #include <time.h>
  49
  50 #define SK_ADD_RANDOM_BIT_FLIPS
  51
  52 static Fuzz* fuzz;
  53 static const int kBitmapSize = 24;
  54
  55 static bool return_large = false;
  56 static bool return_undef = false;
  57
  58 static int R(float x) {
  59     return (int)floor(SkScalarToFloat(fuzz->nextF1()) * x);
  60 }
  61
  62 #if defined _WIN32
  63 #pragma warning ( push )
  64 // we are intentionally causing an overflow here
  65 //      (warning C4756: overflow in constant arithmetic)
  66 #pragma warning ( disable : 4756 )
  67 #endif
  68
  69 static float huge() {
  70     double d = 1e100;
  71     float f = (float)d;
  72     return f;
  73 }
  74
  75 #if defined _WIN32
  76 #pragma warning ( pop )
  77 #endif
  78
  79 static float make_number(bool positiveOnly) {
  80     float f = positiveOnly ? 1.0f : 0.0f;
  81     float v = f;
  82     int sel;
  83
  84     if (return_large) sel = R(6); else sel = R(4);
  85     if (!return_undef && sel == 0) sel = 1;
  86
  87     if (R(2) == 1) v = (float)(R(100)+f); else
  88
  89     switch (sel) {
  90         case 0: break;
  91         case 1: v = f; break;
  92         case 2: v = 0.000001f; break;
  93         case 3: v = 10000.0f; break;
  94         case 4: v = 2000000000.0f; break;
  95         case 5: v = huge(); break;
  96     }
  97
  98     if (!positiveOnly && (R(4) == 1)) v = -v;
  99     return v;
 100 }
 101
 102 static SkScalar make_scalar(bool positiveOnly = false) {
 103     return make_number(positiveOnly);
 104 }
 105
 106 static SkString make_string() {
 107     int length = R(1000);
 108     SkString str(length);
 109     for (int i = 0; i < length; ++i) {
 110         str[i] = static_cast<char>(R(256));
 111     }
 112     return str;
 113 }
 114
 115 static SkString make_font_name() {
 116     int sel = R(8);
 117
 118     switch(sel) {
 119         case 0: return SkString("Courier New");
 120         case 1: return SkString("Helvetica");
 121         case 2: return SkString("monospace");
 122         case 3: return SkString("sans-serif");
 123         case 4: return SkString("serif");
 124         case 5: return SkString("Times");
 125         case 6: return SkString("Times New Roman");
 126         case 7:
 127         default:
 128             return make_string();
 129     }
 130 }
 131
 132 static bool make_bool() {
 133     return R(2) == 1;
 134 }
 135
 136 static SkRect make_rect() {
 137     return SkRect::MakeWH(SkIntToScalar(R(static_cast<float>(kBitmapSize))),
 138                           SkIntToScalar(R(static_cast<float>(kBitmapSize))));
 139 }
 140
 141 static SkRegion make_region() {
 142     SkIRect iRegion = SkIRect::MakeXYWH(R(static_cast<float>(kBitmapSize)),
 143                                         R(static_cast<float>(kBitmapSize)),
 144                                         R(static_cast<float>(kBitmapSize)),
 145                                         R(static_cast<float>(kBitmapSize)));
 146     return SkRegion(iRegion);
 147 }
 148
 149 static SkMatrix make_matrix() {
 150     SkMatrix m;
 151     for (int i = 0; i < 9; ++i) {
 152         m[i] = make_scalar();
 153     }
 154     return m;
 155 }
 156
 157 static SkXfermode::Mode make_xfermode() {
 158     return static_cast<SkXfermode::Mode>(R(SkXfermode::kLastMode+1));
 159 }
 160
 161 static SkPaint::Align make_paint_align() {
 162     return static_cast<SkPaint::Align>(R(SkPaint::kRight_Align+1));
 163 }
 164
 165 static SkPaint::Hinting make_paint_hinting() {
 166     return static_cast<SkPaint::Hinting>(R(SkPaint::kFull_Hinting+1));
 167 }
 168
 169 static SkPaint::Style make_paint_style() {
 170     return static_cast<SkPaint::Style>(R(SkPaint::kStrokeAndFill_Style+1));
 171 }
 172
 173 static SkPaint::Cap make_paint_cap() {
 174     return static_cast<SkPaint::Cap>(R(SkPaint::kDefault_Cap+1));
 175 }
 176
 177 static SkPaint::Join make_paint_join() {
 178     return static_cast<SkPaint::Join>(R(SkPaint::kDefault_Join+1));
 179 }
 180
 181 static SkPaint::TextEncoding make_paint_text_encoding() {
 182     return static_cast<SkPaint::TextEncoding>(R(SkPaint::kGlyphID_TextEncoding+1));
 183 }
 184
 185 static SkBlurStyle make_blur_style() {
 186     return static_cast<SkBlurStyle>(R(kLastEnum_SkBlurStyle+1));
 187 }
 188
 189 static SkBlurMaskFilter::BlurFlags make_blur_mask_filter_flag() {
 190     return static_cast<SkBlurMaskFilter::BlurFlags>(R(SkBlurMaskFilter::kAll_BlurFlag+1));
 191 }
 192
 193 static SkFilterQuality make_filter_quality() {
 194     return static_cast<SkFilterQuality>(R(kHigh_SkFilterQuality+1));
 195 }
 196
 197 static SkFontStyle make_typeface_style() {
 198     return SkFontStyle::FromOldStyle(R(SkTypeface::kBoldItalic+1));
 199 }
 200
 201 static SkPath1DPathEffect::Style make_path_1d_path_effect_style() {
 202     return static_cast<SkPath1DPathEffect::Style>(R((int)SkPath1DPathEffect::kLastEnum_Style + 1));
 203 }
 204
 205 static SkColor make_color() {
 206     return (R(2) == 1) ? 0xFFC0F0A0 : 0xFF000090;
 207 }
 208
 209 static SkDropShadowImageFilter::ShadowMode make_shadow_mode() {
 210     return (R(2) == 1) ? SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode :
 211                          SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode;
 212 }
 213
 214 static SkPoint3 make_point() {
 215     return SkPoint3::Make(make_scalar(), make_scalar(), make_scalar(true));
 216 }
 217
 218 static SkDisplacementMapEffect::ChannelSelectorType make_channel_selector_type() {
 219     return static_cast<SkDisplacementMapEffect::ChannelSelectorType>(R(4)+1);
 220 }
 221
 222 static bool valid_for_raster_canvas(const SkImageInfo& info) {
 223     switch (info.colorType()) {
 224         case kAlpha_8_SkColorType:
 225         case kRGB_565_SkColorType:
 226             return true;
 227         case kN32_SkColorType:
 228             return kPremul_SkAlphaType == info.alphaType() ||
 229                    kOpaque_SkAlphaType == info.alphaType();
 230         default:
 231             break;
 232     }
 233     return false;
 234 }
 235
 236 static SkColorType rand_colortype() {
 237     return (SkColorType)R(kLastEnum_SkColorType + 1);
 238 }
 239
 240 static void rand_bitmap_for_canvas(SkBitmap* bitmap) {
 241     SkImageInfo info;
 242     do {
 243         info = SkImageInfo::Make(kBitmapSize, kBitmapSize, rand_colortype(),
 244                                  kPremul_SkAlphaType);
 245     } while (!valid_for_raster_canvas(info) || !bitmap->tryAllocPixels(info));
 246 }
 247
 248 static void make_g_bitmap(SkBitmap& bitmap) {
 249     rand_bitmap_for_canvas(&bitmap);
 250
 251     SkCanvas canvas(bitmap);
 252     canvas.clear(0x00000000);
 253     SkPaint paint;
 254     paint.setAntiAlias(true);
 255     paint.setColor(0xFF884422);
 256     paint.setTextSize(SkIntToScalar(kBitmapSize/2));
 257     const char* str = "g";
 258     canvas.drawText(str, strlen(str), SkIntToScalar(kBitmapSize/8),
 259                     SkIntToScalar(kBitmapSize/4), paint);
 260 }
 261
 262 static void make_checkerboard_bitmap(SkBitmap& bitmap) {
 263     rand_bitmap_for_canvas(&bitmap);
 264
 265     SkCanvas canvas(bitmap);
 266     canvas.clear(0x00000000);
 267     SkPaint darkPaint;
 268     darkPaint.setColor(0xFF804020);
 269     SkPaint lightPaint;
 270     lightPaint.setColor(0xFF244484);
 271     const int i = kBitmapSize / 8;
 272     const SkScalar f = SkIntToScalar(i);
 273     for (int y = 0; y < kBitmapSize; y += i) {
 274         for (int x = 0; x < kBitmapSize; x += i) {
 275             canvas.save();
 276             canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
 277             canvas.drawRect(SkRect::MakeXYWH(0, 0, f, f), darkPaint);
 278             canvas.drawRect(SkRect::MakeXYWH(f, 0, f, f), lightPaint);
 279             canvas.drawRect(SkRect::MakeXYWH(0, f, f, f), lightPaint);
 280             canvas.drawRect(SkRect::MakeXYWH(f, f, f, f), darkPaint);
 281             canvas.restore();
 282         }
 283     }
 284 }
 285
 286 static const SkBitmap& make_bitmap() {
 287     static SkBitmap bitmap[2];
 288     static bool initialized = false;
 289     if (!initialized) {
 290         make_g_bitmap(bitmap[0]);
 291         make_checkerboard_bitmap(bitmap[1]);
 292         initialized = true;
 293     }
 294     return bitmap[R(2)];
 295 }
 296
 297 static sk_sp<SkData> make_3Dlut(int* cubeDimension, bool invR, bool invG, bool invB) {
 298     int size = 4 << R(5);
 299     auto data = SkData::MakeUninitialized(sizeof(SkColor) * size * size * size);
 300     SkColor* pixels = (SkColor*)(data->writable_data());
 301     SkAutoTMalloc<uint8_t> lutMemory(size);
 302     SkAutoTMalloc<uint8_t> invLutMemory(size);
 303     uint8_t* lut = lutMemory.get();
 304     uint8_t* invLut = invLutMemory.get();
 305     const int maxIndex = size - 1;
 306     for (int i = 0; i < size; i++) {
 307         lut[i] = (i * 255) / maxIndex;
 308         invLut[i] = ((maxIndex - i) * 255) / maxIndex;
 309     }
 310     for (int r = 0; r < size; ++r) {
 311         for (int g = 0; g < size; ++g) {
 312             for (int b = 0; b < size; ++b) {
 313                 pixels[(size * ((size * b) + g)) + r] = SkColorSetARGB(0xFF,
 314                         invR ? invLut[r] : lut[r],
 315                         invG ? invLut[g] : lut[g],
 316                         invB ? invLut[b] : lut[b]);
 317             }
 318         }
 319     }
 320     if (cubeDimension) {
 321         *cubeDimension = size;
 322     }
 323     return data;
 324 }
 325
 326 static void drawSomething(SkCanvas* canvas) {
 327     SkPaint paint;
 328
 329     canvas->save();
 330     canvas->scale(0.5f, 0.5f);
 331     canvas->drawBitmap(make_bitmap(), 0, 0, nullptr);
 332     canvas->restore();
 333
 334     paint.setAntiAlias(true);
 335
 336     paint.setColor(SK_ColorRED);
 337     canvas->drawCircle(SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/3), paint);
 338     paint.setColor(SK_ColorBLACK);
 339     paint.setTextSize(SkIntToScalar(kBitmapSize/3));
 340     canvas->drawText("Picture", 7, SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
 341 }
 342
 343 static void rand_color_table(uint8_t* table) {
 344     for (int i = 0; i < 256; ++i) {
 345         table[i] = R(256);
 346     }
 347 }
 348
 349 static sk_sp<SkColorFilter> make_color_filter() {
 350     switch (R(6)) {
 351         case 0: {
 352             SkScalar array[20];
 353             for (int i = 0; i < 20; ++i) {
 354                 array[i] = make_scalar();
 355             }
 356             return SkColorFilter::MakeMatrixFilterRowMajor255(array);
 357         }
 358         case 1:
 359             return SkLumaColorFilter::Make();
 360         case 2: {
 361             uint8_t tableA[256];
 362             uint8_t tableR[256];
 363             uint8_t tableG[256];
 364             uint8_t tableB[256];
 365             rand_color_table(tableA);
 366             rand_color_table(tableR);
 367             rand_color_table(tableG);
 368             rand_color_table(tableB);
 369             return SkTableColorFilter::MakeARGB(tableA, tableR, tableG, tableB);
 370         }
 371         case 3:
 372             return SkColorFilter::MakeModeFilter(make_color(), make_xfermode());
 373         case 4:
 374             return SkColorMatrixFilter::MakeLightingFilter(make_color(), make_color());
 375         case 5:
 376         default:
 377             break;
 378     }
 379     return nullptr;
 380 }
 381
 382 static SkPath make_path() {
 383     SkPath path;
 384     int numOps = R(30);
 385     for (int i = 0; i < numOps; ++i) {
 386         switch (R(6)) {
 387             case 0:
 388                 path.moveTo(make_scalar(), make_scalar());
 389                 break;
 390             case 1:
 391                 path.lineTo(make_scalar(), make_scalar());
 392                 break;
 393             case 2:
 394                 path.quadTo(make_scalar(), make_scalar(), make_scalar(), make_scalar());
 395                 break;
 396             case 3:
 397                 path.conicTo(make_scalar(), make_scalar(), make_scalar(), make_scalar(), make_scalar());
 398                 break;
 399             case 4:
 400                 path.cubicTo(make_scalar(), make_scalar(), make_scalar(),
 401                              make_scalar(), make_scalar(), make_scalar());
 402                 break;
 403             case 5:
 404             default:
 405                 path.arcTo(make_scalar(), make_scalar(), make_scalar(), make_scalar(), make_scalar());
 406                 break;
 407
 408         }
 409     }
 410     path.close();
 411     return path;
 412 }
 413
 414 static sk_sp<SkPathEffect> make_path_effect(bool canBeNull = true) {
 415     sk_sp<SkPathEffect> pathEffect;
 416     if (canBeNull && (R(3) == 1)) { return pathEffect; }
 417
 418     switch (R(9)) {
 419         case 0:
 420             pathEffect = SkArcToPathEffect::Make(make_scalar(true));
 421             break;
 422         case 1:
 423             pathEffect = SkComposePathEffect::Make(make_path_effect(false),
 424                                                    make_path_effect(false));
 425             break;
 426         case 2:
 427             pathEffect = SkCornerPathEffect::Make(make_scalar());
 428             break;
 429         case 3: {
 430             int count = R(10);
 431             SkScalar intervals[10];
 432             for (int i = 0; i < count; ++i) {
 433                 intervals[i] = make_scalar();
 434             }
 435             pathEffect = SkDashPathEffect::Make(intervals, count, make_scalar());
 436             break;
 437         }
 438         case 4:
 439             pathEffect = SkDiscretePathEffect::Make(make_scalar(), make_scalar());
 440             break;
 441         case 5:
 442             pathEffect = SkPath1DPathEffect::Make(make_path(), make_scalar(), make_scalar(),
 443                                                   make_path_1d_path_effect_style());
 444             break;
 445         case 6:
 446             pathEffect = SkLine2DPathEffect::Make(make_scalar(), make_matrix());
 447             break;
 448         case 7:
 449             pathEffect = SkPath2DPathEffect::Make(make_matrix(), make_path());
 450             break;
 451         case 8:
 452         default:
 453             pathEffect = SkSumPathEffect::Make(make_path_effect(false),
 454                                                make_path_effect(false));
 455             break;
 456     }
 457     return pathEffect;
 458 }
 459
 460 static sk_sp<SkMaskFilter> make_mask_filter() {
 461     sk_sp<SkMaskFilter> maskFilter;
 462     switch (R(3)) {
 463         case 0:
 464             maskFilter = SkBlurMaskFilter::Make(make_blur_style(), make_scalar(),
 465                                                 make_blur_mask_filter_flag());
 466         case 1: {
 467             SkEmbossMaskFilter::Light light;
 468             for (int i = 0; i < 3; ++i) {
 469                 light.fDirection[i] = make_scalar();
 470             }
 471             light.fPad = R(65536);
 472             light.fAmbient = R(256);
 473             light.fSpecular = R(256);
 474             maskFilter = SkEmbossMaskFilter::Make(make_scalar(), light);
 475         }
 476         case 2:
 477         default:
 478             break;
 479     }
 480     return maskFilter;
 481 }
 482
 483 static sk_sp<SkImageFilter> make_image_filter(bool canBeNull = true);
 484
 485 static SkPaint make_paint() {
 486     SkPaint paint;
 487     paint.setHinting(make_paint_hinting());
 488     paint.setAntiAlias(make_bool());
 489     paint.setDither(make_bool());
 490     paint.setLinearText(make_bool());
 491     paint.setSubpixelText(make_bool());
 492     paint.setLCDRenderText(make_bool());
 493     paint.setEmbeddedBitmapText(make_bool());
 494     paint.setAutohinted(make_bool());
 495     paint.setVerticalText(make_bool());
 496     paint.setUnderlineText(make_bool());
 497     paint.setStrikeThruText(make_bool());
 498     paint.setFakeBoldText(make_bool());
 499     paint.setDevKernText(make_bool());
 500     paint.setFilterQuality(make_filter_quality());
 501     paint.setStyle(make_paint_style());
 502     paint.setColor(make_color());
 503     paint.setStrokeWidth(make_scalar());
 504     paint.setStrokeMiter(make_scalar());
 505     paint.setStrokeCap(make_paint_cap());
 506     paint.setStrokeJoin(make_paint_join());
 507     paint.setColorFilter(make_color_filter());
 508     paint.setXfermodeMode(make_xfermode());
 509     paint.setPathEffect(make_path_effect());
 510     paint.setMaskFilter(make_mask_filter());
 511
 512     if (false) {
 513         // our validating buffer does not support typefaces yet, so skip this for now
 514         paint.setTypeface(SkTypeface::MakeFromName(make_font_name().c_str(),make_typeface_style()));
 515     }
 516
 517     SkLayerRasterizer::Builder rasterizerBuilder;
 518     SkPaint paintForRasterizer;
 519     if (R(2) == 1) {
 520         paintForRasterizer = make_paint();
 521     }
 522     rasterizerBuilder.addLayer(paintForRasterizer);
 523     paint.setRasterizer(rasterizerBuilder.detach());
 524     paint.setImageFilter(make_image_filter());
 525     sk_sp<SkData> data(make_3Dlut(nullptr, make_bool(), make_bool(), make_bool()));
 526     paint.setTextAlign(make_paint_align());
 527     paint.setTextSize(make_scalar());
 528     paint.setTextScaleX(make_scalar());
 529     paint.setTextSkewX(make_scalar());
 530     paint.setTextEncoding(make_paint_text_encoding());
 531     return paint;
 532 }
 533
 534 static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
 535     sk_sp<SkImageFilter> filter;
 536
 537     // Add a 1 in 3 chance to get a nullptr input
 538     if (canBeNull && (R(3) == 1)) {
 539         return filter;
 540     }
 541
 542     enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
 543            XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
 544            DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
 545            MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS };
 546
 547     switch (R(NUM_FILTERS)) {
 548     case ALPHA_THRESHOLD:
 549         filter = SkAlphaThresholdFilter::Make(make_region(),
 550                                               make_scalar(),
 551                                               make_scalar(),
 552                                               make_image_filter());
 553         break;
 554     case MERGE:
 555         filter = SkMergeImageFilter::Make(make_image_filter(),
 556                                           make_image_filter(),
 557                                           make_xfermode());
 558         break;
 559     case COLOR: {
 560         sk_sp<SkColorFilter> cf(make_color_filter());
 561         filter = cf ? SkColorFilterImageFilter::Make(std::move(cf), make_image_filter())
 562                     : nullptr;
 563         break;
 564     }
 565     case LUT3D: {
 566         int cubeDimension;
 567         sk_sp<SkData> lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1)));
 568         sk_sp<SkColorFilter> cf(SkColorCubeFilter::Make(std::move(lut3D), cubeDimension));
 569         filter = cf ? SkColorFilterImageFilter::Make(std::move(cf), make_image_filter())
 570                     : nullptr;
 571         break;
 572     }
 573     case BLUR:
 574         filter = SkBlurImageFilter::Make(make_scalar(true),
 575                                          make_scalar(true),
 576                                          make_image_filter());
 577         break;
 578     case MAGNIFIER:
 579         filter = SkMagnifierImageFilter::Make(make_rect(),
 580                                               make_scalar(true),
 581                                               make_image_filter());
 582         break;
 583     case XFERMODE:
 584         filter = SkXfermodeImageFilter::Make(SkXfermode::Make(make_xfermode()),
 585                                              make_image_filter(),
 586                                              make_image_filter(),
 587                                              nullptr);
 588         break;
 589     case OFFSET:
 590         filter = SkOffsetImageFilter::Make(make_scalar(), make_scalar(), make_image_filter());
 591         break;
 592     case MATRIX:
 593         filter = SkImageFilter::MakeMatrixFilter(make_matrix(),
 594                                                  (SkFilterQuality)R(4),
 595                                                  make_image_filter());
 596         break;
 597     case MATRIX_CONVOLUTION: {
 598         SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
 599                                                      SkIntToScalar(kBitmapSize)));
 600         SkISize size = SkISize::Make(R(10)+1, R(10)+1);
 601         int arraySize = size.width() * size.height();
 602         SkTArray<SkScalar> kernel(arraySize);
 603         for (int i = 0; i < arraySize; ++i) {
 604             kernel.push_back() = make_scalar();
 605         }
 606         SkIPoint kernelOffset = SkIPoint::Make(R(SkIntToScalar(size.width())),
 607                                                R(SkIntToScalar(size.height())));
 608
 609         filter = SkMatrixConvolutionImageFilter::Make(size,
 610                                                       kernel.begin(),
 611                                                       make_scalar(),
 612                                                       make_scalar(),
 613                                                       kernelOffset,
 614                                                       (SkMatrixConvolutionImageFilter::TileMode)R(3),
 615                                                       R(2) == 1,
 616                                                       make_image_filter(),
 617                                                       &cropR);
 618         break;
 619     }
 620     case COMPOSE:
 621         filter = SkComposeImageFilter::Make(make_image_filter(), make_image_filter());
 622         break;
 623     case DISTANT_LIGHT:
 624         filter = (R(2) == 1)
 625                  ? SkLightingImageFilter::MakeDistantLitDiffuse(make_point(), make_color(),
 626                                                                 make_scalar(), make_scalar(),
 627                                                                 make_image_filter())
 628                  : SkLightingImageFilter::MakeDistantLitSpecular(make_point(), make_color(),
 629                                                                  make_scalar(), make_scalar(),
 630                                                                  SkIntToScalar(R(10)),
 631                                                                  make_image_filter());
 632         break;
 633     case POINT_LIGHT:
 634         filter = (R(2) == 1)
 635                  ? SkLightingImageFilter::MakePointLitDiffuse(make_point(), make_color(),
 636                                                               make_scalar(), make_scalar(),
 637                                                               make_image_filter())
 638                  : SkLightingImageFilter::MakePointLitSpecular(make_point(), make_color(),
 639                                                                make_scalar(), make_scalar(),
 640                                                                SkIntToScalar(R(10)),
 641                                                                make_image_filter());
 642         break;
 643     case SPOT_LIGHT:
 644         filter = (R(2) == 1)
 645                  ? SkLightingImageFilter::MakeSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
 646                                                              make_point(), make_scalar(),
 647                                                              make_scalar(), make_color(),
 648                                                              make_scalar(), make_scalar(),
 649                                                              make_image_filter())
 650                  : SkLightingImageFilter::MakeSpotLitSpecular(SkPoint3::Make(0, 0, 0),
 651                                                               make_point(), make_scalar(),
 652                                                               make_scalar(), make_color(),
 653                                                               make_scalar(), make_scalar(),
 654                                                               SkIntToScalar(R(10)),
 655                                                               make_image_filter());
 656         break;
 657     case NOISE: {
 658         sk_sp<SkShader> shader((R(2) == 1)
 659                 ? SkPerlinNoiseShader::MakeFractalNoise(make_scalar(true), make_scalar(true),
 660                                                         R(10.0f), make_scalar())
 661                 : SkPerlinNoiseShader::MakeTurbulence(make_scalar(true), make_scalar(true),
 662                                                       R(10.0f), make_scalar()));
 663         SkPaint paint;
 664         paint.setShader(shader);
 665         SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
 666                                                      SkIntToScalar(kBitmapSize)));
 667         filter = SkPaintImageFilter::Make(paint, &cropR);
 668         break;
 669     }
 670     case DROP_SHADOW:
 671         filter = SkDropShadowImageFilter::Make(make_scalar(),
 672                                                make_scalar(),
 673                                                make_scalar(true),
 674                                                make_scalar(true),
 675                                                make_color(),
 676                                                make_shadow_mode(),
 677                                                make_image_filter(),
 678                                                nullptr);
 679         break;
 680     case MORPHOLOGY:
 681         if (R(2) == 1) {
 682             filter = SkDilateImageFilter::Make(R(static_cast<float>(kBitmapSize)),
 683                                                R(static_cast<float>(kBitmapSize)),
 684                                                make_image_filter());
 685         } else {
 686             filter = SkErodeImageFilter::Make(R(static_cast<float>(kBitmapSize)),
 687                                               R(static_cast<float>(kBitmapSize)),
 688                                               make_image_filter());
 689         }
 690         break;
 691     case BITMAP: {
 692         sk_sp<SkImage> image(SkImage::MakeFromBitmap(make_bitmap()));
 693         if (R(2) == 1) {
 694             filter = SkImageSource::Make(std::move(image),
 695                                          make_rect(),
 696                                          make_rect(),
 697                                          kHigh_SkFilterQuality);
 698         } else {
 699             filter = SkImageSource::Make(std::move(image));
 700         }
 701         break;
 702     }
 703     case DISPLACE:
 704         filter = SkDisplacementMapEffect::Make(make_channel_selector_type(),
 705                                                make_channel_selector_type(),
 706                                                make_scalar(),
 707                                                make_image_filter(false),
 708                                                make_image_filter());
 709         break;
 710     case TILE:
 711         filter = SkTileImageFilter::Make(make_rect(), make_rect(), make_image_filter(false));
 712         break;
 713     case PICTURE: {
 714         SkRTreeFactory factory;
 715         SkPictureRecorder recorder;
 716         SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize),
 717                                                             SkIntToScalar(kBitmapSize),
 718                                                             &factory, 0);
 719         drawSomething(recordingCanvas);
 720         sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
 721         filter = SkPictureImageFilter::Make(pict, make_rect());
 722         break;
 723     }
 724     case PAINT: {
 725         SkImageFilter::CropRect cropR(make_rect());
 726         filter = SkPaintImageFilter::Make(make_paint(), &cropR);
 727         break;
 728     }
 729     default:
 730         break;
 731     }
 732     return (filter || canBeNull) ? filter : make_image_filter(canBeNull);
 733 }
 734
 735 static SkImageFilter* make_serialized_image_filter() {
 736     sk_sp<SkImageFilter> filter(make_image_filter(false));
 737     sk_sp<SkData> data(SkValidatingSerializeFlattenable(filter.get()));
 738     const unsigned char* ptr = static_cast<const unsigned char*>(data->data());
 739     size_t len = data->size();
 740 #ifdef SK_ADD_RANDOM_BIT_FLIPS
 741     unsigned char* p = const_cast<unsigned char*>(ptr);
 742     for (size_t i = 0; i < len; ++i, ++p) {
 743         if (R(250) == 1) { // 0.4% of the time, flip a bit or byte
 744             if (R(10) == 1) { // Then 10% of the time, change a whole byte
 745                 switch(R(3)) {
 746                 case 0:
 747                     *p ^= 0xFF; // Flip entire byte
 748                     break;
 749                 case 1:
 750                     *p = 0xFF; // Set all bits to 1
 751                     break;
 752                 case 2:
 753                     *p = 0x00; // Set all bits to 0
 754                     break;
 755                 }
 756             } else {
 757                 *p ^= (1 << R(8));
 758             }
 759         }
 760     }
 761 #endif // SK_ADD_RANDOM_BIT_FLIPS
 762     SkFlattenable* flattenable = SkValidatingDeserializeFlattenable(ptr, len,
 763                                     SkImageFilter::GetFlattenableType());
 764     return static_cast<SkImageFilter*>(flattenable);
 765 }
 766
 767 static void drawClippedBitmap(SkCanvas* canvas, int x, int y, const SkPaint& paint) {
 768     canvas->save();
 769     canvas->clipRect(SkRect::MakeXYWH(SkIntToScalar(x), SkIntToScalar(y),
 770         SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize)));
 771     canvas->drawBitmap(make_bitmap(), SkIntToScalar(x), SkIntToScalar(y), &paint);
 772     canvas->restore();
 773 }
 774
 775 DEF_FUZZ(SerializedImageFilter, f) {
 776     fuzz = f;
 777     SkImageFilter* filter = make_serialized_image_filter();
 778
 779     SkPaint paint;
 780     SkSafeUnref(paint.setImageFilter(filter));
 781     SkBitmap bitmap;
 782     SkCanvas canvas(bitmap);
 783     drawClippedBitmap(&canvas, 0, 0, paint);
 784 }