Fix the speeling of "purgeable" in Gr code

include/gpu/GrGpuResource.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 GrGpuResource_DEFINED
 #define GrGpuResource_DEFINED
 
@@ skipping 16 matching lines @@
  *   1) Normal ref (+ by ref(), - by unref()): These are used by code that is issuing draw calls
  *      that read and write the resource via GrDrawTarget and by any object that must own a
  *      GrGpuResource and is itself owned (directly or indirectly) by Skia-client code.
  *   2) Pending read (+ by addPendingRead(), - by completedRead()): GrContext has scheduled a read
  *      of the resource by the GPU as a result of a skia API call but hasn't executed it yet.
  *   3) Pending write (+ by addPendingWrite(), - by completedWrite()): GrContext has scheduled a
  *      write to the resource by the GPU as a result of a skia API call but hasn't executed it yet.
  *
  * The latter two ref types are private and intended only for Gr core code.
  *
- * When an item is purgable DERIVED:notifyIsPurgable() will be called (static poly morphism using
+ * When an item is purgeable DERIVED:notifyIsPurgeable() will be called (static poly morphism using
  * CRTP). GrIORef and GrGpuResource are separate classes for organizational reasons and to be
  * able to give access via friendship to only the functions related to pending IO operations.
  */
 template <typename DERIVED> class GrIORef : public SkNoncopyable {
 public:
     SK_DECLARE_INST_COUNT(GrIORef)
 
     // Some of the signatures are written to mirror SkRefCnt so that GrGpuResource can work with
     // templated helper classes (e.g. SkAutoTUnref). However, we have different categories of
     // refs (e.g. pending reads). We also don't require thread safety as GrCacheable objects are
@@ skipping 14 matching lines @@
         SkASSERT(fRefCnt >= 0);
         SkASSERT(fPendingReads >= 0);
         SkASSERT(fPendingWrites >= 0);
         SkASSERT(fRefCnt + fPendingReads + fPendingWrites >= 0);
 #endif
     }
 
 protected:
     GrIORef() : fRefCnt(1), fPendingReads(0), fPendingWrites(0) { }
 
-    bool isPurgable() const { return !this->internalHasRef() && !this->internalHasPendingIO(); }
+    bool isPurgeable() const { return !this->internalHasRef() && !this->internalHasPendingIO(); }
 
     bool internalHasPendingRead() const { return SkToBool(fPendingReads); }
     bool internalHasPendingWrite() const { return SkToBool(fPendingWrites); }
     bool internalHasPendingIO() const { return SkToBool(fPendingWrites | fPendingReads); }
 
     bool internalHasRef() const { return SkToBool(fRefCnt); }
 
 private:
     void addPendingRead() const {
         this->validate();
@@ skipping 13 matching lines @@
 
     void completedWrite() const {
         this->validate();
         --fPendingWrites;
         this->didUnref();
     }
 
 private:
     void didUnref() const {
         if (0 == fPendingReads && 0 == fPendingWrites && 0 == fRefCnt) {
-            static_cast<const DERIVED*>(this)->notifyIsPurgable();
+            static_cast<const DERIVED*>(this)->notifyIsPurgeable();
         }
     }
 
     mutable int32_t fRefCnt;
     mutable int32_t fPendingReads;
     mutable int32_t fPendingWrites;
 
     // This class is used to manage conversion of refs to pending reads/writes.
     friend class GrGpuResourceRef;
     friend class GrResourceCache2; // to check IO ref counts.
@@ skipping 136 matching lines @@
 private:
     /**
      * Frees the object in the underlying 3D API. Called by CacheAccess.
      */
     void release();
 
     virtual size_t onGpuMemorySize() const = 0;
 
     // See comments in CacheAccess.
     bool setContentKey(const GrContentKey& contentKey);
-    void notifyIsPurgable() const;
+    void notifyIsPurgeable() const;
     void removeScratchKey();
     void makeBudgeted();
     void makeUnbudgeted();
 
 #ifdef SK_DEBUG
     friend class GrGpu; // for assert in GrGpu to access getGpu
 #endif
 
     static uint32_t CreateUniqueID();
 
     // We're in an internal doubly linked list owned by GrResourceCache2
     SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrGpuResource);
 
 
     static const size_t kInvalidGpuMemorySize = ~static_cast<size_t>(0);
     GrScratchKey                fScratchKey;
     GrContentKey                fContentKey;
 
     // This is not ref'ed but abandon() or release() will be called before the GrGpu object
     // is destroyed. Those calls set will this to NULL.
     GrGpu*                      fGpu;
     mutable size_t              fGpuMemorySize;
 
     LifeCycle                   fLifeCycle;
     const uint32_t              fUniqueID;
 
     SkAutoTUnref<const SkData>  fData;
 
     typedef GrIORef<GrGpuResource> INHERITED;
-    friend class GrIORef<GrGpuResource>; // to access notifyIsPurgable.
+    friend class GrIORef<GrGpuResource>; // to access notifyIsPurgeable.
 };
 
 #endif