Move Google3-specific stack limitation logic to template classes. Remove #ifdefs in other files.

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 177 matching lines @@
 
     /** Destroys previous objects in the array and default constructs count number of objects */
     void reset(int count) {
         T* start = fArray;
         T* iter = start + fCount;
         while (iter > start) {
             (--iter)->~T();
         }
 
         if (fCount != count) {
-            if (fCount > N) {
+            if (fCount > N_ADJ) {

[mtklein, 2016/02/02 03:04:29]

Ditto here.  It just seems easy to accidentally use N instead of N_ADJ.  Let's
make the user-supplied value have the weird name, e.g. N_REQUESTED, and the
value we're supposed to use be the simple one, e.g. N.

[dogben, 2016/02/02 19:39:34]

Done. I made the naming consistent with SkAutoSMalloc.

                 // 'fArray' was allocated last time so free it now
                 SkASSERT((T*) fStorage != fArray);
                 sk_free(fArray);
             }
 
-            if (count > N) {
+            if (count > N_ADJ) {
                 const uint64_t size64 = sk_64_mul(count, sizeof(T));
                 const size_t size = static_cast<size_t>(size64);
                 if (size != size64) {
                     sk_out_of_memory();
                 }
                 fArray = (T*) sk_malloc_throw(size);
             } else if (count > 0) {
                 fArray = (T*) fStorage;
             } else {
                 fArray = NULL;
@@ skipping 18 matching lines @@
     T* get() const { return fArray; }
 
     /** Return the nth element in the array
      */
     T&  operator[](int index) const {
         SkASSERT(index < fCount);
         return fArray[index];
     }
 
 private:
+#if defined(GOOGLE3)
+    // Stack frame size is limited for GOOGLE3. 4k is less than the actual max, but some functions
+    // have multiple large stack allocations.
+    static const int MAX_BYTES = 4 * 1024;
+    static const int N_ADJ = N * sizeof(T) > MAX_BYTES ? MAX_BYTES / sizeof(T) : N;
+#else
+    static const int N_ADJ = N;
+#endif
+
     int     fCount;
     T*      fArray;
     // since we come right after fArray, fStorage should be properly aligned
-    char    fStorage[N * sizeof(T)];
+    char    fStorage[N_ADJ * sizeof(T)];
 };
 
 /** Manages an array of T elements, freeing the array in the destructor.
  *  Does NOT call any constructors/destructors on T (T must be POD).
  */
 template <typename T> class SkAutoTMalloc : SkNoncopyable {
 public:
     /** Takes ownership of the ptr. The ptr must be a value which can be passed to sk_free. */
     explicit SkAutoTMalloc(T* ptr = NULL) {
         fPtr = ptr;
@@ skipping 58 matching lines @@
 
 private:
     T* fPtr;
 };
 
 template <size_t N, typename T> class SkAutoSTMalloc : SkNoncopyable {
 public:
     SkAutoSTMalloc() : fPtr(fTStorage) {}
 
     SkAutoSTMalloc(size_t count) {
-        if (count > N) {
+        if (count > N_ADJ) {
             fPtr = (T*)sk_malloc_flags(count * sizeof(T), SK_MALLOC_THROW | SK_MALLOC_TEMP);
         } else {
             fPtr = fTStorage;
         }
     }
 
     ~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) {
+        if (count > N_ADJ) {
             fPtr = (T*)sk_malloc_throw(count * sizeof(T));
         } else {
             fPtr = fTStorage;
         }
         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 (count > N_ADJ) {
             if (fPtr == fTStorage) {
                 fPtr = (T*)sk_malloc_throw(count * sizeof(T));
-                memcpy(fPtr, fTStorage, N * sizeof(T));
+                memcpy(fPtr, fTStorage, N_ADJ * 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));
         }
     }
 
 private:
+    // Since we use uint32_t storage, we might be able to get more elements for free.
+    static const size_t N_WITH_PADDING = (((N*sizeof(T) + 3) >> 2) << 2) / sizeof(T);
+#if defined(GOOGLE3)
+    // Stack frame size is limited for GOOGLE3. 4k is less than the actual max, but some functions
+    // have multiple large stack allocations.
+    static const size_t MAX_BYTES = 4 * 1024;
+    static const size_t N_ADJ = N * sizeof(T) > MAX_BYTES ? MAX_BYTES / sizeof(T) : N_WITH_PADDING;
+#else
+    static const size_t N_ADJ = N_WITH_PADDING;
+#endif
+
     T*          fPtr;
     union {
-        uint32_t    fStorage32[(N*sizeof(T) + 3) >> 2];
+        uint32_t    fStorage32[(N_ADJ*sizeof(T) + 3) >> 2];
         T           fTStorage[1];   // do NOT want to invoke T::T()
     };
 };
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  *  Pass the object and the storage that was offered during SkInPlaceNewCheck, and this will
  *  safely destroy (and free if it was dynamically allocated) the object.
  */
@@ skipping 52 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