"NULL !=" = NULL

src/gpu/GrResourceCache.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
@@ skipping 99 matching lines @@
         fCache.remove(entry->fKey, entry);
 
         // remove from our llist
         this->internalDetach(entry);
 
         delete entry;
     }
 }
 
 void GrResourceCache::getLimits(int* maxResources, size_t* maxResourceBytes) const{
-    if (NULL != maxResources) {
+    if (maxResources) {
         *maxResources = fMaxCount;
     }
-    if (NULL != maxResourceBytes) {
+    if (maxResourceBytes) {
         *maxResourceBytes = fMaxBytes;
     }
 }
 
 void GrResourceCache::setLimits(int maxResources, size_t maxResourceBytes) {
     bool smaller = (maxResources < fMaxCount) || (maxResourceBytes < fMaxBytes);
 
     fMaxCount = maxResources;
     fMaxBytes = maxResourceBytes;
 
@@ skipping 202 matching lines @@
         return;
     }
 
     fPurging = true;
 
     this->purgeInvalidated();
 
     this->internalPurge(extraCount, extraBytes);
     if (((fEntryCount+extraCount) > fMaxCount ||
         (fEntryBytes+extraBytes) > fMaxBytes) &&
-        NULL != fOverbudgetCB) {
+        fOverbudgetCB) {
         // Despite the purge we're still over budget. See if Ganesh can
         // release some resources and purge again.
         if ((*fOverbudgetCB)(fOverbudgetData)) {
             this->internalPurge(extraCount, extraBytes);
         }
     }
 
     fPurging = false;
 }
 
@@ skipping 38 matching lines @@
         EntryList::Iter iter;
 
         changed = false;
 
         // Note: the following code relies on the fact that the
         // doubly linked list doesn't invalidate its data/pointers
         // outside of the specific area where a deletion occurs (e.g.,
         // in internalDetach)
         GrResourceCacheEntry* entry = iter.init(fList, EntryList::Iter::kTail_IterStart);
 
-        while (NULL != entry) {
+        while (entry) {
             GrAutoResourceCacheValidate atcv(this);
 
             if ((fEntryCount+extraCount) <= fMaxCount &&
                 (fEntryBytes+extraBytes) <= fMaxBytes) {
                 withinBudget = true;
                 break;
             }
 
             GrResourceCacheEntry* prev = iter.prev();
             if (entry->fResource->unique()) {
@@ skipping 39 matching lines @@
 
 #ifdef SK_DEBUG
 size_t GrResourceCache::countBytes(const EntryList& list) {
     size_t bytes = 0;
 
     EntryList::Iter iter;
 
     const GrResourceCacheEntry* entry = iter.init(const_cast<EntryList&>(list),
                                                   EntryList::Iter::kTail_IterStart);
 
-    for ( ; NULL != entry; entry = iter.prev()) {
+    for ( ; entry; entry = iter.prev()) {
         bytes += entry->resource()->gpuMemorySize();
     }
     return bytes;
 }
 
 static bool both_zero_or_nonzero(int count, size_t bytes) {
     return (count == 0 && bytes == 0) || (count > 0 && bytes > 0);
 }
 
 void GrResourceCache::validate() const {
     fList.validate();
     fExclusiveList.validate();
     SkASSERT(both_zero_or_nonzero(fEntryCount, fEntryBytes));
     SkASSERT(both_zero_or_nonzero(fClientDetachedCount, fClientDetachedBytes));
     SkASSERT(fClientDetachedBytes <= fEntryBytes);
     SkASSERT(fClientDetachedCount <= fEntryCount);
     SkASSERT((fEntryCount - fClientDetachedCount) == fCache.count());
 
     EntryList::Iter iter;
 
     // check that the exclusively held entries are okay
     const GrResourceCacheEntry* entry = iter.init(const_cast<EntryList&>(fExclusiveList),
                                                   EntryList::Iter::kHead_IterStart);
 
-    for ( ; NULL != entry; entry = iter.next()) {
+    for ( ; entry; entry = iter.next()) {
         entry->validate();
     }
 
     // check that the shareable entries are okay
     entry = iter.init(const_cast<EntryList&>(fList), EntryList::Iter::kHead_IterStart);
 
     int count = 0;
-    for ( ; NULL != entry; entry = iter.next()) {
+    for ( ; entry; entry = iter.next()) {
         entry->validate();
         SkASSERT(fCache.find(entry->key()));
         count += 1;
     }
     SkASSERT(count == fEntryCount - fClientDetachedCount);
 
     size_t bytes = countBytes(fList);
     SkASSERT(bytes == fEntryBytes  - fClientDetachedBytes);
 
     bytes = countBytes(fExclusiveList);
     SkASSERT(bytes == fClientDetachedBytes);
 
     SkASSERT(fList.countEntries() == fEntryCount - fClientDetachedCount);
 
     SkASSERT(fExclusiveList.countEntries() == fClientDetachedCount);
 }
 #endif // SK_DEBUG
 
 #if GR_CACHE_STATS
 
 void GrResourceCache::printStats() {
     int locked = 0;
 
     EntryList::Iter iter;
 
     GrResourceCacheEntry* entry = iter.init(fList, EntryList::Iter::kTail_IterStart);
 
-    for ( ; NULL != entry; entry = iter.prev()) {
+    for ( ; entry; entry = iter.prev()) {
         if (entry->fResource->getRefCnt() > 1) {
             ++locked;
         }
     }
 
     SkDebugf("Budget: %d items %d bytes\n", fMaxCount, fMaxBytes);
     SkDebugf("\t\tEntry Count: current %d (%d locked) high %d\n",
                 fEntryCount, locked, fHighWaterEntryCount);
     SkDebugf("\t\tEntry Bytes: current %d high %d\n",
                 fEntryBytes, fHighWaterEntryBytes);
     SkDebugf("\t\tDetached Entry Count: current %d high %d\n",
                 fClientDetachedCount, fHighWaterClientDetachedCount);
     SkDebugf("\t\tDetached Bytes: current %d high %d\n",
                 fClientDetachedBytes, fHighWaterClientDetachedBytes);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////