Replace uses of GR_DEBUGCODE by SkDEBUGCODE.

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
     #define VALIDATE this->validate()
 #else
     #define VALIDATE
 #endif
 
 GrMemoryPool::GrMemoryPool(size_t preallocSize, size_t minAllocSize) {
-    GR_DEBUGCODE(fAllocationCnt = 0);
+    SkDEBUGCODE(fAllocationCnt = 0);
 
     minAllocSize = GrMax<size_t>(minAllocSize, 1 << 10);
     fMinAllocSize = GrSizeAlignUp(minAllocSize + kPerAllocPad, kAlignment),
     fPreallocSize = GrSizeAlignUp(preallocSize + kPerAllocPad, kAlignment);
     fPreallocSize = GrMax(fPreallocSize, fMinAllocSize);
 
     fHead = CreateBlock(fPreallocSize);
     fTail = fHead;
     fHead->fNext = NULL;
     fHead->fPrev = NULL;
@@ skipping 26 matching lines @@
     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.
     *reinterpret_cast<BlockHeader**>(ptr) = fTail;
     ptr += kPerAllocPad;
     fTail->fPrevPtr = fTail->fCurrPtr;
     fTail->fCurrPtr += size;
     fTail->fFreeSize -= size;
     fTail->fLiveCount += 1;
-    GR_DEBUGCODE(++fAllocationCnt);
+    SkDEBUGCODE(++fAllocationCnt);
     VALIDATE;
     return reinterpret_cast<void*>(ptr);
 }
 
 void GrMemoryPool::release(void* p) {
     VALIDATE;
     intptr_t ptr = reinterpret_cast<intptr_t>(p) - kPerAllocPad;
     BlockHeader* block = *reinterpret_cast<BlockHeader**>(ptr);
     if (1 == block->fLiveCount) {
         // the head block is special, it is reset rather than deleted
@@ skipping 16 matching lines @@
             DeleteBlock(block);
         }
     } else {
         --block->fLiveCount;
         // Trivial reclaim: if we're releasing the most recent allocation, reuse it
         if (block->fPrevPtr == ptr) {
             block->fFreeSize += (block->fCurrPtr - block->fPrevPtr);
             block->fCurrPtr = block->fPrevPtr;
         }
     }
-    GR_DEBUGCODE(--fAllocationCnt);
+    SkDEBUGCODE(--fAllocationCnt);
     VALIDATE;
 }
 
 GrMemoryPool::BlockHeader* GrMemoryPool::CreateBlock(size_t size) {
     BlockHeader* block =
         reinterpret_cast<BlockHeader*>(GrMalloc(size + kHeaderSize));
     // we assume malloc gives us aligned memory
     SkASSERT(!(reinterpret_cast<intptr_t>(block) % kAlignment));
     block->fLiveCount = 0;
     block->fFreeSize = size;
@@ skipping 40 matching lines @@
             SkASSERT(userStart == block->fCurrPtr);
         } else {
             SkASSERT(block == *reinterpret_cast<BlockHeader**>(userStart));
         }
         prev = block;
     } while ((block = block->fNext));
     SkASSERT(allocCount == fAllocationCnt);
     SkASSERT(prev == fTail);
 #endif
 }