Refactor GrBufferAllocPools to use resource cache

src/gpu/GrResourceProvider.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrResourceProvider.h"
 
 #include "GrGpu.h"
@@ skipping 45 matching lines @@
 }
 
 const GrIndexBuffer* GrResourceProvider::createQuadIndexBuffer() {
     static const int kMaxQuads = 1 << 12; // max possible: (1 << 14) - 1;
     GR_STATIC_ASSERT(4 * kMaxQuads <= 65535);
     static const uint16_t kPattern[] = { 0, 1, 2, 0, 2, 3 };
 
     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;
+}