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

include/gpu/GrGpuResource.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 GrGpuResource_DEFINED
 #define GrGpuResource_DEFINED
 
@@ skipping 173 matching lines @@
 
     GrGpu* getGpu() const { return fGpu; }
 
     /** Overridden to free GPU resources in the backend API. */
     virtual void onRelease() { }
     /** Overridden to abandon any internal handles, ptrs, etc to backend API resources.
         This may be called when the underlying 3D context is no longer valid and so no
         backend API calls should be made. */
     virtual void onAbandon() { }
 
-    bool isWrapped() const { return kWrapped_FlagBit & fFlags; }
+    bool isWrapped() const { return SkToBool(kWrapped_Flag & fFlags); }
 
     /**
      * This entry point should be called whenever gpuMemorySize() should report a different size.
      * The cache will call gpuMemorySize() to update the current size of the resource.
      */
     void didChangeGpuMemorySize() const;
 
     /**
      * Optionally called by the GrGpuResource subclass if the resource can be used as scratch.
      * By default resources are not usable as scratch. This should only be called once.
      **/
     void setScratchKey(const GrResourceKey& scratchKey);
 
 private:
     /**
      * Frees the object in the underlying 3D API. Called by CacheAccess.
      */
     void release();
 
     /**
      * Removes references to objects in the underlying 3D API without freeing them. 
      * Called by CacheAccess.
      */
     void abandon();
 
     virtual size_t onGpuMemorySize() const = 0;
 
     // See comments in CacheAccess.
     bool setContentKey(const GrResourceKey& contentKey);
-
+    void setBudgeted(bool countsAgainstBudget);
     void notifyIsPurgable() const;
 
 #ifdef SK_DEBUG
     friend class GrGpu; // for assert in GrGpu to access getGpu
 #endif
 
     static uint32_t CreateUniqueID();
 
     // We're in an internal doubly linked list owned by GrResourceCache2
     SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrGpuResource);
 
-    // This is not ref'ed but abandon() or release() will be called before the GrGpu object
-    // is destroyed. Those calls set will this to NULL.
-    GrGpu* fGpu;
 
+    static const size_t kInvalidGpuMemorySize = ~static_cast<size_t>(0);
     enum Flags {
         /**
-         * This object wraps a GPU object given to us by the user.
-         * Lifetime management is left up to the user (i.e., we will not
-         * free it).
+         * The resource counts against the resource cache's budget.
          */
-        kWrapped_FlagBit         = 0x1,
+        kBudgeted_Flag      = 0x1,
+
+        /**
+         * This object wraps a GPU object given to us by Skia's client. Skia will not free the
+         * underlying backend API GPU resources when the GrGpuResource is destroyed. This also
+         * implies that kBudgeted_Flag is not set.
+         */
+        kWrapped_Flag       = 0x2,
+
+        /**
+         * If set then fContentKey is valid and the resource is cached based on its content.
+         */
+        kContentKeySet_Flag = 0x4,
     };
 
-    static const size_t kInvalidGpuMemorySize = ~static_cast<size_t>(0);
-
-    uint32_t                fFlags;
-
-    mutable size_t          fGpuMemorySize;
-    const uint32_t          fUniqueID;
-
     // TODO(bsalomon): Remove GrResourceKey and use different simpler types for content and scratch
     // keys.
     GrResourceKey           fScratchKey;
     GrResourceKey           fContentKey;
-    bool                    fContentKeySet;
+
+    // This is not ref'ed but abandon() or release() will be called before the GrGpu object
+    // is destroyed. Those calls set will this to NULL.
+    GrGpu*                  fGpu;
+    mutable size_t          fGpuMemorySize;
+
+    uint32_t                fFlags;
+    const uint32_t          fUniqueID;
 
     typedef GrIORef<GrGpuResource> INHERITED;
     friend class GrIORef<GrGpuResource>; // to access notifyIsPurgable.
 };
 
 #endif