Style Change: NULL->nullptr

src/core/SkBitmapHeap.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapHeap.h"
 #include "SkBitmap.h"
@@ skipping 47 matching lines @@
     } else if (a.fHeight < b.fHeight) {
         return true;
     }
     return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBitmapHeap::SkBitmapHeap(int32_t preferredSize, int32_t ownerCount)
     : INHERITED()
-    , fExternalStorage(NULL)
-    , fMostRecentlyUsed(NULL)
-    , fLeastRecentlyUsed(NULL)
+    , fExternalStorage(nullptr)
+    , fMostRecentlyUsed(nullptr)
+    , fLeastRecentlyUsed(nullptr)
     , fPreferredCount(preferredSize)
     , fOwnerCount(ownerCount)
     , fBytesAllocated(0)
     , fDeferAddingOwners(false) {
 }
 
 SkBitmapHeap::SkBitmapHeap(ExternalStorage* storage, int32_t preferredSize)
     : INHERITED()
     , fExternalStorage(storage)
-    , fMostRecentlyUsed(NULL)
-    , fLeastRecentlyUsed(NULL)
+    , fMostRecentlyUsed(nullptr)
+    , fLeastRecentlyUsed(nullptr)
     , fPreferredCount(preferredSize)
     , fOwnerCount(IGNORE_OWNERS)
     , fBytesAllocated(0)
     , fDeferAddingOwners(false) {
     SkSafeRef(storage);
 }
 
 SkBitmapHeap::~SkBitmapHeap() {
     SkDEBUGCODE(
     for (int i = 0; i < fStorage.count(); i++) {
@@ skipping 12 matching lines @@
     )
     SkASSERT(0 == fBytesAllocated);
     fStorage.deleteAll();
     SkSafeUnref(fExternalStorage);
     fLookupTable.deleteAll();
 }
 
 void SkBitmapHeap::removeFromLRU(SkBitmapHeap::LookupEntry* entry) {
     if (fMostRecentlyUsed == entry) {
         fMostRecentlyUsed = entry->fLessRecentlyUsed;
-        if (NULL == fMostRecentlyUsed) {
+        if (nullptr == fMostRecentlyUsed) {
             SkASSERT(fLeastRecentlyUsed == entry);
-            fLeastRecentlyUsed = NULL;
+            fLeastRecentlyUsed = nullptr;
         } else {
-            fMostRecentlyUsed->fMoreRecentlyUsed = NULL;
+            fMostRecentlyUsed->fMoreRecentlyUsed = nullptr;
         }
     } else {
         // Remove entry from its prior place, and make sure to cover the hole.
         if (fLeastRecentlyUsed == entry) {
-            SkASSERT(entry->fMoreRecentlyUsed != NULL);
+            SkASSERT(entry->fMoreRecentlyUsed != nullptr);
             fLeastRecentlyUsed = entry->fMoreRecentlyUsed;
         }
         // Since we have already considered the case where entry is the most recently used, it must
         // have a more recently used at this point.
-        SkASSERT(entry->fMoreRecentlyUsed != NULL);
+        SkASSERT(entry->fMoreRecentlyUsed != nullptr);
         entry->fMoreRecentlyUsed->fLessRecentlyUsed = entry->fLessRecentlyUsed;
 
-        if (entry->fLessRecentlyUsed != NULL) {
+        if (entry->fLessRecentlyUsed != nullptr) {
             SkASSERT(fLeastRecentlyUsed != entry);
             entry->fLessRecentlyUsed->fMoreRecentlyUsed = entry->fMoreRecentlyUsed;
         }
     }
-    entry->fMoreRecentlyUsed = NULL;
+    entry->fMoreRecentlyUsed = nullptr;
 }
 
 void SkBitmapHeap::appendToLRU(SkBitmapHeap::LookupEntry* entry) {
-    if (fMostRecentlyUsed != NULL) {
-        SkASSERT(NULL == fMostRecentlyUsed->fMoreRecentlyUsed);
+    if (fMostRecentlyUsed != nullptr) {
+        SkASSERT(nullptr == fMostRecentlyUsed->fMoreRecentlyUsed);
         fMostRecentlyUsed->fMoreRecentlyUsed = entry;
         entry->fLessRecentlyUsed = fMostRecentlyUsed;
     }
     fMostRecentlyUsed = entry;
-    if (NULL == fLeastRecentlyUsed) {
+    if (nullptr == fLeastRecentlyUsed) {
         fLeastRecentlyUsed = entry;
     }
 }
 
 // iterate through our LRU cache and try to find an entry to evict
 SkBitmapHeap::LookupEntry* SkBitmapHeap::findEntryToReplace(const SkBitmap& replacement) {
     SkASSERT(fPreferredCount != UNLIMITED_SIZE);
     SkASSERT(fStorage.count() >= fPreferredCount);
 
     SkBitmapHeap::LookupEntry* iter = fLeastRecentlyUsed;
-    while (iter != NULL) {
+    while (iter != nullptr) {
         SkBitmapHeapEntry* heapEntry = fStorage[iter->fStorageSlot];
         if (heapEntry->fRefCount > 0) {
             // If the least recently used bitmap has not been unreferenced
             // by its owner, then according to our LRU specifications a more
             // recently used one can not have used all its references yet either.
-            return NULL;
+            return nullptr;
         }
         if (replacement.getGenerationID() == iter->fGenerationId) {
             // Do not replace a bitmap with a new one using the same
             // pixel ref. Instead look for a different one that will
             // potentially free up more space.
             iter = iter->fMoreRecentlyUsed;
         } else {
             return iter;
         }
     }
-    return NULL;
+    return nullptr;
 }
 
 size_t SkBitmapHeap::freeMemoryIfPossible(size_t bytesToFree) {
     if (UNLIMITED_SIZE == fPreferredCount) {
         return 0;
     }
     LookupEntry* iter = fLeastRecentlyUsed;
     size_t origBytesAllocated = fBytesAllocated;
     // Purge starting from LRU until a non-evictable bitmap is found or until
     // everything is evicted.
-    while (iter != NULL) {
+    while (iter != nullptr) {
         SkBitmapHeapEntry* heapEntry = fStorage[iter->fStorageSlot];
         if (heapEntry->fRefCount > 0) {
             break;
         }
         LookupEntry* next = iter->fMoreRecentlyUsed;
         this->removeEntryFromLookupTable(iter);
         // Free the pixel memory. removeEntryFromLookupTable already reduced
         // fBytesAllocated properly.
         heapEntry->fBitmap.reset();
         // Add to list of unused slots which can be reused in the future.
         fUnusedSlots.push(heapEntry->fSlot);
         iter = next;
         if (origBytesAllocated - fBytesAllocated >= bytesToFree) {
             break;
         }
     }
 
     if (fLeastRecentlyUsed != iter) {
         // There was at least one eviction.
         fLeastRecentlyUsed = iter;
-        if (NULL == fLeastRecentlyUsed) {
+        if (nullptr == fLeastRecentlyUsed) {
             // Everything was evicted
-            fMostRecentlyUsed = NULL;
+            fMostRecentlyUsed = nullptr;
             fBytesAllocated -= (fStorage.count() * sizeof(SkBitmapHeapEntry));
             fStorage.deleteAll();
             fUnusedSlots.reset();
             SkASSERT(0 == fBytesAllocated);
         } else {
-            fLeastRecentlyUsed->fLessRecentlyUsed = NULL;
+            fLeastRecentlyUsed->fLessRecentlyUsed = nullptr;
         }
     }
 
     return origBytesAllocated - fBytesAllocated;
 }
 
 int SkBitmapHeap::findInLookupTable(const LookupEntry& indexEntry, SkBitmapHeapEntry** entry) {
     int index = SkTSearch<const LookupEntry, LookupEntry::Less>(
                                              (const LookupEntry**)fLookupTable.begin(),
                                              fLookupTable.count(),
                                              &indexEntry, sizeof(void*));
 
     if (index < 0) {
         // insert ourselves into the bitmapIndex
         index = ~index;
         *fLookupTable.insert(index) = new LookupEntry(indexEntry);
-    } else if (entry != NULL) {
+    } else if (entry != nullptr) {
         // populate the entry if needed
         *entry = fStorage[fLookupTable[index]->fStorageSlot];
     }
 
     return index;
 }
 
 bool SkBitmapHeap::copyBitmap(const SkBitmap& originalBitmap, SkBitmap& copiedBitmap) {
     SkASSERT(!fExternalStorage);
 
     // If the bitmap is mutable, we need to do a deep copy, since the
     // caller may modify it afterwards.
     if (originalBitmap.isImmutable()) {
         copiedBitmap = originalBitmap;
 // TODO if we have the pixel ref in the heap we could pass it here to avoid a potential deep copy
-//    else if (sharedPixelRef != NULL) {
+//    else if (sharedPixelRef != nullptr) {
 //        copiedBitmap = orig;
 //        copiedBitmap.setPixelRef(sharedPixelRef, originalBitmap.pixelRefOffset());
     } else if (originalBitmap.empty()) {
         copiedBitmap.reset();
     } else if (!originalBitmap.deepCopyTo(&copiedBitmap)) {
         return false;
     }
     copiedBitmap.setImmutable();
     return true;
 }
 
 int SkBitmapHeap::removeEntryFromLookupTable(LookupEntry* entry) {
     // remove the bitmap index for the deleted entry
     SkDEBUGCODE(int count = fLookupTable.count();)
-    int index = this->findInLookupTable(*entry, NULL);
+    int index = this->findInLookupTable(*entry, nullptr);
     // Verify that findInLookupTable found an existing entry rather than adding
     // a new entry to the lookup table.
     SkASSERT(count == fLookupTable.count());
     fBytesAllocated -= fStorage[entry->fStorageSlot]->fBytesAllocated;
     delete fLookupTable[index];
     fLookupTable.remove(index);
     return index;
 }
 
 int32_t SkBitmapHeap::insert(const SkBitmap& originalBitmap) {
-    SkBitmapHeapEntry* entry = NULL;
+    SkBitmapHeapEntry* entry = nullptr;
     int searchIndex = this->findInLookupTable(LookupEntry(originalBitmap), &entry);
 
     if (entry) {
         // Already had a copy of the bitmap in the heap.
         if (fOwnerCount != IGNORE_OWNERS) {
             if (fDeferAddingOwners) {
                 *fDeferredEntries.append() = entry->fSlot;
             } else {
                 entry->addReferences(fOwnerCount);
             }
         }
         if (fPreferredCount != UNLIMITED_SIZE) {
             LookupEntry* lookupEntry = fLookupTable[searchIndex];
             if (lookupEntry != fMostRecentlyUsed) {
                 this->removeFromLRU(lookupEntry);
                 this->appendToLRU(lookupEntry);
             }
         }
         return entry->fSlot;
     }
 
     // decide if we need to evict an existing heap entry or create a new one
     if (fPreferredCount != UNLIMITED_SIZE && fStorage.count() >= fPreferredCount) {
         // iterate through our LRU cache and try to find an entry to evict
         LookupEntry* lookupEntry = this->findEntryToReplace(originalBitmap);
-        if (lookupEntry != NULL) {
+        if (lookupEntry != nullptr) {
             // we found an entry to evict
             entry = fStorage[lookupEntry->fStorageSlot];
             // Remove it from the LRU. The new entry will be added to the LRU later.
             this->removeFromLRU(lookupEntry);
             int index = this->removeEntryFromLookupTable(lookupEntry);
 
             // update the current search index now that we have removed one
             if (index < searchIndex) {
                 searchIndex--;
             }
@@ skipping 66 matching lines @@
 
 void SkBitmapHeap::deferAddingOwners() {
     fDeferAddingOwners = true;
 }
 
 void SkBitmapHeap::endAddingOwnersDeferral(bool add) {
     if (add) {
         for (int i = 0; i < fDeferredEntries.count(); i++) {
             SkASSERT(fOwnerCount != IGNORE_OWNERS);
             SkBitmapHeapEntry* heapEntry = this->getEntry(fDeferredEntries[i]);
-            SkASSERT(heapEntry != NULL);
+            SkASSERT(heapEntry != nullptr);
             heapEntry->addReferences(fOwnerCount);
         }
     }
     fDeferAddingOwners = false;
     fDeferredEntries.reset();
 }