Add sentinel to GrMemoryPool's block header

src/gpu/GrMemoryPool.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrMemoryPool.h"
 
 #ifdef SK_DEBUG
@@ skipping 37 matching lines @@
         BlockHeader* block = CreateBlock(blockSize);
 
         block->fPrev = fTail;
         block->fNext = nullptr;
         SkASSERT(nullptr == fTail->fNext);
         fTail->fNext = block;
         fTail = block;
         fSize += block->fSize;
         SkDEBUGCODE(++fAllocBlockCnt);
     }
+    SkASSERT(kAssignedMarker == fTail->fBlockSentinal);
     SkASSERT(fTail->fFreeSize >= size);
     intptr_t ptr = fTail->fCurrPtr;
     // We stash a pointer to the block header, just before the allocated space,
     // so that we can decrement the live count on delete in constant time.
     AllocHeader* allocData = reinterpret_cast<AllocHeader*>(ptr);
     SkDEBUGCODE(allocData->fSentinal = kAssignedMarker);
     allocData->fHeader = fTail;
     ptr += kPerAllocPad;
     fTail->fPrevPtr = fTail->fCurrPtr;
     fTail->fCurrPtr += size;
     fTail->fFreeSize -= size;
     fTail->fLiveCount += 1;
 
     SkDEBUGCODE(++fAllocationCnt);
     VALIDATE;
     return reinterpret_cast<void*>(ptr);
 }
 
 void GrMemoryPool::release(void* p) {
     VALIDATE;
     intptr_t ptr = reinterpret_cast<intptr_t>(p) - kPerAllocPad;
     AllocHeader* allocData = reinterpret_cast<AllocHeader*>(ptr);
     SkASSERT(kAssignedMarker == allocData->fSentinal);
     SkDEBUGCODE(allocData->fSentinal = kFreedMarker);
     BlockHeader* block = allocData->fHeader;
+    SkASSERT(kAssignedMarker == block->fBlockSentinal);
     if (1 == block->fLiveCount) {
         // the head block is special, it is reset rather than deleted
         if (fHead == block) {
             fHead->fCurrPtr = reinterpret_cast<intptr_t>(fHead) + kHeaderSize;
             fHead->fLiveCount = 0;
             fHead->fFreeSize = fPreallocSize;
         } else {
             BlockHeader* prev = block->fPrev;
             BlockHeader* next = block->fNext;
             SkASSERT(prev);
@@ skipping 19 matching lines @@
     SkDEBUGCODE(--fAllocationCnt);
     VALIDATE;
 }
 
 GrMemoryPool::BlockHeader* GrMemoryPool::CreateBlock(size_t size) {
     size_t paddedSize = size + kHeaderSize;
     BlockHeader* block =
         reinterpret_cast<BlockHeader*>(sk_malloc_throw(paddedSize));
     // we assume malloc gives us aligned memory
     SkASSERT(!(reinterpret_cast<intptr_t>(block) % kAlignment));
+    SkDEBUGCODE(block->fBlockSentinal = kAssignedMarker);
     block->fLiveCount = 0;
     block->fFreeSize = size;
     block->fCurrPtr = reinterpret_cast<intptr_t>(block) + kHeaderSize;
     block->fPrevPtr = 0; // gcc warns on assigning nullptr to an intptr_t.
     block->fSize = paddedSize;
     return block;
 }
 
 void GrMemoryPool::DeleteBlock(BlockHeader* block) {
+    SkASSERT(kAssignedMarker == block->fBlockSentinal);
+    SkDEBUGCODE(block->fBlockSentinal = kFreedMarker); // FWIW
     sk_free(block);
 }
 
 void GrMemoryPool::validate() {
 #ifdef SK_DEBUG
     BlockHeader* block = fHead;
     BlockHeader* prev = nullptr;
     SkASSERT(block);
     int allocCount = 0;
     do {
+        SkASSERT(kAssignedMarker == block->fBlockSentinal);
         allocCount += block->fLiveCount;
         SkASSERT(prev == block->fPrev);
         if (prev) {
             SkASSERT(prev->fNext == block);
         }
 
         intptr_t b = reinterpret_cast<intptr_t>(block);
         size_t ptrOffset = block->fCurrPtr - b;
         size_t totalSize = ptrOffset + block->fFreeSize;
         size_t userSize = totalSize - kHeaderSize;
@@ skipping 19 matching lines @@
             SkASSERT(block == allocData->fHeader);
         }
 
         prev = block;
     } while ((block = block->fNext));
     SkASSERT(allocCount == fAllocationCnt);
     SkASSERT(prev == fTail);
     SkASSERT(fAllocBlockCnt != 0 || fSize == 0);
 #endif
 }