Make TRecorder alloc_back return a void*

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 50 matching lines @@
 
     ~GrTRecorder() {
         this->reset();
         MemBlock::Free(fHeadBlock);
     }
 
     bool empty() { return !fLastItem; }
 
     TBase& back() {
         SkASSERT(!this->empty());
-        return *fLastItem;
+        return *reinterpret_cast<TBase*>(fLastItem);
     }
 
     /**
      * Removes and destroys the last block added to the recorder. It may not be called when the
      * recorder is empty.
      */
     void pop_back();
 
     /**
      * Destruct all items in the list and reset to empty.
@@ skipping 21 matching lines @@
 private:
     template<typename TItem> struct length_of {
         enum { kValue = (sizeof(TItem) + sizeof(TAlign) - 1) / sizeof(TAlign) };
     };
     static int LengthOf(int bytes) { return (bytes + sizeof(TAlign) - 1) / sizeof(TAlign); }
 
     struct Header {
         int fTotalLength; // The length of an entry including header, item, and data in TAligns.
         int fPrevLength;  // Same but for the previous entry. Used for iterating backwards.
     };
-    template<typename TItem> TItem* alloc_back(int dataLength);
+    template<typename TItem> void* alloc_back(int dataLength);
 
     struct MemBlock : SkNoncopyable {
         /** Allocates a new block and appends it to prev if not NULL. The length param is in units
             of TAlign. */
         static MemBlock* Alloc(int length, MemBlock* prev) {
             MemBlock* block = reinterpret_cast<MemBlock*>(
                 sk_malloc_throw(sizeof(TAlign) * (length_of<MemBlock>::kValue + length)));
             block->fLength = length;
             block->fBack = 0;
             block->fNext = NULL;
@@ skipping 23 matching lines @@
         }
 
         int       fLength; // Length in units of TAlign of the block.
         int       fBack;   // Offset, in TAligns, to unused portion of the memory block.
         MemBlock* fNext;
         MemBlock* fPrev;
     };
     MemBlock* const fHeadBlock;
     MemBlock* fTailBlock;
 
-    TBase*    fLastItem;
+    void*    fLastItem; // really a ptr to TBase
 
     template<typename TItem> friend struct GrTRecorderAllocWrapper;
 
     template <typename UBase, typename UAlign, typename UItem>
     friend void* operator new(size_t, GrTRecorder<UBase, UAlign>&,
                               const GrTRecorderAllocWrapper<UItem>&);
 
     friend class Iter;
     friend class ReverseIter;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 template<typename TBase, typename TAlign>
 void GrTRecorder<TBase, TAlign>::pop_back() {
     SkASSERT(fLastItem);
     Header* header = reinterpret_cast<Header*>(
         reinterpret_cast<TAlign*>(fLastItem) - length_of<Header>::kValue);
     fTailBlock->fBack -= header->fTotalLength;
-    fLastItem->~TBase();
+    reinterpret_cast<TBase*>(fLastItem)->~TBase();
 
     int lastItemLength = header->fPrevLength;
 
     if (!header->fPrevLength) {
         // We popped the first entry in the recorder.
         SkASSERT(0 == fTailBlock->fBack);
         fLastItem = NULL;
         return;
     }
     while (!fTailBlock->fBack) {
         // We popped the last entry in a block that isn't the head block. Move back a block but
         // don't free it since we'll probably grow into it shortly.
         fTailBlock = fTailBlock->fPrev;
         SkASSERT(fTailBlock);
     }
-    fLastItem = reinterpret_cast<TBase*>(
-        &(*fTailBlock)[fTailBlock->fBack - lastItemLength + length_of<Header>::kValue]);
+    fLastItem = &(*fTailBlock)[fTailBlock->fBack - lastItemLength + length_of<Header>::kValue];
 }
 
 template<typename TBase, typename TAlign>
 template<typename TItem>
-TItem* GrTRecorder<TBase, TAlign>::alloc_back(int dataLength) {
+void* GrTRecorder<TBase, TAlign>::alloc_back(int dataLength) {
     // Find the header of the previous entry and get its length. We need to store that in the new
     // header for backwards iteration (pop_back()).
     int prevLength = 0;
     if (fLastItem) {
         Header* lastHeader = reinterpret_cast<Header*>(
             reinterpret_cast<TAlign*>(fLastItem) - length_of<Header>::kValue);
         prevLength = lastHeader->fTotalLength;
     }
 
     const int totalLength = length_of<Header>::kValue + length_of<TItem>::kValue + dataLength;
 
     // Check if there is room in the current block and if not walk to next (allocating if
     // necessary). Note that pop_back() and reset() can leave the recorder in a state where it
     // has preallocated blocks hanging off the tail that are currently unused.
     while (fTailBlock->fBack + totalLength > fTailBlock->fLength) {
         if (!fTailBlock->fNext) {
             fTailBlock = MemBlock::Alloc(SkTMax(2 * fTailBlock->fLength, totalLength), fTailBlock);
         } else {
             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]);
+    void* rawPtr = &(*fTailBlock)[fTailBlock->fBack + length_of<Header>::kValue];
 
     header->fTotalLength = totalLength;
     header->fPrevLength = prevLength;
     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
@@ skipping 148 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