detach -> release

src/core/SkResourceCache.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkChecksum.h"
 #include "SkMessageBus.h"
 #include "SkMipMap.h"
@@ skipping 261 matching lines @@
     }
 
     // since the new rec may push us over-budget, we perform a purge check now
     this->purgeAsNeeded();
 }
 
 void SkResourceCache::remove(Rec* rec) {
     size_t used = rec->bytesUsed();
     SkASSERT(used <= fTotalBytesUsed);
 
-    this->detach(rec);
+    this->release(rec);
     fHash->remove(rec->getKey());
 
     fTotalBytesUsed -= used;
     fCount -= 1;
 
     if (gDumpCacheTransactions) {
         SkString bytesStr, totalStr;
         make_size_str(used, &bytesStr);
         make_size_str(fTotalBytesUsed, &totalStr);
         SkDebugf("RC: remove %5s %12p key %08x -- total %5s, count %d\n",
@@ skipping 95 matching lines @@
     if (fDiscardableFactory) {
         SkDiscardableMemory* dm = fDiscardableFactory(bytes);
         return dm ? new SkCachedData(bytes, dm) : nullptr;
     } else {
         return new SkCachedData(sk_malloc_throw(bytes), bytes);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkResourceCache::detach(Rec* rec) {
+void SkResourceCache::release(Rec* rec) {
     Rec* prev = rec->fPrev;
     Rec* next = rec->fNext;
 
     if (!prev) {
         SkASSERT(fHead == rec);
         fHead = next;
     } else {
         prev->fNext = next;
     }
 
     if (!next) {
         fTail = prev;
     } else {
         next->fPrev = prev;
     }
 
     rec->fNext = rec->fPrev = nullptr;
 }
 
 void SkResourceCache::moveToHead(Rec* rec) {
     if (fHead == rec) {
         return;
     }
 
     SkASSERT(fHead);
     SkASSERT(fTail);
 
     this->validate();
 
-    this->detach(rec);
+    this->release(rec);
 
     fHead->fPrev = rec;
     rec->fNext = fHead;
     fHead = rec;
 
     this->validate();
 }
 
 void SkResourceCache::addToHead(Rec* rec) {
     this->validate();
@@ skipping 261 matching lines @@
         dump->dumpNumericValue(dumpName.c_str(), "size", "bytes", rec.bytesUsed());
         dump->setMemoryBacking(dumpName.c_str(), "malloc", nullptr);
     }
 }
 
 void SkResourceCache::DumpMemoryStatistics(SkTraceMemoryDump* dump) {
     // Since resource could be backed by malloc or discardable, the cache always dumps detailed
     // stats to be accurate.
     VisitAll(sk_trace_dump_visitor, dump);
 }