detach -> release

include/core/SkTypes.h

 /*
  * 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.
  */
 
 #ifndef SkTypes_DEFINED
 #define SkTypes_DEFINED
 
@@ skipping 496 matching lines @@
     void* set(void* ptr) {
         void* prev = fPtr;
         fPtr = ptr;
         return prev;
     }
 
     /** Transfer ownership of the current ptr to the caller, setting the
         internal reference to null. Note the caller is reponsible for calling
         sk_free on the returned address.
     */
-    void* detach() { return this->set(NULL); }
+    void* release() { return this->set(NULL); }
 
     /** Free the current buffer, and set the internal reference to NULL. Same
-        as calling sk_free(detach())
+        as calling sk_free(release())
     */
     void free() {
         sk_free(fPtr);
         fPtr = NULL;
     }
 
 private:
     void* fPtr;
     // illegal
     SkAutoFree(const SkAutoFree&);
     SkAutoFree& operator=(const SkAutoFree&);
 };
 #define SkAutoFree(...) SK_REQUIRE_LOCAL_VAR(SkAutoFree)
 
 /**
  *  Manage an allocated block of heap memory. This object is the sole manager of
  *  the lifetime of the block, so the caller must not call sk_free() or delete
- *  on the block, unless detach() was called.
+ *  on the block, unless release() was called.
  */
 class SkAutoMalloc : SkNoncopyable {
 public:
     explicit SkAutoMalloc(size_t size = 0) {
         fPtr = size ? sk_malloc_throw(size) : NULL;
         fSize = size;
     }
 
     ~SkAutoMalloc() {
         sk_free(fPtr);
@@ skipping 50 matching lines @@
     /**
      *  Return the allocated block.
      */
     void* get() { return fPtr; }
     const void* get() const { return fPtr; }
 
    /** Transfer ownership of the current ptr to the caller, setting the
        internal reference to null. Note the caller is reponsible for calling
        sk_free on the returned address.
     */
-    void* detach() {
+    void* release() {
         void* ptr = fPtr;
         fPtr = NULL;
         fSize = 0;
         return ptr;
     }
 
 private:
     void*   fPtr;
     size_t  fSize;  // can be larger than the requested size (see kReuse)
 };
@@ skipping 89 matching lines @@
 
     void*       fPtr;
     size_t      fSize;  // can be larger than the requested size (see kReuse)
     uint32_t    fStorage[kSize >> 2];
 };
 // Can't guard the constructor because it's a template class.
 
 #endif /* C++ */
 
 #endif