Add GrGpuResource::CacheAccess

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 156 matching lines @@
 
     /**
      * Retrieves the amount of GPU memory used by 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
      */
     virtual size_t gpuMemorySize() const = 0;
 
-    // TODO(bsalomon): Move this stuff to GrGpuResourcePriv.
-    bool setContentKey(const GrResourceKey& contentKey);
-    void setCacheEntry(GrResourceCacheEntry* cacheEntry);
-    GrResourceCacheEntry* getCacheEntry() const { return fCacheEntry; }
-    bool isScratch() const;
-    /** 
-     * If this resource can be used as a scratch resource this returns a valid
-     * scratch key. Otherwise it returns a key for which isNullScratch is true.
-     * The resource may currently be used as content resource rather than scratch.
-     * Check isScratch().
-     */
-    const GrResourceKey& getScratchKey() const { return fScratchKey; }
-    /** 
-     * If this resource is currently cached by its contents then this will return
-     * the content key. Otherwise, NULL is returned.
-     */
-    const GrResourceKey* getContentKey() const;
-
     /**
      * Gets an id that is unique for this GrGpuResource object. It is static in that it does
      * not change when the content of the GrGpuResource object changes. This will never return
      * 0.
      */
     uint32_t getUniqueID() const { return fUniqueID; }
 
+    /**
+     * Internal-only helper class used for cache manipulations of the reosurce.
+     */
+    class CacheAccess;
+    inline CacheAccess cacheAccess();
+    inline const CacheAccess cacheAccess() 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*, bool isWrapped);
     virtual ~GrGpuResource();
 
-    bool isInCache() const { return SkToBool(fCacheEntry); }
-
     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; }
 
     /**
      * This entry point should be called whenever gpuMemorySize() begins
      * reporting a different size. If the object is in the cache, it will call
      * gpuMemorySize() immediately and pass the new size on to the resource
      * cache.
      */
     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:
+    // 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
 
     static uint32_t CreateUniqueID();
 
     // We're in an internal doubly linked list owned by GrResourceCache2
     SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrGpuResource);
@@ skipping 20 matching lines @@
     // keys.
     GrResourceKey           fScratchKey;
     GrResourceKey           fContentKey;
     bool                    fContentKeySet;
 
     typedef GrIORef<GrGpuResource> INHERITED;
     friend class GrIORef<GrGpuResource>; // to access notifyIsPurgable.
 };
 
 #endif