Add specialized content key class for resources.

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 92 matching lines @@
 #ifdef SK_DEBUG
     // This is not particularly fast and only used for validation, so debug only.
     int countScratchEntriesForKey(const GrScratchKey& scratchKey) const {
         return fScratchMap.countForKey(scratchKey);
     }
 #endif
 
     /**
      * Find a resource that matches a content key.
      */
-    GrGpuResource* findAndRefContentResource(const GrResourceKey& contentKey) {
+    GrGpuResource* findAndRefContentResource(const GrContentKey& contentKey) {
         GrGpuResource* resource = fContentHash.find(contentKey);
         if (resource) {
             resource->ref();
             this->makeResourceMRU(resource);
         }
         return resource;
     }
 
     /**
      * Query whether a content key exists in the cache.
      */
-    bool hasContentKey(const GrResourceKey& contentKey) const {
+    bool hasContentKey(const GrContentKey& contentKey) const {
         return SkToBool(fContentHash.find(contentKey));
     }
 
     /** Purges all resources that don't have external owners. */
     void purgeAllUnlocked();
 
     /**
      * The callback function used by the cache when it is still over budget after a purge. The
      * passed in 'data' is the same 'data' handed to setOverbudgetCallback.
      */
@@ skipping 50 matching lines @@
     struct ScratchMapTraits {
         static const GrScratchKey& GetKey(const GrGpuResource& r) {
             return r.cacheAccess().getScratchKey();
         }
 
         static uint32_t Hash(const GrScratchKey& key) { return key.hash(); }
     };
     typedef SkTMultiMap<GrGpuResource, GrScratchKey, ScratchMapTraits> ScratchMap;
 
     struct ContentHashTraits {
-        static const GrResourceKey& GetKey(const GrGpuResource& r) {
-            return *r.cacheAccess().getContentKey();
+        static const GrContentKey& GetKey(const GrGpuResource& r) {
+            return r.cacheAccess().getContentKey();
         }
 
-        static uint32_t Hash(const GrResourceKey& key) { return key.getHash(); }
+        static uint32_t Hash(const GrContentKey& key) { return key.hash(); }
     };
-    typedef SkTDynamicHash<GrGpuResource, GrResourceKey, ContentHashTraits> ContentHash;
+    typedef SkTDynamicHash<GrGpuResource, GrContentKey, ContentHashTraits> ContentHash;
 
     typedef SkTInternalLList<GrGpuResource> ResourceList;
 
     ResourceList                        fResources;
     // This map holds all resources that can be used as scratch resources.
     ScratchMap                          fScratchMap;
     // This holds all resources that have content keys.
     ContentHash                         fContentHash;
 
     // our budget, used in purgeAsNeeded()
@@ skipping 82 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