Replace uses of GR_DEBUG by SK_DEBUG.

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 19 matching lines @@
     // we assume ownership of the resource, and will unref it when we die
     SkASSERT(resource);
     resource->ref();
 }
 
 GrResourceEntry::~GrResourceEntry() {
     fResource->setCacheEntry(NULL);
     fResource->unref();
 }
 
-#if GR_DEBUG
+#ifdef SK_DEBUG
 void GrResourceEntry::validate() const {
     SkASSERT(fResource);
     SkASSERT(fResource->getCacheEntry() == this);
     fResource->validate();
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrResourceCache::GrResourceCache(int maxCount, size_t maxBytes) :
@@ skipping 169 matching lines @@
 }
 
 void GrResourceCache::makeExclusive(GrResourceEntry* entry) {
     GrAutoResourceCacheValidate atcv(this);
 
     // When scratch textures are detached (to hide them from future finds) they
     // still count against the resource budget
     this->internalDetach(entry, kIgnore_BudgetBehavior);
     fCache.remove(entry->key(), entry);
 
-#if GR_DEBUG
+#ifdef SK_DEBUG
     fExclusiveList.addToHead(entry);
 #endif
 }
 
 void GrResourceCache::removeInvalidResource(GrResourceEntry* entry) {
     // If the resource went invalid while it was detached then purge it
     // This can happen when a 3D context was lost,
     // the client called GrContext::contextDestroyed() to notify Gr,
     // and then later an SkGpuDevice's destructor releases its backing
     // texture (which was invalidated at contextDestroyed time).
     fClientDetachedCount -= 1;
     fEntryCount -= 1;
     size_t size = entry->resource()->sizeInBytes();
     fClientDetachedBytes -= size;
     fEntryBytes -= size;
 }
 
 void GrResourceCache::makeNonExclusive(GrResourceEntry* entry) {
     GrAutoResourceCacheValidate atcv(this);
 
-#if GR_DEBUG
+#ifdef SK_DEBUG
     fExclusiveList.remove(entry);
 #endif
 
     if (entry->resource()->isValid()) {
         // Since scratch textures still count against the cache budget even
         // when they have been removed from the cache, re-adding them doesn't
         // alter the budget information.
         attachToHead(entry, kIgnore_BudgetBehavior);
         fCache.insert(entry->key(), entry);
     } else {
@@ skipping 91 matching lines @@
     // we can have one GrResource holding a lock on another
     // 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
+#ifdef SK_DEBUG
     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.
         SkASSERT(fEntryCount == fClientDetachedCount);
         SkASSERT(fEntryBytes == fClientDetachedBytes);
         SkASSERT(fList.isEmpty());
     }
 #endif
 
     fMaxBytes = savedMaxBytes;
     fMaxCount = savedMaxCount;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#if GR_DEBUG
+#ifdef SK_DEBUG
 size_t GrResourceCache::countBytes(const EntryList& list) {
     size_t bytes = 0;
 
     EntryList::Iter iter;
 
     const GrResourceEntry* entry = iter.init(const_cast<EntryList&>(list),
                                              EntryList::Iter::kTail_IterStart);
 
     for ( ; NULL != entry; entry = iter.prev()) {
         bytes += entry->resource()->sizeInBytes();
@@ skipping 41 matching lines @@
     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 // GR_DEBUG
+#endif // SK_DEBUG
 
 #if GR_CACHE_STATS
 
 void GrResourceCache::printStats() {
     int locked = 0;
 
     EntryList::Iter iter;
 
     GrResourceEntry* entry = iter.init(fList, EntryList::Iter::kTail_IterStart);
 
@@ skipping 10 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
 
 ///////////////////////////////////////////////////////////////////////////////