Delay setting initial memory block until it officially exists.

src/gpu/GrAllocator.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAllocator_DEFINED
 #define GrAllocator_DEFINED
 
@@ skipping 21 matching lines @@
             fItemSize(itemSize),
             fItemsPerBlock(itemsPerBlock),
             fOwnFirstBlock(NULL == initialBlock),
             fCount(0) {
         SkASSERT(itemsPerBlock > 0);
         fBlockSize = fItemSize * fItemsPerBlock;
         fBlocks.push_back() = initialBlock;
         SkDEBUGCODE(if (!fOwnFirstBlock) {*((char*)initialBlock+fBlockSize-1)='a';} );
     }
 
+    /*
+     * Set first block of memory to write into.  Must be called before any other methods.
+     * This requires that you have passed NULL in the constructor.
+     *
+     * @param   initialBlock    optional memory to use for the first block.
+     *                          Must be at least itemSize*itemsPerBlock sized.
+     *                          Caller is responsible for freeing this memory.
+     */
+    void setInitialBlock(void* initialBlock) {
+        SkASSERT(0 == fCount);
+        SkASSERT(1 == fBlocks.count());
+        SkASSERT(NULL == fBlocks.back());
+        fOwnFirstBlock = false;
+        fBlocks.back() = initialBlock;
+    }
+
     /**
      * Adds an item and returns pointer to it.
      *
      * @return pointer to the added item.
      */
     void* push_back() {
         int indexInBlock = fCount % fItemsPerBlock;
         // we always have at least one block
         if (0 == indexInBlock) {
             if (0 != fCount) {
@@ skipping 86 matching lines @@
 
 template <typename T>
 class GrTAllocator : public SkNoncopyable {
 public:
     virtual ~GrTAllocator() { this->reset(); };
 
     /**
      * Create an allocator
      *
      * @param   itemsPerBlock   the number of items to allocate at once
-     * @param   initialBlock    optional memory to use for the first block.
-     *                          Must be at least size(T)*itemsPerBlock sized.
-     *                          Caller is responsible for freeing this memory.
      */
     explicit GrTAllocator(int itemsPerBlock)
         : fAllocator(sizeof(T), itemsPerBlock, NULL) {}
 
     /**
      * Adds an item and returns it.
      *
      * @return the added item.
      */
     T& push_back() {
@@ skipping 55 matching lines @@
     }
 
     /**
      * access item by index.
      */
     const T& operator[] (int i) const {
         return *(const T*)(fAllocator[i]);
     }
 
 protected:
-    GrTAllocator(int itemsPerBlock, void* initialBlock)
-        : fAllocator(sizeof(T), itemsPerBlock, initialBlock) {
+    /*
+     * Set first block of memory to write into.  Must be called before any other methods.
+     *
+     * @param   initialBlock    optional memory to use for the first block.
+     *                          Must be at least size(T)*itemsPerBlock sized.
+     *                          Caller is responsible for freeing this memory.
+     */
+    void setInitialBlock(void* initialBlock) {
+        fAllocator.setInitialBlock(initialBlock);
     }
 
 private:
     GrAllocator fAllocator;
     typedef SkNoncopyable INHERITED;
 };
 
 template <int N, typename T> class GrSTAllocator : public GrTAllocator<T> {
 private:
     typedef GrTAllocator<T> INHERITED;
 
 public:
-    GrSTAllocator() : INHERITED(N, fStorage.get()) {
+    GrSTAllocator() : INHERITED(N) {
+        this->setInitialBlock(fStorage.get());
     }
 
 private:
     SkAlignedSTStorage<N, T> fStorage;
 };
 
 #endif