Rename GrContentKey to GrUniqueKey

src/gpu/GrResourceCache.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 GrResourceCache_DEFINED
 #define GrResourceCache_DEFINED
@@ skipping 11 matching lines @@
 
 class SkString;
 
 /**
  * Manages the lifetime of all GrGpuResource instances.
  *
  * Resources may have optionally have two types of keys:
  *      1) A scratch key. This is for resources whose allocations are cached but not their contents.
  *         Multiple resources can share the same scratch key. This is so a caller can have two
  *         resource instances with the same properties (e.g. multipass rendering that ping-pongs
- *         between two temporary surfaces. The scratch key is set at resource creation time and
+ *         between two temporary surfaces). The scratch key is set at resource creation time and
  *         should never change. Resources need not have a scratch key.
- *      2) A content key. This key represents the contents of the resource rather than just its
- *         allocation properties. They may not collide. The content key can be set after resource
+ *      2) A unique key. This key's meaning is specific to the domain that created the key. Only one
+ *         resource may have a given unique key. The unique key can be set after resource creation
  *         creation. Currently it may only be set once and cannot be cleared. This restriction will
  *         be removed.
+ * A unique key always takes precedence over a scratch key when a resource has both types of keys.
  * If a resource has neither key type then it will be deleted as soon as the last reference to it
- * is dropped. If a key has both keys the content key takes precedence.
+ * is dropped.
  */
 class GrResourceCache {
 public:
     GrResourceCache();
     ~GrResourceCache();
 
     /** Used to access functionality needed by GrGpuResource for lifetime management. */
     class ResourceAccess;
     ResourceAccess resourceAccess();
 
@@ skipping 59 matching lines @@
     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 GrScratchKey& scratchKey) const {
         return fScratchMap.countForKey(scratchKey);
     }
 #endif
 
     /**
-     * Find a resource that matches a content key.
+     * Find a resource that matches a unique key.
      */
-    GrGpuResource* findAndRefContentResource(const GrContentKey& contentKey) {
-        GrGpuResource* resource = fContentHash.find(contentKey);
+    GrGpuResource* findAndRefUniqueResource(const GrUniqueKey& key) {
+        GrGpuResource* resource = fUniqueHash.find(key);
         if (resource) {
             this->refAndMakeResourceMRU(resource);
         }
         return resource;
     }
 
     /**
-     * Query whether a content key exists in the cache.
+     * Query whether a unique key exists in the cache.
      */
-    bool hasContentKey(const GrContentKey& contentKey) const {
-        return SkToBool(fContentHash.find(contentKey));
+    bool hasUniqueKey(const GrUniqueKey& key) const {
+        return SkToBool(fUniqueHash.find(key));
     }
 
-    /** Purges resources to become under budget and processes resources with invalidated content
+    /** Purges resources to become under budget and processes resources with invalidated unique
         keys. */
     void purgeAsNeeded() {
-        SkTArray<GrContentKeyInvalidatedMessage> invalidKeyMsgs;
-        fInvalidContentKeyInbox.poll(&invalidKeyMsgs);
+        SkTArray<GrUniqueKeyInvalidatedMessage> invalidKeyMsgs;
+        fInvalidUniqueKeyInbox.poll(&invalidKeyMsgs);
         if (invalidKeyMsgs.count()) {
-            this->processInvalidContentKeys(invalidKeyMsgs);
+            this->processInvalidUniqueKeys(invalidKeyMsgs);
         }
         if (fBudgetedCount <= fMaxCount && fBudgetedBytes <= fMaxBytes) {
             return;
         }
         this->internalPurgeAsNeeded();
     }
 
     /** Purges all resources that don't have external owners. */
     void purgeAllUnlocked();
 
@@ skipping 18 matching lines @@
 #endif
 
 private:
     ///////////////////////////////////////////////////////////////////////////
     /// @name Methods accessible via ResourceAccess
     ////
     void insertResource(GrGpuResource*);
     void removeResource(GrGpuResource*);
     void notifyPurgeable(GrGpuResource*);
     void didChangeGpuMemorySize(const GrGpuResource*, size_t oldSize);
-    bool didSetContentKey(GrGpuResource*);
+    bool didSetUniqueKey(GrGpuResource*);
     void willRemoveScratchKey(const GrGpuResource*);
-    void willRemoveContentKey(const GrGpuResource*);
+    void willRemoveUniqueKey(const GrGpuResource*);
     void didChangeBudgetStatus(GrGpuResource*);
     void refAndMakeResourceMRU(GrGpuResource*);
     /// @}
 
     void internalPurgeAsNeeded();
-    void processInvalidContentKeys(const SkTArray<GrContentKeyInvalidatedMessage>&);
+    void processInvalidUniqueKeys(const SkTArray<GrUniqueKeyInvalidatedMessage>&);
     void addToNonpurgeableArray(GrGpuResource*);
     void removeFromNonpurgeableArray(GrGpuResource*);
     bool overBudget() const { return fBudgetedBytes > fMaxBytes || fBudgetedCount > fMaxCount; }
 
 #ifdef SK_DEBUG
     bool isInCache(const GrGpuResource* r) const;
     void validate() const;
 #else
     void validate() const {}
 #endif
 
     class AutoValidate;
 
     class AvailableForScratchUse;
 
     struct ScratchMapTraits {
         static const GrScratchKey& GetKey(const GrGpuResource& r) {
             return r.resourcePriv().getScratchKey();
         }
 
         static uint32_t Hash(const GrScratchKey& key) { return key.hash(); }
     };
     typedef SkTMultiMap<GrGpuResource, GrScratchKey, ScratchMapTraits> ScratchMap;
 
-    struct ContentHashTraits {
-        static const GrContentKey& GetKey(const GrGpuResource& r) {
-            return r.getContentKey();
-        }
+    struct UniqueHashTraits {
+        static const GrUniqueKey& GetKey(const GrGpuResource& r) { return r.getUniqueKey(); }
 
-        static uint32_t Hash(const GrContentKey& key) { return key.hash(); }
+        static uint32_t Hash(const GrUniqueKey& key) { return key.hash(); }
     };
-    typedef SkTDynamicHash<GrGpuResource, GrContentKey, ContentHashTraits> ContentHash;
+    typedef SkTDynamicHash<GrGpuResource, GrUniqueKey, UniqueHashTraits> UniqueHash;
 
     static bool CompareTimestamp(GrGpuResource* const& a, GrGpuResource* const& b) {
         return a->cacheAccess().timestamp() < b->cacheAccess().timestamp();
     }
 
     static int* AccessResourceIndex(GrGpuResource* const& res) {
         return res->cacheAccess().accessCacheIndex();
     }
 
-    typedef SkMessageBus<GrContentKeyInvalidatedMessage>::Inbox InvalidContentKeyInbox;
+    typedef SkMessageBus<GrUniqueKeyInvalidatedMessage>::Inbox InvalidUniqueKeyInbox;
     typedef SkTDPQueue<GrGpuResource*, CompareTimestamp, AccessResourceIndex> PurgeableQueue;
     typedef SkTDArray<GrGpuResource*> ResourceArray;
 
     // Whenever a resource is added to the cache or the result of a cache lookup, fTimestamp is
     // assigned as the resource's timestamp and then incremented. fPurgeableQueue orders the
     // purgeable resources by this value, and thus is used to purge resources in LRU order.
     uint32_t                            fTimestamp;
     PurgeableQueue                      fPurgeableQueue;
     ResourceArray                       fNonpurgeableResources;
 
     // This map holds all resources that can be used as scratch resources.
     ScratchMap                          fScratchMap;
-    // This holds all resources that have content keys.
-    ContentHash                         fContentHash;
+    // This holds all resources that have unique keys.
+    UniqueHash                          fUniqueHash;
 
     // our budget, used in purgeAsNeeded()
     int                                 fMaxCount;
     size_t                              fMaxBytes;
 
 #if GR_CACHE_STATS
     int                                 fHighWaterCount;
     size_t                              fHighWaterBytes;
     int                                 fBudgetedHighWaterCount;
     size_t                              fBudgetedHighWaterBytes;
 #endif
 
     // our current stats for all resources
     SkDEBUGCODE(int                     fCount;)
     size_t                              fBytes;
 
     // our current stats for resources that count against the budget
     int                                 fBudgetedCount;
     size_t                              fBudgetedBytes;
 
     PFOverBudgetCB                      fOverBudgetCB;
     void*                               fOverBudgetData;
 
-    InvalidContentKeyInbox              fInvalidContentKeyInbox;
+    InvalidUniqueKeyInbox               fInvalidUniqueKeyInbox;
 };
 
 class GrResourceCache::ResourceAccess {
 private:
     ResourceAccess(GrResourceCache* cache) : fCache(cache) { }
     ResourceAccess(const ResourceAccess& that) : fCache(that.fCache) { }
     ResourceAccess& operator=(const ResourceAccess&); // unimpl
 
     /**
      * Insert a resource into the cache.
@@ skipping 11 matching lines @@
     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.
+     * Called by GrGpuResources when their unique keys change.
      *
      * This currently returns a bool and fails when an existing resource has a key that collides
-     * with the new content key. In the future it will null out the content key for the existing
-     * resource. The failure is a temporary measure taken because duties are split between two
-     * cache objects currently.
+     * with the new key. In the future it will null out the unique key for the existing resource.
+     * The failure is a temporary measure which will be fixed soon.
      */
-    bool didSetContentKey(GrGpuResource* resource) { return fCache->didSetContentKey(resource); }
+    bool didSetUniqueKey(GrGpuResource* resource) { return fCache->didSetUniqueKey(resource); }
 
     /**
-     * Called by a GrGpuResource when it removes its content key.
+     * Called by a GrGpuResource when it removes its unique key.
      */
-    void willRemoveContentKey(GrGpuResource* resource) {
-        return fCache->willRemoveContentKey(resource);
+    void willRemoveUniqueKey(GrGpuResource* resource) {
+        return fCache->willRemoveUniqueKey(resource);
     }
 
     /**
      * Called by a GrGpuResource when it removes its scratch key.
      */
     void willRemoveScratchKey(const GrGpuResource* resource) {
         fCache->willRemoveScratchKey(resource);
     }
 
     /**
      * Called by GrGpuResources when they change from budgeted to unbudgeted or vice versa.
      */
     void didChangeBudgetStatus(GrGpuResource* resource) { fCache->didChangeBudgetStatus(resource); }
 
     // No taking addresses of this type.
     const ResourceAccess* operator&() const;
     ResourceAccess* operator&();
 
     GrResourceCache* fCache;
 
     friend class GrGpuResource; // To access all the proxy inline methods.
     friend class GrResourceCache; // To create this type.
 };
 
 inline GrResourceCache::ResourceAccess GrResourceCache::resourceAccess() {
     return ResourceAccess(this);
 }
 
 #endif