Fix the speeling of "purgeable" in Gr code

src/gpu/GrResourceCache2.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 "GrResourceCache2.h"
@@ skipping 54 matching lines @@
     , fHighWaterCount(0)
     , fHighWaterBytes(0)
     , fBudgetedHighWaterCount(0)
     , fBudgetedHighWaterBytes(0)
 #endif
     , fCount(0)
     , fBytes(0)
     , fBudgetedCount(0)
     , fBudgetedBytes(0)
     , fPurging(false)
-    , fNewlyPurgableResourceWhilePurging(false)
+    , fNewlyPurgeableResourceWhilePurging(false)
     , fOverBudgetCB(NULL)
     , fOverBudgetData(NULL) {
 }
 
 GrResourceCache2::~GrResourceCache2() {
     this->releaseAll();
 }
 
 void GrResourceCache2::setLimits(int count, size_t bytes) {
     fMaxCount = count;
@@ skipping 152 matching lines @@
 }
 
 void GrResourceCache2::makeResourceMRU(GrGpuResource* resource) {
     SkASSERT(!fPurging);
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
     fResources.remove(resource);    
     fResources.addToHead(resource);
 }
 
-void GrResourceCache2::notifyPurgable(GrGpuResource* resource) {
+void GrResourceCache2::notifyPurgeable(GrGpuResource* resource) {
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
-    SkASSERT(resource->isPurgable());
+    SkASSERT(resource->isPurgeable());
 
     // We can't purge if in the middle of purging because purge is iterating. Instead record
-    // that additional resources became purgable.
+    // that additional resources became purgeable.
     if (fPurging) {
-        fNewlyPurgableResourceWhilePurging = true;
+        fNewlyPurgeableResourceWhilePurging = true;
         return;
     }
 
     bool release = false;
 
     if (resource->cacheAccess().isWrapped()) {
         release = true;
     } else if (!resource->cacheAccess().isBudgeted()) {
         // Check whether this resource could still be used as a scratch resource.
         if (resource->cacheAccess().getScratchKey().isValid()) {
@@ skipping 69 matching lines @@
     } else {
         --fBudgetedCount;
         fBudgetedBytes -= size;
     }
 
     this->validate();
 }
 
 void GrResourceCache2::internalPurgeAsNeeded() {
     SkASSERT(!fPurging);
-    SkASSERT(!fNewlyPurgableResourceWhilePurging);
+    SkASSERT(!fNewlyPurgeableResourceWhilePurging);
     SkASSERT(fBudgetedCount > fMaxCount || fBudgetedBytes > fMaxBytes);
 
     fPurging = true;
 
     bool overBudget = true;
     do {
-        fNewlyPurgableResourceWhilePurging = false;
+        fNewlyPurgeableResourceWhilePurging = false;
         ResourceList::Iter resourceIter;
         GrGpuResource* resource = resourceIter.init(fResources,
                                                     ResourceList::Iter::kTail_IterStart);
 
         while (resource) {
             GrGpuResource* prev = resourceIter.prev();
-            if (resource->isPurgable()) {
+            if (resource->isPurgeable()) {
                 resource->cacheAccess().release();
             }
             resource = prev;
             if (fBudgetedCount <= fMaxCount && fBudgetedBytes <= fMaxBytes) {
                 overBudget = false;
                 resource = NULL;
             }
         }
 
-        if (!fNewlyPurgableResourceWhilePurging && overBudget && fOverBudgetCB) {
+        if (!fNewlyPurgeableResourceWhilePurging && overBudget && fOverBudgetCB) {
             // Despite the purge we're still over budget. Call our over budget callback.
             (*fOverBudgetCB)(fOverBudgetData);
         }
-    } while (overBudget && fNewlyPurgableResourceWhilePurging);
+    } while (overBudget && fNewlyPurgeableResourceWhilePurging);
 
-    fNewlyPurgableResourceWhilePurging = false;
+    fNewlyPurgeableResourceWhilePurging = false;
     fPurging = false;
     this->validate();
 }
 
 void GrResourceCache2::purgeAllUnlocked() {
     SkASSERT(!fPurging);
-    SkASSERT(!fNewlyPurgableResourceWhilePurging);
+    SkASSERT(!fNewlyPurgeableResourceWhilePurging);
 
     fPurging = true;
 
     do {
-        fNewlyPurgableResourceWhilePurging = false;
+        fNewlyPurgeableResourceWhilePurging = false;
         ResourceList::Iter resourceIter;
         GrGpuResource* resource =
             resourceIter.init(fResources, ResourceList::Iter::kTail_IterStart);
 
         while (resource) {
             GrGpuResource* prev = resourceIter.prev();
-            if (resource->isPurgable()) {
+            if (resource->isPurgeable()) {
                 resource->cacheAccess().release();
             }
             resource = prev;
         }
 
-        if (!fNewlyPurgableResourceWhilePurging && fCount && fOverBudgetCB) {
+        if (!fNewlyPurgeableResourceWhilePurging && fCount && fOverBudgetCB) {
             (*fOverBudgetCB)(fOverBudgetData);
         }
-    } while (fNewlyPurgableResourceWhilePurging);
+    } while (fNewlyPurgeableResourceWhilePurging);
     fPurging = false;
     this->validate();
 }
 
 #ifdef SK_DEBUG
 void GrResourceCache2::validate() const {
     // Reduce the frequency of validations for large resource counts.
     static SkRandom gRandom;
     int mask = (SkNextPow2(fCount + 1) >> 5) - 1;
     if (~mask && (gRandom.nextU() & mask)) {
         return;
     }
 
     size_t bytes = 0;
     int count = 0;
     int budgetedCount = 0;
     size_t budgetedBytes = 0;
     int locked = 0;
     int scratch = 0;
     int couldBeScratch = 0;
     int content = 0;
 
     ResourceList::Iter iter;
     GrGpuResource* resource = iter.init(fResources, ResourceList::Iter::kHead_IterStart);
     for ( ; resource; resource = iter.next()) {
         bytes += resource->gpuMemorySize();
         ++count;
 
-        if (!resource->isPurgable()) {
+        if (!resource->isPurgeable()) {
             ++locked;
         }
 
         if (resource->cacheAccess().isScratch()) {
             SkASSERT(!resource->cacheAccess().getContentKey().isValid());
             ++scratch;
             SkASSERT(fScratchMap.countForKey(resource->cacheAccess().getScratchKey()));
             SkASSERT(!resource->cacheAccess().isWrapped());
         } else if (resource->cacheAccess().getScratchKey().isValid()) {
             SkASSERT(!resource->cacheAccess().isBudgeted() ||
@@ skipping 26 matching lines @@
     SkASSERT(fBudgetedHighWaterCount <= fHighWaterCount);
     SkASSERT(fBudgetedHighWaterBytes <= fHighWaterBytes);
     SkASSERT(bytes <= fHighWaterBytes);
     SkASSERT(count <= fHighWaterCount);
     SkASSERT(budgetedBytes <= fBudgetedHighWaterBytes);
     SkASSERT(budgetedCount <= fBudgetedHighWaterCount);
 #endif
     SkASSERT(content == fContentHash.count());
     SkASSERT(scratch + couldBeScratch == fScratchMap.count());
 
-    // This assertion is not currently valid because we can be in recursive notifyIsPurgable()
+    // This assertion is not currently valid because we can be in recursive notifyIsPurgeable()
     // calls. This will be fixed when subresource registration is explicit.
     // bool overBudget = budgetedBytes > fMaxBytes || budgetedCount > fMaxCount;
     // SkASSERT(!overBudget || locked == count || fPurging);
 }
 #endif
 
 #if GR_CACHE_STATS
 void GrResourceCache2::printStats() const {
     this->validate();
 
     int locked = 0;
     int scratch = 0;
     int wrapped = 0;
     size_t unbudgetedSize = 0;
 
     ResourceList::Iter iter;
     GrGpuResource* resource = iter.init(fResources, ResourceList::Iter::kHead_IterStart);
 
     for ( ; resource; resource = iter.next()) {
-        if (!resource->isPurgable()) {
+        if (!resource->isPurgeable()) {
             ++locked;
         }
         if (resource->cacheAccess().isScratch()) {
             ++scratch;
         }
         if (resource->cacheAccess().isWrapped()) {
             ++wrapped;
         }
         if (!resource->cacheAccess().isBudgeted()) {
             unbudgetedSize += resource->gpuMemorySize();
         }
     }
 
     float countUtilization = (100.f * fBudgetedCount) / fMaxCount;
     float byteUtilization = (100.f * fBudgetedBytes) / fMaxBytes;
 
     SkDebugf("Budget: %d items %d bytes\n", fMaxCount, fMaxBytes);
     SkDebugf("\t\tEntry Count: current %d"
              " (%d budgeted, %d wrapped, %d locked, %d scratch %.2g%% full), high %d\n",
         fCount, fBudgetedCount, wrapped, locked, scratch, countUtilization, fHighWaterCount);
     SkDebugf("\t\tEntry Bytes: current %d (budgeted %d, %.2g%% full, %d unbudgeted) high %d\n",
                 fBytes, fBudgetedBytes, byteUtilization, unbudgetedSize, fHighWaterBytes);
 }
 
 #endif