Revert of Replace GrResourceCache with GrResourceCache2.

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
 
 #include "GrGpuResource.h"
 #include "GrGpuResourceCacheAccess.h"
 #include "GrResourceKey.h"
 #include "SkRefCnt.h"
 #include "SkTInternalLList.h"
 #include "SkTMultiMap.h"
 
 /**
- * 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 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
- *         creation. Currently it may only be set once and cannot be cleared. This restriction will
- *         be removed.
- * 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.
+ *  Eventual replacement for GrResourceCache. Currently it simply holds a list
+ *  of all GrGpuResource objects for a GrContext. It is used to invalidate all
+ *  the resources when necessary.
  */
 class GrResourceCache2 {
 public:
-    GrResourceCache2();
+    GrResourceCache2() : fCount(0) {};
     ~GrResourceCache2();
 
-    /** Used to access functionality needed by GrGpuResource for lifetime management. */
-    class ResourceAccess;
-    ResourceAccess resourceAccess();
+    void insertResource(GrGpuResource*);
 
-    /**
-     * Sets the cache limits in terms of number of resources and max gpu memory byte size.
-     */
-    void setLimits(int count, size_t bytes);
+    void removeResource(GrGpuResource*);
 
-    /**
-     * Returns the number of cached resources.
-     */
-    int getResourceCount() const { return fCount; }
+    // 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.
+    bool didSetContentKey(GrGpuResource*);
 
-    /**
-     * Returns the number of bytes consumed by cached resources.
-     */
-    size_t getResourceBytes() const { return fBytes; }
-
-    /**
-     * Returns the cached resources count budget.
-     */
-    int getMaxResourceCount() const { return fMaxCount; }
-
-    /**
-     * Returns the number of bytes consumed by cached resources.
-     */
-    size_t getMaxResourceBytes() const { return fMaxBytes; }
-
-    /**
-     * Abandons the backend API resources owned by all GrGpuResource objects and removes them from
-     * the cache.
-     */
     void abandonAll();
 
-    /**
-     * Releases the backend API resources owned by all GrGpuResource objects and removes them from
-     * the cache.
-     */
     void releaseAll();
 
     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);
     
 #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());
         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;
+        return SkSafeRef(fContentHash.find(contentKey));
     }
 
-    /**
-     * 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.
-     */
-    typedef void (*PFOverBudgetCB)(void* data);
-
-    /**
-     * Set the callback the cache should use when it is still over budget after a purge. The 'data'
-     * provided here will be passed back to the callback. Note that the cache will attempt to purge
-     * any resources newly freed by the callback.
-     */
-    void setOverBudgetCallback(PFOverBudgetCB overBudgetCB, void* data) {
-        fOverBudgetCB = overBudgetCB;
-        fOverBudgetData = data;
-    }
-
-#if GR_GPU_STATS
-    void printStats() const;
-#endif
-
 private:
-    ///////////////////////////////////////////////////////////////////////////
-    /// @name Methods accessible via ResourceAccess
-    ////
-    void insertResource(GrGpuResource*);
-    void removeResource(GrGpuResource*);
-    void notifyPurgable(const GrGpuResource*);
-    void didChangeGpuMemorySize(const GrGpuResource*, size_t oldSize);
-    bool didSetContentKey(GrGpuResource*);
-    void makeResourceMRU(GrGpuResource*);
-    /// @}
-
-    void purgeAsNeeded() {
-        if (fPurging || (fCount <= fMaxCount && fBytes < fMaxBytes)) {
-            return;
-        }
-        this->internalPurgeAsNeeded();
-    }
-
-    void internalPurgeAsNeeded();
-
 #ifdef SK_DEBUG
     bool isInCache(const GrGpuResource* r) const { return fResources.isInList(r); }
-    void validate() const;
-#else
-    void validate() const {}
 #endif
 
-    class AutoValidate;
-
     class AvailableForScratchUse;
 
     struct ScratchMapTraits {
         static const GrResourceKey& GetKey(const GrGpuResource& r) {
             return r.cacheAccess().getScratchKey();
         }
 
         static uint32_t Hash(const GrResourceKey& key) { return key.getHash(); }
     };
     typedef SkTMultiMap<GrGpuResource, GrResourceKey, 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;
 
-    typedef SkTInternalLList<GrGpuResource> ResourceList;
-
-    ResourceList                        fResources;
+    int                                 fCount;
+    SkTInternalLList<GrGpuResource>     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()
-    int                                 fMaxCount;
-    size_t                              fMaxBytes;
-
-#if GR_CACHE_STATS
-    int                                 fHighWaterCount;
-    size_t                              fHighWaterBytes;
-#endif
-
-    // our current stats, related to our budget
-    int                                 fCount;
-    size_t                              fBytes;
-
-    // prevents recursive purging
-    bool                                fPurging;
-    bool                                fNewlyPurgableResourceWhilePurging;
-
-    PFOverBudgetCB                      fOverBudgetCB;
-    void*                               fOverBudgetData;
-
 };
 
-class GrResourceCache2::ResourceAccess {
-private:
-    ResourceAccess(GrResourceCache2* cache) : fCache(cache) { }
-    ResourceAccess(const ResourceAccess& that) : fCache(that.fCache) { }
-    ResourceAccess& operator=(const ResourceAccess&); // unimpl
-
-    /**
-     * Insert a resource into the cache.
-     */
-    void insertResource(GrGpuResource* resource) { fCache->insertResource(resource); }
-
-    /**
-     * Removes a resource from the cache.
-     */
-    void removeResource(GrGpuResource* resource) { fCache->removeResource(resource); }
-
-    /**
-     * Called by GrGpuResources when they detects that they are newly purgable.
-     */
-    void notifyPurgable(const GrGpuResource* resource) { fCache->notifyPurgable(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.
-     *
-     * 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.
-     */
-    bool didSetContentKey(GrGpuResource* resource) { return fCache->didSetContentKey(resource); }
-
-    // No taking addresses of this type.
-    const ResourceAccess* operator&() const;
-    ResourceAccess* operator&();
-
-    GrResourceCache2* fCache;
-
-    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