Style Change: NULL->nullptr

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) {
     SkDEBUGCODE(fAllocationCnt = 0);
     SkDEBUGCODE(fAllocBlockCnt = 0);
 
     minAllocSize = SkTMax<size_t>(minAllocSize, 1 << 10);
     fMinAllocSize = GrSizeAlignUp(minAllocSize + kPerAllocPad, kAlignment),
     fPreallocSize = GrSizeAlignUp(preallocSize + kPerAllocPad, kAlignment);
     fPreallocSize = SkTMax(fPreallocSize, fMinAllocSize);
     fSize = fPreallocSize;
 
     fHead = CreateBlock(fPreallocSize);
     fTail = fHead;
-    fHead->fNext = NULL;
-    fHead->fPrev = NULL;
+    fHead->fNext = nullptr;
+    fHead->fPrev = nullptr;
     VALIDATE;
 };
 
 GrMemoryPool::~GrMemoryPool() {
     VALIDATE;
     SkASSERT(0 == fAllocationCnt);
     SkASSERT(fHead == fTail);
     SkASSERT(0 == fHead->fLiveCount);
     DeleteBlock(fHead);
 };
 
 void* GrMemoryPool::allocate(size_t size) {
     VALIDATE;
     size = GrSizeAlignUp(size, kAlignment);
     size += kPerAllocPad;
     if (fTail->fFreeSize < size) {
         size_t blockSize = size;
         blockSize = SkTMax<size_t>(blockSize, fMinAllocSize);
         BlockHeader* block = CreateBlock(blockSize);
 
         block->fPrev = fTail;
-        block->fNext = NULL;
-        SkASSERT(NULL == fTail->fNext);
+        block->fNext = nullptr;
+        SkASSERT(nullptr == fTail->fNext);
         fTail->fNext = block;
         fTail = block;
         fSize += block->fSize;
         SkDEBUGCODE(++fAllocBlockCnt);
     }
     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;
@@ skipping 47 matching lines @@
 
 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));
     block->fLiveCount = 0;
     block->fFreeSize = size;
     block->fCurrPtr = reinterpret_cast<intptr_t>(block) + kHeaderSize;
-    block->fPrevPtr = 0; // gcc warns on assigning NULL to an intptr_t.
+    block->fPrevPtr = 0; // gcc warns on assigning nullptr to an intptr_t.
     block->fSize = paddedSize;
     return block;
 }
 
 void GrMemoryPool::DeleteBlock(BlockHeader* block) {
     sk_free(block);
 }
 
 void GrMemoryPool::validate() {
 #ifdef SK_DEBUG
     BlockHeader* block = fHead;
-    BlockHeader* prev = NULL;
+    BlockHeader* prev = nullptr;
     SkASSERT(block);
     int allocCount = 0;
     do {
         allocCount += block->fLiveCount;
         SkASSERT(prev == block->fPrev);
         if (prev) {
             SkASSERT(prev->fNext == block);
         }
 
         intptr_t b = reinterpret_cast<intptr_t>(block);
@@ skipping 18 matching lines @@
         } else {
             SkASSERT(block == *reinterpret_cast<BlockHeader**>(userStart));
         }
         prev = block;
     } while ((block = block->fNext));
     SkASSERT(allocCount == fAllocationCnt);
     SkASSERT(prev == fTail);
     SkASSERT(fAllocBlockCnt != 0 || fSize == fPreallocSize);
 #endif
 }