change SkStreams to work with sk_sp<SkData> instead of SkData*

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 "SkCanvas.h"
 #include "SkCodec.h"
@@ skipping 16 matching lines @@
 
 DEFINE_string2(type, t, "api", "How to interpret --bytes, either 'image_scale', 'image_mode', 'skp', 'icc', or 'api'.");
 DEFINE_string2(dump, d, "", "If not empty, dump 'image*' or 'skp' types as a PNG with this name.");
 
 static int printUsage(const char* name) {
     SkDebugf("Usage: %s -t <type> -b <path/to/file> [-n api-to-fuzz]\n", name);
     return 1;
 }
 static uint8_t calculate_option(SkData*);
 
-static int fuzz_api(SkData*);
-static int fuzz_img(SkData*, uint8_t, uint8_t);
-static int fuzz_skp(SkData*);
-static int fuzz_icc(SkData*);
-static int fuzz_color_deserialize(SkData*);
+static int fuzz_api(sk_sp<SkData>);
+static int fuzz_img(sk_sp<SkData>, uint8_t, uint8_t);
+static int fuzz_skp(sk_sp<SkData>);
+static int fuzz_icc(sk_sp<SkData>);
+static int fuzz_color_deserialize(sk_sp<SkData>);
 
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
 
     const char* path = FLAGS_bytes.isEmpty() ? argv[0] : FLAGS_bytes[0];
     sk_sp<SkData> bytes(SkData::MakeFromFileName(path));
     if (!bytes) {
         SkDebugf("Could not read %s\n", path);
         return 2;
     }
 
     uint8_t option = calculate_option(bytes.get());
 
     if (!FLAGS_type.isEmpty()) {
         switch (FLAGS_type[0][0]) {
-            case 'a': return fuzz_api(bytes.get());
+            case 'a': return fuzz_api(bytes);
 
-            case 'c': return fuzz_color_deserialize(bytes.get());
+            case 'c': return fuzz_color_deserialize(bytes);
 
             case 'i':
                 if (FLAGS_type[0][1] == 'c') { //icc
-                    return fuzz_icc(bytes.get());
+                    return fuzz_icc(bytes);
                 }
                 // We only allow one degree of freedom to avoid a search space explosion for afl-fuzz.
                 if (FLAGS_type[0][6] == 's') { // image_scale
-                    return fuzz_img(bytes.get(), option, 0);
+                    return fuzz_img(bytes, option, 0);
                 }
                 // image_mode
-                return fuzz_img(bytes.get(), 0, option);
-            case 's': return fuzz_skp(bytes.get());
+                return fuzz_img(bytes, 0, option);
+            case 's': return fuzz_skp(bytes);
         }
     }
     return printUsage(argv[0]);
 }
 
 // This adds up the first 1024 bytes and returns it as an 8 bit integer.  This allows afl-fuzz to
 // deterministically excercise different paths, or *options* (such as different scaling sizes or
 // different image modes) without needing to introduce a parameter.  This way we don't need a
 // image_scale1, image_scale2, image_scale4, etc fuzzer, we can just have a image_scale fuzzer.
 // Clients are expected to transform this number into a different range, e.g. with modulo (%).
 static uint8_t calculate_option(SkData* bytes) {
     uint8_t total = 0;
     const uint8_t* data = bytes->bytes();
     for (size_t i = 0; i < 1024 && i < bytes->size(); i++) {
         total += data[i];
     }
     return total;
 }
 
-int fuzz_api(SkData* bytes) {
+int fuzz_api(sk_sp<SkData> bytes) {
     const char* name = FLAGS_name.isEmpty() ? "" : FLAGS_name[0];
 
     for (auto r = SkTRegistry<Fuzzable>::Head(); r; r = r->next()) {
         auto fuzzable = r->factory();
         if (0 == strcmp(name, fuzzable.name)) {
             SkDebugf("Fuzzing %s...\n", fuzzable.name);
             Fuzz fuzz(bytes);
             fuzzable.fn(&fuzz);
             SkDebugf("[terminated] Success!\n");
             return 0;
         }
     }
 
     SkDebugf("When using --type api, please choose an API to fuzz with --name/-n:\n");
     for (auto r = SkTRegistry<Fuzzable>::Head(); r; r = r->next()) {
         auto fuzzable = r->factory();
         SkDebugf("\t%s\n", fuzzable.name);
     }
     return 1;
 }
 
 static void dump_png(SkBitmap bitmap) {
     if (!FLAGS_dump.isEmpty()) {
         SkImageEncoder::EncodeFile(FLAGS_dump[0], bitmap, SkImageEncoder::kPNG_Type, 100);
         SkDebugf("Dumped to %s\n", FLAGS_dump[0]);
     }
 }
 
-int fuzz_img(SkData* bytes, uint8_t scale, uint8_t mode) {
+int fuzz_img(sk_sp<SkData> bytes, uint8_t scale, uint8_t mode) {
     // We can scale 1x, 2x, 4x, 8x, 16x
     scale = scale % 5;
     float fscale = (float)pow(2.0f, scale);
     SkDebugf("Scaling factor: %f\n", fscale);
 
     // We have 4 different modes of decoding, just like DM.
     mode = mode % 4;
     SkDebugf("Mode: %d\n", mode);
 
     // This is mostly copied from DMSrcSink's CodecSrc::draw method.
@@ skipping 222 matching lines @@
             break;
         }
         default:
             SkDebugf("[terminated] Mode not implemented yet\n");
     }
 
     dump_png(bitmap);
     return 0;
 }
 
-int fuzz_skp(SkData* bytes) {
+int fuzz_skp(sk_sp<SkData> bytes) {
     SkMemoryStream stream(bytes);
     SkDebugf("Decoding\n");
     sk_sp<SkPicture> pic(SkPicture::MakeFromStream(&stream));
     if (!pic) {
         SkDebugf("[terminated] Couldn't decode as a picture.\n");
         return 3;
     }
     SkDebugf("Rendering\n");
     SkBitmap bitmap;
     if (!FLAGS_dump.isEmpty()) {
         SkIRect size = pic->cullRect().roundOut();
         bitmap.allocN32Pixels(size.width(), size.height());
     }
     SkCanvas canvas(bitmap);
     canvas.drawPicture(pic);
     SkDebugf("[terminated] Success! Decoded and rendered an SkPicture!\n");
     dump_png(bitmap);
     return 0;
 }
 
-int fuzz_icc(SkData* bytes) {
+int fuzz_icc(sk_sp<SkData> bytes) {
     sk_sp<SkColorSpace> space(SkColorSpace::NewICC(bytes->data(), bytes->size()));
     if (!space) {
         SkDebugf("[terminated] Couldn't decode ICC.\n");
         return 1;
     }
     SkDebugf("[terminated] Success! Decoded ICC.\n");
     return 0;
 }
 
-int fuzz_color_deserialize(SkData* bytes) {
+int fuzz_color_deserialize(sk_sp<SkData> bytes) {
     sk_sp<SkColorSpace> space(SkColorSpace::Deserialize(bytes->data(), bytes->size()));
     if (!space) {
         SkDebugf("[terminated] Couldn't deserialize Colorspace.\n");
         return 1;
     }
     SkDebugf("[terminated] Success! deserialized Colorspace.\n");
     return 0;
 }
 
-Fuzz::Fuzz(SkData* bytes) : fBytes(SkSafeRef(bytes)), fNextByte(0) {}
+Fuzz::Fuzz(sk_sp<SkData> bytes) : fBytes(bytes), fNextByte(0) {}
 
 void Fuzz::signalBug   () { SkDebugf("Signal bug\n"); raise(SIGSEGV); }
 void Fuzz::signalBoring() { SkDebugf("Signal boring\n"); exit(0); }
 
 size_t Fuzz::size() { return fBytes->size(); }
 
 size_t Fuzz::remaining() {
     return fBytes->size() - fNextByte;
 }
 
@@ skipping 37 matching lines @@
     if (min > max) {
         SkDebugf("Check mins and maxes (%f, %f)\n", min, max);
         this->signalBoring();
     }
     float f = std::abs(this->nextF());
     if (!std::isnormal(f) && f != 0.0) {
         this->signalBoring();
     }
     return min + fmod(f, (max - min + 1));
 }