Allow GrGpuResources' unique keys to be changed.

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 14 matching lines @@
 /**
  * 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
  *         should never change. Resources need not have a scratch key.
  *      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.
+ *         resource may have a given unique key. The unique key can be set, cleared, or changed
+ *         anytime after resource creation.
+ *
  * 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.
  */
 class GrResourceCache {
 public:
     GrResourceCache();
     ~GrResourceCache();
 
     /** Used to access functionality needed by GrGpuResource for lifetime management. */
@@ skipping 124 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 didSetUniqueKey(GrGpuResource*);
+    void changeUniqueKey(GrGpuResource*, const GrUniqueKey&);
+    void removeUniqueKey(GrGpuResource*);
     void willRemoveScratchKey(const GrGpuResource*);
-    void willRemoveUniqueKey(const GrGpuResource*);
     void didChangeBudgetStatus(GrGpuResource*);
     void refAndMakeResourceMRU(GrGpuResource*);
     /// @}
 
     void internalPurgeAsNeeded();
     void processInvalidUniqueKeys(const SkTArray<GrUniqueKeyInvalidatedMessage>&);
     void addToNonpurgeableArray(GrGpuResource*);
     void removeFromNonpurgeableArray(GrGpuResource*);
     bool overBudget() const { return fBudgetedBytes > fMaxBytes || fBudgetedCount > fMaxCount; }
 
@@ skipping 95 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 unique keys change.
-     *
-     * This currently returns a bool and fails when an existing resource has a key that collides
-     * 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.
+     * Called by GrGpuResources to change their unique keys.
      */
-    bool didSetUniqueKey(GrGpuResource* resource) { return fCache->didSetUniqueKey(resource); }
-
-    /**
-     * Called by a GrGpuResource when it removes its unique key.
-     */
-    void willRemoveUniqueKey(GrGpuResource* resource) {
-        return fCache->willRemoveUniqueKey(resource);
+    void changeUniqueKey(GrGpuResource* resource, const GrUniqueKey& newKey) {
+         fCache->changeUniqueKey(resource, newKey);
     }
 
     /**
+     * Called by a GrGpuResource to remove its unique key.
+     */
+    void removeUniqueKey(GrGpuResource* resource) { fCache->removeUniqueKey(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