Style Change: NULL->nullptr

src/core/SkGlyphCache.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 "SkGlyphCache.h"
 #include "SkGlyphCache_Globals.h"
 #include "SkGraphics.h"
@@ skipping 25 matching lines @@
 #define kMinAllocAmount     ((sizeof(SkGlyph) + kMinGlyphImageSize) * kMinGlyphCount)
 
 SkGlyphCache::SkGlyphCache(SkTypeface* typeface, const SkDescriptor* desc, SkScalerContext* ctx)
     : fDesc(desc->copy())
     , fScalerContext(ctx)
     , fGlyphAlloc(kMinAllocAmount) {
     SkASSERT(typeface);
     SkASSERT(desc);
     SkASSERT(ctx);
 
-    fPrev = fNext = NULL;
+    fPrev = fNext = nullptr;
 
     fScalerContext->getFontMetrics(&fFontMetrics);
 
     fMemoryUsed = sizeof(*this);
 
-    fAuxProcList = NULL;
+    fAuxProcList = nullptr;
 }
 
 SkGlyphCache::~SkGlyphCache() {
     fGlyphMap.foreach ([](SkGlyph* g) { delete g->fPath; });
     SkDescriptor::Free(fDesc);
     delete fScalerContext;
     this->invokeAndRemoveAuxProcs();
 }
 
 SkGlyphCache::CharGlyphRec* SkGlyphCache::getCharGlyphRec(PackedUnicharID packedUnicharID) {
-    if (NULL == fPackedUnicharIDToPackedGlyphID.get()) {
+    if (nullptr == fPackedUnicharIDToPackedGlyphID.get()) {
         // Allocate the array.
         fPackedUnicharIDToPackedGlyphID.reset(kHashCount);
         // Initialize array to map character and position with the impossible glyph ID. This
         // represents no mapping.
         for (int i = 0; i <kHashCount; ++i) {
             fPackedUnicharIDToPackedGlyphID[i].fPackedUnicharID = SkGlyph::kImpossibleID;
             fPackedUnicharIDToPackedGlyphID[i].fPackedGlyphID = 0;
         }
     }
 
@@ skipping 80 matching lines @@
         rec->fPackedGlyphID = combinedID;
         return this->lookupByPackedGlyphID(combinedID, type);
     } else {
         return this->lookupByPackedGlyphID(rec->fPackedGlyphID, type);
     }
 }
 
 SkGlyph* SkGlyphCache::lookupByPackedGlyphID(PackedGlyphID packedGlyphID, MetricsType type) {
     SkGlyph* glyph = fGlyphMap.find(packedGlyphID);
 
-    if (NULL == glyph) {
+    if (nullptr == glyph) {
         glyph = this->allocateNewGlyph(packedGlyphID, type);
     } else {
         if (type == kFull_MetricsType && glyph->isJustAdvance()) {
            fScalerContext->getMetrics(glyph);
         }
     }
     return glyph;
 }
 
 SkGlyph* SkGlyphCache::allocateNewGlyph(PackedGlyphID packedGlyphID, MetricsType mtype) {
@@ skipping 12 matching lines @@
         SkASSERT(kFull_MetricsType == mtype);
         fScalerContext->getMetrics(glyphPtr);
     }
 
     SkASSERT(glyphPtr->fID != SkGlyph::kImpossibleID);
     return glyphPtr;
 }
 
 const void* SkGlyphCache::findImage(const SkGlyph& glyph) {
     if (glyph.fWidth > 0 && glyph.fWidth < kMaxGlyphWidth) {
-        if (NULL == glyph.fImage) {
+        if (nullptr == glyph.fImage) {
             size_t  size = glyph.computeImageSize();
             const_cast<SkGlyph&>(glyph).fImage = fGlyphAlloc.alloc(size,
                                         SkChunkAlloc::kReturnNil_AllocFailType);
             // check that alloc() actually succeeded
             if (glyph.fImage) {
                 fScalerContext->getImage(glyph);
                 // TODO: the scaler may have changed the maskformat during
                 // getImage (e.g. from AA or LCD to BW) which means we may have
                 // overallocated the buffer. Check if the new computedImageSize
                 // is smaller, and if so, strink the alloc size in fImageAlloc.
                 fMemoryUsed += size;
             }
         }
     }
     return glyph.fImage;
 }
 
 const SkPath* SkGlyphCache::findPath(const SkGlyph& glyph) {
     if (glyph.fWidth) {
-        if (glyph.fPath == NULL) {
+        if (glyph.fPath == nullptr) {
             const_cast<SkGlyph&>(glyph).fPath = new SkPath;
             fScalerContext->getPath(glyph, glyph.fPath);
             fMemoryUsed += sizeof(SkPath) +
                     glyph.fPath->countPoints() * sizeof(SkPoint);
         }
     }
     return glyph.fPath;
 }
 
 void SkGlyphCache::dump() const {
@@ skipping 25 matching lines @@
                 *dataPtr = rec->fData;
             }
             return true;
         }
         rec = rec->fNext;
     }
     return false;
 }
 
 void SkGlyphCache::setAuxProc(void (*proc)(void*), void* data) {
-    if (proc == NULL) {
+    if (proc == nullptr) {
         return;
     }
 
     AuxProcRec* rec = fAuxProcList;
     while (rec) {
         if (rec->fProc == proc) {
             rec->fData = data;
             return;
         }
         rec = rec->fNext;
@@ skipping 76 matching lines @@
     SkASSERT(desc);
 
     SkGlyphCache_Globals& globals = get_globals();
     SkGlyphCache*         cache;
 
     {
         AutoAcquire ac(globals.fLock);
 
         globals.validate();
 
-        for (cache = globals.internalGetHead(); cache != NULL; cache = cache->fNext) {
+        for (cache = globals.internalGetHead(); cache != nullptr; cache = cache->fNext) {
             if (cache->fDesc->equals(*desc)) {
                 globals.internalDetachCache(cache);
                 if (!proc(cache, context)) {
                     globals.internalAttachCacheToHead(cache);
-                    cache = NULL;
+                    cache = nullptr;
                 }
                 return cache;
             }
         }
     }
 
     // Check if we can create a scaler-context before creating the glyphcache.
     // If not, we may have exhausted OS/font resources, so try purging the
     // cache once and try again.
     {
         // pass true the first time, to notice if the scalercontext failed,
         // so we can try the purge.
         SkScalerContext* ctx = typeface->createScalerContext(desc, true);
         if (!ctx) {
             get_globals().purgeAll();
             ctx = typeface->createScalerContext(desc, false);
             SkASSERT(ctx);
         }
         cache = new SkGlyphCache(typeface, desc, ctx);
     }
 
     AutoValidate av(cache);
 
     if (!proc(cache, context)) {   // need to reattach
         globals.attachCacheToHead(cache);
-        cache = NULL;
+        cache = nullptr;
     }
     return cache;
 }
 
 void SkGlyphCache::AttachCache(SkGlyphCache* cache) {
     SkASSERT(cache);
-    SkASSERT(cache->fNext == NULL);
+    SkASSERT(cache->fNext == nullptr);
 
     get_globals().attachCacheToHead(cache);
 }
 
 static void dump_visitor(const SkGlyphCache& cache, void* context) {
     int* counter = (int*)context;
     int index = *counter;
     *counter += 1;
 
     const SkScalerContextRec& rec = cache.getScalerContext()->getRec();
@@ skipping 15 matching lines @@
     SkGlyphCache::VisitAll(dump_visitor, &counter);
 }
 
 void SkGlyphCache::VisitAll(Visitor visitor, void* context) {
     SkGlyphCache_Globals& globals = get_globals();
     AutoAcquire           ac(globals.fLock);
     SkGlyphCache*         cache;
 
     globals.validate();
 
-    for (cache = globals.internalGetHead(); cache != NULL; cache = cache->fNext) {
+    for (cache = globals.internalGetHead(); cache != nullptr; cache = cache->fNext) {
         visitor(*cache, context);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGlyphCache_Globals::attachCacheToHead(SkGlyphCache* cache) {
     AutoAcquire ac(fLock);
 
     this->validate();
@@ skipping 37 matching lines @@
     if (!countNeeded && !bytesNeeded) {
         return 0;
     }
 
     size_t  bytesFreed = 0;
     int     countFreed = 0;
 
     // we start at the tail and proceed backwards, as the linklist is in LRU
     // order, with unimportant entries at the tail.
     SkGlyphCache* cache = this->internalGetTail();
-    while (cache != NULL &&
+    while (cache != nullptr &&
            (bytesFreed < bytesNeeded || countFreed < countNeeded)) {
         SkGlyphCache* prev = cache->fPrev;
         bytesFreed += cache->fMemoryUsed;
         countFreed += 1;
 
         this->internalDetachCache(cache);
         delete cache;
         cache = prev;
     }
 
     this->validate();
 
 #ifdef SPEW_PURGE_STATUS
     if (countFreed) {
         SkDebugf("purging %dK from font cache [%d entries]\n",
                  (int)(bytesFreed >> 10), countFreed);
     }
 #endif
 
     return bytesFreed;
 }
 
 void SkGlyphCache_Globals::internalAttachCacheToHead(SkGlyphCache* cache) {
-    SkASSERT(NULL == cache->fPrev && NULL == cache->fNext);
+    SkASSERT(nullptr == cache->fPrev && nullptr == cache->fNext);
     if (fHead) {
         fHead->fPrev = cache;
         cache->fNext = fHead;
     }
     fHead = cache;
 
     fCacheCount += 1;
     fTotalMemoryUsed += cache->fMemoryUsed;
 }
 
 void SkGlyphCache_Globals::internalDetachCache(SkGlyphCache* cache) {
     SkASSERT(fCacheCount > 0);
     fCacheCount -= 1;
     fTotalMemoryUsed -= cache->fMemoryUsed;
 
     if (cache->fPrev) {
         cache->fPrev->fNext = cache->fNext;
     } else {
         fHead = cache->fNext;
     }
     if (cache->fNext) {
         cache->fNext->fPrev = cache->fPrev;
     }
-    cache->fPrev = cache->fNext = NULL;
+    cache->fPrev = cache->fNext = nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 
 void SkGlyphCache::validate() const {
 #ifdef SK_DEBUG_GLYPH_CACHE
     int count = fGlyphArray.count();
     for (int i = 0; i < count; i++) {
         const SkGlyph* glyph = &fGlyphArray[i];
         SkASSERT(glyph);
         if (glyph->fImage) {
             SkASSERT(fGlyphAlloc.contains(glyph->fImage));
         }
     }
 #endif
 }
 
 void SkGlyphCache_Globals::validate() const {
     size_t computedBytes = 0;
     int computedCount = 0;
 
     const SkGlyphCache* head = fHead;
-    while (head != NULL) {
+    while (head != nullptr) {
         computedBytes += head->fMemoryUsed;
         computedCount += 1;
         head = head->fNext;
     }
 
     SkASSERTF(fCacheCount == computedCount, "fCacheCount: %d, computedCount: %d", fCacheCount,
               computedCount);
     SkASSERTF(fTotalMemoryUsed == computedBytes, "fTotalMemoryUsed: %d, computedBytes: %d",
               fTotalMemoryUsed, computedBytes);
 }
@@ skipping 30 matching lines @@
 }
 
 void SkGraphics::PurgeFontCache() {
     get_globals().purgeAll();
     SkTypefaceCache::PurgeAll();
 }
 
 // TODO(herb): clean up TLS apis.
 size_t SkGraphics::GetTLSFontCacheLimit() { return 0; }
 void SkGraphics::SetTLSFontCacheLimit(size_t bytes) { }