Style Change: NULL->nullptr

src/effects/gradients/SkGradientBitmapCache.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkGradientBitmapCache.h"
 
 struct SkGradientBitmapCache::Entry {
     Entry*      fPrev;
     Entry*      fNext;
 
     void*       fBuffer;
     size_t      fSize;
     SkBitmap    fBitmap;
 
     Entry(const void* buffer, size_t size, const SkBitmap& bm)
-            : fPrev(NULL),
-              fNext(NULL),
+            : fPrev(nullptr),
+              fNext(nullptr),
               fBitmap(bm) {
         fBuffer = sk_malloc_throw(size);
         fSize = size;
         memcpy(fBuffer, buffer, size);
     }
 
     ~Entry() { sk_free(fBuffer); }
 
     bool equals(const void* buffer, size_t size) const {
         return (fSize == size) && !memcmp(fBuffer, buffer, size);
     }
 };
 
 SkGradientBitmapCache::SkGradientBitmapCache(int max) : fMaxEntries(max) {
     fEntryCount = 0;
-    fHead = fTail = NULL;
+    fHead = fTail = nullptr;
 
     this->validate();
 }
 
 SkGradientBitmapCache::~SkGradientBitmapCache() {
     this->validate();
 
     Entry* entry = fHead;
     while (entry) {
         Entry* next = entry->fNext;
@@ skipping 14 matching lines @@
         SkASSERT(fTail != entry);
         entry->fNext->fPrev = entry->fPrev;
     } else {
         SkASSERT(fTail == entry);
         fTail = entry->fPrev;
     }
     return entry;
 }
 
 void SkGradientBitmapCache::attachToHead(Entry* entry) const {
-    entry->fPrev = NULL;
+    entry->fPrev = nullptr;
     entry->fNext = fHead;
     if (fHead) {
         fHead->fPrev = entry;
     } else {
         fTail = entry;
     }
     fHead = entry;
 }
 
 bool SkGradientBitmapCache::find(const void* buffer, size_t size, SkBitmap* bm) const {
@@ skipping 30 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 
 void SkGradientBitmapCache::validate() const {
     SkASSERT(fEntryCount >= 0 && fEntryCount <= fMaxEntries);
 
     if (fEntryCount > 0) {
-        SkASSERT(NULL == fHead->fPrev);
-        SkASSERT(NULL == fTail->fNext);
+        SkASSERT(nullptr == fHead->fPrev);
+        SkASSERT(nullptr == fTail->fNext);
 
         if (fEntryCount == 1) {
             SkASSERT(fHead == fTail);
         } else {
             SkASSERT(fHead != fTail);
         }
 
         Entry* entry = fHead;
         int count = 0;
         while (entry) {
             count += 1;
             entry = entry->fNext;
         }
         SkASSERT(count == fEntryCount);
 
         entry = fTail;
         while (entry) {
             count -= 1;
             entry = entry->fPrev;
         }
         SkASSERT(0 == count);
     } else {
-        SkASSERT(NULL == fHead);
-        SkASSERT(NULL == fTail);
+        SkASSERT(nullptr == fHead);
+        SkASSERT(nullptr == fTail);
     }
 }
 
 #endif