Add fuzz executable to GN

fuzz/FuzzParsePath.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 "SkString.h"
 #include "SkParsePath.h"
@@ skipping 11 matching lines @@
     { 'V', 1 },
     { 'L', 2 },
     { 'Q', 4 },
     { 'T', 2 },
     { 'C', 6 },
     { 'S', 4 },
     { 'A', 4 },
     { 'Z', 0 },
 };
 
-bool gEasy = false;  // set to true while debugging to suppress unusual whitespace
+bool _gEasy = false;  // set to true while debugging to suppress unusual whitespace

[mtklein_C, 2016/10/03 17:39:39]

The author of this fuzz probably meant to write

   static bool gEasy = false;

here.  That'll fix the linker error.

He also probably meant that for gLegal (static const struct Legal ...) and
gWhitespace (static const char gWhitespace[] = ...)

That same author probably also meant to make his globals static in
random_parse_path too, but we only need to change one file to make this work. 
:)

[kjlubick, 2016/10/03 18:05:45]

Thanks for the tip.  Done.

 
 // mostly do nothing, then bias towards spaces
 const char gWhiteSpace[] = { 0, 0, 0, 0, 0, 0, 0, 0, ' ', ' ', ' ', ' ', 0x09, 0x0D, 0x0A };
 
 static void add_white(Fuzz* fuzz, SkString* atom) {
-    if (gEasy) {
+    if (_gEasy) {
         atom->append(" ");
         return;
     }
     int reps = fuzz->nextRangeU(0, 2);
     for (int rep = 0; rep < reps; ++rep) {
         int index = fuzz->nextRangeU(0, (int) SK_ARRAY_COUNT(gWhiteSpace) - 1);
         if (gWhiteSpace[index]) {
             atom->append(&gWhiteSpace[index], 1);
         }
     }
 }
 
 static void add_comma(Fuzz* fuzz, SkString* atom) {
-    if (gEasy) {
+    if (_gEasy) {
         atom->append(",");
         return;
     }
     size_t count = atom->size();
     add_white(fuzz, atom);
     if (fuzz->nextBool()) {
         atom->append(",");
     }
     do {
         add_white(fuzz, atom);
     } while (count == atom->size());
 }
 
 static void add_some_white(Fuzz* fuzz, SkString* atom) {
     size_t count = atom->size();
     do {
         add_white(fuzz, atom);
     } while (count == atom->size());
 }
 
 SkString MakeRandomParsePathPiece(Fuzz* fuzz) {
     SkString atom;
     int index = fuzz->nextRangeU(0, (int) SK_ARRAY_COUNT(gLegal) - 1);
     const Legal& legal = gLegal[index];
-    gEasy ? atom.append("\n") : add_white(fuzz, &atom);
+    _gEasy ? atom.append("\n") : add_white(fuzz, &atom);
     char symbol = legal.fSymbol | (fuzz->nextBool() ? 0x20 : 0);
     atom.append(&symbol, 1);
     int reps = fuzz->nextRangeU(1, 3);
     for (int rep = 0; rep < reps; ++rep) {
         for (int index = 0; index < legal.fScalars; ++index) {
             SkScalar coord = fuzz->nextRangeF(0, 100);
             add_white(fuzz, &atom);
             atom.appendScalar(coord);
             if (rep < reps - 1 && index < legal.fScalars - 1) {
                 add_comma(fuzz, &atom);
@@ skipping 18 matching lines @@
     SkString spec;
     uint32_t count = fuzz->nextRangeU(0, 40);
     for (uint32_t i = 0; i < count; ++i) {
         spec.append(MakeRandomParsePathPiece(fuzz));
     }
     SkDebugf("SkParsePath::FromSVGString(%s, &path);\n",spec.c_str());
     if (!SkParsePath::FromSVGString(spec.c_str(), &path)){
         fuzz->signalBug();
     }
 }