Update GrTRecorder to preserve memory allocations

src/gpu/GrTRecorder.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 GrTRecorder_DEFINED
 #define GrTRecorder_DEFINED
 
@@ skipping 133 matching lines @@
     friend class Iter;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 template<typename TBase, typename TAlign>
 template<typename TItem>
 TItem* GrTRecorder<TBase, TAlign>::alloc_back(int dataLength) {
     const int totalLength = length_of<Header>::kValue + length_of<TItem>::kValue + dataLength;
 
-    if (fTailBlock->fBack + totalLength > fTailBlock->fLength) {
-        SkASSERT(!fTailBlock->fNext);
-        fTailBlock->fNext = MemBlock::Alloc(SkTMax(2 * fTailBlock->fLength, totalLength));
+    while (fTailBlock->fBack + totalLength > fTailBlock->fLength) {
+        if (!fTailBlock->fNext) {
+            fTailBlock->fNext = MemBlock::Alloc(SkTMax(2 * fTailBlock->fLength, totalLength));
+        }
         fTailBlock = fTailBlock->fNext;
+        SkASSERT(0 == fTailBlock->fBack);
     }
 
     Header* header = reinterpret_cast<Header*>(&(*fTailBlock)[fTailBlock->fBack]);
     TItem* rawPtr = reinterpret_cast<TItem*>(
                         &(*fTailBlock)[fTailBlock->fBack + length_of<Header>::kValue]);
 
     header->fTotalLength = totalLength;
     fLastItem = rawPtr;
     fTailBlock->fBack += totalLength;
 
     // FIXME: We currently require that the base and subclass share the same start address.
     // This is not required by the C++ spec, and is likely to not be true in the case of
     // multiple inheritance or a base class that doesn't have virtual methods (when the
     // subclass does). It would be ideal to find a more robust solution that comes at no
     // extra cost to performance or code generality.
     SkDEBUGCODE(void* baseAddr = fLastItem;
                 void* subclassAddr = rawPtr);
     SkASSERT(baseAddr == subclassAddr);
 
     return rawPtr;
 }
 
 template<typename TBase, typename TAlign>
 class GrTRecorder<TBase, TAlign>::Iter {
 public:
     Iter(GrTRecorder& recorder) : fBlock(recorder.fHeadBlock), fPosition(0), fItem(NULL) {}
 
     bool next() {
-        if (fPosition >= fBlock->fBack) {
+        while (fPosition >= fBlock->fBack) {
             SkASSERT(fPosition == fBlock->fBack);
             if (!fBlock->fNext) {
                 return false;
             }
-            SkASSERT(0 != fBlock->fNext->fBack);
             fBlock = fBlock->fNext;
             fPosition = 0;
         }
 
         Header* header = reinterpret_cast<Header*>(&(*fBlock)[fPosition]);
         fItem = reinterpret_cast<TBase*>(&(*fBlock)[fPosition + length_of<Header>::kValue]);
         fPosition += header->fTotalLength;
         return true;
     }
 
     TBase* get() const {
         SkASSERT(fItem);
         return fItem;
     }
 
     TBase* operator->() const { return this->get(); }
 
 private:
     MemBlock* fBlock;
     int       fPosition;
     TBase*    fItem;
 };
 
 template<typename TBase, typename TAlign>
 void GrTRecorder<TBase, TAlign>::reset() {
     Iter iter(*this);
     while (iter.next()) {
         iter->~TBase();
     }
-    fHeadBlock->fBack = 0;
-    MemBlock::Free(fHeadBlock->fNext);
-    fHeadBlock->fNext = NULL;
+
+    // Assume the next time this recorder fills up it will use approximately the same

[bsalomon, 2014/11/07 20:06:42]

In the future we might want to consider exposing control of the functionality to
the caller.

[Chris Dalton, 2014/11/07 20:42:39]

Agreed.

+    // amount of space as last time. Leave enough space for up to ~50% growth; free
+    // everything else.
+    if (fTailBlock->fBack <= fTailBlock->fLength / 2) {
+        MemBlock::Free(fTailBlock->fNext);
+        fTailBlock->fNext = NULL;
+    } else if (fTailBlock->fNext) {
+        MemBlock::Free(fTailBlock->fNext->fNext);
+        fTailBlock->fNext->fNext = NULL;
+    }
+
+    for (MemBlock* block = fHeadBlock; block; block = block->fNext) {
+        block->fBack = 0;
+    }
+
     fTailBlock = fHeadBlock;
     fLastItem = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 template<typename TItem> struct GrTRecorderAllocWrapper {
     GrTRecorderAllocWrapper() : fDataLength(0) {}
 
     template <typename TBase, typename TAlign>
@@ skipping 17 matching lines @@
     SK_CRASH();
 }
 
 #define GrNEW_APPEND_TO_RECORDER(recorder, type_name, args) \
     (new (recorder, GrTRecorderAllocWrapper<type_name>()) type_name args)
 
 #define GrNEW_APPEND_WITH_DATA_TO_RECORDER(recorder, type_name, args, size_of_data) \
     (new (recorder, GrTRecorderAllocWrapper<type_name>(recorder, size_of_data)) type_name args)
 
 #endif