Restore creature comforts to fuzz binary

fuzz/fuzz.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 "SkCommandLineFlags.h"
+#include <signal.h>
 #include <stdlib.h>
-#include <signal.h>
+
+DEFINE_string2(bytes, b, "", "A path to a file containing fuzzed bytes.");
+DEFINE_string2(match, m, "", "The usual --match, applied to DEF_FUZZ names.");
 
 int main(int argc, char** argv) {
-    if (argc < 3) {
-        SkDebugf("Usage: %s <fuzz name> <path/to/fuzzed.data>\n", argv[0]);
+    SkCommandLineFlags::Parse(argc, argv);
+
+    if (FLAGS_bytes.isEmpty()) {
+        SkDebugf("Usage: %s -b <path/to/fuzzed.data> [-m pattern]\n", argv[0]);

[kjlubick, 2016/01/15 14:05:20]

Protip: afl-fuzz also has a -m flag.  It can be confused sometimes if we supply
a -m flag.  We can keep it in for when we, the humans, run this.  It's just
something to be aware if you ask afl-fuzz to do so.

         return 1;
     }
-    const char* name = argv[1];
-    const char* path = argv[2];
-
-    SkAutoTUnref<SkData> bytes(SkData::NewFromFileName(path));
-    Fuzz fuzz(bytes);
+    SkAutoTUnref<SkData> bytes(SkData::NewFromFileName(FLAGS_bytes[0]));
 
     for (auto r = SkTRegistry<Fuzzable>::Head(); r; r = r->next()) {
         auto fuzzable = r->factory();
-        if (0 == strcmp(name, fuzzable.name)) {
-            SkDebugf("Running %s\n", fuzzable.name);
+        if (!SkCommandLineFlags::ShouldSkip(FLAGS_match, fuzzable.name)) {
+            SkDebugf("Fuzzing %s...\n", fuzzable.name);
+            Fuzz fuzz(bytes);
             fuzzable.fn(&fuzz);
-            return 0;
         }
     }
-    return 1;
+    return 0;
 }
 
 
 Fuzz::Fuzz(SkData* bytes) : fBytes(SkSafeRef(bytes)), fNextByte(0) {}
 
 void Fuzz::signalBug   () { raise(SIGSEGV); }
 void Fuzz::signalBoring() { exit(0); }
 
 template <typename T>
 T Fuzz::nextT() {
     if (fNextByte + sizeof(T) > fBytes->size()) {
         this->signalBoring();
     }
 
     T val;
     memcpy(&val, fBytes->bytes() + fNextByte, sizeof(T));
     fNextByte += sizeof(T);
     return val;
 }
 
 uint8_t  Fuzz::nextB() { return this->nextT<uint8_t >(); }
 uint32_t Fuzz::nextU() { return this->nextT<uint32_t>(); }
 float    Fuzz::nextF() { return this->nextT<float   >(); }