Make container classes in SkTemplates.h more consistent

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 308 matching lines @@
     T* fPtr;
 };
 
 template <size_t kCountRequested, typename T> class SkAutoSTMalloc : SkNoncopyable {
 public:
     SkAutoSTMalloc() : fPtr(fTStorage) {}
 
     SkAutoSTMalloc(size_t count) {
         if (count > kCount) {
             fPtr = (T*)sk_malloc_flags(count * sizeof(T), SK_MALLOC_THROW | SK_MALLOC_TEMP);
+        } else if (count > 0) {
+            fPtr = fTStorage;
         } else {
-            fPtr = fTStorage;
+            SkASSERT(0 == count);

[reed1, 2016/06/22 11:33:30]

Can this ever not be true?

[csmartdalton, 2016/06/23 17:07:46]

The idea would be that if somebody unintentionally calls this with a negative
number it helps them find their bug. Of course, it's already making the pointer
null, which would bring it to their attention pretty quickly anyway.

[reed1, 2016/06/23 17:44:36]

but count is size_t, which will never appear to be negative

[csmartdalton, 2016/06/23 18:07:26]

Yeah, I realized it was size_t after the fact :)

+            fPtr = nullptr;
         }
     }
 
     ~SkAutoSTMalloc() {
         if (fPtr != fTStorage) {
             sk_free(fPtr);
         }
     }
 
     // doesn't preserve contents
     T* reset(size_t count) {
         if (fPtr != fTStorage) {
             sk_free(fPtr);
         }
         if (count > kCount) {
             fPtr = (T*)sk_malloc_throw(count * sizeof(T));
+        } else if (count > 0) {
+            fPtr = fTStorage;
         } else {
-            fPtr = fTStorage;
+            SkASSERT(0 == count);
+            fPtr = nullptr;
         }
         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) {

[bsalomon, 2016/06/22 13:30:29]

Wouldn't this need to be updated, too?

[csmartdalton, 2016/06/23 18:07:26]

Updated to what?

         if (count > kCount) {
             if (fPtr == fTStorage) {
                 fPtr = (T*)sk_malloc_throw(count * sizeof(T));
                 memcpy(fPtr, fTStorage, kCount * sizeof(T));
             } else {
                 fPtr = (T*)sk_realloc_throw(fPtr, count * sizeof(T));
             }
         } else if (fPtr != fTStorage) {
             fPtr = (T*)sk_realloc_throw(fPtr, count * sizeof(T));
         }
@@ skipping 87 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