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 190 matching lines @@
     GrGpuResource(GrGpu*, bool isWrapped);
     virtual ~GrGpuResource();
 
     GrGpu* getGpu() const { return fGpu; }
 
     // Derived classes should always call their parent class' onRelease
     // and onAbandon methods in their overrides.
     virtual void onRelease() {};
     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:
     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

[bsalomon, 2014/11/13 19:20:54]

Mostly shuffling order and removed fContentKeySet since it is now a flag.

+    // 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