detach -> release

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 223 matching lines @@
         return new SkMemoryStream();
     }
 
     if (fData.get()) {
         return new SkMemoryStream(fData);
     }
 
     if (!fName.isEmpty()) {
         SkAutoTDelete<SkFILEStream> that(new SkFILEStream(fName.c_str()));
         if (sk_fidentical(that->fFILE, this->fFILE)) {
-            return that.detach();
+            return that.release();
         }
     }
 
     fData = SkData::MakeFromFILE(fFILE);
     if (nullptr == fData) {
         return nullptr;
     }
     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 {
     SkAutoTDelete<SkStreamAsset> that(this->duplicate());
     that->seek(this->getPosition());
-    return that.detach();
+    return that.release();
 }
 
 size_t SkFILEStream::getLength() const {
     return sk_fgetsize(fFILE);
 }
 
 const void* SkFILEStream::getMemoryBase() {
     if (nullptr == fData.get()) {
         return nullptr;
     }
@@ skipping 115 matching lines @@
     return true;
 }
 
 bool SkMemoryStream::move(long offset) {
     return this->seek(fOffset + offset);
 }
 
 SkMemoryStream* SkMemoryStream::fork() const {
     SkAutoTDelete<SkMemoryStream> that(this->duplicate());
     that->seek(fOffset);
-    return that.detach();
+    return that.release();
 }
 
 size_t SkMemoryStream::getLength() const {
     return fData->size();
 }
 
 const void* SkMemoryStream::getMemoryBase() {
     return fData->data();
 }
 
@@ skipping 361 matching lines @@
 
     bool move(long offset) override {
         return seek(fOffset + offset);
     }
 
     SkBlockMemoryStream* fork() const override {
         SkAutoTDelete<SkBlockMemoryStream> that(this->duplicate());
         that->fCurrent = this->fCurrent;
         that->fOffset = this->fOffset;
         that->fCurrentOffset = this->fCurrentOffset;
-        return that.detach();
+        return that.release();
     }
 
     size_t getLength() const override {
         return fSize;
     }
 
     const void* getMemoryBase() override {
         if (nullptr != fBlockMemory->fHead &&
             nullptr == fBlockMemory->fHead->fNext) {
             return fBlockMemory->fHead->start();
@@ skipping 107 matching lines @@
     while (true) {
         count = input->read(scratch, sizeof(scratch));
         if (0 == count) {
             return true;
         }
         if (!out->write(scratch, count)) {
             return false;
         }
     }
 }