Make GrResourceCache2 responsible for calling release, abandon, and ~.

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 38 matching lines @@
         this->validate();
         ++fRefCnt;
     }
 
     void unref() const {
         this->validate();
         --fRefCnt;
         this->didUnref();
     }
 
-    bool isPurgable() const { return this->reffedOnlyByCache() && !this->internalHasPendingIO(); }
-    bool reffedOnlyByCache() const { return 1 == fRefCnt; }
-
     void validate() const {
 #ifdef SK_DEBUG
         SkASSERT(fRefCnt >= 0);
         SkASSERT(fPendingReads >= 0);
         SkASSERT(fPendingWrites >= 0);
-        SkASSERT(fRefCnt + fPendingReads + fPendingWrites > 0);
+        SkASSERT(fRefCnt + fPendingReads + fPendingWrites >= 0);
 #endif
     }
 
 protected:
     GrIORef() : fRefCnt(1), fPendingReads(0), fPendingWrites(0) { }
 
+    bool isPurgable() const { return !this->internalHasRef() && !this->internalHasPendingIO(); }
+
     bool internalHasPendingRead() const { return SkToBool(fPendingReads); }
     bool internalHasPendingWrite() const { return SkToBool(fPendingWrites); }
     bool internalHasPendingIO() const { return SkToBool(fPendingWrites | fPendingReads); }
 
     bool internalHasRef() const { return SkToBool(fRefCnt); }
 
 private:
     void addPendingRead() const {
         this->validate();
         ++fPendingReads;
@@ skipping 11 matching lines @@
     }
 
     void completedWrite() const {
         this->validate();
         --fPendingWrites;
         this->didUnref();
     }
 
 private:
     void didUnref() const {
-        if (0 == fPendingReads && 0 == fPendingWrites) {
-            if (0 == fRefCnt) {
-                // Must call derived destructor since this is not a virtual class.
-                SkDELETE(static_cast<const DERIVED*>(this));
-            } else if (1 == fRefCnt) {
-                // The one ref is the cache's
-                static_cast<const DERIVED*>(this)->notifyIsPurgable();
-            }
+        if (0 == fPendingReads && 0 == fPendingWrites && 0 == fRefCnt) {
+            static_cast<const DERIVED*>(this)->notifyIsPurgable();
         }
     }
 
     mutable int32_t fRefCnt;
     mutable int32_t fPendingReads;
     mutable int32_t fPendingWrites;
 
     // This class is used to manage conversion of refs to pending reads/writes.
     friend class GrGpuResourceRef;
     friend class GrResourceCache2; // to check IO ref counts.
 
     template <typename, GrIOType> friend class GrPendingIOResource;
 };
 
 /**
  * Base class for objects that can be kept in the GrResourceCache2.
  */
 class SK_API GrGpuResource : public GrIORef<GrGpuResource> {
 public:
     SK_DECLARE_INST_COUNT(GrGpuResource)
 
     /**
-     * Frees the object in the underlying 3D API. It must be safe to call this
-     * when the object has been previously abandoned.
-     */
-    void release();
-
-    /**
-     * Removes references to objects in the underlying 3D API without freeing
-     * them. Used when the API context has been torn down before the GrContext.
-     */
-    void abandon();
-
-    /**
      * 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; }
@@ skipping 39 matching lines @@
 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*, 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() {};
+    /** 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; }
 
     /**
      * 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 notifyIsPurgable() const;
 
 #ifdef SK_DEBUG
     friend class GrGpu; // for assert in GrGpu to access getGpu
 #endif
@@ skipping 27 matching lines @@
     // keys.
     GrResourceKey           fScratchKey;
     GrResourceKey           fContentKey;
     bool                    fContentKeySet;
 
     typedef GrIORef<GrGpuResource> INHERITED;
     friend class GrIORef<GrGpuResource>; // to access notifyIsPurgable.
 };
 
 #endif