Refactor GrBufferAllocPools to use resource cache

include/gpu/GrTextureProvider.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrTextureProvider_DEFINED
 #define GrTextureProvider_DEFINED
 
@@ skipping 43 matching lines @@
     /**
      * Determines whether a texture is associated with the unique key. If the texture is found it
      * will not be locked or returned. This call does not affect the priority of the resource for
      * deletion.
      */
     bool existsTextureWithUniqueKey(const GrUniqueKey& key) const {
         return this->existsResourceWithUniqueKey(key);
     }
 
     /**
-     * Enum that determines how closely a returned scratch texture must match
-     * a provided GrSurfaceDesc. TODO: Remove this. createTexture() should be used
+     * Enum that determines how closely a returned scratch resource must match
+     * a provided information. TODO: Remove this. createTexture()/createBuffer() should be used
      * for exact match and refScratchTexture() should be replaced with createApproxTexture().
      */
-    enum ScratchTexMatch {
+    enum ScratchMatch {
         /**
-         * Finds a texture that exactly matches the descriptor.
+         * Finds a resource that exactly matches the description.
          */
-        kExact_ScratchTexMatch,
+        kExact_ScratchMatch,
         /**
-         * Finds a texture that approximately matches the descriptor. Will be
-         * at least as large in width and height as desc specifies. If desc
-         * specifies that texture is a render target then result will be a
-         * render target. If desc specifies a render target and doesn't set the
-         * no stencil flag then result will have a stencil. Format and aa level
-         * will always match.
+         * Finds a resource that approximately matches the description. 
+         * For textures, this will be at least as large in width and height as 
+         * desc specifies. If desc specifies that texture is a render target 
+         * then result will be a render target. If desc specifies a render 
+         * target and doesn't set the no stencil flag then result will have 
+         * a stencil. Format and aa level will always match.
          */
-        kApprox_ScratchTexMatch
+        kApprox_ScratchMatch
     };
 
     /**
      * Returns a texture matching the desc. It's contents are unknown. The caller
      * owns a ref on the returned texture and must balance with a call to unref.
      * It is guaranteed that the same texture will not be returned in subsequent
      * calls until all refs to the texture are dropped.
      *
      * internalFlag is a temporary workaround until changes in the internal
      * architecture are complete. Use the default value.
      *
      * TODO: Once internal flag can be removed, this should be replaced with
      * createApproxTexture() and exact textures should be created with
      * createTexture().
      */
-    GrTexture* refScratchTexture(const GrSurfaceDesc&, ScratchTexMatch match,
+    GrTexture* refScratchTexture(const GrSurfaceDesc&, ScratchMatch match,
                                  bool internalFlag = false);
 
     ///////////////////////////////////////////////////////////////////////////
     // Wrapped Backend Surfaces
 
     /**
      * Wraps an existing texture with a GrTexture object.
      *
      * OpenGL: if the object is a texture Gr may change its GL texture params
      *         when it is drawn.
@@ skipping 10 matching lines @@
      * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that
      * the client will resolve to a texture).
      *
      * @param  desc     description of the object to create.
      *
      * @return GrTexture object or NULL on failure.
      */
      GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc);
 
 protected:
+    enum ScratchFlags {
+        kExact_ScratchFlag           = 0x1,
+        kNoPendingIO_ScratchFlag     = 0x2,
+        kNoCreate_ScratchFlag        = 0x4,
+    };
+
     GrTextureProvider(GrGpu* gpu, GrResourceCache* cache) : fCache(cache), fGpu(gpu) {}
 
     /**
      * Assigns a unique key to a resource. If the key is associated with another resource that
      * association is removed and replaced by this resource.
      */
     void assignUniqueKeyToResource(const GrUniqueKey&, GrGpuResource*);
 
     /**
      * Finds a resource in the cache, based on the specified key. This is intended for use in
@@ skipping 15 matching lines @@
         fCache = NULL;
         fGpu = NULL;
     }
 
     GrResourceCache* cache() { return fCache; }
     const GrResourceCache* cache() const { return fCache; }
 
     GrGpu* gpu() { return fGpu; }
     const GrGpu* gpu() const { return fGpu; }
 
-private:
     bool isAbandoned() const {
         SkASSERT(SkToBool(fGpu) == SkToBool(fCache));
         return !SkToBool(fCache);
     }
 
+private:
     GrResourceCache* fCache;
     GrGpu* fGpu;
 };
 
 #endif