Make SkStream *not* ref counted.

src/pdf/SkPDFImage.cpp

 /*
  * Copyright 2010 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPDFImage.h"
 
 #include "SkBitmap.h"
@@ skipping 221 matching lines @@
                                     const SkIRect& srcRect,
                                     bool extractAlpha, bool* isTransparent) {
     SkColorType colorType = bitmap.colorType();
     if (extractAlpha && (kIndex_8_SkColorType == colorType ||
                          kRGB_565_SkColorType == colorType)) {
         if (isTransparent != NULL) {
             *isTransparent = false;
         }
         return NULL;
     }
-    bool isOpaque = true;
-    bool transparent = extractAlpha;
-    SkStream* stream = NULL;
 
     SkAutoLockPixels lock(bitmap);
     if (NULL == bitmap.getPixels()) {
         return NULL;
     }
 
+    bool isOpaque = true;
+    bool transparent = extractAlpha;
+    SkAutoTDelete<SkStream> stream;
+
     switch (colorType) {
         case kIndex_8_SkColorType:
             if (!extractAlpha) {
-                stream = extract_index8_image(bitmap, srcRect);
+                stream.reset(extract_index8_image(bitmap, srcRect));
             }
             break;
         case kARGB_4444_SkColorType:
-            stream = extract_argb4444_data(bitmap, srcRect, extractAlpha,
-                                           &isOpaque, &transparent);
+            stream.reset(extract_argb4444_data(bitmap, srcRect, extractAlpha,
+                                               &isOpaque, &transparent));
             break;
         case kRGB_565_SkColorType:
             if (!extractAlpha) {
-                stream = extract_rgb565_image(bitmap, srcRect);
+                stream.reset(extract_rgb565_image(bitmap, srcRect));
             }
             break;
         case kN32_SkColorType:
-            stream = extract_argb8888_data(bitmap, srcRect, extractAlpha,
-                                           &isOpaque, &transparent);
+            stream.reset(extract_argb8888_data(bitmap, srcRect, extractAlpha,
+                                               &isOpaque, &transparent));
             break;
         case kAlpha_8_SkColorType:
             if (!extractAlpha) {
-                stream = create_black_image();
+                stream.reset(create_black_image());
             } else {
-                stream = extract_a8_alpha(bitmap, srcRect,
-                                          &isOpaque, &transparent);
+                stream.reset(extract_a8_alpha(bitmap, srcRect,
+                                              &isOpaque, &transparent));
             }
             break;
         default:
             SkASSERT(false);
     }
 
     if (isTransparent != NULL) {
         *isTransparent = transparent;
     }
     if (extractAlpha && (transparent || isOpaque)) {
-        SkSafeUnref(stream);
         return NULL;
     }
-    return stream;
+    return stream.detach();
 }
 
 static SkPDFArray* make_indexed_color_space(SkColorTable* table) {
     SkPDFArray* result = new SkPDFArray();
     result->reserve(4);
     result->appendName("Indexed");
     result->appendName("DeviceRGB");
     result->appendInt(table->count() - 1);
 
     // Potentially, this could be represented in fewer bytes with a stream.
@@ skipping 161 matching lines @@
 
 // static
 SkPDFImage* SkPDFImage::CreateImage(const SkBitmap& bitmap,
                                     const SkIRect& srcRect,
                                     SkPicture::EncodeBitmap encoder) {
     if (bitmap.colorType() == kUnknown_SkColorType) {
         return NULL;
     }
 
     bool isTransparent = false;
-    SkAutoTUnref<SkStream> alphaData;
+    SkAutoTDelete<SkStream> alphaData;
     if (!bitmap.isOpaque()) {
         // Note that isOpaque is not guaranteed to return false for bitmaps
         // with alpha support but a completely opaque alpha channel,
         // so alphaData may still be NULL if we have a completely opaque
         // (or transparent) bitmap.
         alphaData.reset(
                 extract_image_data(bitmap, srcRect, true, &isTransparent));
     }
     if (isTransparent) {
         return NULL;
@@ skipping 150 matching lines @@
 
                 insertName("Filter", "DCTDecode");
                 insertInt("ColorTransform", kNoColorTransform);
                 insertInt("Length", this->dataSize());
                 setState(kCompressed_State);
                 return true;
             }
         }
         // Fallback method
         if (!fStreamValid) {
-            SkAutoTUnref<SkStream> stream(
+            SkAutoTDelete<SkStream> stream(
                     extract_image_data(fBitmap, fSrcRect, fIsAlpha, NULL));
             this->setData(stream);
             fStreamValid = true;
         }
         return INHERITED::populate(catalog);
     } else if (getState() == kNoCompression_State &&
             !skip_compression(catalog) &&
             (SkFlate::HaveFlate() || fEncoder)) {
         // Compression has not been requested when the stream was first created,
         // but the new catalog wants it compressed.
@@ skipping 91 matching lines @@
     if (SkIRect::MakeWH(bitmap.width(), bitmap.height()) == subset) {
         SkAutoTUnref<SkData> encodedData(ref_encoded_data(bitmap));
         if (is_jfif_jpeg(encodedData)) {
             return SkNEW_ARGS(PDFJPEGImage,
                               (encodedData, bitmap.width(), bitmap.height()));
         }
     }
 #endif
     return SkPDFImage::CreateImage(bitmap, subset, encoder);
 }