formatting change: FuzzCanvas.cpp

Change-Id: I55345c193e6a15f650a992053d00bc42ef6a8854
Reviewed-on: https://skia-review.googlesource.com/9412
Reviewed-by: Hal Canary <halcanary@google.com>
Commit-Queue: Hal Canary <halcanary@google.com>

1 files changed, 179 insertions, 202 deletions

diff --git a/fuzz/FuzzCanvas.cpp b/fuzz/FuzzCanvas.cpp
index 924de9fbc0..1a1a3ad7b0 100644
--- a/fuzz/FuzzCanvas.cpp
+++ b/fuzz/FuzzCanvas.cpp
@@ -143,13 +143,14 @@ static void fuzz_region(Fuzz* fuzz, SkRegion* region) {
     }
 }
 
-template <> inline void Fuzz::next(SkShader::TileMode* m) {
+template <>
+inline void Fuzz::next(SkShader::TileMode* m) {
     using U = skstd::underlying_type_t<SkShader::TileMode>;
     this->nextRange((U*)m, (U)0, (U)(SkShader::kTileModeCount - 1));
 }
 
-
-template <> inline void Fuzz::next(SkMatrix* m) {
+template <>
+inline void Fuzz::next(SkMatrix* m) {
     constexpr int kArrayLength = 9;
     SkScalar buffer[kArrayLength];
     int matrixType;
@@ -184,7 +185,8 @@ template <> inline void Fuzz::next(SkMatrix* m) {
     }
 }
 
-template <> inline void Fuzz::next(SkRRect* rr) {
+template <>
+inline void Fuzz::next(SkRRect* rr) {
     SkRect r;
     SkVector radii[4];
     this->next(&r);
@@ -198,7 +200,8 @@ template <> inline void Fuzz::next(SkRRect* rr) {
     rr->setRectRadii(r, radii);
 }
 
-template <> inline void Fuzz::next(SkBlendMode* mode) {
+template <>
+inline void Fuzz::next(SkBlendMode* mode) {
     using U = skstd::underlying_type_t<SkBlendMode>;
     this->nextRange((U*)mode, (U)0, (U)SkBlendMode::kLastMode);
 }
@@ -281,7 +284,7 @@ void make_pos(Fuzz* fuzz, SkScalar* pos, int colorCount) {
     for (int i = 0; i < colorCount; ++i) {
         pos[i] *= totalPos;
     }
-    //SkASSERT(fabs(pos[colorCount - 1] - 1.0f) < 0.00001f);
+    // SkASSERT(fabs(pos[colorCount - 1] - 1.0f) < 0.00001f);
     pos[colorCount - 1] = 1.0f;
 }
 
@@ -335,144 +338,130 @@ sk_sp<SkShader> MakeFuzzShader(Fuzz* fuzz, int depth) {
             shader2 = MakeFuzzShader(fuzz, depth - 1);
             fuzz->next(&blendMode);
             return SkShader::MakeComposeShader(std::move(shader1), std::move(shader2), blendMode);
-        case 8:
-            {
-                auto pic = make_picture(fuzz, depth);
-                bool useTile;
-                SkRect tile;
-                fuzz->next(&tmX, &tmY, &useMatrix, &useTile);
-                if (useMatrix) {
-                    fuzz->next(&matrix);
-                }
-                if (useTile) {
-                    fuzz->next(&tile);
-                }
-                return SkShader::MakePictureShader(std::move(pic), tmX, tmY,
-                                                   useMatrix ? &matrix : nullptr,
-                                                   useTile ? &tile : nullptr);
+        case 8: {
+            auto pic = make_picture(fuzz, depth);
+            bool useTile;
+            SkRect tile;
+            fuzz->next(&tmX, &tmY, &useMatrix, &useTile);
+            if (useMatrix) {
+                fuzz->next(&matrix);
+            }
+            if (useTile) {
+                fuzz->next(&tile);
             }
+            return SkShader::MakePictureShader(std::move(pic), tmX, tmY,
+                                               useMatrix ? &matrix : nullptr,
+                                               useTile ? &tile : nullptr);
+        }
         // EFFECTS:
         case 9:
             return SkGaussianEdgeShader::Make();
-        case 10:
-            {
-                constexpr int kMaxColors = 12;
-                SkPoint pts[2];
-                SkColor colors[kMaxColors];
-                SkScalar pos[kMaxColors];
-                int colorCount;
-                bool usePos;
-                fuzz->nextN(pts, 2);
-                fuzz->nextRange(&colorCount, 2, kMaxColors);
-                fuzz->nextN(colors, colorCount);
-                fuzz->next(&tmX, &useMatrix, &usePos);
-                if (useMatrix) {
-                    fuzz->next(&matrix);
-                }
-                if (usePos) {
-                    make_pos(fuzz, pos, colorCount);
-                }
-                return SkGradientShader::MakeLinear(pts,
-                                                    colors,
-                                                    usePos ? pos : nullptr,
-                                                    colorCount,
-                                                    tmX, 0,
-                                                    useMatrix ? &matrix : nullptr);
-            }
-        case 11:
-            {
-                constexpr int kMaxColors = 12;
-                SkPoint center;
-                SkScalar radius;
-                int colorCount;
-                bool usePos;
-                SkColor colors[kMaxColors];
-                SkScalar pos[kMaxColors];
-                fuzz->next(&tmX, &useMatrix, &usePos, &center, &radius);
-                fuzz->nextRange(&colorCount, 2, kMaxColors);
-                fuzz->nextN(colors, colorCount);
-                if (useMatrix) {
-                    fuzz->next(&matrix);
-                }
-                if (usePos) {
-                    make_pos(fuzz, pos, colorCount);
-                }
-                return SkGradientShader::MakeRadial(center, radius, colors,
-                                                    usePos ? pos : nullptr,
-                                                    colorCount, tmX, 0,
-                                                    useMatrix ? &matrix : nullptr);
-            }
-        case 12:
-            {
-                constexpr int kMaxColors = 12;
-                SkPoint start, end;
-                SkScalar startRadius, endRadius;
-                int colorCount;
-                bool usePos;
-                SkColor colors[kMaxColors];
-                SkScalar pos[kMaxColors];
-                fuzz->next(&tmX, &useMatrix, &usePos, &startRadius, &endRadius, &start, &end);
-                fuzz->nextRange(&colorCount, 2, kMaxColors);
-                fuzz->nextN(colors, colorCount);
-                if (useMatrix) {
-                    fuzz->next(&matrix);
-                }
-                if (usePos) {
-                    make_pos(fuzz, pos, colorCount);
-                }
-                return SkGradientShader::MakeTwoPointConical(start, startRadius, end, endRadius,
-                                                             colors, usePos ? pos : nullptr,
-                                                             colorCount, tmX, 0,
-                                                             useMatrix ? &matrix : nullptr);
-            }
-        case 13:
-            {
-                constexpr int kMaxColors = 12;
-                SkScalar cx, cy;
-                int colorCount;
-                bool usePos;
-                SkColor colors[kMaxColors];
-                SkScalar pos[kMaxColors];
-                fuzz->next(&cx, &cy, &useMatrix, &usePos);
-                fuzz->nextRange(&colorCount, 2, kMaxColors);
-                fuzz->nextN(colors, colorCount);
-                if (useMatrix) {
-                    fuzz->next(&matrix);
-                }
-                if (usePos) {
-                    make_pos(fuzz, pos, colorCount);
-                }
-                return SkGradientShader::MakeSweep(cx, cy, colors, usePos ? pos : nullptr,
-                                                   colorCount, 0, useMatrix ? &matrix : nullptr);
-            }
-        case 14:
-            {
-                SkScalar baseFrequencyX, baseFrequencyY, seed;
-                int numOctaves;
-                SkISize tileSize;
-                bool useTileSize, turbulence;
-                fuzz->next(&baseFrequencyX, &baseFrequencyY, &seed, &useTileSize, &turbulence);
-                if (useTileSize) {
-                    fuzz->next(&tileSize);
-                }
-                fuzz->nextRange(&numOctaves, 2, 7);
-                if (turbulence) {
-                    return SkPerlinNoiseShader::MakeTurbulence(baseFrequencyX, baseFrequencyY,
-                                                               numOctaves, seed,
-                                                               useTileSize ? &tileSize : nullptr);
-                } else {
-                    return SkPerlinNoiseShader::MakeFractalNoise(baseFrequencyX, baseFrequencyY,
-                                                                 numOctaves, seed,
-                                                                 useTileSize ? &tileSize : nullptr);
-                }
+        case 10: {
+            constexpr int kMaxColors = 12;
+            SkPoint pts[2];
+            SkColor colors[kMaxColors];
+            SkScalar pos[kMaxColors];
+            int colorCount;
+            bool usePos;
+            fuzz->nextN(pts, 2);
+            fuzz->nextRange(&colorCount, 2, kMaxColors);
+            fuzz->nextN(colors, colorCount);
+            fuzz->next(&tmX, &useMatrix, &usePos);
+            if (useMatrix) {
+                fuzz->next(&matrix);
             }
+            if (usePos) {
+                make_pos(fuzz, pos, colorCount);
+            }
+            return SkGradientShader::MakeLinear(pts, colors, usePos ? pos : nullptr, colorCount,
+                                                tmX, 0, useMatrix ? &matrix : nullptr);
+        }
+        case 11: {
+            constexpr int kMaxColors = 12;
+            SkPoint center;
+            SkScalar radius;
+            int colorCount;
+            bool usePos;
+            SkColor colors[kMaxColors];
+            SkScalar pos[kMaxColors];
+            fuzz->next(&tmX, &useMatrix, &usePos, &center, &radius);
+            fuzz->nextRange(&colorCount, 2, kMaxColors);
+            fuzz->nextN(colors, colorCount);
+            if (useMatrix) {
+                fuzz->next(&matrix);
+            }
+            if (usePos) {
+                make_pos(fuzz, pos, colorCount);
+            }
+            return SkGradientShader::MakeRadial(center, radius, colors, usePos ? pos : nullptr,
+                                                colorCount, tmX, 0, useMatrix ? &matrix : nullptr);
+        }
+        case 12: {
+            constexpr int kMaxColors = 12;
+            SkPoint start, end;
+            SkScalar startRadius, endRadius;
+            int colorCount;
+            bool usePos;
+            SkColor colors[kMaxColors];
+            SkScalar pos[kMaxColors];
+            fuzz->next(&tmX, &useMatrix, &usePos, &startRadius, &endRadius, &start, &end);
+            fuzz->nextRange(&colorCount, 2, kMaxColors);
+            fuzz->nextN(colors, colorCount);
+            if (useMatrix) {
+                fuzz->next(&matrix);
+            }
+            if (usePos) {
+                make_pos(fuzz, pos, colorCount);
+            }
+            return SkGradientShader::MakeTwoPointConical(start, startRadius, end, endRadius, colors,
+                                                         usePos ? pos : nullptr, colorCount, tmX, 0,
+                                                         useMatrix ? &matrix : nullptr);
+        }
+        case 13: {
+            constexpr int kMaxColors = 12;
+            SkScalar cx, cy;
+            int colorCount;
+            bool usePos;
+            SkColor colors[kMaxColors];
+            SkScalar pos[kMaxColors];
+            fuzz->next(&cx, &cy, &useMatrix, &usePos);
+            fuzz->nextRange(&colorCount, 2, kMaxColors);
+            fuzz->nextN(colors, colorCount);
+            if (useMatrix) {
+                fuzz->next(&matrix);
+            }
+            if (usePos) {
+                make_pos(fuzz, pos, colorCount);
+            }
+            return SkGradientShader::MakeSweep(cx, cy, colors, usePos ? pos : nullptr, colorCount,
+                                               0, useMatrix ? &matrix : nullptr);
+        }
+        case 14: {
+            SkScalar baseFrequencyX, baseFrequencyY, seed;
+            int numOctaves;
+            SkISize tileSize;
+            bool useTileSize, turbulence;
+            fuzz->next(&baseFrequencyX, &baseFrequencyY, &seed, &useTileSize, &turbulence);
+            if (useTileSize) {
+                fuzz->next(&tileSize);
+            }
+            fuzz->nextRange(&numOctaves, 2, 7);
+            if (turbulence) {
+                return SkPerlinNoiseShader::MakeTurbulence(baseFrequencyX, baseFrequencyY,
+                                                           numOctaves, seed,
+                                                           useTileSize ? &tileSize : nullptr);
+            } else {
+                return SkPerlinNoiseShader::MakeFractalNoise(baseFrequencyX, baseFrequencyY,
+                                                             numOctaves, seed,
+                                                             useTileSize ? &tileSize : nullptr);
+            }
+        }
         default:
             break;
     }
     return nullptr;
 }
 
-
 sk_sp<SkPathEffect> MakeFuzzPathEffect(Fuzz* fuzz) { return nullptr; /*TODO*/ }
 
 sk_sp<SkMaskFilter> MakeFuzzMaskFilter(Fuzz* fuzz) { return nullptr; /*TODO*/ }
@@ -507,8 +496,8 @@ sk_sp<SkImage> MakeFuzzImage(Fuzz* fuzz) {
         data[i] = SkPreMultiplyColor(c);
     }
     (void)data.release();
-    return SkImage::MakeFromRaster(
-            pixmap, [](const void* p, void*) { sk_free((void*)p); }, nullptr);
+    return SkImage::MakeFromRaster(pixmap, [](const void* p, void*) { sk_free((void*)p); },
+                                   nullptr);
 }
 
 SkBitmap MakeFuzzBitmap(Fuzz* fuzz) {
@@ -537,14 +526,14 @@ void FuzzPaint(Fuzz* fuzz, SkPaint* paint, int depth) {
     fuzz_input<bool, &SkPaint::setDither>(fuzz, paint);
     fuzz_input<SkColor, &SkPaint::setColor>(fuzz, paint);
     fuzz_enum_input<SkBlendMode, &SkPaint::setBlendMode>(fuzz, paint, (SkBlendMode)0,
-                                                            SkBlendMode::kLastMode);
+                                                         SkBlendMode::kLastMode);
     fuzz_enum_input<SkPaint::Hinting, &SkPaint::setHinting>(fuzz, paint, SkPaint::kNo_Hinting,
-                                                               SkPaint::kFull_Hinting);
+                                                            SkPaint::kFull_Hinting);
     fuzz_enum_input<SkFilterQuality, &SkPaint::setFilterQuality>(
             fuzz, paint, SkFilterQuality::kNone_SkFilterQuality,
             SkFilterQuality::kLast_SkFilterQuality);
     fuzz_enum_input<SkPaint::Style, &SkPaint::setStyle>(fuzz, paint, SkPaint::kFill_Style,
-                                                           SkPaint::kStrokeAndFill_Style);
+                                                        SkPaint::kStrokeAndFill_Style);
     paint->setShader(MakeFuzzShader(fuzz, depth));
     paint->setPathEffect(MakeFuzzPathEffect(fuzz));
     paint->setMaskFilter(MakeFuzzMaskFilter(fuzz));
@@ -555,9 +544,9 @@ void FuzzPaint(Fuzz* fuzz, SkPaint* paint, int depth) {
         fuzz_input<SkScalar, &SkPaint::setStrokeWidth>(fuzz, paint);
         fuzz_input<SkScalar, &SkPaint::setStrokeMiter>(fuzz, paint);
         fuzz_enum_input<SkPaint::Cap, &SkPaint::setStrokeCap>(fuzz, paint, SkPaint::kButt_Cap,
-                                                                 SkPaint::kLast_Cap);
+                                                              SkPaint::kLast_Cap);
         fuzz_enum_input<SkPaint::Join, &SkPaint::setStrokeJoin>(fuzz, paint, SkPaint::kMiter_Join,
-                                                                   SkPaint::kLast_Join);
+                                                                SkPaint::kLast_Join);
     }
 }
 
@@ -575,7 +564,7 @@ void FuzzPaintText(Fuzz* fuzz, SkPaint* paint) {
     fuzz_input<bool, &SkPaint::setFakeBoldText>(fuzz, paint);
     fuzz_input<bool, &SkPaint::setDevKernText>(fuzz, paint);
     fuzz_enum_input<SkPaint::Align, &SkPaint::setTextAlign>(fuzz, paint, SkPaint::kLeft_Align,
-                                                               SkPaint::kRight_Align);
+                                                            SkPaint::kRight_Align);
     fuzz_enum_input<SkPaint::TextEncoding, &SkPaint::setTextEncoding>(
             fuzz, paint, SkPaint::kUTF8_TextEncoding, SkPaint::kGlyphID_TextEncoding);
 }
@@ -583,9 +572,8 @@ void FuzzPaintText(Fuzz* fuzz, SkPaint* paint) {
 SkTDArray<uint8_t> fuzz_text(Fuzz* fuzz, const SkPaint& paint) {
     SkTDArray<uint8_t> array;
     if (SkPaint::kGlyphID_TextEncoding == paint.getTextEncoding()) {
-        int glyphRange = paint.getTypeface()
-                       ? paint.getTypeface()->countGlyphs()
-                       : SkTypeface::MakeDefault()->countGlyphs();
+        int glyphRange = paint.getTypeface() ? paint.getTypeface()->countGlyphs()
+                                             : SkTypeface::MakeDefault()->countGlyphs();
         constexpr int kMaxGlyphCount = 20;
         int glyphCount;
         fuzz->nextRange(&glyphCount, 0, kMaxGlyphCount);
@@ -601,7 +589,7 @@ SkTDArray<uint8_t> fuzz_text(Fuzz* fuzz, const SkPaint& paint) {
         {0x0400, 0x0500},
     };
     int32_t count = 0;
-    for (size_t i = 0; i < SK_ARRAY_COUNT(ranges); ++i){
+    for (size_t i = 0; i < SK_ARRAY_COUNT(ranges); ++i) {
         count += (ranges[i][1] - ranges[i][0]);
     }
     constexpr int kMaxLength = 30;
@@ -611,7 +599,7 @@ SkTDArray<uint8_t> fuzz_text(Fuzz* fuzz, const SkPaint& paint) {
     for (int j = 0; j < length; ++j) {
         int32_t value;
         fuzz->nextRange(&value, 0, count - 1);
-        for (size_t i = 0; i < SK_ARRAY_COUNT(ranges); ++i){
+        for (size_t i = 0; i < SK_ARRAY_COUNT(ranges); ++i) {
             if (value + ranges[i][0] < ranges[i][1]) {
                 buffer[j] = value + ranges[i][0];
                 break;
@@ -621,40 +609,35 @@ SkTDArray<uint8_t> fuzz_text(Fuzz* fuzz, const SkPaint& paint) {
         }
     }
     switch (paint.getTextEncoding()) {
-        case SkPaint::kUTF8_TextEncoding:
-            {
-                size_t utf8len = 0;
-                for (int j = 0; j < length; ++j) {
-                    utf8len += SkUTF8_FromUnichar(buffer[j], nullptr);
-                }
-                char* ptr = (char*)array.append(utf8len);
-                for (int j = 0; j < length; ++j) {
-                    ptr += SkUTF8_FromUnichar(buffer[j], ptr);
-                }
+        case SkPaint::kUTF8_TextEncoding: {
+            size_t utf8len = 0;
+            for (int j = 0; j < length; ++j) {
+                utf8len += SkUTF8_FromUnichar(buffer[j], nullptr);
             }
-            break;
-        case SkPaint::kUTF16_TextEncoding:
-            {
-                size_t utf16len = 0;
-                for (int j = 0; j < length; ++j) {
-                    utf16len += SkUTF16_FromUnichar(buffer[j]);
-                }
-                uint16_t* ptr = (uint16_t*)array.append(utf16len * sizeof(uint16_t));
-                for (int j = 0; j < length; ++j) {
-                    ptr += SkUTF16_FromUnichar(buffer[j], ptr);
-                }
+            char* ptr = (char*)array.append(utf8len);
+            for (int j = 0; j < length; ++j) {
+                ptr += SkUTF8_FromUnichar(buffer[j], ptr);
             }
-            break;
+        } break;
+        case SkPaint::kUTF16_TextEncoding: {
+            size_t utf16len = 0;
+            for (int j = 0; j < length; ++j) {
+                utf16len += SkUTF16_FromUnichar(buffer[j]);
+            }
+            uint16_t* ptr = (uint16_t*)array.append(utf16len * sizeof(uint16_t));
+            for (int j = 0; j < length; ++j) {
+                ptr += SkUTF16_FromUnichar(buffer[j], ptr);
+            }
+        } break;
         case SkPaint::kUTF32_TextEncoding:
             memcpy(array.append(length * sizeof(SkUnichar)), buffer, length * sizeof(SkUnichar));
             break;
         default:
-           SkASSERT(false);
+            SkASSERT(false);
     }
     return array;
 }
 
-
 void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 4) {
     if (!fuzz || !canvas || depth <= 0) {
         return;
@@ -915,9 +898,9 @@ void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 4) {
                 if (usePaint) {
                     FuzzPaint(fuzz, &paint, depth);
                 }
-                SkCanvas::SrcRectConstraint constraint = make_bool(fuzz)
-                                                       ? SkCanvas::kStrict_SrcRectConstraint
-                                                       : SkCanvas::kFast_SrcRectConstraint;
+                SkCanvas::SrcRectConstraint constraint =
+                        make_bool(fuzz) ? SkCanvas::kStrict_SrcRectConstraint
+                                        : SkCanvas::kFast_SrcRectConstraint;
                 canvas->drawImageRect(img, src, dst, usePaint ? &paint : nullptr, constraint);
                 break;
             }
@@ -930,9 +913,9 @@ void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 4) {
                 if (usePaint) {
                     FuzzPaint(fuzz, &paint, depth);
                 }
-                SkCanvas::SrcRectConstraint constraint = make_bool(fuzz)
-                                                       ? SkCanvas::kStrict_SrcRectConstraint
-                                                       : SkCanvas::kFast_SrcRectConstraint;
+                SkCanvas::SrcRectConstraint constraint =
+                        make_bool(fuzz) ? SkCanvas::kStrict_SrcRectConstraint
+                                        : SkCanvas::kFast_SrcRectConstraint;
                 canvas->drawImageRect(img, src, dst, usePaint ? &paint : nullptr, constraint);
                 break;
             }
@@ -944,9 +927,9 @@ void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 4) {
                 if (usePaint) {
                     FuzzPaint(fuzz, &paint, depth);
                 }
-                SkCanvas::SrcRectConstraint constraint = make_bool(fuzz)
-                                                       ? SkCanvas::kStrict_SrcRectConstraint
-                                                       : SkCanvas::kFast_SrcRectConstraint;
+                SkCanvas::SrcRectConstraint constraint =
+                        make_bool(fuzz) ? SkCanvas::kStrict_SrcRectConstraint
+                                        : SkCanvas::kFast_SrcRectConstraint;
                 canvas->drawImageRect(img, dst, usePaint ? &paint : nullptr, constraint);
                 break;
             }
@@ -981,9 +964,9 @@ void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 4) {
                 if (usePaint) {
                     FuzzPaint(fuzz, &paint, depth);
                 }
-                SkCanvas::SrcRectConstraint constraint = make_bool(fuzz)
-                                                       ? SkCanvas::kStrict_SrcRectConstraint
-                                                       : SkCanvas::kFast_SrcRectConstraint;
+                SkCanvas::SrcRectConstraint constraint =
+                        make_bool(fuzz) ? SkCanvas::kStrict_SrcRectConstraint
+                                        : SkCanvas::kFast_SrcRectConstraint;
                 canvas->drawBitmapRect(bitmap, src, dst, usePaint ? &paint : nullptr, constraint);
                 break;
             }
@@ -996,9 +979,9 @@ void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 4) {
                 if (usePaint) {
                     FuzzPaint(fuzz, &paint, depth);
                 }
-                SkCanvas::SrcRectConstraint constraint = make_bool(fuzz)
-                                                       ? SkCanvas::kStrict_SrcRectConstraint
-                                                       : SkCanvas::kFast_SrcRectConstraint;
+                SkCanvas::SrcRectConstraint constraint =
+                        make_bool(fuzz) ? SkCanvas::kStrict_SrcRectConstraint
+                                        : SkCanvas::kFast_SrcRectConstraint;
                 canvas->drawBitmapRect(img, src, dst, usePaint ? &paint : nullptr, constraint);
                 break;
             }
@@ -1010,9 +993,9 @@ void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 4) {
                 if (usePaint) {
                     FuzzPaint(fuzz, &paint, depth);
                 }
-                SkCanvas::SrcRectConstraint constraint = make_bool(fuzz)
-                                                       ? SkCanvas::kStrict_SrcRectConstraint
-                                                       : SkCanvas::kFast_SrcRectConstraint;
+                SkCanvas::SrcRectConstraint constraint =
+                        make_bool(fuzz) ? SkCanvas::kStrict_SrcRectConstraint
+                                        : SkCanvas::kFast_SrcRectConstraint;
                 canvas->drawBitmapRect(img, dst, usePaint ? &paint : nullptr, constraint);
                 break;
             }
@@ -1087,8 +1070,7 @@ void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 4) {
                 pos[0] = {0, 0};
                 for (int i = 1; i < glyphCount; ++i) {
                     float y;
-                    fuzz->nextRange(&y, -0.5f * paint.getTextSize(),
-                                         0.5f * paint.getTextSize());
+                    fuzz->nextRange(&y, -0.5f * paint.getTextSize(), 0.5f * paint.getTextSize());
                     pos[i] = {pos[i - 1].x() + widths[i - 1], y};
                 }
                 canvas->drawPosText(text.begin(), SkToSizeT(text.count()), pos.get(), paint);
@@ -1110,13 +1092,12 @@ void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 4) {
                     x += widths[i];
                     SkScalar offset;
                     fuzz->nextRange(&offset, -0.125f * paint.getTextSize(),
-                                              0.125f * paint.getTextSize());
+                                    0.125f * paint.getTextSize());
                     widths[i] += offset;
                 }
                 SkScalar y;
                 fuzz->next(&y);
-                canvas->drawPosTextH(text.begin(), SkToSizeT(text.count()),
-                                     widths.get(), y, paint);
+                canvas->drawPosTextH(text.begin(), SkToSizeT(text.count()), widths.get(), y, paint);
                 break;
             }
             case 48: {
@@ -1127,8 +1108,8 @@ void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 4) {
                 fuzz_path(fuzz, &path, 20);
                 SkScalar hOffset, vOffset;
                 fuzz->next(&hOffset, &vOffset);
-                canvas->drawTextOnPathHV(text.begin(), SkToSizeT(text.count()),
-                                         path, hOffset, vOffset, paint);
+                canvas->drawTextOnPathHV(text.begin(), SkToSizeT(text.count()), path, hOffset,
+                                         vOffset, paint);
                 break;
             }
             case 49: {
@@ -1200,13 +1181,9 @@ void fuzz_canvas(Fuzz* fuzz, SkCanvas* canvas, int depth = 4) {
                         fuzz->nextRange(&indices[i], 0, vertexCount - 1);
                     }
                 }
-                canvas->drawVertices(vertexMode, vertexCount, vertices,
-                                     useTexs ? texs : nullptr,
-                                     useColors ? colors : nullptr,
-                                     mode,
-                                     indexCount > 0 ? indices : nullptr,
-                                     indexCount,
-                                     paint);
+                canvas->drawVertices(vertexMode, vertexCount, vertices, useTexs ? texs : nullptr,
+                                     useColors ? colors : nullptr, mode,
+                                     indexCount > 0 ? indices : nullptr, indexCount, paint);
                 break;
             }
             case 54: {