Replace uses of GrAssert by SkASSERT.

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 10 matching lines @@
     }
 
     return static_cast<ResourceType>(type);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrResourceEntry::GrResourceEntry(const GrResourceKey& key, GrResource* resource)
         : fKey(key), fResource(resource) {
     // we assume ownership of the resource, and will unref it when we die
-    GrAssert(resource);
+    SkASSERT(resource);
     resource->ref();
 }
 
 GrResourceEntry::~GrResourceEntry() {
     fResource->setCacheEntry(NULL);
     fResource->unref();
 }
 
 #if GR_DEBUG
 void GrResourceEntry::validate() const {
-    GrAssert(fResource);
-    GrAssert(fResource->getCacheEntry() == this);
+    SkASSERT(fResource);
+    SkASSERT(fResource->getCacheEntry() == this);
     fResource->validate();
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrResourceCache::GrResourceCache(int maxCount, size_t maxBytes) :
         fMaxCount(maxCount),
         fMaxBytes(maxBytes) {
 #if GR_CACHE_STATS
@@ skipping 65 matching lines @@
 #if GR_CACHE_STATS
         if (fHighWaterClientDetachedCount < fClientDetachedCount) {
             fHighWaterClientDetachedCount = fClientDetachedCount;
         }
         if (fHighWaterClientDetachedBytes < fClientDetachedBytes) {
             fHighWaterClientDetachedBytes = fClientDetachedBytes;
         }
 #endif
 
     } else {
-        GrAssert(kAccountFor_BudgetBehavior == behavior);
+        SkASSERT(kAccountFor_BudgetBehavior == behavior);
 
         fEntryCount -= 1;
         fEntryBytes -= entry->resource()->sizeInBytes();
     }
 }
 
 void GrResourceCache::attachToHead(GrResourceEntry* entry,
                                    BudgetBehaviors behavior) {
     fList.addToHead(entry);
 
     // update our stats
     if (kIgnore_BudgetBehavior == behavior) {
         fClientDetachedCount -= 1;
         fClientDetachedBytes -= entry->resource()->sizeInBytes();
     } else {
-        GrAssert(kAccountFor_BudgetBehavior == behavior);
+        SkASSERT(kAccountFor_BudgetBehavior == behavior);
 
         fEntryCount += 1;
         fEntryBytes += entry->resource()->sizeInBytes();
 
 #if GR_CACHE_STATS
         if (fHighWaterEntryCount < fEntryCount) {
             fHighWaterEntryCount = fEntryCount;
         }
         if (fHighWaterEntryBytes < fEntryBytes) {
             fHighWaterEntryBytes = fEntryBytes;
@@ skipping 36 matching lines @@
         this->internalDetach(entry);
         this->attachToHead(entry);
     }
 
     return entry->fResource;
 }
 
 void GrResourceCache::addResource(const GrResourceKey& key,
                                   GrResource* resource,
                                   uint32_t ownershipFlags) {
-    GrAssert(NULL == resource->getCacheEntry());
+    SkASSERT(NULL == resource->getCacheEntry());
     // we don't expect to create new resources during a purge. In theory
     // this could cause purgeAsNeeded() into an infinite loop (e.g.
     // each resource destroyed creates and locks 2 resources and
     // unlocks 1 thereby causing a new purge).
-    GrAssert(!fPurging);
+    SkASSERT(!fPurging);
     GrAutoResourceCacheValidate atcv(this);
 
     GrResourceEntry* entry = SkNEW_ARGS(GrResourceEntry, (key, resource));
     resource->setCacheEntry(entry);
 
     this->attachToHead(entry);
     fCache.insert(key, entry);
 
     if (ownershipFlags & kHide_OwnershipFlag) {
         this->makeExclusive(entry);
@@ skipping 74 matching lines @@
         // release some resources and purge again.
         if ((*fOverbudgetCB)(fOverbudgetData)) {
             this->internalPurge(extraCount, extraBytes);
         }
     }
 
     fPurging = false;
 }
 
 void GrResourceCache::deleteResource(GrResourceEntry* entry) {
-    GrAssert(1 == entry->fResource->getRefCnt());
+    SkASSERT(1 == entry->fResource->getRefCnt());
 
     // remove from our cache
     fCache.remove(entry->key(), entry);
 
     // remove from our llist
     this->internalDetach(entry);
     delete entry;
 }
 
 void GrResourceCache::internalPurge(int extraCount, size_t extraBytes) {
@@ skipping 41 matching lines @@
     // so we don't want to just do a simple loop kicking each
     // entry out. Instead change the budget and purge.
 
     int savedMaxBytes = fMaxBytes;
     int savedMaxCount = fMaxCount;
     fMaxBytes = (size_t) -1;
     fMaxCount = 0;
     this->purgeAsNeeded();
 
 #if GR_DEBUG
-    GrAssert(fExclusiveList.countEntries() == fClientDetachedCount);
-    GrAssert(countBytes(fExclusiveList) == fClientDetachedBytes);
+    SkASSERT(fExclusiveList.countEntries() == fClientDetachedCount);
+    SkASSERT(countBytes(fExclusiveList) == fClientDetachedBytes);
     if (!fCache.count()) {
         // Items may have been detached from the cache (such as the backing
         // texture for an SkGpuDevice). The above purge would not have removed
         // them.
-        GrAssert(fEntryCount == fClientDetachedCount);
-        GrAssert(fEntryBytes == fClientDetachedBytes);
-        GrAssert(fList.isEmpty());
+        SkASSERT(fEntryCount == fClientDetachedCount);
+        SkASSERT(fEntryBytes == fClientDetachedBytes);
+        SkASSERT(fList.isEmpty());
     }
 #endif
 
     fMaxBytes = savedMaxBytes;
     fMaxCount = savedMaxCount;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #if GR_DEBUG
@@ skipping 11 matching lines @@
     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();
-    GrAssert(both_zero_or_nonzero(fEntryCount, fEntryBytes));
-    GrAssert(both_zero_or_nonzero(fClientDetachedCount, fClientDetachedBytes));
-    GrAssert(fClientDetachedBytes <= fEntryBytes);
-    GrAssert(fClientDetachedCount <= fEntryCount);
-    GrAssert((fEntryCount - fClientDetachedCount) == fCache.count());
+    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());
 
     fCache.validate();
 
 
     EntryList::Iter iter;
 
     // check that the exclusively held entries are okay
     const GrResourceEntry* entry = iter.init(const_cast<EntryList&>(fExclusiveList),
                                              EntryList::Iter::kHead_IterStart);
 
     for ( ; NULL != 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()) {
         entry->validate();
-        GrAssert(fCache.find(entry->key()));
+        SkASSERT(fCache.find(entry->key()));
         count += 1;
     }
-    GrAssert(count == fEntryCount - fClientDetachedCount);
+    SkASSERT(count == fEntryCount - fClientDetachedCount);
 
     size_t bytes = countBytes(fList);
-    GrAssert(bytes == fEntryBytes  - fClientDetachedBytes);
+    SkASSERT(bytes == fEntryBytes  - fClientDetachedBytes);
 
     bytes = countBytes(fExclusiveList);
-    GrAssert(bytes == fClientDetachedBytes);
+    SkASSERT(bytes == fClientDetachedBytes);
 
-    GrAssert(fList.countEntries() == fEntryCount - fClientDetachedCount);
+    SkASSERT(fList.countEntries() == fEntryCount - fClientDetachedCount);
 
-    GrAssert(fExclusiveList.countEntries() == fClientDetachedCount);
+    SkASSERT(fExclusiveList.countEntries() == fClientDetachedCount);
 }
 #endif // GR_DEBUG
 
 #if GR_CACHE_STATS
 
 void GrResourceCache::printStats() {
     int locked = 0;
 
     EntryList::Iter iter;
 
@@ skipping 12 matching lines @@
                 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
 
 ///////////////////////////////////////////////////////////////////////////////