Rename GrContentKey to GrUniqueKey

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 109 matching lines @@
 /**
  * Base class for objects that can be kept in the GrResourceCache.
  */
 class SK_API GrGpuResource : public GrIORef<GrGpuResource> {
 public:
     SK_DECLARE_INST_COUNT(GrGpuResource)
 
     enum LifeCycle {
         /**
          * The resource is cached and owned by Skia. Resources with this status may be kept alive
-         * by the cache as either scratch or content resources even when there are no refs to them.
+         * by the cache as either scratch or unique resources even when there are no refs to them.
          * The cache may release them whenever there are no refs.
          */
         kCached_LifeCycle,
         /**
          * The resource is uncached. As soon as there are no more refs to it, it is released. Under
          * the hood the cache may opaquely recycle it as a cached resource.
          */
         kUncached_LifeCycle,
         /**
          * Similar to uncached, but Skia does not manage the lifetime of the underlying backend
@@ skipping 39 matching lines @@
         return fGpuMemorySize;
     }
 
     /**
      * Gets an id that is unique for this GrGpuResource object. It is static in that it does
      * not change when the content of the GrGpuResource object changes. This will never return
      * 0.
      */
     uint32_t getUniqueID() const { return fUniqueID; }
 
-    /** Returns the current content key for the resource. It will be invalid if the resource has not
-        been cached by its contents. */
-    const GrContentKey& getContentKey() const { return fContentKey; }
+    /** Returns the current unique key for the resource. It will be invalid if the resource has no
+        associated unique key. */
+    const GrUniqueKey& getUniqueKey() const { return fUniqueKey; }
 
     /**
      * Attach a custom data object to this resource. The data will remain attached
      * for the lifetime of this resource (until it is abandoned or released).
      * Takes a ref on data. Previously attached data, if any, is unrefed.
      * Returns the data argument, for convenience.
      */
     const SkData* setCustomData(const SkData* data);
 
     /**
@@ skipping 59 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 and ResourcePriv.
-    bool setContentKey(const GrContentKey& contentKey);
-    void removeContentKey();
+    bool setUniqueKey(const GrUniqueKey&);
+    void removeUniqueKey();
     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();
 
     // An index into a heap when this resource is purgeable or an array when not. This is maintained
     // by the cache.
     int                         fCacheArrayIndex;
     // This value reflects how recently this resource was accessed in the cache. This is maintained
     // by the cache.
     uint32_t                    fTimestamp;
 
     static const size_t kInvalidGpuMemorySize = ~static_cast<size_t>(0);
     GrScratchKey                fScratchKey;
-    GrContentKey                fContentKey;
+    GrUniqueKey                 fUniqueKey;
 
     // 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 notifyIsPurgeable.
 };
 
 #endif