1 /*
2 * Copyright 2017 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
8 #include "Fuzz.h"
9 #include "FuzzCommon.h"
10
11 // CORE
12 #include "SkCanvas.h"
13 #include "SkColorFilter.h"
14 #include "SkDebugCanvas.h"
15 #include "SkFontMgr.h"
16 #include "SkImageFilter.h"
17 #include "SkMaskFilter.h"
18 #include "SkNullCanvas.h"
19 #include "SkOSFile.h"
20 #include "SkPDFDocument.h"
21 #include "SkPathEffect.h"
22 #include "SkPicturePriv.h"
23 #include "SkPictureRecorder.h"
24 #include "SkPoint3.h"
25 #include "SkRSXform.h"
26 #include "SkRegion.h"
27 #include "SkSurface.h"
28 #include "SkTo.h"
29 #include "SkTypeface.h"
30
31 // EFFECTS
32 #include "Sk1DPathEffect.h"
33 #include "Sk2DPathEffect.h"
34 #include "SkAlphaThresholdFilter.h"
35 #include "SkArithmeticImageFilter.h"
36 #include "SkBlurImageFilter.h"
37 #include "SkBlurMaskFilter.h"
38 #include "SkColorFilterImageFilter.h"
39 #include "SkColorMatrixFilter.h"
40 #include "SkComposeImageFilter.h"
41 #include "SkCornerPathEffect.h"
42 #include "SkDashPathEffect.h"
43 #include "SkDiscretePathEffect.h"
44 #include "SkDisplacementMapEffect.h"
45 #include "SkDropShadowImageFilter.h"
46 #include "SkGradientShader.h"
47 #include "SkHighContrastFilter.h"
48 #include "SkImageSource.h"
49 #include "SkLightingImageFilter.h"
50 #include "SkLumaColorFilter.h"
51 #include "SkMagnifierImageFilter.h"
52 #include "SkMatrixConvolutionImageFilter.h"
53 #include "SkMergeImageFilter.h"
54 #include "SkMorphologyImageFilter.h"
55 #include "SkOffsetImageFilter.h"
56 #include "SkPaintImageFilter.h"
57 #include "SkPerlinNoiseShader.h"
58 #include "SkPictureImageFilter.h"
59 #include "SkReadBuffer.h"
60 #include "SkTableColorFilter.h"
61 #include "SkTextBlob.h"
62 #include "SkTileImageFilter.h"
63 #include "SkXfermodeImageFilter.h"
64
65 // SRC
66 #include "SkCommandLineFlags.h"
67 #include "SkUTF.h"
68
69 #if SK_SUPPORT_GPU
70 #include "GrContextFactory.h"
71 #include "GrContextPriv.h"
72 #include "gl/GrGLFunctions.h"
73 #include "gl/GrGLGpu.h"
74 #include "gl/GrGLUtil.h"
75 #endif
76
77 // MISC
78
79 #include <iostream>
80 #include <utility>
81
82 DEFINE_bool2(gpuInfo, g, false, "Display GPU information on relevant targets.");
83
84 // TODO:
85 // SkTextBlob with Unicode
86 // SkImage: more types
87
88 // be careful: `foo(make_fuzz_t<T>(f), make_fuzz_t<U>(f))` is undefined.
89 // In fact, all make_fuzz_foo() functions have this potential problem.
90 // Use sequence points!
91 template <typename T>
make_fuzz_t(Fuzz * fuzz)92 inline T make_fuzz_t(Fuzz* fuzz) {
93 T t;
94 fuzz->next(&t);
95 return t;
96 }
97
98 static sk_sp<SkImage> make_fuzz_image(Fuzz*);
99
100 static SkBitmap make_fuzz_bitmap(Fuzz*);
101
102 static sk_sp<SkPicture> make_fuzz_picture(Fuzz*, int depth);
103
make_fuzz_colorfilter(Fuzz * fuzz,int depth)104 static sk_sp<SkColorFilter> make_fuzz_colorfilter(Fuzz* fuzz, int depth) {
105 if (depth <= 0) {
106 return nullptr;
107 }
108 int colorFilterType;
109 fuzz->nextRange(&colorFilterType, 0, 8);
110 switch (colorFilterType) {
111 case 0:
112 return nullptr;
113 case 1: {
114 SkColor color;
115 SkBlendMode mode;
116 fuzz->next(&color);
117 fuzz->nextRange(&mode, 0, SkBlendMode::kLastMode);
118 return SkColorFilter::MakeModeFilter(color, mode);
119 }
120 case 2: {
121 sk_sp<SkColorFilter> outer = make_fuzz_colorfilter(fuzz, depth - 1);
122 if (!outer) {
123 return nullptr;
124 }
125 sk_sp<SkColorFilter> inner = make_fuzz_colorfilter(fuzz, depth - 1);
126 // makeComposed should be able to handle nullptr.
127 return outer->makeComposed(std::move(inner));
128 }
129 case 3: {
130 SkScalar array[20];
131 fuzz->nextN(array, SK_ARRAY_COUNT(array));
132 return SkColorFilter::MakeMatrixFilterRowMajor255(array);
133 }
134 case 4: {
135 SkColor mul, add;
136 fuzz->next(&mul, &add);
137 return SkColorMatrixFilter::MakeLightingFilter(mul, add);
138 }
139 case 5: {
140 bool grayscale;
141 int invertStyle;
142 float contrast;
143 fuzz->next(&grayscale);
144 fuzz->nextRange(&invertStyle, 0, 2);
145 fuzz->nextRange(&contrast, -1.0f, 1.0f);
146 return SkHighContrastFilter::Make(SkHighContrastConfig(
147 grayscale, SkHighContrastConfig::InvertStyle(invertStyle), contrast));
148 }
149 case 6:
150 return SkLumaColorFilter::Make();
151 case 7: {
152 uint8_t table[256];
153 fuzz->nextN(table, SK_ARRAY_COUNT(table));
154 return SkTableColorFilter::Make(table);
155 }
156 case 8: {
157 uint8_t tableA[256];
158 uint8_t tableR[256];
159 uint8_t tableG[256];
160 uint8_t tableB[256];
161 fuzz->nextN(tableA, SK_ARRAY_COUNT(tableA));
162 fuzz->nextN(tableR, SK_ARRAY_COUNT(tableR));
163 fuzz->nextN(tableG, SK_ARRAY_COUNT(tableG));
164 fuzz->nextN(tableB, SK_ARRAY_COUNT(tableB));
165 return SkTableColorFilter::MakeARGB(tableA, tableR, tableG, tableB);
166 }
167 default:
168 SkASSERT(false);
169 break;
170 }
171 return nullptr;
172 }
173
fuzz_gradient_stops(Fuzz * fuzz,SkScalar * pos,int colorCount)174 static void fuzz_gradient_stops(Fuzz* fuzz, SkScalar* pos, int colorCount) {
175 SkScalar totalPos = 0;
176 for (int i = 0; i < colorCount; ++i) {
177 fuzz->nextRange(&pos[i], 1.0f, 1024.0f);
178 totalPos += pos[i];
179 }
180 totalPos = 1.0f / totalPos;
181 for (int i = 0; i < colorCount; ++i) {
182 pos[i] *= totalPos;
183 }
184 // SkASSERT(fabs(pos[colorCount - 1] - 1.0f) < 0.00001f);
185 pos[colorCount - 1] = 1.0f;
186 }
187
make_fuzz_shader(Fuzz * fuzz,int depth)188 static sk_sp<SkShader> make_fuzz_shader(Fuzz* fuzz, int depth) {
189 sk_sp<SkShader> shader1(nullptr), shader2(nullptr);
190 sk_sp<SkColorFilter> colorFilter(nullptr);
191 SkBitmap bitmap;
192 sk_sp<SkImage> img;
193 SkShader::TileMode tmX, tmY;
194 bool useMatrix;
195 SkColor color;
196 SkMatrix matrix;
197 SkBlendMode blendMode;
198 int shaderType;
199 if (depth <= 0) {
200 return nullptr;
201 }
202 fuzz->nextRange(&shaderType, 0, 14);
203 switch (shaderType) {
204 case 0:
205 return nullptr;
206 case 1:
207 return SkShader::MakeEmptyShader();
208 case 2:
209 fuzz->next(&color);
210 return SkShader::MakeColorShader(color);
211 case 3:
212 img = make_fuzz_image(fuzz);
213 fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
214 fuzz->nextRange(&tmY, 0, SkShader::TileMode::kLast_TileMode);
215 fuzz->next(&useMatrix);
216 if (useMatrix) {
217 FuzzNiceMatrix(fuzz, &matrix);
218 }
219 return img->makeShader(tmX, tmY, useMatrix ? &matrix : nullptr);
220 case 4:
221 bitmap = make_fuzz_bitmap(fuzz);
222 fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
223 fuzz->nextRange(&tmY, 0, SkShader::TileMode::kLast_TileMode);
224 fuzz->next(&useMatrix);
225 if (useMatrix) {
226 FuzzNiceMatrix(fuzz, &matrix);
227 }
228 return SkShader::MakeBitmapShader(bitmap, tmX, tmY, useMatrix ? &matrix : nullptr);
229 case 5:
230 shader1 = make_fuzz_shader(fuzz, depth - 1); // limit recursion.
231 FuzzNiceMatrix(fuzz, &matrix);
232 return shader1 ? shader1->makeWithLocalMatrix(matrix) : nullptr;
233 case 6:
234 shader1 = make_fuzz_shader(fuzz, depth - 1); // limit recursion.
235 colorFilter = make_fuzz_colorfilter(fuzz, depth - 1);
236 return shader1 ? shader1->makeWithColorFilter(std::move(colorFilter)) : nullptr;
237 case 7:
238 shader1 = make_fuzz_shader(fuzz, depth - 1); // limit recursion.
239 shader2 = make_fuzz_shader(fuzz, depth - 1);
240 fuzz->nextRange(&blendMode, 0, SkBlendMode::kLastMode);
241 return SkShader::MakeComposeShader(std::move(shader1), std::move(shader2), blendMode);
242 case 8: {
243 auto pic = make_fuzz_picture(fuzz, depth - 1);
244 bool useTile;
245 SkRect tile;
246 fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
247 fuzz->nextRange(&tmY, 0, SkShader::TileMode::kLast_TileMode);
248 fuzz->next(&useMatrix, &useTile);
249 if (useMatrix) {
250 FuzzNiceMatrix(fuzz, &matrix);
251 }
252 if (useTile) {
253 fuzz->next(&tile);
254 }
255 return SkShader::MakePictureShader(std::move(pic), tmX, tmY,
256 useMatrix ? &matrix : nullptr,
257 useTile ? &tile : nullptr);
258 }
259 // EFFECTS:
260 case 9:
261 // Deprecated SkGaussianEdgeShader
262 return nullptr;
263 case 10: {
264 constexpr int kMaxColors = 12;
265 SkPoint pts[2];
266 SkColor colors[kMaxColors];
267 SkScalar pos[kMaxColors];
268 int colorCount;
269 bool usePos;
270 fuzz->nextN(pts, 2);
271 fuzz->nextRange(&colorCount, 2, kMaxColors);
272 fuzz->nextN(colors, colorCount);
273 fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
274 fuzz->next(&useMatrix, &usePos);
275 if (useMatrix) {
276 FuzzNiceMatrix(fuzz, &matrix);
277 }
278 if (usePos) {
279 fuzz_gradient_stops(fuzz, pos, colorCount);
280 }
281 return SkGradientShader::MakeLinear(pts, colors, usePos ? pos : nullptr, colorCount,
282 tmX, 0, useMatrix ? &matrix : nullptr);
283 }
284 case 11: {
285 constexpr int kMaxColors = 12;
286 SkPoint center;
287 SkScalar radius;
288 int colorCount;
289 bool usePos;
290 SkColor colors[kMaxColors];
291 SkScalar pos[kMaxColors];
292 fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
293 fuzz->next(&useMatrix, &usePos, ¢er, &radius);
294 fuzz->nextRange(&colorCount, 2, kMaxColors);
295 fuzz->nextN(colors, colorCount);
296 if (useMatrix) {
297 FuzzNiceMatrix(fuzz, &matrix);
298 }
299 if (usePos) {
300 fuzz_gradient_stops(fuzz, pos, colorCount);
301 }
302 return SkGradientShader::MakeRadial(center, radius, colors, usePos ? pos : nullptr,
303 colorCount, tmX, 0, useMatrix ? &matrix : nullptr);
304 }
305 case 12: {
306 constexpr int kMaxColors = 12;
307 SkPoint start, end;
308 SkScalar startRadius, endRadius;
309 int colorCount;
310 bool usePos;
311 SkColor colors[kMaxColors];
312 SkScalar pos[kMaxColors];
313 fuzz->nextRange(&tmX, 0, SkShader::TileMode::kLast_TileMode);
314 fuzz->next(&useMatrix, &usePos, &startRadius, &endRadius, &start, &end);
315 fuzz->nextRange(&colorCount, 2, kMaxColors);
316 fuzz->nextN(colors, colorCount);
317 if (useMatrix) {
318 FuzzNiceMatrix(fuzz, &matrix);
319 }
320 if (usePos) {
321 fuzz_gradient_stops(fuzz, pos, colorCount);
322 }
323 return SkGradientShader::MakeTwoPointConical(start, startRadius, end, endRadius, colors,
324 usePos ? pos : nullptr, colorCount, tmX, 0,
325 useMatrix ? &matrix : nullptr);
326 }
327 case 13: {
328 constexpr int kMaxColors = 12;
329 SkScalar cx, cy;
330 int colorCount;
331 bool usePos;
332 SkColor colors[kMaxColors];
333 SkScalar pos[kMaxColors];
334 fuzz->next(&cx, &cy, &useMatrix, &usePos);
335 fuzz->nextRange(&colorCount, 2, kMaxColors);
336 fuzz->nextN(colors, colorCount);
337 if (useMatrix) {
338 FuzzNiceMatrix(fuzz, &matrix);
339 }
340 if (usePos) {
341 fuzz_gradient_stops(fuzz, pos, colorCount);
342 }
343 return SkGradientShader::MakeSweep(cx, cy, colors, usePos ? pos : nullptr, colorCount,
344 0, useMatrix ? &matrix : nullptr);
345 }
346 case 14: {
347 SkScalar baseFrequencyX, baseFrequencyY, seed;
348 int numOctaves;
349 SkISize tileSize;
350 bool useTileSize, turbulence;
351 fuzz->next(&baseFrequencyX, &baseFrequencyY, &seed, &useTileSize, &turbulence);
352 if (useTileSize) {
353 fuzz->next(&tileSize);
354 }
355 fuzz->nextRange(&numOctaves, 2, 7);
356 if (turbulence) {
357 return SkPerlinNoiseShader::MakeTurbulence(baseFrequencyX, baseFrequencyY,
358 numOctaves, seed,
359 useTileSize ? &tileSize : nullptr);
360 } else {
361 return SkPerlinNoiseShader::MakeFractalNoise(baseFrequencyX, baseFrequencyY,
362 numOctaves, seed,
363 useTileSize ? &tileSize : nullptr);
364 }
365 }
366 default:
367 SkASSERT(false);
368 break;
369 }
370 return nullptr;
371 }
372
make_fuzz_patheffect(Fuzz * fuzz,int depth)373 static sk_sp<SkPathEffect> make_fuzz_patheffect(Fuzz* fuzz, int depth) {
374 if (depth <= 0) {
375 return nullptr;
376 }
377 uint8_t pathEffectType;
378 fuzz->nextRange(&pathEffectType, 0, 8);
379 switch (pathEffectType) {
380 case 0: {
381 return nullptr;
382 }
383 case 1: {
384 sk_sp<SkPathEffect> first = make_fuzz_patheffect(fuzz, depth - 1);
385 sk_sp<SkPathEffect> second = make_fuzz_patheffect(fuzz, depth - 1);
386 return SkPathEffect::MakeSum(std::move(first), std::move(second));
387 }
388 case 2: {
389 sk_sp<SkPathEffect> first = make_fuzz_patheffect(fuzz, depth - 1);
390 sk_sp<SkPathEffect> second = make_fuzz_patheffect(fuzz, depth - 1);
391 return SkPathEffect::MakeCompose(std::move(first), std::move(second));
392 }
393 case 3: {
394 SkPath path;
395 FuzzNicePath(fuzz, &path, 20);
396 SkScalar advance, phase;
397 fuzz->next(&advance, &phase);
398 SkPath1DPathEffect::Style style;
399 fuzz->nextRange(&style, 0, SkPath1DPathEffect::kLastEnum_Style);
400 return SkPath1DPathEffect::Make(path, advance, phase, style);
401 }
402 case 4: {
403 SkScalar width;
404 SkMatrix matrix;
405 fuzz->next(&width);
406 FuzzNiceMatrix(fuzz, &matrix);
407 return SkLine2DPathEffect::Make(width, matrix);
408 }
409 case 5: {
410 SkPath path;
411 FuzzNicePath(fuzz, &path, 20);
412 SkMatrix matrix;
413 FuzzNiceMatrix(fuzz, &matrix);
414 return SkPath2DPathEffect::Make(matrix, path);
415 }
416 case 6: {
417 SkScalar radius;
418 fuzz->next(&radius);
419 return SkCornerPathEffect::Make(radius);
420 }
421 case 7: {
422 SkScalar phase;
423 fuzz->next(&phase);
424 SkScalar intervals[20];
425 int count;
426 fuzz->nextRange(&count, 0, (int)SK_ARRAY_COUNT(intervals));
427 fuzz->nextN(intervals, count);
428 return SkDashPathEffect::Make(intervals, count, phase);
429 }
430 case 8: {
431 SkScalar segLength, dev;
432 uint32_t seed;
433 fuzz->next(&segLength, &dev, &seed);
434 return SkDiscretePathEffect::Make(segLength, dev, seed);
435 }
436 default:
437 SkASSERT(false);
438 return nullptr;
439 }
440 }
441
make_fuzz_maskfilter(Fuzz * fuzz)442 static sk_sp<SkMaskFilter> make_fuzz_maskfilter(Fuzz* fuzz) {
443 int maskfilterType;
444 fuzz->nextRange(&maskfilterType, 0, 1);
445 switch (maskfilterType) {
446 case 0:
447 return nullptr;
448 case 1: {
449 SkBlurStyle blurStyle;
450 fuzz->nextRange(&blurStyle, 0, kLastEnum_SkBlurStyle);
451 SkScalar sigma;
452 fuzz->next(&sigma);
453 bool respectCTM;
454 fuzz->next(&respectCTM);
455 return SkMaskFilter::MakeBlur(blurStyle, sigma, respectCTM);
456 }
457 default:
458 SkASSERT(false);
459 return nullptr;
460 }
461 }
462
make_fuzz_typeface(Fuzz * fuzz)463 static sk_sp<SkTypeface> make_fuzz_typeface(Fuzz* fuzz) {
464 if (make_fuzz_t<bool>(fuzz)) {
465 return nullptr;
466 }
467 auto fontMugger = SkFontMgr::RefDefault();
468 SkASSERT(fontMugger);
469 int familyCount = fontMugger->countFamilies();
470 int i, j;
471 fuzz->nextRange(&i, 0, familyCount - 1);
472 sk_sp<SkFontStyleSet> family(fontMugger->createStyleSet(i));
473 int styleCount = family->count();
474 fuzz->nextRange(&j, 0, styleCount - 1);
475 return sk_sp<SkTypeface>(family->createTypeface(j));
476 }
477
478 static sk_sp<SkImageFilter> make_fuzz_imageFilter(Fuzz* fuzz, int depth);
479
make_fuzz_lighting_imagefilter(Fuzz * fuzz,int depth)480 static sk_sp<SkImageFilter> make_fuzz_lighting_imagefilter(Fuzz* fuzz, int depth) {
481 if (depth <= 0) {
482 return nullptr;
483 }
484 uint8_t imageFilterType;
485 fuzz->nextRange(&imageFilterType, 1, 6);
486 SkPoint3 p, q;
487 SkColor lightColor;
488 SkScalar surfaceScale, k, specularExponent, cutoffAngle, shininess;
489 sk_sp<SkImageFilter> input;
490 SkImageFilter::CropRect cropRect;
491 bool useCropRect;
492 fuzz->next(&useCropRect);
493 if (useCropRect) {
494 fuzz->next(&cropRect);
495 }
496 switch (imageFilterType) {
497 case 1:
498 fuzz->next(&p, &lightColor, &surfaceScale, &k);
499 input = make_fuzz_imageFilter(fuzz, depth - 1);
500 return SkLightingImageFilter::MakeDistantLitDiffuse(p, lightColor, surfaceScale, k,
501 std::move(input),
502 useCropRect ? &cropRect : nullptr);
503 case 2:
504 fuzz->next(&p, &lightColor, &surfaceScale, &k);
505 input = make_fuzz_imageFilter(fuzz, depth - 1);
506 return SkLightingImageFilter::MakePointLitDiffuse(p, lightColor, surfaceScale, k,
507 std::move(input),
508 useCropRect ? &cropRect : nullptr);
509 case 3:
510 fuzz->next(&p, &q, &specularExponent, &cutoffAngle, &lightColor, &surfaceScale, &k);
511 input = make_fuzz_imageFilter(fuzz, depth - 1);
512 return SkLightingImageFilter::MakeSpotLitDiffuse(
513 p, q, specularExponent, cutoffAngle, lightColor, surfaceScale, k,
514 std::move(input), useCropRect ? &cropRect : nullptr);
515 case 4:
516 fuzz->next(&p, &lightColor, &surfaceScale, &k, &shininess);
517 input = make_fuzz_imageFilter(fuzz, depth - 1);
518 return SkLightingImageFilter::MakeDistantLitSpecular(p, lightColor, surfaceScale, k,
519 shininess, std::move(input),
520 useCropRect ? &cropRect : nullptr);
521 case 5:
522 fuzz->next(&p, &lightColor, &surfaceScale, &k, &shininess);
523 input = make_fuzz_imageFilter(fuzz, depth - 1);
524 return SkLightingImageFilter::MakePointLitSpecular(p, lightColor, surfaceScale, k,
525 shininess, std::move(input),
526 useCropRect ? &cropRect : nullptr);
527 case 6:
528 fuzz->next(&p, &q, &specularExponent, &cutoffAngle, &lightColor, &surfaceScale, &k,
529 &shininess);
530 input = make_fuzz_imageFilter(fuzz, depth - 1);
531 return SkLightingImageFilter::MakeSpotLitSpecular(
532 p, q, specularExponent, cutoffAngle, lightColor, surfaceScale, k, shininess,
533 std::move(input), useCropRect ? &cropRect : nullptr);
534 default:
535 SkASSERT(false);
536 return nullptr;
537 }
538 }
539
540 static void fuzz_paint(Fuzz* fuzz, SkPaint* paint, int depth);
541
make_fuzz_imageFilter(Fuzz * fuzz,int depth)542 static sk_sp<SkImageFilter> make_fuzz_imageFilter(Fuzz* fuzz, int depth) {
543 if (depth <= 0) {
544 return nullptr;
545 }
546 uint8_t imageFilterType;
547 fuzz->nextRange(&imageFilterType, 0, 23);
548 switch (imageFilterType) {
549 case 0:
550 return nullptr;
551 case 1: {
552 SkScalar sigmaX, sigmaY;
553 sk_sp<SkImageFilter> input = make_fuzz_imageFilter(fuzz, depth - 1);
554 bool useCropRect;
555 fuzz->next(&sigmaX, &sigmaY, &useCropRect);
556 SkImageFilter::CropRect cropRect;
557 if (useCropRect) {
558 fuzz->next(&cropRect);
559 }
560 return SkBlurImageFilter::Make(sigmaX, sigmaY, std::move(input),
561 useCropRect ? &cropRect : nullptr);
562 }
563 case 2: {
564 SkMatrix matrix;
565 FuzzNiceMatrix(fuzz, &matrix);
566 SkFilterQuality quality;
567 fuzz->nextRange(&quality, 0, SkFilterQuality::kLast_SkFilterQuality);
568 sk_sp<SkImageFilter> input = make_fuzz_imageFilter(fuzz, depth - 1);
569 return SkImageFilter::MakeMatrixFilter(matrix, quality, std::move(input));
570 }
571 case 3: {
572 SkRegion region;
573 SkScalar innerMin, outerMax;
574 sk_sp<SkImageFilter> input = make_fuzz_imageFilter(fuzz, depth - 1);
575 bool useCropRect;
576 fuzz->next(®ion, &innerMin, &outerMax, &useCropRect);
577 SkImageFilter::CropRect cropRect;
578 if (useCropRect) {
579 fuzz->next(&cropRect);
580 }
581 return SkAlphaThresholdFilter::Make(region, innerMin, outerMax, std::move(input),
582 useCropRect ? &cropRect : nullptr);
583 }
584 case 4: {
585 float k1, k2, k3, k4;
586 bool enforcePMColor;
587 bool useCropRect;
588 fuzz->next(&k1, &k2, &k3, &k4, &enforcePMColor, &useCropRect);
589 sk_sp<SkImageFilter> background = make_fuzz_imageFilter(fuzz, depth - 1);
590 sk_sp<SkImageFilter> foreground = make_fuzz_imageFilter(fuzz, depth - 1);
591 SkImageFilter::CropRect cropRect;
592 if (useCropRect) {
593 fuzz->next(&cropRect);
594 }
595 return SkArithmeticImageFilter::Make(k1, k2, k3, k4, enforcePMColor,
596 std::move(background), std::move(foreground),
597 useCropRect ? &cropRect : nullptr);
598 }
599 case 5: {
600 sk_sp<SkColorFilter> cf = make_fuzz_colorfilter(fuzz, depth - 1);
601 sk_sp<SkImageFilter> input = make_fuzz_imageFilter(fuzz, depth - 1);
602 bool useCropRect;
603 SkImageFilter::CropRect cropRect;
604 fuzz->next(&useCropRect);
605 if (useCropRect) {
606 fuzz->next(&cropRect);
607 }
608 return SkColorFilterImageFilter::Make(std::move(cf), std::move(input),
609 useCropRect ? &cropRect : nullptr);
610 }
611 case 6: {
612 sk_sp<SkImageFilter> ifo = make_fuzz_imageFilter(fuzz, depth - 1);
613 sk_sp<SkImageFilter> ifi = make_fuzz_imageFilter(fuzz, depth - 1);
614 return SkComposeImageFilter::Make(std::move(ifo), std::move(ifi));
615 }
616 case 7: {
617 SkDisplacementMapEffect::ChannelSelectorType xChannelSelector, yChannelSelector;
618 fuzz->nextRange(&xChannelSelector, 1, 4);
619 fuzz->nextRange(&yChannelSelector, 1, 4);
620 SkScalar scale;
621 bool useCropRect;
622 fuzz->next(&scale, &useCropRect);
623 SkImageFilter::CropRect cropRect;
624 if (useCropRect) {
625 fuzz->next(&cropRect);
626 }
627 sk_sp<SkImageFilter> displacement = make_fuzz_imageFilter(fuzz, depth - 1);
628 sk_sp<SkImageFilter> color = make_fuzz_imageFilter(fuzz, depth - 1);
629 return SkDisplacementMapEffect::Make(xChannelSelector, yChannelSelector, scale,
630 std::move(displacement), std::move(color),
631 useCropRect ? &cropRect : nullptr);
632 }
633 case 8: {
634 SkScalar dx, dy, sigmaX, sigmaY;
635 SkColor color;
636 SkDropShadowImageFilter::ShadowMode shadowMode;
637 fuzz->nextRange(&shadowMode, 0, 1);
638 bool useCropRect;
639 fuzz->next(&dx, &dy, &sigmaX, &sigmaY, &color, &useCropRect);
640 SkImageFilter::CropRect cropRect;
641 if (useCropRect) {
642 fuzz->next(&cropRect);
643 }
644 sk_sp<SkImageFilter> input = make_fuzz_imageFilter(fuzz, depth - 1);
645 return SkDropShadowImageFilter::Make(dx, dy, sigmaX, sigmaY, color, shadowMode,
646 std::move(input),
647 useCropRect ? &cropRect : nullptr);
648 }
649 case 9:
650 return SkImageSource::Make(make_fuzz_image(fuzz));
651 case 10: {
652 sk_sp<SkImage> image = make_fuzz_image(fuzz);
653 SkRect srcRect, dstRect;
654 SkFilterQuality filterQuality;
655 fuzz->next(&srcRect, &dstRect);
656 fuzz->nextRange(&filterQuality, 0, SkFilterQuality::kLast_SkFilterQuality);
657 return SkImageSource::Make(std::move(image), srcRect, dstRect, filterQuality);
658 }
659 case 11:
660 return make_fuzz_lighting_imagefilter(fuzz, depth - 1);
661 case 12: {
662 SkRect srcRect;
663 SkScalar inset;
664 bool useCropRect;
665 SkImageFilter::CropRect cropRect;
666 fuzz->next(&srcRect, &inset, &useCropRect);
667 if (useCropRect) {
668 fuzz->next(&cropRect);
669 }
670 sk_sp<SkImageFilter> input = make_fuzz_imageFilter(fuzz, depth - 1);
671 return SkMagnifierImageFilter::Make(srcRect, inset, std::move(input),
672 useCropRect ? &cropRect : nullptr);
673 }
674 case 13: {
675 constexpr int kMaxKernelSize = 5;
676 int32_t n, m;
677 fuzz->nextRange(&n, 1, kMaxKernelSize);
678 fuzz->nextRange(&m, 1, kMaxKernelSize);
679 SkScalar kernel[kMaxKernelSize * kMaxKernelSize];
680 fuzz->nextN(kernel, n * m);
681 int32_t offsetX, offsetY;
682 fuzz->nextRange(&offsetX, 0, n - 1);
683 fuzz->nextRange(&offsetY, 0, m - 1);
684 SkScalar gain, bias;
685 bool convolveAlpha, useCropRect;
686 fuzz->next(&gain, &bias, &convolveAlpha, &useCropRect);
687 SkMatrixConvolutionImageFilter::TileMode tileMode;
688 fuzz->nextRange(&tileMode, 0, SkMatrixConvolutionImageFilter::TileMode::kLast_TileMode);
689 SkImageFilter::CropRect cropRect;
690 if (useCropRect) {
691 fuzz->next(&cropRect);
692 }
693 sk_sp<SkImageFilter> input = make_fuzz_imageFilter(fuzz, depth - 1);
694 return SkMatrixConvolutionImageFilter::Make(
695 SkISize{n, m}, kernel, gain, bias, SkIPoint{offsetX, offsetY}, tileMode,
696 convolveAlpha, std::move(input), useCropRect ? &cropRect : nullptr);
697 }
698 case 14: {
699 sk_sp<SkImageFilter> first = make_fuzz_imageFilter(fuzz, depth - 1);
700 sk_sp<SkImageFilter> second = make_fuzz_imageFilter(fuzz, depth - 1);
701 bool useCropRect;
702 fuzz->next(&useCropRect);
703 SkImageFilter::CropRect cropRect;
704 if (useCropRect) {
705 fuzz->next(&cropRect);
706 }
707 return SkMergeImageFilter::Make(std::move(first), std::move(second),
708 useCropRect ? &cropRect : nullptr);
709 }
710 case 15: {
711 constexpr int kMaxCount = 4;
712 sk_sp<SkImageFilter> ifs[kMaxCount];
713 int count;
714 fuzz->nextRange(&count, 1, kMaxCount);
715 for (int i = 0; i < count; ++i) {
716 ifs[i] = make_fuzz_imageFilter(fuzz, depth - 1);
717 }
718 bool useCropRect;
719 fuzz->next(&useCropRect);
720 SkImageFilter::CropRect cropRect;
721 if (useCropRect) {
722 fuzz->next(&cropRect);
723 }
724 return SkMergeImageFilter::Make(ifs, count, useCropRect ? &cropRect : nullptr);
725 }
726 case 16: {
727 int rx, ry;
728 fuzz->next(&rx, &ry);
729 bool useCropRect;
730 fuzz->next(&useCropRect);
731 SkImageFilter::CropRect cropRect;
732 if (useCropRect) {
733 fuzz->next(&cropRect);
734 }
735 sk_sp<SkImageFilter> input = make_fuzz_imageFilter(fuzz, depth - 1);
736 return SkDilateImageFilter::Make(rx, ry, std::move(input),
737 useCropRect ? &cropRect : nullptr);
738 }
739 case 17: {
740 int rx, ry;
741 fuzz->next(&rx, &ry);
742 bool useCropRect;
743 fuzz->next(&useCropRect);
744 SkImageFilter::CropRect cropRect;
745 if (useCropRect) {
746 fuzz->next(&cropRect);
747 }
748 sk_sp<SkImageFilter> input = make_fuzz_imageFilter(fuzz, depth - 1);
749 return SkErodeImageFilter::Make(rx, ry, std::move(input),
750 useCropRect ? &cropRect : nullptr);
751 }
752 case 18: {
753 SkScalar dx, dy;
754 fuzz->next(&dx, &dy);
755 bool useCropRect;
756 fuzz->next(&useCropRect);
757 SkImageFilter::CropRect cropRect;
758 if (useCropRect) {
759 fuzz->next(&cropRect);
760 }
761 sk_sp<SkImageFilter> input = make_fuzz_imageFilter(fuzz, depth - 1);
762 return SkOffsetImageFilter::Make(dx, dy, std::move(input),
763 useCropRect ? &cropRect : nullptr);
764 }
765 case 19: {
766 SkPaint paint;
767 fuzz_paint(fuzz, &paint, depth - 1);
768 bool useCropRect;
769 fuzz->next(&useCropRect);
770 SkImageFilter::CropRect cropRect;
771 if (useCropRect) {
772 fuzz->next(&cropRect);
773 }
774 return SkPaintImageFilter::Make(paint, useCropRect ? &cropRect : nullptr);
775 }
776 case 20: {
777 sk_sp<SkPicture> picture = make_fuzz_picture(fuzz, depth - 1);
778 return SkPictureImageFilter::Make(std::move(picture));
779 }
780 case 21: {
781 SkRect cropRect;
782 fuzz->next(&cropRect);
783 sk_sp<SkPicture> picture = make_fuzz_picture(fuzz, depth - 1);
784 return SkPictureImageFilter::Make(std::move(picture), cropRect);
785 }
786 case 22: {
787 SkRect src, dst;
788 fuzz->next(&src, &dst);
789 sk_sp<SkImageFilter> input = make_fuzz_imageFilter(fuzz, depth - 1);
790 return SkTileImageFilter::Make(src, dst, std::move(input));
791 }
792 case 23: {
793 SkBlendMode blendMode;
794 bool useCropRect;
795 fuzz->next(&useCropRect);
796 fuzz->nextRange(&blendMode, 0, SkBlendMode::kLastMode);
797 SkImageFilter::CropRect cropRect;
798 if (useCropRect) {
799 fuzz->next(&cropRect);
800 }
801 sk_sp<SkImageFilter> bg = make_fuzz_imageFilter(fuzz, depth - 1);
802 sk_sp<SkImageFilter> fg = make_fuzz_imageFilter(fuzz, depth - 1);
803 return SkXfermodeImageFilter::Make(blendMode, std::move(bg), std::move(fg),
804 useCropRect ? &cropRect : nullptr);
805 }
806 default:
807 SkASSERT(false);
808 return nullptr;
809 }
810 }
811
make_fuzz_image(Fuzz * fuzz)812 static sk_sp<SkImage> make_fuzz_image(Fuzz* fuzz) {
813 int w, h;
814 fuzz->nextRange(&w, 1, 1024);
815 fuzz->nextRange(&h, 1, 1024);
816 SkAutoTMalloc<SkPMColor> data(w * h);
817 SkPixmap pixmap(SkImageInfo::MakeN32Premul(w, h), data.get(), w * sizeof(SkPMColor));
818 int n = w * h;
819 for (int i = 0; i < n; ++i) {
820 SkColor c;
821 fuzz->next(&c);
822 data[i] = SkPreMultiplyColor(c);
823 }
824 (void)data.release();
825 return SkImage::MakeFromRaster(pixmap, [](const void* p, void*) { sk_free((void*)p); },
826 nullptr);
827 }
828
make_fuzz_bitmap(Fuzz * fuzz)829 static SkBitmap make_fuzz_bitmap(Fuzz* fuzz) {
830 SkBitmap bitmap;
831 int w, h;
832 fuzz->nextRange(&w, 1, 1024);
833 fuzz->nextRange(&h, 1, 1024);
834 if (!bitmap.tryAllocN32Pixels(w, h)) {
835 SkDEBUGF("Could not allocate pixels %d x %d", w, h);
836 return bitmap;
837 }
838 for (int y = 0; y < h; ++y) {
839 for (int x = 0; x < w; ++x) {
840 SkColor c;
841 fuzz->next(&c);
842 *bitmap.getAddr32(x, y) = SkPreMultiplyColor(c);
843 }
844 }
845 return bitmap;
846 }
847
848 template <typename T, typename Min, typename Max>
make_fuzz_t_range(Fuzz * fuzz,Min minv,Max maxv)849 inline T make_fuzz_t_range(Fuzz* fuzz, Min minv, Max maxv) {
850 T value;
851 fuzz->nextRange(&value, minv, maxv);
852 return value;
853 }
854
fuzz_paint(Fuzz * fuzz,SkPaint * paint,int depth)855 static void fuzz_paint(Fuzz* fuzz, SkPaint* paint, int depth) {
856 if (!fuzz || !paint || depth <= 0) {
857 return;
858 }
859
860 paint->setAntiAlias( make_fuzz_t<bool>(fuzz));
861 paint->setDither( make_fuzz_t<bool>(fuzz));
862 paint->setColor( make_fuzz_t<SkColor>(fuzz));
863 paint->setBlendMode( make_fuzz_t_range<SkBlendMode>(fuzz, 0, SkBlendMode::kLastMode));
864 paint->setFilterQuality(make_fuzz_t_range<SkFilterQuality>(fuzz, 0, kLast_SkFilterQuality));
865 paint->setStyle( make_fuzz_t_range<SkPaint::Style>(fuzz, 0, 2));
866 paint->setShader( make_fuzz_shader(fuzz, depth - 1));
867 paint->setPathEffect( make_fuzz_patheffect(fuzz, depth - 1));
868 paint->setMaskFilter( make_fuzz_maskfilter(fuzz));
869 paint->setImageFilter( make_fuzz_imageFilter(fuzz, depth - 1));
870 paint->setColorFilter( make_fuzz_colorfilter(fuzz, depth - 1));
871
872 if (paint->getStyle() != SkPaint::kFill_Style) {
873 paint->setStrokeWidth(make_fuzz_t<SkScalar>(fuzz));
874 paint->setStrokeMiter(make_fuzz_t<SkScalar>(fuzz));
875 paint->setStrokeCap( make_fuzz_t_range<SkPaint::Cap>(fuzz, 0, SkPaint::kLast_Cap));
876 paint->setStrokeJoin( make_fuzz_t_range<SkPaint::Join>(fuzz, 0, SkPaint::kLast_Join));
877 }
878 }
879
fuzz_font(Fuzz * fuzz)880 static SkFont fuzz_font(Fuzz* fuzz) {
881 SkFont font;
882 font.setTypeface( make_fuzz_typeface(fuzz));
883 font.setSize( make_fuzz_t<SkScalar>(fuzz));
884 font.setScaleX( make_fuzz_t<SkScalar>(fuzz));
885 font.setSkewX( make_fuzz_t<SkScalar>(fuzz));
886 font.setLinearMetrics( make_fuzz_t<bool>(fuzz));
887 font.setSubpixel( make_fuzz_t<bool>(fuzz));
888 font.setEmbeddedBitmaps( make_fuzz_t<bool>(fuzz));
889 font.setForceAutoHinting( make_fuzz_t<bool>(fuzz));
890 font.setEmbolden( make_fuzz_t<bool>(fuzz));
891 font.setHinting( make_fuzz_t_range<SkFontHinting>(fuzz, 0, kFull_SkFontHinting));
892 font.setEdging( make_fuzz_t_range<SkFont::Edging>(fuzz, 0,
893 (int)SkFont::Edging::kSubpixelAntiAlias));
894 return font;
895 }
896
fuzz_paint_text_encoding(Fuzz * fuzz)897 static SkTextEncoding fuzz_paint_text_encoding(Fuzz* fuzz) {
898 return make_fuzz_t_range<SkTextEncoding>(fuzz, 0, 3);
899 }
900
901 constexpr int kMaxGlyphCount = 30;
902
make_fuzz_text(Fuzz * fuzz,const SkFont & font,SkTextEncoding encoding)903 static SkTDArray<uint8_t> make_fuzz_text(Fuzz* fuzz, const SkFont& font, SkTextEncoding encoding) {
904 SkTDArray<uint8_t> array;
905 if (kGlyphID_SkTextEncoding == encoding) {
906 int glyphRange = font.getTypefaceOrDefault()->countGlyphs();
907 if (glyphRange == 0) {
908 // Some fuzzing environments have no fonts, so empty array is the best
909 // we can do.
910 return array;
911 }
912 int glyphCount;
913 fuzz->nextRange(&glyphCount, 1, kMaxGlyphCount);
914 SkGlyphID* glyphs = (SkGlyphID*)array.append(glyphCount * sizeof(SkGlyphID));
915 for (int i = 0; i < glyphCount; ++i) {
916 fuzz->nextRange(&glyphs[i], 0, glyphRange - 1);
917 }
918 return array;
919 }
920 static const SkUnichar ranges[][2] = {
921 {0x0020, 0x007F},
922 {0x00A1, 0x0250},
923 {0x0400, 0x0500},
924 };
925 int32_t count = 0;
926 for (size_t i = 0; i < SK_ARRAY_COUNT(ranges); ++i) {
927 count += (ranges[i][1] - ranges[i][0]);
928 }
929 constexpr int kMaxLength = kMaxGlyphCount;
930 SkUnichar buffer[kMaxLength];
931 int length;
932 fuzz->nextRange(&length, 1, kMaxLength);
933 for (int j = 0; j < length; ++j) {
934 int32_t value;
935 fuzz->nextRange(&value, 0, count - 1);
936 for (size_t i = 0; i < SK_ARRAY_COUNT(ranges); ++i) {
937 if (value + ranges[i][0] < ranges[i][1]) {
938 buffer[j] = value + ranges[i][0];
939 break;
940 } else {
941 value -= (ranges[i][1] - ranges[i][0]);
942 }
943 }
944 }
945 switch (encoding) {
946 case kUTF8_SkTextEncoding: {
947 size_t utf8len = 0;
948 for (int j = 0; j < length; ++j) {
949 utf8len += SkUTF::ToUTF8(buffer[j], nullptr);
950 }
951 char* ptr = (char*)array.append(utf8len);
952 for (int j = 0; j < length; ++j) {
953 ptr += SkUTF::ToUTF8(buffer[j], ptr);
954 }
955 } break;
956 case kUTF16_SkTextEncoding: {
957 size_t utf16len = 0;
958 for (int j = 0; j < length; ++j) {
959 utf16len += SkUTF::ToUTF16(buffer[j]);
960 }
961 uint16_t* ptr = (uint16_t*)array.append(utf16len * sizeof(uint16_t));
962 for (int j = 0; j < length; ++j) {
963 ptr += SkUTF::ToUTF16(buffer[j], ptr);
964 }
965 } break;
966 case kUTF32_SkTextEncoding:
967 memcpy(array.append(length * sizeof(SkUnichar)), buffer, length * sizeof(SkUnichar));
968 break;
969 default:
970 SkASSERT(false);
971 break;
972 }
973 return array;
974 }
975
make_fuzz_textblob(Fuzz * fuzz)976 static sk_sp<SkTextBlob> make_fuzz_textblob(Fuzz* fuzz) {
977 SkTextBlobBuilder textBlobBuilder;
978 int8_t runCount;
979 fuzz->nextRange(&runCount, (int8_t)1, (int8_t)8);
980 while (runCount-- > 0) {
981 SkFont font;
982 SkTextEncoding encoding = fuzz_paint_text_encoding(fuzz);
983 font.setEdging(make_fuzz_t<bool>(fuzz) ? SkFont::Edging::kAlias : SkFont::Edging::kAntiAlias);
984 SkTDArray<uint8_t> text = make_fuzz_text(fuzz, font, encoding);
985 int glyphCount = font.countText(text.begin(), SkToSizeT(text.count()), encoding);
986 SkASSERT(glyphCount <= kMaxGlyphCount);
987 SkScalar x, y;
988 const SkTextBlobBuilder::RunBuffer* buffer;
989 uint8_t runType;
990 fuzz->nextRange(&runType, (uint8_t)0, (uint8_t)2);
991 const void* textPtr = text.begin();
992 size_t textLen = SkToSizeT(text.count());
993 switch (runType) {
994 case 0:
995 fuzz->next(&x, &y);
996 // TODO: Test other variations of this.
997 buffer = &textBlobBuilder.allocRun(font, glyphCount, x, y);
998 (void)font.textToGlyphs(textPtr, textLen, encoding, buffer->glyphs, glyphCount);
999 break;
1000 case 1:
1001 fuzz->next(&y);
1002 // TODO: Test other variations of this.
1003 buffer = &textBlobBuilder.allocRunPosH(font, glyphCount, y);
1004 (void)font.textToGlyphs(textPtr, textLen, encoding, buffer->glyphs, glyphCount);
1005 fuzz->nextN(buffer->pos, glyphCount);
1006 break;
1007 case 2:
1008 // TODO: Test other variations of this.
1009 buffer = &textBlobBuilder.allocRunPos(font, glyphCount);
1010 (void)font.textToGlyphs(textPtr, textLen, encoding, buffer->glyphs, glyphCount);
1011 fuzz->nextN(buffer->pos, glyphCount * 2);
1012 break;
1013 default:
1014 SkASSERT(false);
1015 break;
1016 }
1017 }
1018 return textBlobBuilder.make();
1019 }
1020
1021 extern std::atomic<bool> gSkUseDeltaAA;
1022 extern std::atomic<bool> gSkForceDeltaAA;
1023
fuzz_canvas(Fuzz * fuzz,SkCanvas * canvas,int depth=9)1024 static void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 9) {
1025 if (!fuzz || !canvas || depth <= 0) {
1026 return;
1027 }
1028 SkAutoCanvasRestore autoCanvasRestore(canvas, false);
1029 bool useDAA;
1030 fuzz->next(&useDAA);
1031 if (useDAA) {
1032 gSkForceDeltaAA = true;
1033 gSkUseDeltaAA = true;
1034 }
1035 unsigned N;
1036 fuzz->nextRange(&N, 0, 2000);
1037 for (unsigned i = 0; i < N; ++i) {
1038 if (fuzz->exhausted()) {
1039 return;
1040 }
1041 SkPaint paint;
1042 SkFont font;
1043 unsigned drawCommand;
1044 fuzz->nextRange(&drawCommand, 0, 53);
1045 switch (drawCommand) {
1046 case 0:
1047 canvas->flush();
1048 break;
1049 case 1:
1050 canvas->save();
1051 break;
1052 case 2: {
1053 SkRect bounds;
1054 fuzz->next(&bounds);
1055 fuzz_paint(fuzz, &paint, depth - 1);
1056 canvas->saveLayer(&bounds, &paint);
1057 break;
1058 }
1059 case 3: {
1060 SkRect bounds;
1061 fuzz->next(&bounds);
1062 canvas->saveLayer(&bounds, nullptr);
1063 break;
1064 }
1065 case 4:
1066 fuzz_paint(fuzz, &paint, depth - 1);
1067 canvas->saveLayer(nullptr, &paint);
1068 break;
1069 case 5:
1070 canvas->saveLayer(nullptr, nullptr);
1071 break;
1072 case 6: {
1073 uint8_t alpha;
1074 fuzz->next(&alpha);
1075 canvas->saveLayerAlpha(nullptr, (U8CPU)alpha);
1076 break;
1077 }
1078 case 7: {
1079 SkRect bounds;
1080 uint8_t alpha;
1081 fuzz->next(&bounds, &alpha);
1082 canvas->saveLayerAlpha(&bounds, (U8CPU)alpha);
1083 break;
1084 }
1085 case 8: {
1086 SkCanvas::SaveLayerRec saveLayerRec;
1087 SkRect bounds;
1088 if (make_fuzz_t<bool>(fuzz)) {
1089 fuzz->next(&bounds);
1090 saveLayerRec.fBounds = &bounds;
1091 }
1092 if (make_fuzz_t<bool>(fuzz)) {
1093 fuzz_paint(fuzz, &paint, depth - 1);
1094 saveLayerRec.fPaint = &paint;
1095 }
1096 sk_sp<SkImageFilter> imageFilter;
1097 if (make_fuzz_t<bool>(fuzz)) {
1098 imageFilter = make_fuzz_imageFilter(fuzz, depth - 1);
1099 saveLayerRec.fBackdrop = imageFilter.get();
1100 }
1101 // _DumpCanvas can't handle this.
1102 // if (make_fuzz_t<bool>(fuzz)) {
1103 // saveLayerRec.fSaveLayerFlags |= SkCanvas::kPreserveLCDText_SaveLayerFlag;
1104 // }
1105
1106 canvas->saveLayer(saveLayerRec);
1107 break;
1108 }
1109 case 9:
1110 canvas->restore();
1111 break;
1112 case 10: {
1113 int saveCount;
1114 fuzz->next(&saveCount);
1115 canvas->restoreToCount(saveCount);
1116 break;
1117 }
1118 case 11: {
1119 SkScalar x, y;
1120 fuzz->next(&x, &y);
1121 canvas->translate(x, y);
1122 break;
1123 }
1124 case 12: {
1125 SkScalar x, y;
1126 fuzz->next(&x, &y);
1127 canvas->scale(x, y);
1128 break;
1129 }
1130 case 13: {
1131 SkScalar v;
1132 fuzz->next(&v);
1133 canvas->rotate(v);
1134 break;
1135 }
1136 case 14: {
1137 SkScalar x, y, v;
1138 fuzz->next(&x, &y, &v);
1139 canvas->rotate(v, x, y);
1140 break;
1141 }
1142 case 15: {
1143 SkScalar x, y;
1144 fuzz->next(&x, &y);
1145 canvas->skew(x, y);
1146 break;
1147 }
1148 case 16: {
1149 SkMatrix mat;
1150 FuzzNiceMatrix(fuzz, &mat);
1151 canvas->concat(mat);
1152 break;
1153 }
1154 case 17: {
1155 SkMatrix mat;
1156 FuzzNiceMatrix(fuzz, &mat);
1157 canvas->setMatrix(mat);
1158 break;
1159 }
1160 case 18:
1161 canvas->resetMatrix();
1162 break;
1163 case 19: {
1164 SkRect r;
1165 int op;
1166 bool doAntiAlias;
1167 fuzz->next(&r, &doAntiAlias);
1168 fuzz->nextRange(&op, 0, 1);
1169 r.sort();
1170 canvas->clipRect(r, (SkClipOp)op, doAntiAlias);
1171 break;
1172 }
1173 case 20: {
1174 SkRRect rr;
1175 int op;
1176 bool doAntiAlias;
1177 FuzzNiceRRect(fuzz, &rr);
1178 fuzz->next(&doAntiAlias);
1179 fuzz->nextRange(&op, 0, 1);
1180 canvas->clipRRect(rr, (SkClipOp)op, doAntiAlias);
1181 break;
1182 }
1183 case 21: {
1184 SkPath path;
1185 FuzzNicePath(fuzz, &path, 30);
1186 int op;
1187 bool doAntiAlias;
1188 fuzz->next(&doAntiAlias);
1189 fuzz->nextRange(&op, 0, 1);
1190 canvas->clipPath(path, (SkClipOp)op, doAntiAlias);
1191 break;
1192 }
1193 case 22: {
1194 SkRegion region;
1195 int op;
1196 fuzz->next(®ion);
1197 fuzz->nextRange(&op, 0, 1);
1198 canvas->clipRegion(region, (SkClipOp)op);
1199 break;
1200 }
1201 case 23:
1202 fuzz_paint(fuzz, &paint, depth - 1);
1203 canvas->drawPaint(paint);
1204 break;
1205 case 24: {
1206 fuzz_paint(fuzz, &paint, depth - 1);
1207 SkCanvas::PointMode pointMode;
1208 fuzz->nextRange(&pointMode,
1209 SkCanvas::kPoints_PointMode, SkCanvas::kPolygon_PointMode);
1210 size_t count;
1211 constexpr int kMaxCount = 30;
1212 fuzz->nextRange(&count, 0, kMaxCount);
1213 SkPoint pts[kMaxCount];
1214 fuzz->nextN(pts, count);
1215 canvas->drawPoints(pointMode, count, pts, paint);
1216 break;
1217 }
1218 case 25: {
1219 fuzz_paint(fuzz, &paint, depth - 1);
1220 SkRect r;
1221 fuzz->next(&r);
1222 if (!r.isFinite()) {
1223 break;
1224 }
1225 canvas->drawRect(r, paint);
1226 break;
1227 }
1228 case 26: {
1229 fuzz_paint(fuzz, &paint, depth - 1);
1230 SkRegion region;
1231 fuzz->next(®ion);
1232 canvas->drawRegion(region, paint);
1233 break;
1234 }
1235 case 27: {
1236 fuzz_paint(fuzz, &paint, depth - 1);
1237 SkRect r;
1238 fuzz->next(&r);
1239 if (!r.isFinite()) {
1240 break;
1241 }
1242 canvas->drawOval(r, paint);
1243 break;
1244 }
1245 case 28: break; // must have deleted this some time earlier
1246 case 29: {
1247 fuzz_paint(fuzz, &paint, depth - 1);
1248 SkRRect rr;
1249 FuzzNiceRRect(fuzz, &rr);
1250 canvas->drawRRect(rr, paint);
1251 break;
1252 }
1253 case 30: {
1254 fuzz_paint(fuzz, &paint, depth - 1);
1255 SkRRect orr, irr;
1256 FuzzNiceRRect(fuzz, &orr);
1257 FuzzNiceRRect(fuzz, &irr);
1258 if (orr.getBounds().contains(irr.getBounds())) {
1259 canvas->drawDRRect(orr, irr, paint);
1260 }
1261 break;
1262 }
1263 case 31: {
1264 fuzz_paint(fuzz, &paint, depth - 1);
1265 SkRect r;
1266 SkScalar start, sweep;
1267 bool useCenter;
1268 fuzz->next(&r, &start, &sweep, &useCenter);
1269 canvas->drawArc(r, start, sweep, useCenter, paint);
1270 break;
1271 }
1272 case 32: {
1273 fuzz_paint(fuzz, &paint, depth - 1);
1274 SkPath path;
1275 FuzzNicePath(fuzz, &path, 60);
1276 canvas->drawPath(path, paint);
1277 break;
1278 }
1279 case 33: {
1280 sk_sp<SkImage> img = make_fuzz_image(fuzz);
1281 SkScalar left, top;
1282 bool usePaint;
1283 fuzz->next(&left, &top, &usePaint);
1284 if (usePaint) {
1285 fuzz_paint(fuzz, &paint, depth - 1);
1286 }
1287 canvas->drawImage(img.get(), left, top, usePaint ? &paint : nullptr);
1288 break;
1289 }
1290 case 34: {
1291 auto img = make_fuzz_image(fuzz);
1292 SkRect src, dst;
1293 bool usePaint;
1294 fuzz->next(&src, &dst, &usePaint);
1295 if (usePaint) {
1296 fuzz_paint(fuzz, &paint, depth - 1);
1297 }
1298 canvas->drawImageRect(img, src, dst, usePaint ? &paint : nullptr);
1299 break;
1300 }
1301 case 35: {
1302 auto img = make_fuzz_image(fuzz);
1303 SkIRect src;
1304 SkRect dst;
1305 bool usePaint;
1306 fuzz->next(&src, &dst, &usePaint);
1307 if (usePaint) {
1308 fuzz_paint(fuzz, &paint, depth - 1);
1309 }
1310 SkCanvas::SrcRectConstraint constraint =
1311 make_fuzz_t<bool>(fuzz) ? SkCanvas::kStrict_SrcRectConstraint
1312 : SkCanvas::kFast_SrcRectConstraint;
1313 canvas->drawImageRect(img, src, dst, usePaint ? &paint : nullptr, constraint);
1314 break;
1315 }
1316 case 36: {
1317 bool usePaint;
1318 auto img = make_fuzz_image(fuzz);
1319 SkRect dst;
1320 fuzz->next(&dst, &usePaint);
1321 if (usePaint) {
1322 fuzz_paint(fuzz, &paint, depth - 1);
1323 }
1324 canvas->drawImageRect(img, dst, usePaint ? &paint : nullptr);
1325 break;
1326 }
1327 case 37: {
1328 auto img = make_fuzz_image(fuzz);
1329 SkIRect center;
1330 SkRect dst;
1331 bool usePaint;
1332 fuzz->next(&usePaint);
1333 if (usePaint) {
1334 fuzz_paint(fuzz, &paint, depth - 1);
1335 }
1336 if (make_fuzz_t<bool>(fuzz)) {
1337 fuzz->next(¢er);
1338 } else { // Make valid center, see SkLatticeIter::Valid().
1339 fuzz->nextRange(¢er.fLeft, 0, img->width() - 1);
1340 fuzz->nextRange(¢er.fTop, 0, img->height() - 1);
1341 fuzz->nextRange(¢er.fRight, center.fLeft + 1, img->width());
1342 fuzz->nextRange(¢er.fBottom, center.fTop + 1, img->height());
1343 }
1344 fuzz->next(&dst);
1345 canvas->drawImageNine(img, center, dst, usePaint ? &paint : nullptr);
1346 break;
1347 }
1348 case 38: {
1349 SkBitmap bitmap = make_fuzz_bitmap(fuzz);
1350 SkScalar left, top;
1351 bool usePaint;
1352 fuzz->next(&left, &top, &usePaint);
1353 if (usePaint) {
1354 fuzz_paint(fuzz, &paint, depth - 1);
1355 }
1356 canvas->drawBitmap(bitmap, left, top, usePaint ? &paint : nullptr);
1357 break;
1358 }
1359 case 39: {
1360 SkBitmap bitmap = make_fuzz_bitmap(fuzz);
1361 SkRect src, dst;
1362 bool usePaint;
1363 fuzz->next(&src, &dst, &usePaint);
1364 if (usePaint) {
1365 fuzz_paint(fuzz, &paint, depth - 1);
1366 }
1367 SkCanvas::SrcRectConstraint constraint =
1368 make_fuzz_t<bool>(fuzz) ? SkCanvas::kStrict_SrcRectConstraint
1369 : SkCanvas::kFast_SrcRectConstraint;
1370 canvas->drawBitmapRect(bitmap, src, dst, usePaint ? &paint : nullptr, constraint);
1371 break;
1372 }
1373 case 40: {
1374 SkBitmap img = make_fuzz_bitmap(fuzz);
1375 SkIRect src;
1376 SkRect dst;
1377 bool usePaint;
1378 fuzz->next(&src, &dst, &usePaint);
1379 if (usePaint) {
1380 fuzz_paint(fuzz, &paint, depth - 1);
1381 }
1382 SkCanvas::SrcRectConstraint constraint =
1383 make_fuzz_t<bool>(fuzz) ? SkCanvas::kStrict_SrcRectConstraint
1384 : SkCanvas::kFast_SrcRectConstraint;
1385 canvas->drawBitmapRect(img, src, dst, usePaint ? &paint : nullptr, constraint);
1386 break;
1387 }
1388 case 41: {
1389 SkBitmap img = make_fuzz_bitmap(fuzz);
1390 SkRect dst;
1391 bool usePaint;
1392 fuzz->next(&dst, &usePaint);
1393 if (usePaint) {
1394 fuzz_paint(fuzz, &paint, depth - 1);
1395 }
1396 SkCanvas::SrcRectConstraint constraint =
1397 make_fuzz_t<bool>(fuzz) ? SkCanvas::kStrict_SrcRectConstraint
1398 : SkCanvas::kFast_SrcRectConstraint;
1399 canvas->drawBitmapRect(img, dst, usePaint ? &paint : nullptr, constraint);
1400 break;
1401 }
1402 case 42: {
1403 SkBitmap img = make_fuzz_bitmap(fuzz);
1404 SkIRect center;
1405 SkRect dst;
1406 bool usePaint;
1407 fuzz->next(&usePaint);
1408 if (usePaint) {
1409 fuzz_paint(fuzz, &paint, depth - 1);
1410 }
1411 if (make_fuzz_t<bool>(fuzz)) {
1412 fuzz->next(¢er);
1413 } else { // Make valid center, see SkLatticeIter::Valid().
1414 if (img.width() == 0 || img.height() == 0) {
1415 // bitmap may not have had its pixels initialized.
1416 break;
1417 }
1418 fuzz->nextRange(¢er.fLeft, 0, img.width() - 1);
1419 fuzz->nextRange(¢er.fTop, 0, img.height() - 1);
1420 fuzz->nextRange(¢er.fRight, center.fLeft + 1, img.width());
1421 fuzz->nextRange(¢er.fBottom, center.fTop + 1, img.height());
1422 }
1423 fuzz->next(&dst);
1424 canvas->drawBitmapNine(img, center, dst, usePaint ? &paint : nullptr);
1425 break;
1426 }
1427 case 43: {
1428 SkBitmap img = make_fuzz_bitmap(fuzz);
1429 bool usePaint;
1430 SkRect dst;
1431 fuzz->next(&usePaint, &dst);
1432 if (usePaint) {
1433 fuzz_paint(fuzz, &paint, depth - 1);
1434 }
1435 constexpr int kMax = 6;
1436 int xDivs[kMax], yDivs[kMax];
1437 SkCanvas::Lattice lattice{xDivs, yDivs, nullptr, 0, 0, nullptr, nullptr};
1438 fuzz->nextRange(&lattice.fXCount, 2, kMax);
1439 fuzz->nextRange(&lattice.fYCount, 2, kMax);
1440 fuzz->nextN(xDivs, lattice.fXCount);
1441 fuzz->nextN(yDivs, lattice.fYCount);
1442 canvas->drawBitmapLattice(img, lattice, dst, usePaint ? &paint : nullptr);
1443 break;
1444 }
1445 case 44: {
1446 auto img = make_fuzz_image(fuzz);
1447 bool usePaint;
1448 SkRect dst;
1449 fuzz->next(&usePaint, &dst);
1450 if (usePaint) {
1451 fuzz_paint(fuzz, &paint, depth - 1);
1452 }
1453 constexpr int kMax = 6;
1454 int xDivs[kMax], yDivs[kMax];
1455 SkCanvas::Lattice lattice{xDivs, yDivs, nullptr, 0, 0, nullptr, nullptr};
1456 fuzz->nextRange(&lattice.fXCount, 2, kMax);
1457 fuzz->nextRange(&lattice.fYCount, 2, kMax);
1458 fuzz->nextN(xDivs, lattice.fXCount);
1459 fuzz->nextN(yDivs, lattice.fYCount);
1460 canvas->drawImageLattice(img.get(), lattice, dst, usePaint ? &paint : nullptr);
1461 break;
1462 }
1463 case 45: {
1464 fuzz_paint(fuzz, &paint, depth - 1);
1465 font = fuzz_font(fuzz);
1466 SkTextEncoding encoding = fuzz_paint_text_encoding(fuzz);
1467 SkScalar x, y;
1468 fuzz->next(&x, &y);
1469 SkTDArray<uint8_t> text = make_fuzz_text(fuzz, font, encoding);
1470 canvas->drawSimpleText(text.begin(), SkToSizeT(text.count()), encoding, x, y,
1471 font, paint);
1472 break;
1473 }
1474 case 46: {
1475 // was drawPosText
1476 break;
1477 }
1478 case 47: {
1479 // was drawPosTextH
1480 break;
1481 }
1482 case 48: {
1483 // was drawtextonpath
1484 break;
1485 }
1486 case 49: {
1487 // was drawtextonpath
1488 break;
1489 }
1490 case 50: {
1491 // was drawTextRSXform
1492 break;
1493 }
1494 case 51: {
1495 sk_sp<SkTextBlob> blob = make_fuzz_textblob(fuzz);
1496 fuzz_paint(fuzz, &paint, depth - 1);
1497 SkScalar x, y;
1498 fuzz->next(&x, &y);
1499 canvas->drawTextBlob(blob, x, y, paint);
1500 break;
1501 }
1502 case 52: {
1503 SkMatrix matrix;
1504 bool usePaint, useMatrix;
1505 fuzz->next(&usePaint, &useMatrix);
1506 if (usePaint) {
1507 fuzz_paint(fuzz, &paint, depth - 1);
1508 }
1509 if (useMatrix) {
1510 FuzzNiceMatrix(fuzz, &matrix);
1511 }
1512 auto pic = make_fuzz_picture(fuzz, depth - 1);
1513 canvas->drawPicture(pic, useMatrix ? &matrix : nullptr,
1514 usePaint ? &paint : nullptr);
1515 break;
1516 }
1517 case 53: {
1518 fuzz_paint(fuzz, &paint, depth - 1);
1519 SkVertices::VertexMode vertexMode;
1520 SkBlendMode blendMode;
1521 fuzz->nextRange(&vertexMode, 0, SkVertices::kTriangleFan_VertexMode);
1522 fuzz->nextRange(&blendMode, 0, SkBlendMode::kLastMode);
1523 constexpr int kMaxCount = 100;
1524 int vertexCount;
1525 SkPoint vertices[kMaxCount];
1526 SkPoint texs[kMaxCount];
1527 SkColor colors[kMaxCount];
1528 fuzz->nextRange(&vertexCount, 3, kMaxCount);
1529 fuzz->nextN(vertices, vertexCount);
1530 bool useTexs, useColors;
1531 fuzz->next(&useTexs, &useColors);
1532 if (useTexs) {
1533 fuzz->nextN(texs, vertexCount);
1534 }
1535 if (useColors) {
1536 fuzz->nextN(colors, vertexCount);
1537 }
1538 int indexCount = 0;
1539 uint16_t indices[kMaxCount * 2];
1540 if (make_fuzz_t<bool>(fuzz)) {
1541 fuzz->nextRange(&indexCount, vertexCount, vertexCount + kMaxCount);
1542 for (int i = 0; i < indexCount; ++i) {
1543 fuzz->nextRange(&indices[i], 0, vertexCount - 1);
1544 }
1545 }
1546 canvas->drawVertices(SkVertices::MakeCopy(vertexMode, vertexCount, vertices,
1547 useTexs ? texs : nullptr,
1548 useColors ? colors : nullptr,
1549 indexCount, indices),
1550 blendMode, paint);
1551 break;
1552 }
1553 default:
1554 SkASSERT(false);
1555 break;
1556 }
1557 }
1558 }
1559
make_fuzz_picture(Fuzz * fuzz,int depth)1560 static sk_sp<SkPicture> make_fuzz_picture(Fuzz* fuzz, int depth) {
1561 SkScalar w, h;
1562 fuzz->next(&w, &h);
1563 SkPictureRecorder pictureRecorder;
1564 fuzz_canvas(fuzz, pictureRecorder.beginRecording(w, h), depth - 1);
1565 return pictureRecorder.finishRecordingAsPicture();
1566 }
1567
DEF_FUZZ(NullCanvas,fuzz)1568 DEF_FUZZ(NullCanvas, fuzz) {
1569 fuzz_canvas(fuzz, SkMakeNullCanvas().get());
1570 }
1571
1572 constexpr SkISize kCanvasSize = {128, 160};
1573
DEF_FUZZ(RasterN32Canvas,fuzz)1574 DEF_FUZZ(RasterN32Canvas, fuzz) {
1575 auto surface = SkSurface::MakeRasterN32Premul(kCanvasSize.width(), kCanvasSize.height());
1576 if (!surface || !surface->getCanvas()) { fuzz->signalBug(); }
1577 fuzz_canvas(fuzz, surface->getCanvas());
1578 }
1579
DEF_FUZZ(RasterN32CanvasViaSerialization,fuzz)1580 DEF_FUZZ(RasterN32CanvasViaSerialization, fuzz) {
1581 SkPictureRecorder recorder;
1582 fuzz_canvas(fuzz, recorder.beginRecording(SkIntToScalar(kCanvasSize.width()),
1583 SkIntToScalar(kCanvasSize.height())));
1584 sk_sp<SkPicture> pic(recorder.finishRecordingAsPicture());
1585 if (!pic) { fuzz->signalBug(); }
1586 sk_sp<SkData> data = pic->serialize();
1587 if (!data) { fuzz->signalBug(); }
1588 SkReadBuffer rb(data->data(), data->size());
1589 auto deserialized = SkPicturePriv::MakeFromBuffer(rb);
1590 if (!deserialized) { fuzz->signalBug(); }
1591 auto surface = SkSurface::MakeRasterN32Premul(kCanvasSize.width(), kCanvasSize.height());
1592 SkASSERT(surface && surface->getCanvas());
1593 surface->getCanvas()->drawPicture(deserialized);
1594 }
1595
DEF_FUZZ(ImageFilter,fuzz)1596 DEF_FUZZ(ImageFilter, fuzz) {
1597 auto fil = make_fuzz_imageFilter(fuzz, 20);
1598
1599 SkPaint paint;
1600 paint.setImageFilter(fil);
1601 SkBitmap bitmap;
1602 SkCanvas canvas(bitmap);
1603 canvas.saveLayer(SkRect::MakeWH(500, 500), &paint);
1604 }
1605
1606
1607 //SkRandom _rand;
1608 #define SK_ADD_RANDOM_BIT_FLIPS
1609
DEF_FUZZ(SerializedImageFilter,fuzz)1610 DEF_FUZZ(SerializedImageFilter, fuzz) {
1611 auto filter = make_fuzz_imageFilter(fuzz, 20);
1612 if (!filter) {
1613 return;
1614 }
1615 auto data = filter->serialize();
1616 const unsigned char* ptr = static_cast<const unsigned char*>(data->data());
1617 size_t len = data->size();
1618 #ifdef SK_ADD_RANDOM_BIT_FLIPS
1619 unsigned char* p = const_cast<unsigned char*>(ptr);
1620 for (size_t i = 0; i < len; ++i, ++p) {
1621 uint8_t j;
1622 fuzz->nextRange(&j, 1, 250);
1623 if (j == 1) { // 0.4% of the time, flip a bit or byte
1624 uint8_t k;
1625 fuzz->nextRange(&k, 1, 10);
1626 if (k == 1) { // Then 10% of the time, change a whole byte
1627 uint8_t s;
1628 fuzz->nextRange(&s, 0, 2);
1629 switch(s) {
1630 case 0:
1631 *p ^= 0xFF; // Flip entire byte
1632 break;
1633 case 1:
1634 *p = 0xFF; // Set all bits to 1
1635 break;
1636 case 2:
1637 *p = 0x00; // Set all bits to 0
1638 break;
1639 }
1640 } else {
1641 uint8_t s;
1642 fuzz->nextRange(&s, 0, 7);
1643 *p ^= (1 << 7);
1644 }
1645 }
1646 }
1647 #endif // SK_ADD_RANDOM_BIT_FLIPS
1648 auto deserializedFil = SkImageFilter::Deserialize(ptr, len);
1649
1650 // uncomment below to write out a serialized image filter (to make corpus
1651 // for -t filter_fuzz)
1652 // SkString s("./serialized_filters/sf");
1653 // s.appendU32(_rand.nextU());
1654 // auto file = sk_fopen(s.c_str(), SkFILE_Flags::kWrite_SkFILE_Flag);
1655 // sk_fwrite(data->bytes(), data->size(), file);
1656 // sk_fclose(file);
1657
1658 SkPaint paint;
1659 paint.setImageFilter(deserializedFil);
1660 SkBitmap bitmap;
1661 SkCanvas canvas(bitmap);
1662 canvas.saveLayer(SkRect::MakeWH(500, 500), &paint);
1663 }
1664
1665 #if SK_SUPPORT_GPU
1666
dump_GPU_info(GrContext * context)1667 static void dump_GPU_info(GrContext* context) {
1668 const GrGLInterface* gl = static_cast<GrGLGpu*>(context->priv().getGpu())
1669 ->glInterface();
1670 const GrGLubyte* output;
1671 GR_GL_CALL_RET(gl, output, GetString(GR_GL_RENDERER));
1672 SkDebugf("GL_RENDERER %s\n", (const char*) output);
1673
1674 GR_GL_CALL_RET(gl, output, GetString(GR_GL_VENDOR));
1675 SkDebugf("GL_VENDOR %s\n", (const char*) output);
1676
1677 GR_GL_CALL_RET(gl, output, GetString(GR_GL_VERSION));
1678 SkDebugf("GL_VERSION %s\n", (const char*) output);
1679 }
1680
fuzz_ganesh(Fuzz * fuzz,GrContext * context)1681 static void fuzz_ganesh(Fuzz* fuzz, GrContext* context) {
1682 SkASSERT(context);
1683 auto surface = SkSurface::MakeRenderTarget(
1684 context,
1685 SkBudgeted::kNo,
1686 SkImageInfo::Make(kCanvasSize.width(), kCanvasSize.height(), kRGBA_8888_SkColorType, kPremul_SkAlphaType));
1687 SkASSERT(surface && surface->getCanvas());
1688 fuzz_canvas(fuzz, surface->getCanvas());
1689 }
1690
DEF_FUZZ(NativeGLCanvas,fuzz)1691 DEF_FUZZ(NativeGLCanvas, fuzz) {
1692 sk_gpu_test::GrContextFactory f;
1693 GrContext* context = f.get(sk_gpu_test::GrContextFactory::kGL_ContextType);
1694 if (!context) {
1695 context = f.get(sk_gpu_test::GrContextFactory::kGLES_ContextType);
1696 }
1697 if (FLAGS_gpuInfo) {
1698 dump_GPU_info(context);
1699 }
1700 fuzz_ganesh(fuzz, context);
1701 }
1702
1703 // This target is deprecated, NullGLContext is not well maintained.
1704 // Please use MockGPUCanvas instead.
DEF_FUZZ(NullGLCanvas,fuzz)1705 DEF_FUZZ(NullGLCanvas, fuzz) {
1706 sk_gpu_test::GrContextFactory f;
1707 fuzz_ganesh(fuzz, f.get(sk_gpu_test::GrContextFactory::kNullGL_ContextType));
1708 }
1709
DEF_FUZZ(MockGPUCanvas,fuzz)1710 DEF_FUZZ(MockGPUCanvas, fuzz) {
1711 sk_gpu_test::GrContextFactory f;
1712 fuzz_ganesh(fuzz, f.get(sk_gpu_test::GrContextFactory::kMock_ContextType));
1713 }
1714 #endif
1715
DEF_FUZZ(PDFCanvas,fuzz)1716 DEF_FUZZ(PDFCanvas, fuzz) {
1717 SkNullWStream stream;
1718 auto doc = SkPDF::MakeDocument(&stream);
1719 fuzz_canvas(fuzz, doc->beginPage(SkIntToScalar(kCanvasSize.width()),
1720 SkIntToScalar(kCanvasSize.height())));
1721 }
1722
1723 // not a "real" thing to fuzz, used to debug errors found while fuzzing.
DEF_FUZZ(_DumpCanvas,fuzz)1724 DEF_FUZZ(_DumpCanvas, fuzz) {
1725 SkDebugCanvas debugCanvas(kCanvasSize.width(), kCanvasSize.height());
1726 fuzz_canvas(fuzz, &debugCanvas);
1727 std::unique_ptr<SkCanvas> nullCanvas = SkMakeNullCanvas();
1728 UrlDataManager dataManager(SkString("data"));
1729 SkDynamicMemoryWStream stream;
1730 SkJSONWriter writer(&stream, SkJSONWriter::Mode::kPretty);
1731 writer.beginObject(); // root
1732 debugCanvas.toJSON(writer, dataManager, debugCanvas.getSize(), nullCanvas.get());
1733 writer.endObject(); // root
1734 writer.flush();
1735 sk_sp<SkData> json = stream.detachAsData();
1736 fwrite(json->data(), json->size(), 1, stdout);
1737 }
1738