Style Change: NULL->nullptr

src/lazy/SkDiscardableMemoryPool.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 "SkDiscardableMemory.h"
 #include "SkDiscardableMemoryPool.h"
 #include "SkImageGenerator.h"
@@ skipping 11 matching lines @@
 
 /**
  *  This non-global pool can be used for unit tests to verify that the
  *  pool works.
  */
 class DiscardableMemoryPool : public SkDiscardableMemoryPool {
 public:
     /**
      *  Without mutex, will be not be thread safe.
      */
-    DiscardableMemoryPool(size_t budget, SkBaseMutex* mutex = NULL);
+    DiscardableMemoryPool(size_t budget, SkBaseMutex* mutex = nullptr);
     virtual ~DiscardableMemoryPool();
 
     SkDiscardableMemory* create(size_t bytes) override;
 
     size_t getRAMUsed() override;
     void setRAMBudget(size_t budget) override;
     size_t getRAMBudget() override { return fBudget; }
 
     /** purges all unlocked DMs */
     void dumpPool() override;
@@ skipping 49 matching lines @@
     const size_t                 fBytes;
 };
 
 PoolDiscardableMemory::PoolDiscardableMemory(DiscardableMemoryPool* pool,
                                              void* pointer,
                                              size_t bytes)
     : fPool(pool)
     , fLocked(true)
     , fPointer(pointer)
     , fBytes(bytes) {
-    SkASSERT(fPool != NULL);
-    SkASSERT(fPointer != NULL);
+    SkASSERT(fPool != nullptr);
+    SkASSERT(fPointer != nullptr);
     SkASSERT(fBytes > 0);
     fPool->ref();
 }
 
 PoolDiscardableMemory::~PoolDiscardableMemory() {
     SkASSERT(!fLocked); // contract for SkDiscardableMemory
     fPool->free(this);
     fPool->unref();
 }
 
@@ skipping 25 matching lines @@
     #endif  // SK_LAZY_CACHE_STATS
 }
 DiscardableMemoryPool::~DiscardableMemoryPool() {
     // PoolDiscardableMemory objects that belong to this pool are
     // always deleted before deleting this pool since each one has a
     // ref to the pool.
     SkASSERT(fList.isEmpty());
 }
 
 void DiscardableMemoryPool::dumpDownTo(size_t budget) {
-    if (fMutex != NULL) {
+    if (fMutex != nullptr) {
         fMutex->assertHeld();
     }
     if (fUsed <= budget) {
         return;
     }
     typedef SkTInternalLList<PoolDiscardableMemory>::Iter Iter;
     Iter iter;
     PoolDiscardableMemory* cur = iter.init(fList, Iter::kTail_IterStart);
     while ((fUsed > budget) && (cur)) {
         if (!cur->fLocked) {
             PoolDiscardableMemory* dm = cur;
-            SkASSERT(dm->fPointer != NULL);
+            SkASSERT(dm->fPointer != nullptr);
             sk_free(dm->fPointer);
-            dm->fPointer = NULL;
+            dm->fPointer = nullptr;
             SkASSERT(fUsed >= dm->fBytes);
             fUsed -= dm->fBytes;
             cur = iter.prev();
             // Purged DMs are taken out of the list.  This saves times
             // looking them up.  Purged DMs are NOT deleted.
             fList.remove(dm);
         } else {
             cur = iter.prev();
         }
     }
 }
 
 SkDiscardableMemory* DiscardableMemoryPool::create(size_t bytes) {
     void* addr = sk_malloc_flags(bytes, 0);
-    if (NULL == addr) {
-        return NULL;
+    if (nullptr == addr) {
+        return nullptr;
     }
     PoolDiscardableMemory* dm = new PoolDiscardableMemory(this, addr, bytes);
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
     fList.addToHead(dm);
     fUsed += bytes;
     this->dumpDownTo(fBudget);
     return dm;
 }
 
 void DiscardableMemoryPool::free(PoolDiscardableMemory* dm) {
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
     // This is called by dm's destructor.
-    if (dm->fPointer != NULL) {
+    if (dm->fPointer != nullptr) {
         sk_free(dm->fPointer);
-        dm->fPointer = NULL;
+        dm->fPointer = nullptr;
         SkASSERT(fUsed >= dm->fBytes);
         fUsed -= dm->fBytes;
         fList.remove(dm);
     } else {
         SkASSERT(!fList.isInList(dm));
     }
 }
 
 bool DiscardableMemoryPool::lock(PoolDiscardableMemory* dm) {
-    SkASSERT(dm != NULL);
-    if (NULL == dm->fPointer) {
+    SkASSERT(dm != nullptr);
+    if (nullptr == dm->fPointer) {
         #if SK_LAZY_CACHE_STATS
         SkAutoMutexAcquire autoMutexAcquire(fMutex);
         ++fCacheMisses;
         #endif  // SK_LAZY_CACHE_STATS
         return false;
     }
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
-    if (NULL == dm->fPointer) {
+    if (nullptr == dm->fPointer) {
         // May have been purged while waiting for lock.
         #if SK_LAZY_CACHE_STATS
         ++fCacheMisses;
         #endif  // SK_LAZY_CACHE_STATS
         return false;
     }
     dm->fLocked = true;
     fList.remove(dm);
     fList.addToHead(dm);
     #if SK_LAZY_CACHE_STATS
     ++fCacheHits;
     #endif  // SK_LAZY_CACHE_STATS
     return true;
 }
 
 void DiscardableMemoryPool::unlock(PoolDiscardableMemory* dm) {
-    SkASSERT(dm != NULL);
+    SkASSERT(dm != nullptr);
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
     dm->fLocked = false;
     this->dumpDownTo(fBudget);
 }
 
 size_t DiscardableMemoryPool::getRAMUsed() {
     return fUsed;
 }
 void DiscardableMemoryPool::setRAMBudget(size_t budget) {
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
@@ skipping 18 matching lines @@
     return new DiscardableMemoryPool(size, mutex);
 }
 
 SK_DECLARE_STATIC_LAZY_PTR(SkDiscardableMemoryPool, global, create_global_pool);
 
 SkDiscardableMemoryPool* SkGetGlobalDiscardableMemoryPool() {
     return global.get();
 }
 
 ////////////////////////////////////////////////////////////////////////////////