Make SkStream *not* ref counted.

dm/DMSrcSink.cpp

 #include "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCommonFlags.h"
 #include "SkDocument.h"
 #include "SkMultiPictureDraw.h"
 #include "SkOSFile.h"
 #include "SkPictureRecorder.h"
 #include "SkRandom.h"
+#include "SkStream.h"
 
 namespace DM {
 
 GMSrc::GMSrc(skiagm::GMRegistry::Factory factory) : fFactory(factory) {}
 
 Error GMSrc::draw(SkCanvas* canvas) const {
     SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
     canvas->concat(gm->getInitialTransform());
     gm->draw(canvas);
     return "";
@@ skipping 22 matching lines @@
         // Decode the full image.
         SkBitmap bitmap;
         if (!SkImageDecoder::DecodeMemory(encoded->data(), encoded->size(), &bitmap)) {
             return SkStringPrintf("Couldn't decode %s.", fPath.c_str());
         }
         encoded.reset((SkData*)NULL);  // Might as well drop this when we're done with it.
         canvas->drawBitmap(bitmap, 0,0);
         return "";
     }
     // Decode random subsets.  This is a little involved.
-    SkMemoryStream stream(encoded->data(), encoded->size());
-    SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(&stream));
+    SkAutoTDelete<SkMemoryStream> stream(new SkMemoryStream(encoded));
+    SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(stream.get()));
     if (!decoder) {
         return SkStringPrintf("Can't find a good decoder for %s.", fPath.c_str());
     }
+    stream->rewind();
     int w,h;
-    if (!decoder->buildTileIndex(&stream, &w, &h) || w*h == 1) {
+    if (!decoder->buildTileIndex(stream.detach(), &w, &h) || w*h == 1) {
         return "";  // Not an error.  Subset decoding is not always supported.
     }
     SkRandom rand;
     for (int i = 0; i < fSubsets; i++) {
         SkIRect rect;
         do {
             rect.fLeft   = rand.nextULessThan(w);
             rect.fTop    = rand.nextULessThan(h);
             rect.fRight  = rand.nextULessThan(w);
             rect.fBottom = rand.nextULessThan(h);
@@ skipping 29 matching lines @@
     return name;
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 static const SkRect kSKPViewport = {0,0, 1000,1000};
 
 SKPSrc::SKPSrc(SkString path) : fPath(path) {}
 
 Error SKPSrc::draw(SkCanvas* canvas) const {
-    SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(fPath.c_str()));
+    SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(fPath.c_str()));
     if (!stream) {
         return SkStringPrintf("Couldn't read %s.", fPath.c_str());
     }
     SkAutoTUnref<SkPicture> pic(SkPicture::CreateFromStream(stream));
     if (!pic) {
         return SkStringPrintf("Couldn't decode %s as a picture.", fPath.c_str());
     }
     stream.reset((SkStream*)NULL);  // Might as well drop this when we're done with it.
     canvas->clipRect(kSKPViewport);
     canvas->drawPicture(pic);
@@ skipping 143 matching lines @@
     SkPictureRecorder recorder;
     Error err = src.draw(recorder.beginRecording(size.width(), size.height()));
     if (!err.isEmpty()) {
         return err;
     }
     SkAutoTUnref<SkPicture> pic(recorder.endRecording());
 
     // Serialize it and then deserialize it.
     SkDynamicMemoryWStream wStream;
     pic->serialize(&wStream);
-    SkAutoTUnref<SkStream> rStream(wStream.detachAsStream());
+    SkAutoTDelete<SkStream> rStream(wStream.detachAsStream());
     SkAutoTUnref<SkPicture> deserialized(SkPicture::CreateFromStream(rStream));
 
     // Turn that deserialized picture into a Src, draw it into our Sink to fill bitmap or stream.
     struct ProxySrc : public Src {
         const SkPicture* fPic;
         const SkISize fSize;
         ProxySrc(const SkPicture* pic, SkISize size) : fPic(pic), fSize(size) {}
 
         Error draw(SkCanvas* canvas) const SK_OVERRIDE {
             canvas->drawPicture(fPic);
@@ skipping 65 matching lines @@
             surfaces.unrefAll();
             return "";
         }
         SkISize size() const SK_OVERRIDE { return fSize; }
         Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(fW, fH, pic, src.size());
     return fSink->draw(proxy, bitmap, stream);
 }
 
 }  // namespace DM