Style Change: NULL->nullptr

src/core/SkChunkAlloc.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkChunkAlloc.h"
 
 // Don't malloc any chunks smaller than this
@@ skipping 12 matching lines @@
     char*   fFreePtr;
     // data[] follows
 
     size_t blockSize() { 
         char* start = this->startOfData();
         size_t bytes = fFreePtr - start;
         return fFreeSize + bytes;
     }
 
     void reset() {
-        fNext = NULL;
+        fNext = nullptr;
         fFreeSize = this->blockSize();
         fFreePtr = this->startOfData();
     }
 
     char* startOfData() {
         return reinterpret_cast<char*>(this + 1);
     }
 
     static void FreeChain(Block* block) {
         while (block) {
             Block* next = block->fNext;
             sk_free(block);
             block = next;
         }
     };
 
     bool contains(const void* addr) const {
         const char* ptr = reinterpret_cast<const char*>(addr);
         return ptr >= (const char*)(this + 1) && ptr < fFreePtr;
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkChunkAlloc::SkChunkAlloc(size_t minSize) {
     if (minSize < MIN_CHUNKALLOC_BLOCK_SIZE) {
         minSize = MIN_CHUNKALLOC_BLOCK_SIZE;
     }
 
-    fBlock = NULL;
+    fBlock = nullptr;
     fMinSize = minSize;
     fChunkSize = fMinSize;
     fTotalCapacity = 0;
     fTotalUsed = 0;
     SkDEBUGCODE(fTotalLost = 0;)
     SkDEBUGCODE(fBlockCount = 0;)
 }
 
 SkChunkAlloc::~SkChunkAlloc() {
     this->reset();
 }
 
 void SkChunkAlloc::reset() {
     Block::FreeChain(fBlock);
-    fBlock = NULL;
+    fBlock = nullptr;
     fChunkSize = fMinSize;  // reset to our initial minSize
     fTotalCapacity = 0;
     fTotalUsed = 0;
     SkDEBUGCODE(fTotalLost = 0;)
     SkDEBUGCODE(fBlockCount = 0;)
 }
 
 void SkChunkAlloc::rewind() {
     SkDEBUGCODE(this->validate();)
 
@@ skipping 46 matching lines @@
     }
     return block;
 }
 
 SkChunkAlloc::Block* SkChunkAlloc::addBlockIfNecessary(size_t bytes, AllocFailType ftype) {
     SkASSERT(SkIsAlign4(bytes));
 
     if (!fBlock || bytes > fBlock->fFreeSize) {
         Block* block = this->newBlock(bytes, ftype);
         if (!block) {
-            return NULL;
+            return nullptr;
         }
 #ifdef SK_DEBUG
         if (fBlock) {
             fTotalLost += fBlock->fFreeSize;
         }
 #endif
         block->fNext = fBlock;
         fBlock = block;
     }
 
     SkASSERT(fBlock && bytes <= fBlock->fFreeSize);
     return fBlock;
 }
 
 void* SkChunkAlloc::alloc(size_t bytes, AllocFailType ftype) {
     SkDEBUGCODE(this->validate();)
 
     bytes = SkAlign4(bytes);
 
     Block* block = this->addBlockIfNecessary(bytes, ftype);
     if (!block) {
-        return NULL;
+        return nullptr;
     }
 
     char* ptr = block->fFreePtr;
 
     fTotalUsed += bytes;
     block->fFreeSize -= bytes;
     block->fFreePtr = ptr + bytes;
     SkDEBUGCODE(this->validate();)
     return ptr;
 }
@@ skipping 48 matching lines @@
     }
 
     SkASSERT(fBlockCount == numBlocks);
     SkASSERT(fTotalCapacity == totCapacity);
     SkASSERT(fTotalUsed == totUsed);
     SkASSERT(fTotalLost == totLost);
     SkASSERT(totCapacity == totUsed + totLost + totAvailable);
 }
 #endif