Fix fuzzer's bools to be 0 or 1 only

fuzz/FuzzGradients.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Fuzz.h"
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
@@ skipping 62 matching lines @@
     return true;
 }
 
 void fuzzLinearGradient(Fuzz* fuzz) {
         SkScalar a, b, c, d;
         bool useLocalMatrix, useGlobalMatrix;
         if (!fuzz->next<SkScalar>(&a)          ||
                 !fuzz->next<SkScalar>(&b)          ||
                 !fuzz->next<SkScalar>(&c)          ||
                 !fuzz->next<SkScalar>(&d)          ||
-                !fuzz->next<bool>(&useLocalMatrix) ||
-                !fuzz->next<bool>(&useGlobalMatrix)) {
+                !fuzz->next(&useLocalMatrix) ||

[mtklein_C, 2016/10/24 17:45:10]

This code reads inconsistently, before this CL and more now.  If we're going to
line up ||, let's line them all up, and while we're at it, line up all the
!fuzz->next too.

Again, it'd be nice to either always use the type or never use the type when
calling next().  I'd recommend never using the type... it can be inferred in
every single one of these cases.

If you want to use the type, instead of overloading next(T*) with next(bool*),
we can make an explicit template function specialization.  It'd work very
similarly except that next<bool>(...) would pick up the specialized version. 
The downside is that there are some more restrictions on where you can define
it, so let's not get into that unless you really like the <Type> all over the
place.

[kjlubick, 2016/10/24 18:27:01]

All the types removed and the || are lined up as well as !fuzz->next

+                !fuzz->next(&useGlobalMatrix)) {
             return;
         }
         SkPoint pts[2] = {SkPoint::Make(a,b), SkPoint::Make(c, d)};
 
         uint32_t count;
         SkColor* colors;
         SkScalar* pos;
         SkShader::TileMode mode;
         if (!initGradientParams(fuzz, &count, &colors, &pos, &mode)) {
             return;
@@ skipping 25 matching lines @@
             surface->getCanvas()->drawPaint(p);
         }
 }
 
 void fuzzRadialGradient(Fuzz* fuzz) {
         SkScalar a, b, radius;
         bool useLocalMatrix, useGlobalMatrix;
         if (!fuzz->next<SkScalar>(&a)          ||
                 !fuzz->next<SkScalar>(&b)          ||
                 !fuzz->next<SkScalar>(&radius)     ||
-                !fuzz->next<bool>(&useLocalMatrix) ||
-                !fuzz->next<bool>(&useGlobalMatrix)) {
+                !fuzz->next(&useLocalMatrix) ||
+                !fuzz->next(&useGlobalMatrix)) {
             return;
         }
         SkPoint center = SkPoint::Make(a,b);
 
         uint32_t count;
         SkColor* colors;
         SkScalar* pos;
         SkShader::TileMode mode;
         if (!initGradientParams(fuzz, &count, &colors, &pos, &mode)) {
             return;
@@ skipping 29 matching lines @@
 
 void fuzzTwoPointConicalGradient(Fuzz* fuzz) {
         SkScalar a, b, startRadius, c, d, endRadius;
         bool useLocalMatrix, useGlobalMatrix;
         if (!fuzz->next<SkScalar>(&a)           ||
                 !fuzz->next<SkScalar>(&b)           ||
                 !fuzz->next<SkScalar>(&startRadius) ||
                 !fuzz->next<SkScalar>(&c)           ||
                 !fuzz->next<SkScalar>(&d)           ||
                 !fuzz->next<SkScalar>(&endRadius)   ||
-                !fuzz->next<bool>(&useLocalMatrix)  ||
-                !fuzz->next<bool>(&useGlobalMatrix)) {
+                !fuzz->next(&useLocalMatrix)  ||
+                !fuzz->next(&useGlobalMatrix)) {
             return;
         }
         SkPoint start = SkPoint::Make(a, b);
         SkPoint end = SkPoint::Make(c, d);
 
         uint32_t count;
         SkColor* colors;
         SkScalar* pos;
         SkShader::TileMode mode;
         if (!initGradientParams(fuzz, &count, &colors, &pos, &mode)) {
@@ skipping 25 matching lines @@
         } else {
             surface->getCanvas()->drawPaint(p);
         }
 }
 
 void fuzzSweepGradient(Fuzz* fuzz) {
         SkScalar cx, cy;
         bool useLocalMatrix, useGlobalMatrix;
         if (!fuzz->next<SkScalar>(&cx)         ||
                 !fuzz->next<SkScalar>(&cy)         ||
-                !fuzz->next<bool>(&useLocalMatrix) ||
-                !fuzz->next<bool>(&useGlobalMatrix)) {
+                !fuzz->next(&useLocalMatrix) ||
+                !fuzz->next(&useGlobalMatrix)) {
             return;
         }
 
         uint32_t count;
         SkColor* colors;
         SkScalar* pos;
         SkShader::TileMode mode;
         if (!initGradientParams(fuzz, &count, &colors, &pos, &mode)) {
             return;
         }
@@ skipping 45 matching lines @@
             return;
         case 2:
             SkDebugf("TwoPointConicalGradient\n");
             fuzzTwoPointConicalGradient(fuzz);
             return;
     }
     SkDebugf("SweepGradient\n");
     fuzzSweepGradient(fuzz);
     return;
 }