Style Change: NULL->nullptr

src/core/SkResourceCache.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 "SkChecksum.h"
 #include "SkMessageBus.h"
 #include "SkMipMap.h"
@@ skipping 41 matching lines @@
 
 #include "SkTDynamicHash.h"
 
 class SkResourceCache::Hash :
     public SkTDynamicHash<SkResourceCache::Rec, SkResourceCache::Key> {};
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkResourceCache::init() {
-    fHead = NULL;
-    fTail = NULL;
+    fHead = nullptr;
+    fTail = nullptr;
     fHash = new Hash;
     fTotalBytesUsed = 0;
     fCount = 0;
     fSingleAllocationByteLimit = 0;
-    fAllocator = NULL;
+    fAllocator = nullptr;
 
     // One of these should be explicit set by the caller after we return.
     fTotalByteLimit = 0;
-    fDiscardableFactory = NULL;
+    fDiscardableFactory = nullptr;
 }
 
 #include "SkDiscardableMemory.h"
 
 class SkOneShotDiscardablePixelRef : public SkPixelRef {
 public:
 
     // Ownership of the discardablememory is transfered to the pixelref
     SkOneShotDiscardablePixelRef(const SkImageInfo&, SkDiscardableMemory*, size_t rowBytes);
     ~SkOneShotDiscardablePixelRef();
@@ skipping 26 matching lines @@
 
 bool SkOneShotDiscardablePixelRef::onNewLockPixels(LockRec* rec) {
     if (fFirstTime) {
         // we're already locked
         SkASSERT(fDM->data());
         fFirstTime = false;
         goto SUCCESS;
     }
 
     // A previous call to onUnlock may have deleted our DM, so check for that
-    if (NULL == fDM) {
+    if (nullptr == fDM) {
         return false;
     }
 
     if (!fDM->lock()) {
         // since it failed, we delete it now, to free-up the resource
         delete fDM;
-        fDM = NULL;
+        fDM = nullptr;
         return false;
     }
 
 SUCCESS:
     rec->fPixels = fDM->data();
-    rec->fColorTable = NULL;
+    rec->fColorTable = nullptr;
     rec->fRowBytes = fRB;
     return true;
 }
 
 void SkOneShotDiscardablePixelRef::onUnlockPixels() {
     SkASSERT(!fFirstTime);
     fDM->unlock();
 }
 
 size_t SkOneShotDiscardablePixelRef::getAllocatedSizeInBytes() const {
@@ skipping 14 matching lines @@
 };
 
 bool SkResourceCacheDiscardableAllocator::allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable) {
     size_t size = bitmap->getSize();
     uint64_t size64 = bitmap->computeSize64();
     if (0 == size || size64 > (uint64_t)size) {
         return false;
     }
 
     SkDiscardableMemory* dm = fFactory(size);
-    if (NULL == dm) {
+    if (nullptr == dm) {
         return false;
     }
 
     // can we relax this?
     if (kN32_SkColorType != bitmap->colorType()) {
         return false;
     }
 
     SkImageInfo info = bitmap->info();
     bitmap->setPixelRef(new SkOneShotDiscardablePixelRef(info, dm, bitmap->rowBytes()))->unref();
@@ skipping 186 matching lines @@
         this->purgeAsNeeded();
     }
     return prevLimit;
 }
 
 SkCachedData* SkResourceCache::newCachedData(size_t bytes) {
     this->checkMessages();
 
     if (fDiscardableFactory) {
         SkDiscardableMemory* dm = fDiscardableFactory(bytes);
-        return dm ? new SkCachedData(bytes, dm) : NULL;
+        return dm ? new SkCachedData(bytes, dm) : nullptr;
     } else {
         return new SkCachedData(sk_malloc_throw(bytes), bytes);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkResourceCache::detach(Rec* rec) {
     Rec* prev = rec->fPrev;
     Rec* next = rec->fNext;
 
     if (!prev) {
         SkASSERT(fHead == rec);
         fHead = next;
     } else {
         prev->fNext = next;
     }
 
     if (!next) {
         fTail = prev;
     } else {
         next->fPrev = prev;
     }
 
-    rec->fNext = rec->fPrev = NULL;
+    rec->fNext = rec->fPrev = nullptr;
 }
 
 void SkResourceCache::moveToHead(Rec* rec) {
     if (fHead == rec) {
         return;
     }
 
     SkASSERT(fHead);
     SkASSERT(fTail);
 
     this->validate();
 
     this->detach(rec);
 
     fHead->fPrev = rec;
     rec->fNext = fHead;
     fHead = rec;
 
     this->validate();
 }
 
 void SkResourceCache::addToHead(Rec* rec) {
     this->validate();
 
-    rec->fPrev = NULL;
+    rec->fPrev = nullptr;
     rec->fNext = fHead;
     if (fHead) {
         fHead->fPrev = rec;
     }
     fHead = rec;
     if (!fTail) {
         fTail = rec;
     }
     fTotalBytesUsed += rec->bytesUsed();
     fCount += 1;
 
     this->validate();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 void SkResourceCache::validate() const {
-    if (NULL == fHead) {
-        SkASSERT(NULL == fTail);
+    if (nullptr == fHead) {
+        SkASSERT(nullptr == fTail);
         SkASSERT(0 == fTotalBytesUsed);
         return;
     }
 
     if (fHead == fTail) {
-        SkASSERT(NULL == fHead->fPrev);
-        SkASSERT(NULL == fHead->fNext);
+        SkASSERT(nullptr == fHead->fPrev);
+        SkASSERT(nullptr == fHead->fNext);
         SkASSERT(fHead->bytesUsed() == fTotalBytesUsed);
         return;
     }
 
-    SkASSERT(NULL == fHead->fPrev);
+    SkASSERT(nullptr == fHead->fPrev);
     SkASSERT(fHead->fNext);
-    SkASSERT(NULL == fTail->fNext);
+    SkASSERT(nullptr == fTail->fNext);
     SkASSERT(fTail->fPrev);
 
     size_t used = 0;
     int count = 0;
     const Rec* rec = fHead;
     while (rec) {
         count += 1;
         used += rec->bytesUsed();
         SkASSERT(used <= fTotalBytesUsed);
         rec = rec->fNext;
@@ skipping 30 matching lines @@
 size_t SkResourceCache::getSingleAllocationByteLimit() const {
     return fSingleAllocationByteLimit;
 }
 
 size_t SkResourceCache::getEffectiveSingleAllocationByteLimit() const {
     // fSingleAllocationByteLimit == 0 means the caller is asking for our default
     size_t limit = fSingleAllocationByteLimit;
 
     // if we're not discardable (i.e. we are fixed-budget) then cap the single-limit
     // to our budget.
-    if (NULL == fDiscardableFactory) {
+    if (nullptr == fDiscardableFactory) {
         if (0 == limit) {
             limit = fTotalByteLimit;
         } else {
             limit = SkTMin(limit, fTotalByteLimit);
         }
     }
     return limit;
 }
 
 void SkResourceCache::checkMessages() {
     SkTArray<PurgeSharedIDMessage> msgs;
     fPurgeSharedIDInbox.poll(&msgs);
     for (int i = 0; i < msgs.count(); ++i) {
         this->purgeSharedID(msgs[i].fSharedID);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DECLARE_STATIC_MUTEX(gMutex);
-static SkResourceCache* gResourceCache = NULL;
+static SkResourceCache* gResourceCache = nullptr;
 static void cleanup_gResourceCache() {
     // We'll clean this up in our own tests, but disable for clients.
     // Chrome seems to have funky multi-process things going on in unit tests that
     // makes this unsafe to delete when the main process atexit()s.
     // SkLazyPtr does the same sort of thing.
 #if SK_DEVELOPER
     delete gResourceCache;
 #endif
 }
 
 /** Must hold gMutex when calling. */
 static SkResourceCache* get_cache() {
     // gMutex is always held when this is called, so we don't need to be fancy in here.
     gMutex.assertHeld();
-    if (NULL == gResourceCache) {
+    if (nullptr == gResourceCache) {
 #ifdef SK_USE_DISCARDABLE_SCALEDIMAGECACHE
         gResourceCache = new SkResourceCache(SkDiscardableMemory::Create);
 #else
         gResourceCache = new SkResourceCache(SK_DEFAULT_IMAGE_CACHE_LIMIT);
 #endif
         atexit(cleanup_gResourceCache);
     }
     return gResourceCache;
 }
 
@@ skipping 106 matching lines @@
 /////////////
 
 static void dump_visitor(const SkResourceCache::Rec& rec, void*) {
     SkDebugf("RC: %12s bytes %9lu  discardable %p\n",
              rec.getCategory(), rec.bytesUsed(), rec.diagnostic_only_getDiscardable());
 }
 
 void SkResourceCache::TestDumpMemoryStatistics() {
     VisitAll(dump_visitor, nullptr);
 }