Make SkStream *not* ref counted.

src/core/SkStream.cpp

 
 /*
  * Copyright 2006 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 "SkStream.h"
@@ skipping 221 matching lines @@
 SkStreamAsset* SkFILEStream::duplicate() const {
     if (NULL == fFILE) {
         return new SkMemoryStream();
     }
 
     if (fData.get()) {
         return new SkMemoryStream(fData);
     }
 
     if (!fName.isEmpty()) {
-        SkAutoTUnref<SkFILEStream> that(new SkFILEStream(fName.c_str()));
+        SkAutoTDelete<SkFILEStream> that(new SkFILEStream(fName.c_str()));
         if (sk_fidentical(that->fFILE, this->fFILE)) {
             return that.detach();
         }
     }
 
     fData.reset(SkData::NewFromFILE(fFILE));
     if (NULL == fData.get()) {
         return NULL;
     }
     return new SkMemoryStream(fData);
 }
 
 size_t SkFILEStream::getPosition() const {
     return sk_ftell(fFILE);
 }
 
 bool SkFILEStream::seek(size_t position) {
     return sk_fseek(fFILE, position);
 }
 
 bool SkFILEStream::move(long offset) {
     return sk_fmove(fFILE, offset);
 }
 
 SkStreamAsset* SkFILEStream::fork() const {
-    SkAutoTUnref<SkStreamAsset> that(this->duplicate());
+    SkAutoTDelete<SkStreamAsset> that(this->duplicate());
     that->seek(this->getPosition());
     return that.detach();
 }
 
 size_t SkFILEStream::getLength() const {
     return sk_fgetsize(fFILE);
 }
 
 const void* SkFILEStream::getMemoryBase() {
     if (NULL == fData.get()) {
@@ skipping 110 matching lines @@
             ? fData->size()
             : position;
     return true;
 }
 
 bool SkMemoryStream::move(long offset) {
     return this->seek(fOffset + offset);
 }
 
 SkMemoryStream* SkMemoryStream::fork() const {
-    SkAutoTUnref<SkMemoryStream> that(this->duplicate());
+    SkAutoTDelete<SkMemoryStream> that(this->duplicate());
     that->seek(fOffset);
     return that.detach();
 }
 
 size_t SkMemoryStream::getLength() const {
     return fData->size();
 }
 
 const void* SkMemoryStream::getMemoryBase() {
     return fData->data();
@@ skipping 324 matching lines @@
         }
         // Otherwise rewind and move forward.
         return this->rewind() && this->skip(position) == position;
     }
 
     bool move(long offset) SK_OVERRIDE {
         return seek(fOffset + offset);
     }
 
     SkBlockMemoryStream* fork() const SK_OVERRIDE {
-        SkAutoTUnref<SkBlockMemoryStream> that(this->duplicate());
+        SkAutoTDelete<SkBlockMemoryStream> that(this->duplicate());
         that->fCurrent = this->fCurrent;
         that->fOffset = this->fOffset;
         that->fCurrentOffset = this->fCurrentOffset;
         return that.detach();
     }
 
     size_t getLength() const SK_OVERRIDE {
         return fSize;
     }
 
@@ skipping 65 matching lines @@
 SkStreamAsset* SkStream::NewFromFile(const char path[]) {
     SkAutoTUnref<SkData> data(mmap_filename(path));
     if (data.get()) {
         return SkNEW_ARGS(SkMemoryStream, (data.get()));
     }
 
     // If we get here, then our attempt at using mmap failed, so try normal
     // file access.
     SkFILEStream* stream = SkNEW_ARGS(SkFILEStream, (path));
     if (!stream->isValid()) {
-        stream->unref();
+        SkDELETE(stream);
         stream = NULL;
     }
     return stream;
 }
 
 // Declared in SkStreamPriv.h:
 size_t SkCopyStreamToStorage(SkAutoMalloc* storage, SkStream* stream) {
     SkASSERT(storage != NULL);
     SkASSERT(stream != NULL);
 
@@ skipping 38 matching lines @@
         size_t bytesRead = stream->read(buffer, bufferSize);
         tempStream.write(buffer, bytesRead);
     } while (!stream->isAtEnd());
     return tempStream.copyToData();
 }
 
 SkStreamRewindable* SkStreamRewindableFromSkStream(SkStream* stream) {
     if (!stream) {
         return NULL;
     }
-    SkAutoTUnref<SkStreamRewindable> dupStream(stream->duplicate());
+    SkAutoTDelete<SkStreamRewindable> dupStream(stream->duplicate());
     if (dupStream) {
         return dupStream.detach();
     }
     stream->rewind();
     if (stream->hasLength()) {
         size_t length = stream->getLength();
         if (stream->hasPosition()) {  // If stream has length, but can't rewind.
             length -= stream->getPosition();
         }
         SkAutoTUnref<SkData> data(SkData::NewFromStream(stream, length));
         return SkNEW_ARGS(SkMemoryStream, (data.get()));
     }
     SkDynamicMemoryWStream tempStream;
     const size_t bufferSize = 4096;
     char buffer[bufferSize];
     do {
         size_t bytesRead = stream->read(buffer, bufferSize);
         tempStream.write(buffer, bytesRead);
     } while (!stream->isAtEnd());
     return tempStream.detachAsStream();  // returns a SkBlockMemoryStream,
                                          // cheaper than copying to SkData
 }