add realloc method to SkAutoSTMalloc

include/core/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 394 matching lines @@
         return ptr;
     }
 
 private:
     T* fPtr;
 };
 
 template <size_t N, typename T> class SkAutoSTMalloc : SkNoncopyable {
 public:
     SkAutoSTMalloc() {
         fPtr = NULL;

[mtklein, 2015/04/08 13:20:05]

Does it seem weird that we treat count == 0 differently?

I'd think this'd just be fPtr = fTStorage, removing the else check in the other
constructor and reset and realloc.

     }
 
     SkAutoSTMalloc(size_t count) {
         if (count > N) {
             fPtr = (T*)sk_malloc_flags(count * sizeof(T), SK_MALLOC_THROW | SK_MALLOC_TEMP);
         } else if (count) {
             fPtr = fTStorage;
         } else {
             fPtr = NULL;
         }
     }
 
     ~SkAutoSTMalloc() {
         if (fPtr != fTStorage) {
             sk_free(fPtr);
         }
     }
 
     // doesn't preserve contents
     T* reset(size_t count) {
         if (fPtr != fTStorage) {
             sk_free(fPtr);
         }
         if (count > N) {
-            fPtr = (T*)sk_malloc_flags(count * sizeof(T), SK_MALLOC_THROW | SK_MALLOC_TEMP);
+            fPtr = (T*)sk_malloc_throw(count * sizeof(T));
         } else if (count) {
             fPtr = fTStorage;
         } else {
             fPtr = NULL;
         }
         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];
     }
 
+    // Reallocs the array, can be used to shrink the allocation.  Makes no attempt to be intelligent
+    void realloc(size_t count) {
+        if (count > N) {
+            if (fPtr == fTStorage) {
+                fPtr = (T*)sk_malloc_throw(count * sizeof(T));
+                memcpy(fPtr, fTStorage, N * sizeof(T));
+            } else {
+                fPtr = (T*)sk_realloc_throw(fPtr, count * sizeof(T));
+            }
+        } else if (!fPtr) {
+            fPtr = fTStorage;
+        } else if (fPtr != fTStorage) {
+            fPtr = (T*)sk_realloc_throw(fPtr, count * sizeof(T));
+        }
+    }
+
 private:
     T*          fPtr;
     union {
         uint32_t    fStorage32[(N*sizeof(T) + 3) >> 2];
         T           fTStorage[1];   // do NOT want to invoke T::T()
     };
 };
 
 /**
  * Reserves memory that is aligned on double and pointer boundaries.
@@ skipping 22 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(); }
 private:
     SkAlignedSStorage<sizeof(T)*N> fStorage;
 };
 
 #endif