Refactor GrBufferAllocPools to use resource cache

src/gpu/GrResourceProvider.cpp

Index: src/gpu/GrResourceProvider.cpp
diff --git a/src/gpu/GrResourceProvider.cpp b/src/gpu/GrResourceProvider.cpp
index 8fc3272ae2204715650cd45e664b5d56a1ff1399..3bf87ffdf14ff2d9f1868204bd8b8c172a500a3e 100644
--- a/src/gpu/GrResourceProvider.cpp
+++ b/src/gpu/GrResourceProvider.cpp
@@ -63,3 +63,98 @@ const GrIndexBuffer* GrResourceProvider::createQuadIndexBuffer() {
     return this->createInstancedIndexBuffer(kPattern, 6, kMaxQuads, 4, fQuadIndexBufferKey);
 }
 
+GrIndexBuffer* GrResourceProvider::refScratchIndexBuffer(size_t size, bool dynamic,
+                                                         ScratchMatch match,
+                                                         bool calledDuringFlush) {
+    if (this->isAbandoned()) {
+        return NULL;
+    }
+
+    uint32_t flags = 0;
+    if (kExact_ScratchMatch == match) {
+        flags |= kExact_ScratchFlag;
+    }
+    if (calledDuringFlush) {
+        flags |= kNoPendingIO_ScratchFlag;
+    }
+    return this->internalRefIndexBuffer(size, dynamic, flags);
+}
+
+GrIndexBuffer* GrResourceProvider::internalRefIndexBuffer(size_t size, bool dynamic,
+                                                          uint32_t flags) {
+    SkASSERT(!this->isAbandoned());
+
+    if (!(kExact_ScratchFlag & flags)) {
+        // bin by pow2 with a reasonable min
+        static const size_t MIN_SIZE = 1 << 12;
+        size = SkTMax(MIN_SIZE, GrNextPow2(size));
+    }
+
+    GrScratchKey key;
+    GrIndexBuffer::ComputeScratchKey(size, dynamic, &key);
+    uint32_t scratchFlags = 0;
+    if (kNoPendingIO_ScratchFlag & flags) {
+        scratchFlags = GrResourceCache::kRequireNoPendingIO_ScratchFlag;
+    } else {
+        // Prefer no pending IO in order to avoid flushes?
+        scratchFlags = GrResourceCache::kPreferNoPendingIO_ScratchFlag;
+    }
+    GrGpuResource* resource = this->cache()->findAndRefScratchResource(key, scratchFlags);
+    if (resource) {
+        return static_cast<GrIndexBuffer*>(resource);
+    }
+
+    if (!(kNoCreate_ScratchFlag & flags)) {
+        return this->gpu()->createIndexBuffer(size, dynamic);
+    }
+
+    return NULL;
+}
+
+GrVertexBuffer* GrResourceProvider::refScratchVertBuffer(size_t size, bool dynamic, 
+                                                         ScratchMatch match,
+                                                         bool calledDuringFlush) {
+    if (this->isAbandoned()) {
+        return NULL;
+    }
+
+    uint32_t flags = 0;
+    if (kExact_ScratchMatch == match) {
+        flags |= kExact_ScratchFlag;
+    }
+    if (calledDuringFlush) {
+        flags |= kNoPendingIO_ScratchFlag;
+    }
+    return this->internalRefVertexBuffer(size, dynamic, flags);
+}
+
+GrVertexBuffer* GrResourceProvider::internalRefVertexBuffer(size_t size, bool dynamic,
+                                                            uint32_t flags) {
+    SkASSERT(!this->isAbandoned());
+
+    if (!(kExact_ScratchFlag & flags)) {
+        // bin by pow2 with a reasonable min
+        static const size_t MIN_SIZE = 1 << 15;
+        size = SkTMax(MIN_SIZE, GrNextPow2(size));
+    }
+
+    GrScratchKey key;
+    GrVertexBuffer::ComputeScratchKey(size, dynamic, &key);
+    uint32_t scratchFlags = 0;
+    if (kNoPendingIO_ScratchFlag & flags) {
+        scratchFlags = GrResourceCache::kRequireNoPendingIO_ScratchFlag;
+    } else {
+        // Prefer no pending IO in order to avoid flushes?
+        scratchFlags = GrResourceCache::kPreferNoPendingIO_ScratchFlag;
+    }
+    GrGpuResource* resource = this->cache()->findAndRefScratchResource(key, scratchFlags);
+    if (resource) {
+        return static_cast<GrVertexBuffer*>(resource);
+    }
+
+    if (!(kNoCreate_ScratchFlag & flags)) {
+        return this->gpu()->createVertexBuffer(size, dynamic);
+    }
+
+    return NULL;
+}