Style Change: NULL->nullptr

src/gpu/GrResourceCache.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrResourceCache.h"
@@ skipping 54 matching lines @@
     , fMaxUnusedFlushes(kDefaultMaxUnusedFlushes)
 #if GR_CACHE_STATS
     , fHighWaterCount(0)
     , fHighWaterBytes(0)
     , fBudgetedHighWaterCount(0)
     , fBudgetedHighWaterBytes(0)
 #endif
     , fBytes(0)
     , fBudgetedCount(0)
     , fBudgetedBytes(0)
-    , fOverBudgetCB(NULL)
-    , fOverBudgetData(NULL)
-    , fFlushTimestamps(NULL)
+    , fOverBudgetCB(nullptr)
+    , fOverBudgetData(nullptr)
+    , fFlushTimestamps(nullptr)
     , fLastFlushTimestampIndex(0)
     , fPreferVRAMUseOverFlushes(caps->preferVRAMUseOverFlushes()) {
     SkDEBUGCODE(fCount = 0;)
-    SkDEBUGCODE(fNewlyPurgeableResourceForValidation = NULL;)
+    SkDEBUGCODE(fNewlyPurgeableResourceForValidation = nullptr;)
     this->resetFlushTimestamps();
 }
 
 GrResourceCache::~GrResourceCache() {
     this->releaseAll();
     delete[] fFlushTimestamps;
 }
 
 void GrResourceCache::setLimits(int count, size_t bytes, int maxUnusedFlushes) {
     fMaxCount = count;
     fMaxBytes = bytes;
     fMaxUnusedFlushes = maxUnusedFlushes;
     this->resetFlushTimestamps();
     this->purgeAsNeeded();
 }
 
 void GrResourceCache::resetFlushTimestamps() {
     delete[] fFlushTimestamps;
 
     // We assume this number is a power of two when wrapping indices into the timestamp array.
     fMaxUnusedFlushes = SkNextPow2(fMaxUnusedFlushes);
 
     // Since our implementation is to store the timestamps of the last fMaxUnusedFlushes flush calls
     // we just turn the feature off if that array would be large.
     static const int kMaxSupportedTimestampHistory = 128;
 
     if (fMaxUnusedFlushes > kMaxSupportedTimestampHistory) {
-        fFlushTimestamps = NULL;
+        fFlushTimestamps = nullptr;
         return;
     }
 
     fFlushTimestamps = new uint32_t[fMaxUnusedFlushes];
     fLastFlushTimestampIndex = 0;
     // Set all the historical flush timestamps to initially be at the beginning of time (timestamp
     // 0).
     sk_bzero(fFlushTimestamps, fMaxUnusedFlushes * sizeof(uint32_t));
 }
 
@@ skipping 132 matching lines @@
     SkASSERT(scratchKey.isValid());
 
     GrGpuResource* resource;
     if (flags & (kPreferNoPendingIO_ScratchFlag | kRequireNoPendingIO_ScratchFlag)) {
         resource = fScratchMap.find(scratchKey, AvailableForScratchUse(true));
         if (resource) {
             this->refAndMakeResourceMRU(resource);
             this->validate();
             return resource;
         } else if (flags & kRequireNoPendingIO_ScratchFlag) {
-            return NULL;
+            return nullptr;
         }
         // We would prefer to consume more available VRAM rather than flushing
         // immediately, but on ANGLE this can lead to starving of the GPU.
         if (fPreferVRAMUseOverFlushes && this->wouldFit(resourceSize)) {
             // kPrefer is specified, we didn't find a resource without pending io,
             // but there is still space in our budget for the resource so force
             // the caller to allocate a new resource.
-            return NULL;
+            return nullptr;
         }
     }
     resource = fScratchMap.find(scratchKey, AvailableForScratchUse(false));
     if (resource) {
         this->refAndMakeResourceMRU(resource);
         this->validate();
     }
     return resource;
 }
 
@@ skipping 14 matching lines @@
 }
 
 void GrResourceCache::changeUniqueKey(GrGpuResource* resource, const GrUniqueKey& newKey) {
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
 
     // Remove the entry for this resource if it already has a unique key.
     if (resource->getUniqueKey().isValid()) {
         SkASSERT(resource == fUniqueHash.find(resource->getUniqueKey()));
         fUniqueHash.remove(resource->getUniqueKey());
-        SkASSERT(NULL == fUniqueHash.find(resource->getUniqueKey()));
+        SkASSERT(nullptr == fUniqueHash.find(resource->getUniqueKey()));
     }
 
     // If another resource has the new key, remove its key then install the key on this resource.
     if (newKey.isValid()) {
         if (GrGpuResource* old = fUniqueHash.find(newKey)) {
             // If the old resource using the key is purgeable and is unreachable, then remove it.
             if (!old->resourcePriv().getScratchKey().isValid() && old->isPurgeable()) {
                 // release may call validate() which will assert that resource is in fUniqueHash
                 // if it has a valid key. So in debug reset the key here before we assign it.
                 SkDEBUGCODE(resource->cacheAccess().removeUniqueKey();)
                 old->cacheAccess().release();
             } else {
                 fUniqueHash.remove(newKey);
                 old->cacheAccess().removeUniqueKey();
             }
         }
-        SkASSERT(NULL == fUniqueHash.find(newKey));
+        SkASSERT(nullptr == fUniqueHash.find(newKey));
         resource->cacheAccess().setUniqueKey(newKey);
         fUniqueHash.add(resource);
     } else {
         resource->cacheAccess().removeUniqueKey();
     }
 
     this->validate();
 }
 
 void GrResourceCache::refAndMakeResourceMRU(GrGpuResource* resource) {
@@ skipping 23 matching lines @@
     if (SkToBool(ResourceAccess::kRefCntReachedZero_RefNotificationFlag & flags)) {
 #ifdef SK_DEBUG
         // When the timestamp overflows validate() is called. validate() checks that resources in
         // the nonpurgeable array are indeed not purgeable. However, the movement from the array to
         // the purgeable queue happens just below in this function. So we mark it as an exception.
         if (resource->isPurgeable()) {
             fNewlyPurgeableResourceForValidation = resource;
         }
 #endif
         resource->cacheAccess().setTimestamp(this->getNextTimestamp());
-        SkDEBUGCODE(fNewlyPurgeableResourceForValidation = NULL);
+        SkDEBUGCODE(fNewlyPurgeableResourceForValidation = nullptr);
     }
 
     if (!SkToBool(ResourceAccess::kAllCntsReachedZero_RefNotificationFlag & flags)) {
         SkASSERT(!resource->isPurgeable());
         return;
     }
 
     SkASSERT(resource->isPurgeable());
     this->removeFromNonpurgeableArray(resource);
     fPurgeableQueue.insert(resource);
@@ skipping 347 matching lines @@
         return true;
     }
     if (index < fNonpurgeableResources.count() && fNonpurgeableResources[index] == resource) {
         return true;
     }
     SkDEBUGFAIL("Resource index should be -1 or the resource should be in the cache.");
     return false;
 }
 
 #endif