Allow GPU resources to not be counted against the cache budget.

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
+ *         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.
  */
 class GrResourceCache2 {
@@ skipping 118 matching lines @@
 
 private:
     ///////////////////////////////////////////////////////////////////////////
     /// @name Methods accessible via ResourceAccess
     ////
     void insertResource(GrGpuResource*);
     void removeResource(GrGpuResource*);
     void notifyPurgable(GrGpuResource*);
     void didChangeGpuMemorySize(const GrGpuResource*, size_t oldSize);
     bool didSetContentKey(GrGpuResource*);
+    void didChangeBudgetStatus(GrGpuResource*);
     void makeResourceMRU(GrGpuResource*);
     /// @}
 
     void purgeAsNeeded() {
         if (fPurging || (fBudgetedCount <= fMaxCount && fBudgetedBytes < fMaxBytes)) {
             return;
         }
         this->internalPurgeAsNeeded();
     }
 
@@ skipping 95 matching lines @@
     /**
      * 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); }
 
+
+    /**
+     * 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&();
 
     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