Fix the speeling of "purgeable" in Gr code

src/gpu/GrResourceCache2.h

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrResourceCache2_DEFINED
 #define GrResourceCache2_DEFINED
@@ skipping 137 matching lines @@
 #if GR_GPU_STATS
     void printStats() const;
 #endif
 
 private:
     ///////////////////////////////////////////////////////////////////////////
     /// @name Methods accessible via ResourceAccess
     ////
     void insertResource(GrGpuResource*);
     void removeResource(GrGpuResource*);
-    void notifyPurgable(GrGpuResource*);
+    void notifyPurgeable(GrGpuResource*);
     void didChangeGpuMemorySize(const GrGpuResource*, size_t oldSize);
     bool didSetContentKey(GrGpuResource*);
     void willRemoveScratchKey(const GrGpuResource*);
     void didChangeBudgetStatus(GrGpuResource*);
     void makeResourceMRU(GrGpuResource*);
     /// @}
 
     void purgeAsNeeded() {
         if (fPurging || (fBudgetedCount <= fMaxCount && fBudgetedBytes <= fMaxBytes)) {
             return;
@@ skipping 54 matching lines @@
     // our current stats for all resources
     int                                 fCount;
     size_t                              fBytes;
 
     // our current stats for resources that count against the budget
     int                                 fBudgetedCount;
     size_t                              fBudgetedBytes;
 
     // prevents recursive purging
     bool                                fPurging;
-    bool                                fNewlyPurgableResourceWhilePurging;
+    bool                                fNewlyPurgeableResourceWhilePurging;
 
     PFOverBudgetCB                      fOverBudgetCB;
     void*                               fOverBudgetData;
 
 };
 
 class GrResourceCache2::ResourceAccess {
 private:
     ResourceAccess(GrResourceCache2* cache) : fCache(cache) { }
     ResourceAccess(const ResourceAccess& that) : fCache(that.fCache) { }
     ResourceAccess& operator=(const ResourceAccess&); // unimpl
 
     /**
      * Insert a resource into the cache.
      */
     void insertResource(GrGpuResource* resource) { fCache->insertResource(resource); }
 
     /**
      * Removes a resource from the cache.
      */
     void removeResource(GrGpuResource* resource) { fCache->removeResource(resource); }
 
     /**
-     * Called by GrGpuResources when they detects that they are newly purgable.
+     * Called by GrGpuResources when they detects that they are newly purgeable.
      */
-    void notifyPurgable(GrGpuResource* resource) { fCache->notifyPurgable(resource); }
+    void notifyPurgeable(GrGpuResource* resource) { fCache->notifyPurgeable(resource); }
 
     /**
      * Called by GrGpuResources when their sizes change.
      */
     void didChangeGpuMemorySize(const GrGpuResource* resource, size_t oldSize) {
         fCache->didChangeGpuMemorySize(resource, oldSize);
     }
 
     /**
      * Called by GrGpuResources when their content keys change.
@@ skipping 25 matching lines @@
 
     friend class GrGpuResource; // To access all the proxy inline methods.
     friend class GrResourceCache2; // To create this type.
 };
 
 inline GrResourceCache2::ResourceAccess GrResourceCache2::resourceAccess() {
     return ResourceAccess(this);
 }
 
 #endif