Extract most of the mutable state of SkShader into a separate Context object.

src/core/SkSmallAllocator.h

 /*
  * Copyright 2014 Google, Inc
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkSmallAllocator_DEFINED
 #define SkSmallAllocator_DEFINED
 
@@ skipping 24 matching lines @@
     : fStorageUsed(0)
     , fNumObjects(0)
     {}
 
     ~SkSmallAllocator() {
         // Destruct in reverse order, in case an earlier object points to a
         // later object.
         while (fNumObjects > 0) {
             fNumObjects--;
             Rec* rec = &fRecs[fNumObjects];
-            rec->fKillProc(rec->fObj);
+            if (rec->fObj) {
+                rec->fKillProc(rec->fObj);
+            }
             // Safe to do if fObj is in fStorage, since fHeapStorage will
             // point to NULL.
             sk_free(rec->fHeapStorage);
         }
     }
 
     /*
      *  Create a new object of type T. Its lifetime will be handled by this
      *  SkSmallAllocator.
      *  Each version behaves the same but takes a different number of
@@ skipping 68 matching lines @@
             rec->fHeapStorage = NULL;
             SkASSERT(SkIsAlign4(fStorageUsed));
             rec->fObj = static_cast<void*>(fStorage + (fStorageUsed / 4));
             fStorageUsed += storageRequired;
         }
         rec->fKillProc = destroyT<T>;
         fNumObjects++;
         return rec->fObj;
     }
 
+    /*
+     *  Free the memory reserved for an object without calling its destructor.
+     *  Assumes the passed-in pointer has previously been returned by either
+     *  createT or reserveT.
+     */
+    void free(void* obj) {
+        // Find the corresponding Rec.

[scroggo, 2014/03/24 21:24:46]

Do we think it's necessary to allow freeing anything besides the last thing
allocated? I'm guessing the common use case will be to call reserveT, learn that
the object could not be created, then call free.

I'd argue for a function called freeLast(), which would immediately free the
memory (if necessary), and reduce fNumObjects by one. That will avoid this
linear search, which admittedly, is of a short list, but it's still code we may
not need. It also keeps our list of fRecs more consistent (all need to have
their fKillProc called).

In SkChunkAlloc, we have an analogous function called unalloc(), which simply
fails if you request to unalloc anything but the last object allocated. I like
freeLast() better personally, because it needs no parameter.

[Dominik Grewe, 2014/03/26 17:22:22]

Sounds good to me. I've implemented it. If we also want to make the reserved
space available for future allocations we'd have to keep track of allocation
sizes. Do we want to do that?

[scroggo, 2014/03/26 23:13:09]

That seems reasonable. It might be nice to know how often it's necessary to call
freeLast().

[Dominik Grewe, 2014/03/27 14:27:20]

During the tests (excluding the ones using gradient shader) it gets called 6
times.

+        Rec* rec = NULL;
+        for (uint32_t i = 0; i < fNumObjects; i++) {
+            if (fRecs[i].fObj == obj) {
+                rec = &fRecs[i];
+                break;
+            }
+        }
+        SkASSERT(rec);
+        // The rest of the cleanup will be done in the destructor.
+        rec->fObj = NULL;
+    }
+
 private:
     struct Rec {
         void* fObj;
         void* fHeapStorage;
         void  (*fKillProc)(void*);
     };
 
     // Number of bytes used so far.
     size_t              fStorageUsed;
     // Pad the storage size to be 4-byte aligned.
     uint32_t            fStorage[SkAlign4(kTotalBytes) >> 2];
     uint32_t            fNumObjects;
     Rec                 fRecs[kMaxObjects];
 };
 
 #endif // SkSmallAllocator_DEFINED