GrResourceCache2 manages scratch texture.

include/gpu/GrContext.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrContext_DEFINED
 #define GrContext_DEFINED
 
@@ skipping 272 matching lines @@
      * Returns a texture matching the desc. It's contents are unknown. Subsequent
      * requests with the same descriptor are not guaranteed to return the same
      * texture. The same texture is guaranteed not be returned again until it is
      * unlocked. Call must be balanced with an unlockTexture() call. The caller
      * owns a ref on the returned texture and must balance with a call to unref.
      *
      * Textures created by createAndLockTexture() hide the complications of
      * tiling non-power-of-two textures on APIs that don't support this (e.g.
      * unextended GLES2). Tiling a NPOT texture created by lockScratchTexture on
      * such an API will create gaps in the tiling pattern. This includes clamp
-     * mode. (This may be addressed in a future update.)
+     * mode. (This may be addressed in a future update.)7

[bsalomon, 2014/10/07 04:07:55]

will remove the stray 7 and fix up sentence in subsequent comment before
landing.

+     *
+     * internalFlags is a temporary workaround until changes in the internal
+     * architectural changes are complete. Use the default value.
      */
-    GrTexture* lockAndRefScratchTexture(const GrTextureDesc&, ScratchTexMatch match);
-
-    /**
-     *  When done with an entry, call unlockScratchTexture(entry) on it, which returns
-     *  it to the cache, where it may be purged. This does not unref the texture.
-     */
-    void unlockScratchTexture(GrTexture* texture);
+    GrTexture* lockAndRefScratchTexture(const GrTextureDesc&, ScratchTexMatch match,
+                                        uint32_t internalFlags = 0);
 
     /**
      * Creates a texture that is outside the cache. Does not count against
      * cache's budget.
      */
     GrTexture* createUncachedTexture(const GrTextureDesc& desc,
                                      void* srcData,
                                      size_t rowBytes);
 
     /**
@@ skipping 756 matching lines @@
 
     void internalDrawPath(GrDrawTarget* target, bool useAA, const SkPath& path,
                           const GrStrokeInfo& stroke);
 
     GrTexture* createResizedTexture(const GrTextureDesc& desc,
                                     const GrCacheID& cacheID,
                                     const void* srcData,
                                     size_t rowBytes,
                                     bool filter);
 
-    // Needed so GrTexture's returnToCache helper function can call
-    // addExistingTextureToCache
-    friend class GrTexture;
-    friend class GrStencilAndCoverPathRenderer;
-    friend class GrStencilAndCoverTextContext;
-
-    // Add an existing texture to the texture cache. This is intended solely
-    // for use with textures released from an GrAutoScratchTexture.
-    void addExistingTextureToCache(GrTexture* texture);
+    bool createNewScratchTexture(const GrTextureDesc& desc);
 
     /**
      * These functions create premul <-> unpremul effects if it is possible to generate a pair
      * of effects that make a readToUPM->writeToPM->readToUPM cycle invariant. Otherwise, they
      * return NULL.
      */
     const GrFragmentProcessor* createPMToUPMEffect(GrTexture*, bool swapRAndB, const SkMatrix&);
     const GrFragmentProcessor* createUPMToPMEffect(GrTexture*, bool swapRAndB, const SkMatrix&);
 
     /**
      *  This callback allows the resource cache to callback into the GrContext
      *  when the cache is still overbudget after a purge.
      */
     static bool OverbudgetCB(void* data);
 
     typedef SkRefCnt INHERITED;
 };
 
 /**
- * Gets and locks a scratch texture from a descriptor using either exact or approximate criteria.
- * Unlocks texture in the destructor.
+ * This is deprecated. Don't use it.
  */
 class SK_API GrAutoScratchTexture : public ::SkNoncopyable {
 public:
     GrAutoScratchTexture()
         : fContext(NULL)
         , fTexture(NULL) {
     }
 
     GrAutoScratchTexture(GrContext* context,
                          const GrTextureDesc& desc,
-                         GrContext::ScratchTexMatch match = GrContext::kApprox_ScratchTexMatch)
+                         GrContext::ScratchTexMatch match = GrContext::kApprox_ScratchTexMatch,
+                         uint32_t internalFlags = 0)
       : fContext(NULL)
       , fTexture(NULL) {
-      this->set(context, desc, match);
+      this->set(context, desc, match, internalFlags);
     }
 
     ~GrAutoScratchTexture() {
         this->reset();
     }
 
     void reset() {
         if (fContext && fTexture) {
-            fContext->unlockScratchTexture(fTexture);
             fTexture->unref();
             fTexture = NULL;
         }
     }
 
-    /*
-     * When detaching a texture we do not unlock it in the texture cache but
-     * we do set the returnToCache flag. In this way the texture remains
-     * "locked" in the texture cache until it is freed and recycled in
-     * GrTexture::internal_dispose. In reality, the texture has been removed
-     * from the cache (because this is in AutoScratchTexture) and by not
-     * calling unlockScratchTexture we simply don't re-add it. It will be
-     * reattached in GrTexture::internal_dispose.
-     *
-     * Note that the caller is assumed to accept and manage the ref to the
-     * returned texture.
-     */
-    GrTexture* detach();
+    GrTexture* detach() {
+        GrTexture* texture = fTexture;
+        fTexture = NULL;
+        return texture;
+    }
 
     GrTexture* set(GrContext* context,
                    const GrTextureDesc& desc,
-                   GrContext::ScratchTexMatch match = GrContext::kApprox_ScratchTexMatch) {
+                   GrContext::ScratchTexMatch match = GrContext::kApprox_ScratchTexMatch,
+                   uint32_t internalFlags = 0) {
         this->reset();
 
         fContext = context;
         if (fContext) {
-            fTexture = fContext->lockAndRefScratchTexture(desc, match);
+            fTexture = fContext->lockAndRefScratchTexture(desc, match, internalFlags);
             if (NULL == fTexture) {
                 fContext = NULL;
             }
             return fTexture;
         } else {
             return NULL;
         }
     }
 
     GrTexture* texture() { return fTexture; }
 
 private:
     GrContext*                    fContext;
     GrTexture*                    fTexture;
 };
 
 #endif