Correct accounting for wrapped 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 29 matching lines @@
     /** Used to access functionality needed by GrGpuResource for lifetime management. */
     class ResourceAccess;
     ResourceAccess resourceAccess();
 
     /**
      * Sets the cache limits in terms of number of resources and max gpu memory byte size.
      */
     void setLimits(int count, size_t bytes);
 
     /**
-     * Returns the number of cached resources.
+     * Returns the number of resources.
      */
     int getResourceCount() const { return fCount; }
 
     /**
-     * Returns the number of bytes consumed by cached resources.
+     * Returns the number of resources that count against the budget.
+     */
+    int getBudgetedResourceCount() const { return fBudgetedCount; }
+
+    /**
+     * Returns the number of bytes consumed by resources.
      */
     size_t getResourceBytes() const { return fBytes; }
 
     /**
+     * Returns the number of bytes consumed by budgeted resources.
+     */
+    size_t getBudgetedResourceBytes() const { return fBudgetedBytes; }
+
+    /**
      * 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; }
 
     /**
@@ skipping 78 matching lines @@
     ////
     void insertResource(GrGpuResource*);
     void removeResource(GrGpuResource*);
     void notifyPurgable(GrGpuResource*);
     void didChangeGpuMemorySize(const GrGpuResource*, size_t oldSize);
     bool didSetContentKey(GrGpuResource*);
     void makeResourceMRU(GrGpuResource*);
     /// @}
 
     void purgeAsNeeded() {
-        if (fPurging || (fCount <= fMaxCount && fBytes < fMaxBytes)) {
+        if (fPurging || (fBudgetedCount <= fMaxCount && fBudgetedBytes < fMaxBytes)) {
             return;
         }
         this->internalPurgeAsNeeded();
     }
 
     void internalPurgeAsNeeded();
 
 #ifdef SK_DEBUG
     bool isInCache(const GrGpuResource* r) const { return fResources.isInList(r); }
     void validate() const;
@@ skipping 31 matching lines @@
     // 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;
+    int                                 fBudgetedHighWaterCount;
+    size_t                              fBudgetedHighWaterBytes;
 #endif
 
-    // our current stats, related to our budget
+    // our current stats for all resources
     int                                 fCount;
     size_t                              fBytes;
 
+    // our current stats for resources that count against the budget
+    int                                 fBudgetedCount;
+    size_t                              fBudgetedBytes;
+
     // prevents recursive purging
     bool                                fPurging;
     bool                                fNewlyPurgableResourceWhilePurging;
 
     PFOverBudgetCB                      fOverBudgetCB;
     void*                               fOverBudgetData;
 
 };
 
 class GrResourceCache2::ResourceAccess {
@@ skipping 42 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