Add a simpler key type for scratch resource keys.

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 80 matching lines @@
     enum {
         /** Preferentially returns scratch resources with no pending IO. */
         kPreferNoPendingIO_ScratchFlag = 0x1,
         /** Will not return any resources that match but have pending IO. */
         kRequireNoPendingIO_ScratchFlag = 0x2,
     };
 
     /**
      * Find a resource that matches a scratch key.
      */
-    GrGpuResource* findAndRefScratchResource(const GrResourceKey& scratchKey, uint32_t flags = 0);
+    GrGpuResource* findAndRefScratchResource(const GrScratchKey& scratchKey, uint32_t flags = 0);
     
 #ifdef SK_DEBUG
     // This is not particularly fast and only used for validation, so debug only.
-    int countScratchEntriesForKey(const GrResourceKey& scratchKey) const {
-        SkASSERT(scratchKey.isScratch());
+    int countScratchEntriesForKey(const GrScratchKey& scratchKey) const {
         return fScratchMap.countForKey(scratchKey);
     }
 #endif
 
     /**
      * Find a resource that matches a content key.
      */
     GrGpuResource* findAndRefContentResource(const GrResourceKey& contentKey) {
-        SkASSERT(!contentKey.isScratch());
         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 {
-        SkASSERT(!contentKey.isScratch());
         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 41 matching lines @@
     void validate() const;
 #else
     void validate() const {}
 #endif
 
     class AutoValidate;
 
     class AvailableForScratchUse;
 
     struct ScratchMapTraits {
-        static const GrResourceKey& GetKey(const GrGpuResource& r) {
+        static const GrScratchKey& GetKey(const GrGpuResource& r) {
             return r.cacheAccess().getScratchKey();
         }
 
-        static uint32_t Hash(const GrResourceKey& key) { return key.getHash(); }
+        static uint32_t Hash(const GrScratchKey& key) { return key.hash(); }
     };
-    typedef SkTMultiMap<GrGpuResource, GrResourceKey, ScratchMapTraits> ScratchMap;
+    typedef SkTMultiMap<GrGpuResource, GrScratchKey, ScratchMapTraits> ScratchMap;
 
     struct ContentHashTraits {
         static const GrResourceKey& GetKey(const GrGpuResource& r) {
             return *r.cacheAccess().getContentKey();
         }
 
         static uint32_t Hash(const GrResourceKey& key) { return key.getHash(); }
     };
     typedef SkTDynamicHash<GrGpuResource, GrResourceKey, ContentHashTraits> ContentHash;
 
@@ skipping 91 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