Use calloc to allocate data that will be uploaded to vertex/index buffers in Chrome

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 28 matching lines @@
                          (float)((block).fBytesFree) / (block).fBuffer->gpuMemorySize()); \
     (block).fBuffer->unmap();                                                             \
 } while (false)
 
 GrBufferAllocPool::GrBufferAllocPool(GrGpu* gpu,
                                      BufferType bufferType,
                                      size_t blockSize)
     : fBlocks(8) {
 
     fGpu = SkRef(gpu);
-
+    fCpuData = nullptr;
     fBufferType = bufferType;
-    fBufferPtr = NULL;
+    fBufferPtr = nullptr;
     fMinBlockSize = SkTMax(GrBufferAllocPool_MIN_BLOCK_SIZE, blockSize);
 
     fBytesInUse = 0;
 
     fGeometryBufferMapThreshold = gpu->caps()->geometryBufferMapThreshold();
 }
 
 void GrBufferAllocPool::deleteBlocks() {
     if (fBlocks.count()) {
         GrGeometryBuffer* buffer = fBlocks.back().fBuffer;
         if (buffer->isMapped()) {
             UNMAP_BUFFER(fBlocks.back());
         }
     }
     while (!fBlocks.empty()) {
         this->destroyBlock();
     }
     SkASSERT(!fBufferPtr);
 }
 
 GrBufferAllocPool::~GrBufferAllocPool() {
     VALIDATE();
     this->deleteBlocks();
+    sk_free(fCpuData);
     fGpu->unref();
 }
 
 void GrBufferAllocPool::reset() {
     VALIDATE();
     fBytesInUse = 0;
     this->deleteBlocks();
-    // we may have created a large cpu mirror of a large VB. Reset the size
-    // to match our minimum.
-    fCpuData.reset(fMinBlockSize);
+
+    // we may have created a large cpu mirror of a large VB. Reset the size to match our minimum.
+    this->resetCpuData(fMinBlockSize);
+
     VALIDATE();
 }
 
 void GrBufferAllocPool::unmap() {
     VALIDATE();
 
     if (fBufferPtr) {
         BufferBlock& block = fBlocks.back();
         if (block.fBuffer->isMapped()) {
             UNMAP_BUFFER(block);
         } else {
             size_t flushSize = block.fBuffer->gpuMemorySize() - block.fBytesFree;
             this->flushCpuData(fBlocks.back(), flushSize);
         }
-        fBufferPtr = NULL;
+        fBufferPtr = nullptr;
     }
     VALIDATE();
 }
 
 #ifdef SK_DEBUG
 void GrBufferAllocPool::validate(bool unusedBlockAllowed) const {
     bool wasDestroyed = false;
     if (fBufferPtr) {
         SkASSERT(!fBlocks.empty());
         if (fBlocks.back().fBuffer->isMapped()) {
             GrGeometryBuffer* buf = fBlocks.back().fBuffer;
             SkASSERT(buf->mapPtr() == fBufferPtr);
         } else {
-            SkASSERT(fCpuData.get() == fBufferPtr);
+            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());
     }
     for (int i = 0; !wasDestroyed && i < fBlocks.count(); ++i) {
         if (fBlocks[i].fBuffer->wasDestroyed()) {
@@ skipping 44 matching lines @@
 
     // We could honor the space request using by a partial update of the current
     // VB (if there is room). But we don't currently use draw calls to GL that
     // allow the driver to know that previously issued draws won't read from
     // the part of the buffer we update. Also, the GL buffer implementation
     // may be cheating on the actual buffer size by shrinking the buffer on
     // updateData() if the amount of data passed is less than the full buffer
     // size.
 
     if (!this->createBlock(size)) {
-        return NULL;
+        return nullptr;
     }
     SkASSERT(fBufferPtr);
 
     *offset = 0;
     BufferBlock& back = fBlocks.back();
     *buffer = back.fBuffer;
     back.fBytesFree -= size;
     fBytesInUse += size;
     VALIDATE();
     return fBufferPtr;
@@ skipping 30 matching lines @@
 bool GrBufferAllocPool::createBlock(size_t requestSize) {
 
     size_t size = SkTMax(requestSize, fMinBlockSize);
     SkASSERT(size >= GrBufferAllocPool_MIN_BLOCK_SIZE);
 
     VALIDATE();
 
     BufferBlock& block = fBlocks.push_back();
 
     block.fBuffer = this->getBuffer(size);
-    if (NULL == block.fBuffer) {
+    if (!block.fBuffer) {
         fBlocks.pop_back();
         return false;
     }
 
     block.fBytesFree = block.fBuffer->gpuMemorySize();
     if (fBufferPtr) {
         SkASSERT(fBlocks.count() > 1);
         BufferBlock& prev = fBlocks.fromBack(1);
         if (prev.fBuffer->isMapped()) {
             UNMAP_BUFFER(prev);
         } else {
             this->flushCpuData(prev, prev.fBuffer->gpuMemorySize() - prev.fBytesFree);
         }
-        fBufferPtr = NULL;
+        fBufferPtr = nullptr;
     }
 
-    SkASSERT(NULL == fBufferPtr);
+    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 > fGeometryBufferMapThreshold;
     }
 
     if (attemptMap) {
         fBufferPtr = block.fBuffer->map();
     }
 
-    if (NULL == fBufferPtr) {
-        fBufferPtr = fCpuData.reset(block.fBytesFree);
+    if (!fBufferPtr) {
+        fBufferPtr = this->resetCpuData(block.fBytesFree);
     }
 
     VALIDATE(true);
 
     return true;
 }
 
 void GrBufferAllocPool::destroyBlock() {
     SkASSERT(!fBlocks.empty());
 
     BufferBlock& block = fBlocks.back();
 
     SkASSERT(!block.fBuffer->isMapped());
     block.fBuffer->unref();
     fBlocks.pop_back();
-    fBufferPtr = NULL;
+    fBufferPtr = nullptr;
 }
 
+void* GrBufferAllocPool::resetCpuData(size_t newSize) {
+    sk_free(fCpuData);
+    if (newSize) {
+        if (fGpu->caps()->mustClearUploadedBufferData()) {
+            fCpuData = sk_calloc(newSize);
+        } else {
+            fCpuData = sk_malloc_throw(newSize);
+        }
+    } else {
+        fCpuData = nullptr;
+    }
+    return fCpuData;
+}
+
+
 void GrBufferAllocPool::flushCpuData(const BufferBlock& block, size_t flushSize) {
     GrGeometryBuffer* buffer = block.fBuffer;
     SkASSERT(buffer);
     SkASSERT(!buffer->isMapped());
-    SkASSERT(fCpuData.get() == fBufferPtr);
+    SkASSERT(fCpuData == fBufferPtr);
     SkASSERT(flushSize <= buffer->gpuMemorySize());
     VALIDATE(true);
 
     if (GrCaps::kNone_MapFlags != fGpu->caps()->mapBufferFlags() &&
         flushSize > fGeometryBufferMapThreshold) {
         void* data = buffer->map();
         if (data) {
             memcpy(data, fBufferPtr, flushSize);
             UNMAP_BUFFER(block);
             return;
@@ skipping 27 matching lines @@
 void* GrVertexBufferAllocPool::makeSpace(size_t vertexSize,
                                          int vertexCount,
                                          const GrVertexBuffer** buffer,
                                          int* startVertex) {
 
     SkASSERT(vertexCount >= 0);
     SkASSERT(buffer);
     SkASSERT(startVertex);
 
     size_t offset = 0; // assign to suppress warning
-    const GrGeometryBuffer* geomBuffer = NULL; // assign to suppress warning
+    const GrGeometryBuffer* geomBuffer = nullptr; // assign to suppress warning
     void* ptr = INHERITED::makeSpace(vertexSize * vertexCount,
                                      vertexSize,
                                      &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_BufferType, MIN_INDEX_BUFFER_SIZE) {
 }
 
 void* GrIndexBufferAllocPool::makeSpace(int indexCount,
                                         const GrIndexBuffer** buffer,
                                         int* startIndex) {
 
     SkASSERT(indexCount >= 0);
     SkASSERT(buffer);
     SkASSERT(startIndex);
 
     size_t offset = 0; // assign to suppress warning
-    const GrGeometryBuffer* geomBuffer = NULL; // assign to suppress warning
+    const GrGeometryBuffer* geomBuffer = nullptr; // assign to suppress warning
     void* ptr = INHERITED::makeSpace(indexCount * sizeof(uint16_t),
                                      sizeof(uint16_t),
                                      &geomBuffer,
                                      &offset);
 
     *buffer = (const GrIndexBuffer*) geomBuffer;
     SkASSERT(0 == offset % sizeof(uint16_t));
     *startIndex = static_cast<int>(offset / sizeof(uint16_t));
     return ptr;
 }
-
-