Revert of Consolidate GPU buffer implementations

src/gpu/GrBufferAllocPool.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrBufferAllocPool.h"
-#include "GrBuffer.h"
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrGpu.h"
+#include "GrIndexBuffer.h"
 #include "GrResourceProvider.h"
 #include "GrTypes.h"
+#include "GrVertexBuffer.h"
 
 #include "SkTraceEvent.h"
 
 #ifdef SK_DEBUG
     #define VALIDATE validate
 #else
     static void VALIDATE(bool = false) {}
 #endif
 
 static const size_t MIN_VERTEX_BUFFER_SIZE = 1 << 15;
 static const size_t MIN_INDEX_BUFFER_SIZE = 1 << 12;
 
 // page size
 #define GrBufferAllocPool_MIN_BLOCK_SIZE ((size_t)1 << 15)
 
 #define UNMAP_BUFFER(block)                                                               \
 do {                                                                                      \
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("skia.gpu"),                           \
                          "GrBufferAllocPool Unmapping Buffer",                            \
                          TRACE_EVENT_SCOPE_THREAD,                                        \
                          "percent_unwritten",                                             \
                          (float)((block).fBytesFree) / (block).fBuffer->gpuMemorySize()); \
     (block).fBuffer->unmap();                                                             \
 } while (false)
 
 GrBufferAllocPool::GrBufferAllocPool(GrGpu* gpu,
-                                     GrBufferType bufferType,
+                                     BufferType bufferType,
                                      size_t blockSize)
     : fBlocks(8) {
 
     fGpu = SkRef(gpu);
     fCpuData = nullptr;
     fBufferType = bufferType;
     fBufferPtr = nullptr;
     fMinBlockSize = SkTMax(GrBufferAllocPool_MIN_BLOCK_SIZE, blockSize);
 
     fBytesInUse = 0;
 
-    fBufferMapThreshold = gpu->caps()->bufferMapThreshold();
+    fGeometryBufferMapThreshold = gpu->caps()->geometryBufferMapThreshold();
 }
 
 void GrBufferAllocPool::deleteBlocks() {
     if (fBlocks.count()) {
-        GrBuffer* buffer = fBlocks.back().fBuffer;
+        GrGeometryBuffer* buffer = fBlocks.back().fBuffer;
         if (buffer->isMapped()) {
             UNMAP_BUFFER(fBlocks.back());
         }
     }
     while (!fBlocks.empty()) {
         this->destroyBlock();
     }
     SkASSERT(!fBufferPtr);
 }
 
@@ skipping 30 matching lines @@
     }
     VALIDATE();
 }
 
 #ifdef SK_DEBUG
 void GrBufferAllocPool::validate(bool unusedBlockAllowed) const {
     bool wasDestroyed = false;
     if (fBufferPtr) {
         SkASSERT(!fBlocks.empty());
         if (fBlocks.back().fBuffer->isMapped()) {
-            GrBuffer* buf = fBlocks.back().fBuffer;
+            GrGeometryBuffer* buf = fBlocks.back().fBuffer;
             SkASSERT(buf->mapPtr() == fBufferPtr);
         } else {
             SkASSERT(fCpuData == fBufferPtr);
         }
     } else {
         SkASSERT(fBlocks.empty() || !fBlocks.back().fBuffer->isMapped());
     }
     size_t bytesInUse = 0;
     for (int i = 0; i < fBlocks.count() - 1; ++i) {
         SkASSERT(!fBlocks[i].fBuffer->isMapped());
@@ skipping 15 matching lines @@
                      (!fBytesInUse && (fBlocks.count() < 2)));
         } else {
             SkASSERT((0 == fBytesInUse) == fBlocks.empty());
         }
     }
 }
 #endif
 
 void* GrBufferAllocPool::makeSpace(size_t size,
                                    size_t alignment,
-                                   const GrBuffer** buffer,
+                                   const GrGeometryBuffer** buffer,
                                    size_t* offset) {
     VALIDATE();
 
     SkASSERT(buffer);
     SkASSERT(offset);
 
     if (fBufferPtr) {
         BufferBlock& back = fBlocks.back();
         size_t usedBytes = back.fBuffer->gpuMemorySize() - back.fBytesFree;
         size_t pad = GrSizeAlignUpPad(usedBytes, alignment);
@@ skipping 86 matching lines @@
         fBufferPtr = nullptr;
     }
 
     SkASSERT(!fBufferPtr);
 
     // If the buffer is CPU-backed we map it because it is free to do so and saves a copy.
     // Otherwise when buffer mapping is supported we map if the buffer size is greater than the
     // threshold.
     bool attemptMap = block.fBuffer->isCPUBacked();
     if (!attemptMap && GrCaps::kNone_MapFlags != fGpu->caps()->mapBufferFlags()) {
-        attemptMap = size > fBufferMapThreshold;
+        attemptMap = size > fGeometryBufferMapThreshold;
     }
 
     if (attemptMap) {
         fBufferPtr = block.fBuffer->map();
     }
 
     if (!fBufferPtr) {
         fBufferPtr = this->resetCpuData(block.fBytesFree);
     }
 
@@ skipping 22 matching lines @@
             fCpuData = sk_malloc_throw(newSize);
         }
     } else {
         fCpuData = nullptr;
     }
     return fCpuData;
 }
 
 
 void GrBufferAllocPool::flushCpuData(const BufferBlock& block, size_t flushSize) {
-    GrBuffer* buffer = block.fBuffer;
+    GrGeometryBuffer* buffer = block.fBuffer;
     SkASSERT(buffer);
     SkASSERT(!buffer->isMapped());
     SkASSERT(fCpuData == fBufferPtr);
     SkASSERT(flushSize <= buffer->gpuMemorySize());
     VALIDATE(true);
 
     if (GrCaps::kNone_MapFlags != fGpu->caps()->mapBufferFlags() &&
-        flushSize > fBufferMapThreshold) {
+        flushSize > fGeometryBufferMapThreshold) {
         void* data = buffer->map();
         if (data) {
             memcpy(data, fBufferPtr, flushSize);
             UNMAP_BUFFER(block);
             return;
         }
     }
     buffer->updateData(fBufferPtr, flushSize);
     VALIDATE(true);
 }
 
-GrBuffer* GrBufferAllocPool::getBuffer(size_t size) {
+GrGeometryBuffer* GrBufferAllocPool::getBuffer(size_t size) {
 
     GrResourceProvider* rp = fGpu->getContext()->resourceProvider();
 
+    static const GrResourceProvider::BufferUsage kUsage = GrResourceProvider::kDynamic_BufferUsage;
     // Shouldn't have to use this flag (https://bug.skia.org/4156)
     static const uint32_t kFlags = GrResourceProvider::kNoPendingIO_Flag;
-    return rp->createBuffer(fBufferType, size, kDynamic_GrAccessPattern, kFlags);
+    if (kIndex_BufferType == fBufferType) {
+        return rp->createIndexBuffer(size, kUsage, kFlags);
+    } else {
+        SkASSERT(kVertex_BufferType == fBufferType);
+        return rp->createVertexBuffer(size, kUsage, kFlags);
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrVertexBufferAllocPool::GrVertexBufferAllocPool(GrGpu* gpu)
-    : GrBufferAllocPool(gpu, kVertex_GrBufferType, MIN_VERTEX_BUFFER_SIZE) {
+    : GrBufferAllocPool(gpu, kVertex_BufferType, MIN_VERTEX_BUFFER_SIZE) {
 }
 
 void* GrVertexBufferAllocPool::makeSpace(size_t vertexSize,
                                          int vertexCount,
-                                         const GrBuffer** buffer,
+                                         const GrVertexBuffer** buffer,
                                          int* startVertex) {
 
     SkASSERT(vertexCount >= 0);
     SkASSERT(buffer);
     SkASSERT(startVertex);
 
     size_t offset = 0; // assign to suppress warning
+    const GrGeometryBuffer* geomBuffer = nullptr; // assign to suppress warning
     void* ptr = INHERITED::makeSpace(vertexSize * vertexCount,
                                      vertexSize,
-                                     buffer,
+                                     &geomBuffer,
                                      &offset);
 
+    *buffer = (const GrVertexBuffer*) geomBuffer;
     SkASSERT(0 == offset % vertexSize);
     *startVertex = static_cast<int>(offset / vertexSize);
     return ptr;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrIndexBufferAllocPool::GrIndexBufferAllocPool(GrGpu* gpu)
-    : GrBufferAllocPool(gpu, kIndex_GrBufferType, MIN_INDEX_BUFFER_SIZE) {
+    : GrBufferAllocPool(gpu, kIndex_BufferType, MIN_INDEX_BUFFER_SIZE) {
 }
 
 void* GrIndexBufferAllocPool::makeSpace(int indexCount,
-                                        const GrBuffer** buffer,
+                                        const GrIndexBuffer** buffer,
                                         int* startIndex) {
 
     SkASSERT(indexCount >= 0);
     SkASSERT(buffer);
     SkASSERT(startIndex);
 
     size_t offset = 0; // assign to suppress warning
+    const GrGeometryBuffer* geomBuffer = nullptr; // assign to suppress warning
     void* ptr = INHERITED::makeSpace(indexCount * sizeof(uint16_t),
                                      sizeof(uint16_t),
-                                     buffer,
+                                     &geomBuffer,
                                      &offset);
 
+    *buffer = (const GrIndexBuffer*) geomBuffer;
     SkASSERT(0 == offset % sizeof(uint16_t));
     *startIndex = static_cast<int>(offset / sizeof(uint16_t));
     return ptr;
 }