Make SkStream *not* ref counted.

gm/gmmain.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * Code for the "gm" (Golden Master) rendering comparison tool.
  *
@@ skipping 1033 matching lines @@
         SkPictureRecorder recorder;
         SkCanvas* cv = recorder.beginRecording(width, height, factory.get(), recordFlags);
         cv->scale(scale, scale);
         invokeGM(gm, cv, false, false);
         return recorder.endRecording();
     }
 
     static SkPicture* stream_to_new_picture(const SkPicture& src) {
         SkDynamicMemoryWStream storage;
         src.serialize(&storage);
-        SkAutoTUnref<SkStreamAsset> pictReadback(storage.detachAsStream());
+        SkAutoTDelete<SkStreamAsset> pictReadback(storage.detachAsStream());
         SkPicture* retval = SkPicture::CreateFromStream(pictReadback,
                                                         &SkImageDecoder::DecodeMemory);
         return retval;
     }
 
     // Test: draw into a bitmap or pdf.
     // Depending on flags, possibly compare to an expected image.
     // If writePath is not NULL, also write images (or documents) to the specified path.
     ErrorCombination test_drawing(GM* gm, const ConfigData& gRec,
                                   const SkTDArray<const PDFRasterizerData*> &pdfRasterizers,
@@ skipping 12 matching lines @@
                 // JSON look like if we get an "early error" while
                 // trying to generate the image.
                 return errors;
             }
 
             errors.add(this->writeBitmap(gm, gRec, gRec.fName, writePath, *bitmap));
         } else if (gRec.fBackend == kPDF_Backend) {
             if (!generate_pdf(gm, document)) {
                 errors.add(kGeneratePdfFailed_ErrorType);
             } else {
-                SkAutoTUnref<SkStreamAsset> documentStream(document.detachAsStream());
+                SkAutoTDelete<SkStreamAsset> documentStream(document.detachAsStream());
                 if (writePath && (gRec.fFlags & kWrite_ConfigFlag)) {
                     SkString path = make_filename(writePath, gm->getName(), gRec.fName, "", "pdf");
                     errors.add(write_document(path, documentStream));
                 }
 
                 if (!(gm->getFlags() & GM::kSkipPDFRasterization_Flag)) {
                     for (int i = 0; i < pdfRasterizers.count(); i++) {
                         SkBitmap pdfBitmap;
-                        documentStream->rewind();
                         bool success = (*pdfRasterizers[i]->fRasterizerFunction)(
-                                documentStream.get(), &pdfBitmap);
+                                documentStream->duplicate(), &pdfBitmap);

[bungeman-skia, 2015/01/15 22:44:55]

I think you can just rewind and detach here, since it isn't being used later.
write_document above doesn't take ownership of the stream (or else we wouldn't
have it here).

[scroggo, 2015/01/16 19:13:37]

Actually, that won't work. This loops through the rasterizer functions, and the
mac one (SkPDFDocumentToBitmap - unfortunately that one does not make it clear
that it is mac specific...) takes ownership and deletes the stream.

I updated the others to match SkPDFDocumentToBitmap, since it seemed more like
something we actually use.. Alternatively, I could have updated the mac one to
behave like the others.

(The change description explains this change.)

                         if (!success) {
                             SkDebugf("FAILED to render PDF for %s using renderer %s\n",
                                      gm->getName(),
                                      pdfRasterizers[i]->fName);
                             continue;
                         }
 
                         SkString configName(gRec.fName);
                         configName.append("-");
                         configName.append(pdfRasterizers[i]->fName);
 
                         errors.add(this->writeBitmap(gm, gRec, configName.c_str(),
                                                      writePath, pdfBitmap));
                     }
                 } else {
                     errors.add(kIntentionallySkipped_ErrorType);
                 }
             }
         } else if (gRec.fBackend == kXPS_Backend) {
             generate_xps(gm, document);
-            SkAutoTUnref<SkStreamAsset> documentStream(document.detachAsStream());
+            SkAutoTDelete<SkStreamAsset> documentStream(document.detachAsStream());
 
             errors.add(this->compareTestResultsToStoredExpectations(
                            gm, gRec, gRec.fName, NULL));
 
             if (writePath && (gRec.fFlags & kWrite_ConfigFlag)) {
                 SkString path = make_filename(writePath, gm->getName(), gRec.fName, "", "xps");
                 errors.add(write_document(path, documentStream));
             }
         } else {
             SkASSERT(false);
@@ skipping 253 matching lines @@
 #endif // SK_SUPPORT_GPU
 #ifdef SK_SUPPORT_XPS
     /* At present we have no way of comparing XPS files (either natively or by converting to PNG). */
     { kN32_SkColorType, kXPS_Backend,    kDontCare_GLContextType,                  0, kWrite_ConfigFlag, "xps",          true },
 #endif // SK_SUPPORT_XPS
 #ifdef SK_SUPPORT_PDF
     { kN32_SkColorType, kPDF_Backend,    kDontCare_GLContextType,                  0, kRW_ConfigFlag,    "pdf",          true },
 #endif // SK_SUPPORT_PDF
 };
 
-static bool SkNoRasterizePDF(SkStream*, SkBitmap*) { return false; }
+// Deletes SkStream, like other rasterizers.
+static bool SkNoRasterizePDF(SkStream* stream, SkBitmap*) {
+    SkDELETE(stream);
+    return false;
+}
 
 static const PDFRasterizerData kPDFRasterizers[] = {
 #ifdef SK_BUILD_FOR_MAC
     { &SkPDFDocumentToBitmap, "mac",     true },
 #endif
 #ifdef SK_BUILD_POPPLER
     { &SkPopplerRasterizePDF, "poppler", true },
 #endif
 #ifdef SK_BUILD_NATIVE_PDF_RENDERER
     { &SkNativeRasterizePDF,  "native",  true },
@@ skipping 476 matching lines @@
 
 
 /**
  * Read individual lines from a file, pushing them into the given array.
  *
  * @param filename path to the file to read
  * @param lines array of strings to add the lines to
  * @returns true if able to read lines from the file
  */
 static bool read_lines_from_file(const char* filename, SkTArray<SkString> &lines) {
-    SkAutoTUnref<SkStream> streamWrapper(SkStream::NewFromFile(filename));
+    SkAutoTDelete<SkStream> streamWrapper(SkStream::NewFromFile(filename));
     SkStream *stream = streamWrapper.get();
     if (!stream) {
         SkDebugf("unable to read file '%s'\n", filename);
         return false;
     }
 
     char c;
     SkString line;
     while (1 == stream->read(&c, 1)) {
         // If we hit either CR or LF, we've completed a line.
@@ skipping 639 matching lines @@
     if (FLAGS_forceBWtext) {
         canvas->setDrawFilter(SkNEW(BWTextDrawFilter))->unref();
     }
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif