Style Change: NULL->nullptr

src/core/SkDataTable.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkData.h"
 #include "SkDataTable.h"
 
 static void malloc_freeproc(void* context) {
     sk_free(context);
 }
 
 // Makes empty table
 SkDataTable::SkDataTable() {
     fCount = 0;
     fElemSize = 0;   // 0 signals that we use fDir instead of fElems
-    fU.fDir = NULL;
-    fFreeProc = NULL;
-    fFreeProcContext = NULL;
+    fU.fDir = nullptr;
+    fFreeProc = nullptr;
+    fFreeProcContext = nullptr;
 }
 
 SkDataTable::SkDataTable(const void* array, size_t elemSize, int count,
                          FreeProc proc, void* context) {
     SkASSERT(count > 0);
 
     fCount = count;
     fElemSize = elemSize;   // non-zero signals we use fElems instead of fDir
     fU.fElems = (const char*)array;
     fFreeProc = proc;
@@ skipping 39 matching lines @@
             *size = fU.fDir[index].fSize;
         }
         return fU.fDir[index].fPtr;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkDataTable* SkDataTable::NewEmpty() {
     static SkDataTable* gEmpty;
-    if (NULL == gEmpty) {
+    if (nullptr == gEmpty) {
         gEmpty = new SkDataTable;
     }
     gEmpty->ref();
     return gEmpty;
 }
 
 SkDataTable* SkDataTable::NewCopyArrays(const void * const * ptrs,
                                         const size_t sizes[], int count) {
     if (count <= 0) {
         return SkDataTable::NewEmpty();
@@ skipping 38 matching lines @@
         return SkDataTable::NewEmpty();
     }
     return new SkDataTable(array, elemSize, count, proc, ctx);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void chunkalloc_freeproc(void* context) { delete (SkChunkAlloc*)context; }
 
 SkDataTableBuilder::SkDataTableBuilder(size_t minChunkSize)
-    : fHeap(NULL)
+    : fHeap(nullptr)
     , fMinChunkSize(minChunkSize) {}
 
 SkDataTableBuilder::~SkDataTableBuilder() { this->reset(); }
 
 void SkDataTableBuilder::reset(size_t minChunkSize) {
     fMinChunkSize = minChunkSize;
     fDir.reset();
     if (fHeap) {
         delete fHeap;
-        fHeap = NULL;
+        fHeap = nullptr;
     }
 }
 
 void SkDataTableBuilder::append(const void* src, size_t size) {
-    if (NULL == fHeap) {
+    if (nullptr == fHeap) {
         fHeap = new SkChunkAlloc(fMinChunkSize);
     }
 
     void* dst = fHeap->alloc(size, SkChunkAlloc::kThrow_AllocFailType);
     memcpy(dst, src, size);
 
     SkDataTable::Dir* dir = fDir.append();
     dir->fPtr = dst;
     dir->fSize = size;
 }
 
 SkDataTable* SkDataTableBuilder::detachDataTable() {
     const int count = fDir.count();
     if (0 == count) {
         return SkDataTable::NewEmpty();
     }
 
     // Copy the dir into the heap;
     void* dir = fHeap->alloc(count * sizeof(SkDataTable::Dir),
                              SkChunkAlloc::kThrow_AllocFailType);
     memcpy(dir, fDir.begin(), count * sizeof(SkDataTable::Dir));
 
     SkDataTable* table = new SkDataTable((SkDataTable::Dir*)dir, count, chunkalloc_freeproc, fHeap);
     // we have to detach our fHeap, since we are giving that to the table
-    fHeap = NULL;
+    fHeap = nullptr;
     fDir.reset();
     return table;
 }