Remove unneeded features from GrBufferAllocPool

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"
@@ skipping 19 matching lines @@
     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,
                                      BufferType bufferType,
-                                     bool frequentResetHint,
                                      size_t blockSize,
                                      int preallocBufferCnt) :
         fBlocks(SkTMax(8, 2*preallocBufferCnt)) {
 
-    SkASSERT(gpu);
-    fGpu = gpu;
-    fGpu->ref();
-    fGpuIsReffed = true;
+    fGpu = SkRef(gpu);
 
     fBufferType = bufferType;
-    fFrequentResetHint = frequentResetHint;
     fBufferPtr = NULL;
     fMinBlockSize = SkTMax(GrBufferAllocPool_MIN_BLOCK_SIZE, blockSize);
 
     fBytesInUse = 0;
 
     fPreallocBuffersInUse = 0;
     fPreallocBufferStartIdx = 0;
     for (int i = 0; i < preallocBufferCnt; ++i) {
         GrGeometryBuffer* buffer = this->createBuffer(fMinBlockSize);
         if (buffer) {
             *fPreallocBuffers.append() = buffer;
         }
     }
 }
 
 GrBufferAllocPool::~GrBufferAllocPool() {
     VALIDATE();
     if (fBlocks.count()) {
         GrGeometryBuffer* buffer = fBlocks.back().fBuffer;
         if (buffer->isMapped()) {
             UNMAP_BUFFER(fBlocks.back());
         }
     }
     while (!fBlocks.empty()) {
         destroyBlock();
     }
     fPreallocBuffers.unrefAll();
-    releaseGpuRef();
-}
-
-void GrBufferAllocPool::releaseGpuRef() {
-    if (fGpuIsReffed) {
-        fGpu->unref();
-        fGpuIsReffed = false;
-    }
+    fGpu->unref();
 }
 
 void GrBufferAllocPool::reset() {
     VALIDATE();
     fBytesInUse = 0;
     if (fBlocks.count()) {
         GrGeometryBuffer* buffer = fBlocks.back().fBuffer;
         if (buffer->isMapped()) {
             UNMAP_BUFFER(fBlocks.back());
         }
@@ skipping 213 matching lines @@
             UNMAP_BUFFER(prev);
         } else {
             this->flushCpuData(prev, prev.fBuffer->gpuMemorySize() - prev.fBytesFree);
         }
         fBufferPtr = NULL;
     }
 
     SkASSERT(NULL == 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:
-    //      a) If the frequently reset hint is set we only map when the requested size meets a
-    //      threshold (since we don't expect it is likely that we will see more vertex data)
-    //      b) If the hint is not set we map if the buffer size is greater than the threshold.
+    // Otherwise when buffer mapping is supported we map if the buffer size is greater than the
+    // threshold.
     bool attemptMap = block.fBuffer->isCPUBacked();
     if (!attemptMap && GrDrawTargetCaps::kNone_MapFlags != fGpu->caps()->mapBufferFlags()) {
-        if (fFrequentResetHint) {
-            attemptMap = requestSize > GR_GEOM_BUFFER_MAP_THRESHOLD;
-        } else {
-            attemptMap = size > GR_GEOM_BUFFER_MAP_THRESHOLD;
-        }
+        attemptMap = size > GR_GEOM_BUFFER_MAP_THRESHOLD;
     }
 
     if (attemptMap) {
         fBufferPtr = block.fBuffer->map();
     }
 
     if (NULL == fBufferPtr) {
         fBufferPtr = fCpuData.reset(size);
     }
 
@@ skipping 47 matching lines @@
         return fGpu->createIndexBuffer(size, true);
     } else {
         SkASSERT(kVertex_BufferType == fBufferType);
         return fGpu->createVertexBuffer(size, true);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrVertexBufferAllocPool::GrVertexBufferAllocPool(GrGpu* gpu,
-                                                 bool frequentResetHint,
                                                  size_t bufferSize,
                                                  int preallocBufferCnt)
 : GrBufferAllocPool(gpu,
                     kVertex_BufferType,
-                    frequentResetHint,
                     bufferSize,
                     preallocBufferCnt) {
 }
 
 void* GrVertexBufferAllocPool::makeSpace(size_t vertexSize,
                                          int vertexCount,
                                          const GrVertexBuffer** buffer,
                                          int* startVertex) {
 
     SkASSERT(vertexCount >= 0);
@@ skipping 17 matching lines @@
     return static_cast<int>(INHERITED::preallocatedBufferSize() / vertexSize);
 }
 
 int GrVertexBufferAllocPool::currentBufferVertices(size_t vertexSize) const {
     return currentBufferItems(vertexSize);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrIndexBufferAllocPool::GrIndexBufferAllocPool(GrGpu* gpu,
-                                               bool frequentResetHint,
                                                size_t bufferSize,
                                                int preallocBufferCnt)
 : GrBufferAllocPool(gpu,
                     kIndex_BufferType,
-                    frequentResetHint,
                     bufferSize,
                     preallocBufferCnt) {
 }
 
 void* GrIndexBufferAllocPool::makeSpace(int indexCount,
                                         const GrIndexBuffer** buffer,
                                         int* startIndex) {
 
     SkASSERT(indexCount >= 0);
     SkASSERT(buffer);
@@ skipping 12 matching lines @@
     return ptr;
 }
 
 int GrIndexBufferAllocPool::preallocatedBufferIndices() const {
     return static_cast<int>(INHERITED::preallocatedBufferSize() / sizeof(uint16_t));
 }
 
 int GrIndexBufferAllocPool::currentBufferIndices() const {
     return currentBufferItems(sizeof(uint16_t));
 }