Cache render targets that render to wrapped textures

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 121 matching lines @@
     friend class GrResourceCache; // to check IO ref counts.
 
     template <typename, GrIOType> friend class GrPendingIOResource;
 };
 
 /**
  * Base class for objects that can be kept in the GrResourceCache.
  */
 class SK_API GrGpuResource : public GrIORef<GrGpuResource> {
 public:
-
-
-    enum LifeCycle {
-        /**
-         * The resource is cached and owned by Skia. Resources with this status may be kept alive
-         * by the cache as either scratch or unique resources even when there are no refs to them.
-         * The cache may release them whenever there are no refs.
-         */
-        kCached_LifeCycle,
-
-        /**
-         * The resource is uncached. As soon as there are no more refs to it, it is released. Under
-         * the hood the cache may opaquely recycle it as a cached resource.
-         */
-        kUncached_LifeCycle,
-
-        /**
-         * Similar to uncached, but Skia does not manage the lifetime of the underlying backend
-         * 3D API object(s). The client is responsible for freeing those. Used to inject client-
-         * created GPU resources into Skia (e.g. to render to a client-created texture).
-         */
-        kBorrowed_LifeCycle,
-
-        /**
-         * An external resource with ownership transfered into Skia. Skia will free the resource.
-         */
-        kAdopted_LifeCycle,
-    };
-
     /**
      * Tests whether a object has been abandoned or released. All objects will
      * be in this state after their creating GrContext is destroyed or has
      * contextLost called. It's up to the client to test wasDestroyed() before
      * attempting to use an object if it holds refs on objects across
      * ~GrContext, freeResources with the force flag, or contextLost.
      *
      * @return true if the object has been released or abandoned,
      *         false otherwise.
      */
     bool wasDestroyed() const { return NULL == fGpu; }
 
     /**
      * Retrieves the context that owns the object. Note that it is possible for
      * this to return NULL. When objects have been release()ed or abandon()ed
      * they no longer have an owning context. Destroying a GrContext
      * automatically releases all its resources.
      */
     const GrContext* getContext() const;
     GrContext* getContext();
 
     /**
-     * Retrieves the amount of GPU memory used by this resource in bytes. It is
+     * Retrieves the amount of GPU memory used by Skia through this resource in bytes. It is
      * approximate since we aren't aware of additional padding or copies made
      * by the driver.
      *
-     * @return the amount of GPU memory used in bytes
+     * If the resource refers to external backend objects, does not count the size of
+     * those objects.
+     *
+     * @return the amount of GPU memory used in bytes by Skia
      */
     size_t gpuMemorySize() const {
         if (kInvalidGpuMemorySize == fGpuMemorySize) {
             fGpuMemorySize = this->onGpuMemorySize();
             SkASSERT(kInvalidGpuMemorySize != fGpuMemorySize);
         }
         return fGpuMemorySize;
     }
 
     /**
@@ skipping 50 matching lines @@
      * Typically, subclasses should not need to override this, and should only
      * need to override setMemoryBacking.
      **/
     virtual void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;
 
 protected:
     // This must be called by every GrGpuObject. It should be called once the object is fully
     // initialized (i.e. not in a base class constructor).
     void registerWithCache();
 
-    GrGpuResource(GrGpu*, LifeCycle);
+    GrGpuResource(GrGpu*, SkBudgeted);
     virtual ~GrGpuResource();
 
     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 shouldFreeResources() const { return fLifeCycle != kBorrowed_LifeCycle; }
-
-    bool isExternal() const {
-        return GrGpuResource::kAdopted_LifeCycle == fLifeCycle ||
-               GrGpuResource::kBorrowed_LifeCycle == fLifeCycle;
-    }
+    /** Overridden to indicate whether the object references externally allocated backend API
+     * resources. */
+    virtual bool refsWrappedResources() const = 0;
 
     /**
      * 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.
@@ skipping 37 matching lines @@
     uint32_t                    fTimestamp;
 
     static const size_t kInvalidGpuMemorySize = ~static_cast<size_t>(0);
     GrScratchKey                fScratchKey;
     GrUniqueKey                 fUniqueKey;
 
     // 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;
-
-    LifeCycle                   fLifeCycle;
+    SkBudgeted                  fBudgeted;
     const uint32_t              fUniqueID;
 
     SkAutoTUnref<const SkData>  fData;
 
     typedef GrIORef<GrGpuResource> INHERITED;
     friend class GrIORef<GrGpuResource>; // to access notifyAllCntsAreZero and notifyRefCntIsZero.
 };
 
 #endif