Revert of free -> reset

include/private/SkTemplates.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 SkTemplates_DEFINED
@@ skipping 78 matching lines @@
   thread-compatible, and once you dereference it, you get the threadsafety
   guarantees of T.
 
   The size of a SkAutoTDelete is small: sizeof(SkAutoTDelete<T>) == sizeof(T*)
 */
 template <typename T> class SkAutoTDelete : public std::unique_ptr<T> {
 public:
     SkAutoTDelete(T* obj = NULL) : std::unique_ptr<T>(obj) {}
 
     operator T*() const { return this->get(); }
+    void free() { this->reset(nullptr); }
 
     // See SkAutoTUnref for why we do this.
     explicit operator bool() const { return this->get() != nullptr; }
 };
 
 template <typename T> class SkAutoTDeleteArray : public std::unique_ptr<T[]> {
 public:
     SkAutoTDeleteArray(T array[]) : std::unique_ptr<T[]>(array) {}
+
+    void free() { this->reset(nullptr); }
 };
 
 /** Allocate an array of T elements, and free the array in the destructor
  */
 template <typename T> class SkAutoTArray : SkNoncopyable {
 public:
     SkAutoTArray() {
         fArray = NULL;
         SkDEBUGCODE(fCount = 0;)
     }
@@ skipping 154 matching lines @@
     ~SkAutoTMalloc() {
         sk_free(fPtr);
     }
 
     /** Resize the memory area pointed to by the current ptr preserving contents. */
     void realloc(size_t count) {
         fPtr = reinterpret_cast<T*>(sk_realloc_throw(fPtr, count * sizeof(T)));
     }
 
     /** Resize the memory area pointed to by the current ptr without preserving contents. */
-    T* reset(size_t count = 0) {
+    T* reset(size_t count) {
         sk_free(fPtr);
-        fPtr = count ? (T*)sk_malloc_flags(count * sizeof(T), SK_MALLOC_THROW) : nullptr;
+        fPtr = (T*)sk_malloc_flags(count * sizeof(T), SK_MALLOC_THROW);
         return fPtr;
     }
 
     T* get() const { return fPtr; }
 
     operator T*() {
         return fPtr;
     }
 
     operator const T*() const {
         return fPtr;
     }
 
     T& operator[](int index) {
         return fPtr[index];
     }
 
     const T& operator[](int index) const {
         return fPtr[index];
     }
 
     /**
+     *  Releases the block back to the heap
+     */
+    void free() {
+        this->reset(0);
+    }
+
+    /**
      *  Transfer ownership of the ptr to the caller, setting the internal
      *  pointer to NULL. Note that this differs from get(), which also returns
      *  the pointer, but it does not transfer ownership.
      */
     T* release() {
         T* ptr = fPtr;
         fPtr = NULL;
         return ptr;
     }
 
@@ skipping 146 matching lines @@
      * Returns void* because this object does not initialize the
      * memory. Use placement new for types that require a cons.
      */
     void* get() { return fStorage.get(); }
     const void* get() const { return fStorage.get(); }
 private:
     SkAlignedSStorage<sizeof(T)*N> fStorage;
 };
 
 #endif